数码相框——显示图片(缩放功能)

最新推荐文章于 2021-03-16 00:13:34 发布

dream890527

最新推荐文章于 2021-03-16 00:13:34 发布

阅读量1.7k

点赞数 1

分类专栏：项目班文章标签：项目班

本文链接：https://blog.csdn.net/dream890527/article/details/22302905

版权

项目班专栏收录该内容

14 篇文章 1 订阅

订阅专栏

BMP基本知识参考：

http://redwolf.blog.51cto.com/427621/229096

一、 bmp.c

#if 1
#include <pic_operation.h>
#include <stdlib.h>
#include <string.h>
#include <config.h>

/*对于结构体一定注意自己对齐*/
#pragma pack(push) /*±£´æ¶ÔÆë×´Ì¬ */
#pragma pack(1)	/*Éè¶¨Îª4×Ö½Ú¶ÔÆë*/ 

/*¶¨ÒåÎÄ¼þÐÅÏ¢Í·½á¹¹Ìå*/
typedef struct _tagBITMAPFILEHEADER { /* bmfh */
	unsigned short 	 	bfType; 
	unsigned long 		bfSize;
	unsigned short 		bfReserved1;
	unsigned short 		bfReserved2;
	unsigned long 		bfOffBits;
} BITMAPFILEHEADER;

/*¶¨ÒåÎ»Í¼ÐÅÏ¢Í·*/
typedef struct _tagBITMAPINFOHEADER { /* bmih */
	unsigned long	  biSize;
	unsigned long	  biWidth;
	unsigned long	 biHeight;
	unsigned short	 biPlanes;
	unsigned short	 biBitCount;
	unsigned long	 biCompression;
	unsigned long 	 biSizeImage;
	unsigned long     biXPelsPerMeter;
	unsigned long     biYPelsPerMeter;
	unsigned long 	 biClrUsed;
	unsigned long	 biClrImportant;
} BITMAPINFOHEADER;

#pragma pack(pop)	/*»Ö¸´¶ÔÆë×´*/
static int  isSupportBMP(unsigned char * pucFileHead);
static int GetPixelDatasFrmBMP(unsigned char* pucFileHead, PT_PixelDatas ptPixelDatas);
static int  FreePixelDatasForBMP( PT_PixelDatas ptPixelDatas);
	
T_PicFileParese g_tBMPPicFileParese = {
	.name = "bmp",
	.isSupport = isSupportBMP,
	.GetPixelDatas = GetPixelDatasFrmBMP,
	.FreePixelDatas = FreePixelDatasForBMP,
};

static int  isSupportBMP(unsigned char * pucFileHead)
{
	if (pucFileHead[0] != 0x42 || pucFileHead[1] != 0x4d)
		return -1;
	else
		return 0;
}
static int ConvertOneLineFrmBMP(int iWidth, int iSrcBpp, int iDestBpp, unsigned char* pucSrcDatas, unsigned char* pucDestDatas)
{
	unsigned int dwRed;
	unsigned int dwGreen;
	unsigned int dwBlue;
	unsigned int dwColor;
	int iPos = 0;
        int i;
	unsigned short*  pwDestDatas16Bpp = (unsigned short*)pucDestDatas;
	unsigned int*      pdwDestDatas32Bpp = (unsigned int *)pucDestDatas;
	 /* 在这里只处理24Bpp的BMP图片*/
	 if(iSrcBpp != 24)
	 {
		return -1;
	 }
	 if(iDestBpp == 24)
	 {
		memcpy(pucDestDatas, pucSrcDatas, iWidth*3);
		return 0;
	 }
	 else
	 {
	 /*Öð¸öÏñËØ×ª»»*/
		for(i = 0; i <  iWidth ; i++)
		{
			dwBlue= pucSrcDatas[iPos++];
			dwGreen = pucSrcDatas[iPos++];
			dwRed = pucSrcDatas[iPos++];
                        if(iDestBpp == 32)   /*iDestBpp 就是Framebuffer 中Fb中bpp为32 */
			{
				dwColor = (dwRed << 16) | (dwGreen <<8)|(dwBlue);
				*pdwDestDatas32Bpp = dwColor;
				pdwDestDatas32Bpp++;
			}
			else if(iDestBpp == 16)
			{
				/*565*/
				dwRed = (dwRed >> 3) && 0xff;
				dwGreen = (dwGreen>>2) && 0xff;
				dwBlue = (dwBlue>>3) && 0xff;
				dwColor = (dwRed <<11)|(dwGreen<<5)|(dwBlue);
				*pwDestDatas16Bpp = dwColor;
				pwDestDatas16Bpp++;
				
			}
			
		}
		
	 }
	 return 0;
}


/*
*	PT_PixelDatas->iBpp ÎªÊäÈëµÄ£¬±íÊ¾´Ó BMP µÃµ½µÄÊý¾ÝÒª×ª»¯µÄ¸ñÊ½ 
*/
#endif
#if 1
static int GetPixelDatasFrmBMP(unsigned char* pucFileHead, PT_PixelDatas ptPixelDatas)
{
/*ptPixelDatas->iBpp ÊÇÔõÃ´Éè¶¨µÄÄØ*/
/*Õâ¸öiBPP À´×ÔÓÚfbµÄ¹Ì¶¨ÐÅÏ¢iBPP*/
	DBG_PRINTF("in GetPixelDatasFrmBMP\n");
	DBG_PRINTF("aFileHead 0x%X\n",pucFileHead);
	DBG_PRINTF("ptPixelDatas 0x%X\n",ptPixelDatas);
	BITMAPFILEHEADER *ptBITMAPFILEHEADER;
	BITMAPINFOHEADER *ptBITMAPINFOHEADER;
	int iWidth;
	int iHeight;
	int iBMPBpp;
	int y;

	unsigned char *pucSrc;
	unsigned char *pucDest;
	int iLineWidthAlign;
	int iLineWidthReal;
		
	ptBITMAPFILEHEADER = (BITMAPFILEHEADER *)pucFileHead;
	ptBITMAPINFOHEADER = (BITMAPINFOHEADER *)(pucFileHead + sizeof(BITMAPFILEHEADER));
		 iWidth = ptBITMAPINFOHEADER->biWidth;
		 iHeight = ptBITMAPINFOHEADER->biHeight;
		 iBMPBpp = ptBITMAPINFOHEADER->biBitCount;
	DBG_PRINTF("iWidth %d\n",iWidth);
	DBG_PRINTF("iHeight %d\n",iHeight);
	DBG_PRINTF("iBMPBpp %d\n",iBMPBpp);
		/*Ö»´¦Àí24Î»BMP*/
		 if(iBMPBpp != 24)
		 {
			DBG_PRINTF("iBMPBpp = %d\n",iBMPBpp);
			DBG_PRINTF("sizeof(BITMAPFILEHEADER) = %d\n", sizeof(BITMAPFILEHEADER));
			return -1;
		 }

		ptPixelDatas->iWidth	= iWidth;
		ptPixelDatas->iHeight 	= iHeight;


/*·ÖÅä´ÓBMP ×ª»»ºóµÄÊý¾ÝÏàÓ¦µÄÄÚ´æ¿Õ¼ä´óÐ¡*/
/*´ËÊ±Õâ¸ö ptPixelDatas->iBppÀ´×Ô´«½øÀ´µÄ ptDispOpr->iBpp*/ /*在这里犯下严重错误*/
	ptPixelDatas->pucPixelDatas = malloc(iWidth * iHeight * ptPixelDatas->iBpp / 8);
	ptPixelDatas->iLineBytes    = iWidth * ptPixelDatas->iBpp / 8;
	DBG_PRINTF("ptPixelDatas->iLineBytes %d\n",ptPixelDatas->iLineBytes);
	
		 /*´ËÊ±Õâ¸ö ptPixelDatas->iBppÀ´×Ô´«½øÀ´µÄ ptDispOpr->iBpp*/
		 ptPixelDatas->iLineBytes = iWidth * ptPixelDatas->iBpp/8; 
		 
/*°ÑÍ¼Ïñ´æ·Åµ½ÖØÐÂ·ÖÅäµÄÇøÓò*/
		 iLineWidthReal = iWidth*iBMPBpp/8;
		 iLineWidthAlign = (iLineWidthReal+3)&(~0x3);  /*¶ÁÈ¡°´4×Ö½ÚÈ¡Õû*/  /*除4取整*/
	DBG_PRINTF("iLineWidthReal %d\n",iLineWidthReal);
	DBG_PRINTF("iLineWidthAlign %d\n",iLineWidthAlign);
		 pucSrc = pucFileHead + ptBITMAPFILEHEADER->bfOffBits;
		 pucSrc = pucSrc + (iHeight -1) * iLineWidthAlign;

		 
		pucDest = ptPixelDatas->pucPixelDatas; 

		 for(y=0 ; y<iHeight ; y++)
		 {
			ConvertOneLineFrmBMP(iWidth, iBMPBpp, ptPixelDatas->iBpp, pucSrc, pucDest); /*注意图片数据存放的位置*/
			pucSrc  -= iLineWidthAlign;    
			pucDest += ptPixelDatas->iLineBytes;
		 }
		 return 0;
}

static int  FreePixelDatasForBMP( PT_PixelDatas ptPixelDatas)
{
	free(ptPixelDatas->pucPixelDatas);
	return 0;
}
#endif

#if 0
#include <config.h>
#include <pic_operation.h>
#include <stdlib.h>
#include <string.h>

#pragma pack(push) /* ½«µ±Ç°packÉèÖÃÑ¹Õ»±£´æ */
#pragma pack(1)    /* ±ØÐëÔÚ½á¹¹Ìå¶¨ÒåÖ®Ç°Ê¹ÓÃ */

typedef struct tagBITMAPFILEHEADER { /* bmfh */
	unsigned short bfType; 
	unsigned long  bfSize;
	unsigned short bfReserved1;
	unsigned short bfReserved2;
	unsigned long  bfOffBits;
} BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER { /* bmih */
	unsigned long  biSize;
	unsigned long  biWidth;
	unsigned long  biHeight;
	unsigned short biPlanes;
	unsigned short biBitCount;
	unsigned long  biCompression;
	unsigned long  biSizeImage;
	unsigned long  biXPelsPerMeter;
	unsigned long  biYPelsPerMeter;
	unsigned long  biClrUsed;
	unsigned long  biClrImportant;
} BITMAPINFOHEADER;

#pragma pack(pop) /* »Ö¸´ÏÈÇ°µÄpackÉèÖÃ */

static int isBMPFormat(unsigned char *aFileHead);
static int GetPixelDatasFrmBMP(unsigned char *aFileHead, PT_PixelDatas ptPixelDatas);
static int FreePixelDatasForBMP(PT_PixelDatas ptPixelDatas);

T_PicFileParese g_tBMPPicFileParese = {
	.name           = "bmp",
	.isSupport      = isBMPFormat,
	.GetPixelDatas  = GetPixelDatasFrmBMP,
	.FreePixelDatas = FreePixelDatasForBMP,	
};

static int isBMPFormat(unsigned char *aFileHead)
{
	if (aFileHead[0] != 0x42 || aFileHead[1] != 0x4d)
		return -1;
	else
		return 0;
}

static int CovertOneLine(int iWidth, int iSrcBpp, int iDstBpp, unsigned char *pudSrcDatas, unsigned char *pudDstDatas)
{
	unsigned int dwRed;
	unsigned int dwGreen;
	unsigned int dwBlue;
	unsigned int dwColor;

	unsigned short *pwDstDatas16bpp = (unsigned short *)pudDstDatas;
	unsigned int   *pwDstDatas32bpp = (unsigned int *)pudDstDatas;

	int i;
	int pos = 0;

	if (iSrcBpp != 24)
	{
		return -1;
	}

	if (iDstBpp == 24)
	{
		memcpy(pudDstDatas, pudSrcDatas, iWidth*3);
	}
	else
	{
		for (i = 0; i < iWidth; i++)
		{
			dwBlue  = pudSrcDatas[pos++];
			dwGreen = pudSrcDatas[pos++];
			dwRed   = pudSrcDatas[pos++];
			if (iDstBpp == 32)
			{
				dwColor = (dwRed << 16) | (dwGreen << 8) | dwBlue;
				*pwDstDatas32bpp = dwColor;
				pwDstDatas32bpp++;
			}
			else if (iDstBpp == 16)
			{
				/* 565 */
				dwRed   = dwRed >> 3;
				dwGreen = dwGreen >> 2;
				dwBlue  = dwBlue >> 3;
				dwColor = (dwRed << 11) | (dwGreen << 5) | (dwBlue);
				*pwDstDatas16bpp = dwColor;
				pwDstDatas16bpp++;
			}
		}
	}
	return 0;
}

/*
 * ptPixelDatas->iBpp ÊÇÊäÈëµÄ²ÎÊý, Ëü¾ö¶¨´ÓBMPµÃµ½µÄÊý¾ÝÒª×ª»»Îª¸Ã¸ñÊ½
 */
 #endif
 #if 0
static int GetPixelDatasFrmBMP(unsigned char *aFileHead, PT_PixelDatas ptPixelDatas)
{
	DBG_PRINTF("in GetPixelDatasFrmBMP\n");
	DBG_PRINTF("aFileHead 0x%X\n",aFileHead);
	DBG_PRINTF("ptPixelDatas 0x%X\n",ptPixelDatas);
	BITMAPFILEHEADER *ptBITMAPFILEHEADER;
	BITMAPINFOHEADER *ptBITMAPINFOHEADER;

	int iWidth;
	int iHeight;
	int iBMPBpp;
	int y;

	unsigned char *pucSrc;
	unsigned char *pucDest;
	int iLineWidthAlign;
	int iLineWidthReal;
	

	ptBITMAPFILEHEADER = (BITMAPFILEHEADER *)aFileHead;
	ptBITMAPINFOHEADER = (BITMAPINFOHEADER *)(aFileHead + sizeof(BITMAPFILEHEADER));

	iWidth = ptBITMAPINFOHEADER->biWidth;
	iHeight = ptBITMAPINFOHEADER->biHeight;
	iBMPBpp = ptBITMAPINFOHEADER->biBitCount;
	DBG_PRINTF("iWidth %d\n",iWidth);
	DBG_PRINTF("iHeight %d\n",iHeight);
	DBG_PRINTF("iBMPBpp %d\n",iBMPBpp);
	if (iBMPBpp != 24)
	{
		DBG_PRINTF("iBMPBpp = %d\n", iBMPBpp);
		DBG_PRINTF("sizeof(BITMAPFILEHEADER) = %d\n", sizeof(BITMAPFILEHEADER));
		return -1;
	}

	ptPixelDatas->iWidth  = iWidth;
	ptPixelDatas->iHeight = iHeight;
	//ptPixelDatas->iBpp    = iBpp;
	ptPixelDatas->pucPixelDatas = malloc(iWidth * iHeight * ptPixelDatas->iBpp / 8);
	ptPixelDatas->iLineBytes    = iWidth * ptPixelDatas->iBpp / 8;
	DBG_PRINTF("ptPixelDatas->iLineBytes %d\n",ptPixelDatas->iLineBytes);

	if (NULL == ptPixelDatas->pucPixelDatas)
	{
		return -1;
	}
	DBG_PRINTF("iLineWidthReal %d\n",iLineWidthReal);
	DBG_PRINTF("iLineWidthAlign %d\n",iLineWidthAlign);

	iLineWidthReal = iWidth * iBMPBpp / 8;
	iLineWidthAlign = (iLineWidthReal + 3) & ~0x3;   /* Ïò4È¡Õû */

	DBG_PRINTF("iLineWidthReal %d\n",iLineWidthReal);
	DBG_PRINTF("iLineWidthAlign %d\n",iLineWidthAlign);
	
	pucSrc = aFileHead + ptBITMAPFILEHEADER->bfOffBits;
	pucSrc = pucSrc + (iHeight - 1) * iLineWidthAlign;

	pucDest = ptPixelDatas->pucPixelDatas;
	
	DBG_PRINTF("pucSrc 0x%X\n",pucSrc);
	DBG_PRINTF("pucDest 0x%X\n",pucDest);
	DBG_PRINTF("iLineWidthAlign %d\n",iLineWidthAlign);
	DBG_PRINTF("iLineWidthAlign %d\n",iLineWidthAlign);
	DBG_PRINTF("iWidth %d\n",iWidth);
	DBG_PRINTF("iBMPBpp %d\n",iBMPBpp);
	DBG_PRINTF(" ptPixelDatas->iBpp %d\n", ptPixelDatas->iBpp);	



	for (y = 0; y < iHeight; y++)
	{		
		//memcpy(pucDest, pucSrc, iLineWidthReal);
		ConvertOneLineFrmBMP(iWidth, iBMPBpp, ptPixelDatas->iBpp, pucSrc, pucDest);
		pucSrc  -= iLineWidthAlign;
		pucDest += ptPixelDatas->iLineBytes;
	}
	return 0;	
}

static int FreePixelDatasForBMP(PT_PixelDatas ptPixelDatas)
{
	free(ptPixelDatas->pucPixelDatas);
	return 0;
}
#endif

二、pic_operation.h

#ifndef _PIC_OPERATION_H_
#define _PIC_OPERATION_H_

typedef struct PixelDatas {
	int iWidth;
	int iHeight;
	int iBpp;
	int iLineBytes;
	unsigned char* pucPixelDatas;
}T_PixelDatas, *PT_PixelDatas;


typedef struct PicFileParse{
	char *name;
	int  (*isSupport)(unsigned char * pucFileHead);
	int (*GetPixelDatas)(unsigned char* pucFileHead, PT_PixelDatas ptPixelDatas);
	int (*FreePixelDatas)( PT_PixelDatas ptPixelDatas);
}T_PicFileParese, *PT_PicFileParese;
#endif  /*_PIC_OPERATION_H_*/

三、merge.c

#include <pic_operation.h>
 #include <string.h>
 #include <config.h>
/*°ÑÐ¡Í¼ºÏ²¢µ½´óÍ¼ÖÐ*/
int PicMerge(int iX, int iY, PT_PixelDatas ptSmallPic, PT_PixelDatas ptBigPic)
{
	int i;
	unsigned char* pucSrc;
	unsigned char* pucDest;
	DBG_PRINTF("in PicMerge\n");
	DBG_PRINTF("ptSmallPic 0x%X\n",ptSmallPic);
	DBG_PRINTF("ptBigPic 0x%X\n",ptBigPic);
	DBG_PRINTF("ptSmallPic->iWidth %d\n",ptSmallPic->iWidth);
	DBG_PRINTF("ptBigPic->iWidth %d\n", ptBigPic->iWidth);
	DBG_PRINTF("ptSmallPic->iHeight %d\n",ptSmallPic->iHeight);
	DBG_PRINTF("ptBigPic->iHeight %d\n", ptBigPic->iHeight);
	DBG_PRINTF("ptSmallPic->iBpp %d\n", ptSmallPic->iBpp);
	DBG_PRINTF(" ptBigPic->iBpp %d\n",  ptBigPic->iBpp);
	DBG_PRINTF("ptSmallPic->pucPixelDatas 0x%X\n",ptSmallPic->pucPixelDatas);
	DBG_PRINTF("ptBigPic->pucPixelDatas 0x%X\n",ptBigPic->pucPixelDatas);



/*ºÏ·¨ÐÔ¼ì²â*/
	if((ptSmallPic->iWidth > ptBigPic->iWidth) ||
	    (ptSmallPic->iHeight>ptBigPic->iHeight) ||
	    (ptSmallPic->iBpp != ptBigPic->iBpp))
	{
		return -1;
	}
	DBG_PRINTF("ptSmallPic 0x%X\n",ptSmallPic);
	DBG_PRINTF("ptBigPic 0x%X\n",ptBigPic);

	pucSrc = ptSmallPic->pucPixelDatas;
	DBG_PRINTF("ptSmallPic 0x%X\n",ptSmallPic);

	pucDest = ptBigPic->pucPixelDatas + iY*ptBigPic->iLineBytes + iX*ptBigPic->iBpp/8;
	
	DBG_PRINTF("pucSrc 0x%X\n",pucSrc);
	DBG_PRINTF("pucDest 0x%X\n",pucDest);
	for(i=0; i< ptSmallPic->iHeight; i++)
	{
		memcpy(pucDest, pucSrc, ptSmallPic->iLineBytes);
		pucSrc +=ptSmallPic->iLineBytes;
		pucDest +=ptBigPic->iLineBytes;
	}
	DBG_PRINTF("emd PicMerge\n");
	return 0;
}

四、修改fb_demo的bug

#include <config.h>
#include <disp_manager.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/fb.h>
#include <string.h>

/*¹¹Ôì¡¢ÉèÖÃ¡¢×¢²á½á¹¹Ìå²ÉÓÃÃæÏò¶ÔÏóµÄË¼Ïë*/
#if 0
typedef struct DispOpr {
	char* name;
	int	 iXres;
	int 	 iYres;
	int 	 iBpp;
	int	 (*ShowPixel)(int iPenX, int iPenY, unsigned int dwColor);
	int 	 (*CleanScreen)(unsigned int dwBackColor);
	int 	 (*DeviceInit)(void);
	struct DispOpr *ptNext;
}T_DispOpr, *PT_DispOpr;

int RegisterDispOpr(PT_DispOpr ptDispOpr);
void ShowDispOpr(void);
int 	DisplayInit(void);
int	FBInit(void);
#endif
static int FBDeviceInit(void);
static int FBShowPixel(int iX, int iY, unsigned int dwColor);
static int FBCleanScreen(unsigned int dwBackColor);


static T_DispOpr g_tFBOpr = {
	.name = "fb",
	.DeviceInit = FBDeviceInit,
	.ShowPixel = FBShowPixel,
	.CleanScreen = FBCleanScreen,
};

static int g_iFBFd;

static  struct fb_var_screeninfo  g_tFBVar;
static  struct fb_fix_screeninfo   g_tFBFix;

static unsigned int g_dwScreenSize;
static unsigned int g_dwLineWidth;
static unsigned int g_dwPixelWidth;
static unsigned char * g_pucFBMem;

static int FBDeviceInit(void)
{
	g_iFBFd = open(FB_DEVICE_NAME,O_RDWR);
	if(g_iFBFd < 0)
	{
		DBG_PRINTF("open /dev/fb0 failed\n");
		return -1;
	}
	
	if (ioctl(g_iFBFd, FBIOGET_VSCREENINFO, &g_tFBVar))
	{
		DBG_PRINTF("get var information failed\n");
		return -1;
	}
	if (ioctl(g_iFBFd, FBIOGET_FSCREENINFO, &g_tFBFix))
	{
		DBG_PRINTF("get fix information failed\n");
		return -1;
	}
	
	g_dwScreenSize =  g_tFBVar.xres * g_tFBVar.yres *  g_tFBVar.bits_per_pixel /8;
	g_pucFBMem      =  (unsigned char *)mmap(NULL , g_dwScreenSize, PROT_READ | PROT_WRITE, MAP_SHARED, g_iFBFd, 0);
	if(g_pucFBMem == (unsigned char *)-1)
	{
		DBG_PRINTF("g_pucFBMem mmap failed\n ");
		return -1;
	}
	g_tFBOpr.iXres =  g_tFBVar.xres; 
	g_tFBOpr.iYres =  g_tFBVar.yres;
	g_tFBOpr.iBpp  =  g_tFBVar.bits_per_pixel;
	g_tFBOpr.pucDispMem = g_pucFBMem;    /* 此处需要修改*/

	g_dwLineWidth   =  g_tFBVar.xres *  g_tFBVar.bits_per_pixel /8;
	g_dwPixelWidth  =  g_tFBVar.bits_per_pixel /8;
	return 0;
}
static int FBShowPixel(int iPenX, int iPenY, unsigned int dwColor)
{
	unsigned char *pucFB8pp = (unsigned char*)(g_pucFBMem+iPenY*g_dwLineWidth+iPenX*g_dwPixelWidth);
	unsigned short *pwFB16pp;
	unsigned int *pdwFB32pp;
	
	pwFB16pp = (unsigned short*)pucFB8pp;
	pdwFB32pp = (unsigned int*)pucFB8pp;
	
	unsigned char red,green,blue;

	/*0xRRGGBB*/
	switch( g_tFBVar.bits_per_pixel)
	{
		case 8:
			*pucFB8pp = dwColor;
			break;
		case 16:
			red 	   		=  (dwColor >>16)&0xff;
			green  		=  (dwColor>>8)&0xff;
			blue    		=  (dwColor>>0)&0xff;
			dwColor   	= ((red>>3)<<11)|((green>>2)<<5)|((blue>>3)<<0);
			*pwFB16pp	= dwColor;
			break;
		case 32:
			*pdwFB32pp 	= dwColor;
			break;
		default:
			DBG_PRINTF("Can' support  error\n");
			return -1;
	}
	return 0;
}

static int FBCleanScreen(unsigned int dwBackColor)
{
	unsigned char *pucFB8pp = (unsigned char*)(g_pucFBMem);
	unsigned short *pwFB16pp;
	unsigned int *pdwFB32pp;
	
	pwFB16pp = (unsigned short*)pucFB8pp;
	pdwFB32pp = (unsigned int*)pucFB8pp;
	
	unsigned char red,green,blue;
	int i = 0;
	/*0xRRGGBB*/
	switch(g_tFBVar.bits_per_pixel)
	{
		case 8:
			memset(g_pucFBMem, dwBackColor, g_dwScreenSize);
			break;
		case 16:
			red 	   		=  (dwBackColor >>16)&0xff;
			green  		=  (dwBackColor>>8)&0xff;
			blue    		=  (dwBackColor>>0)&0xff;
			dwBackColor   = ((red>>3)<<11)|((green>>2)<<5)|((blue>>3)<<0);
			while(i < g_dwScreenSize)
			{
				*pwFB16pp  = dwBackColor;
				pwFB16pp++;
				i +=2;
			}	
			break;
		case 32:
			while(i < g_dwScreenSize)
			{
				*pdwFB32pp  = dwBackColor;
				pdwFB32pp++;
				i += 4;

			}	
			break;
		default:
			DBG_PRINTF("Can' support  %d bpp\n",g_tFBOpr.iBpp);
			return -1;
	}
	return 0;	
}

int FBInit(void)
{
	return RegisterDispOpr(&g_tFBOpr);
}

五、测试程序

#include <stdio.h>
#include <encoding_manager.h>
#include <fonts_manager.h>
#include <disp_manager.h>
#include <input_manager.h>
#include <debug_manager.h>
#include <page_manager.h>
#include <pic_operation.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <render.h>
#include <config.h>

int main(int argc, char **argv)
{
	int iFdBmp;
	int iRet;
	unsigned char *pucBMPmem;
	struct stat tStatBMPbuf;
		
	PT_DispOpr ptDispOpr;

	extern T_PicFileParese g_tBMPPicFileParese;

	T_PixelDatas tPixelDatas;
	T_PixelDatas tPixelDatasSmall;

	T_PixelDatas tPixelDatasFB;

	if (argc != 2)
	{
		printf("%s <bmp_file>\n", argv[0]);
		return -1;
	}

	DebugInit();
	SelectAndInitChannel();

	DisplayInit();

	ptDispOpr = GetDispOpr("fb");
	ptDispOpr->DeviceInit();
	ptDispOpr->CleanScreen(0);
	
DBG_PRINTF("open!......................\n");
	/* ´ò¿ªBMPÎÄ¼þ */
	iFdBmp = open(argv[1], O_RDWR);
	if (iFdBmp == -1)
	{
		DBG_PRINTF("can't open %s\n", argv[1]);
	}

	fstat(iFdBmp, &tStatBMPbuf);
	DBG_PRINTF("ptStatBMPbuf->st_size %d\n",tStatBMPbuf.st_size);
	pucBMPmem = (unsigned char *)mmap(NULL ,tStatBMPbuf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, iFdBmp, 0);
	if (pucBMPmem == (unsigned char *)-1)
	{
		DBG_PRINTF("mmap error!\n");
		return -1;
	}
	DBG_PRINTF("pucBMPmem 0x%X\n",pucBMPmem);
	/* ÌáÈ¡BMPÎÄ¼þµÄRGBÊý¾Ý, Ëõ·Å, ÔÚLCDÉÏÏÔÊ¾³öÀ´ */
	iRet = g_tBMPPicFileParese.isSupport(pucBMPmem);
	if (iRet == -1)
	{
		DBG_PRINTF("%s is not bmp file\n", argv[1]);
		return -1;		
	}
	
	tPixelDatas.iBpp = ptDispOpr->iBpp;
	iRet = g_tBMPPicFileParese.GetPixelDatas(pucBMPmem, &tPixelDatas);
	if (iRet)
	{
		DBG_PRINTF("GetPixelDatas error!\n");
		return -1;		
	}

	DBG_PRINTF("ptDispOpr->name %s\n",ptDispOpr->name);
	DBG_PRINTF("ptDispOpr->iXres %d\n", ptDispOpr->iXres);
	DBG_PRINTF("ptDispOpr->iYres %d\n",ptDispOpr->iYres);
	DBG_PRINTF("ptDispOpr->iBpp %d\n",ptDispOpr->iBpp);
	DBG_PRINTF("tDispOpr->iXres * ptDispOpr->iBpp / 8 %d\n",ptDispOpr->iXres * ptDispOpr->iBpp / 8);
	tPixelDatasFB.iWidth        = ptDispOpr->iXres;
	tPixelDatasFB.iHeight       = ptDispOpr->iYres;
	tPixelDatasFB.iBpp          = ptDispOpr->iBpp;
	tPixelDatasFB.iLineBytes    = ptDispOpr->iXres * ptDispOpr->iBpp / 8; 
	tPixelDatasFB.pucPixelDatas = ptDispOpr->pucDispMem;
	
	DBG_PRINTF("&tPixelDatas 0x%X\n", &tPixelDatas);
	DBG_PRINTF("&tPixelDatasFB 0x%X\n",&tPixelDatasFB);
	
	
	DBG_PRINTF("tPixelDatas.pucPixelDatas 0x%X\n",tPixelDatas.pucPixelDatas);
	DBG_PRINTF("tPixelDatasFB.pucPixelDatas 0x%X\n",tPixelDatasFB.pucPixelDatas);	
	PicMerge(0, 0, &tPixelDatas, &tPixelDatasFB);

	tPixelDatasSmall.iWidth  = tPixelDatas.iWidth/2;
	tPixelDatasSmall.iHeight = tPixelDatas.iHeight/2;
	tPixelDatasSmall.iBpp    = tPixelDatas.iBpp;
	tPixelDatasSmall.iLineBytes = tPixelDatasSmall.iWidth * tPixelDatasSmall.iBpp / 8;
	tPixelDatasSmall.pucPixelDatas = malloc(tPixelDatasSmall.iLineBytes * tPixelDatasSmall.iHeight);
	
	PicZoom(&tPixelDatas, &tPixelDatasSmall);  /* 图片缩放*/
	PicMerge(128, 128, &tPixelDatasSmall, &tPixelDatasFB);
	return 0;
}

调试信息：

/project1/14th_digital_photo_frame_origin # ./digitalpic 13.bmp 
open!......................
ptStatBMPbuf->st_size 230454    /*13.bmp 文件大小*/
pucBMPmem 0xB5C80000            /*BMP 内存映射地址*/
in GetPixelDatasFrmBMP
aFileHead 0xB5C80000               
ptPixelDatas 0xBEAE7CBC            /*ptPixelDatas 用来存放BMP的地址，可以理解为FB地址 */
iWidth 240                          /* BMP图片的大小*/
iHeight 320
iBMPBpp 24
ptPixelDatas->iLineBytes 960        /*ptPixelDatas 中成员的iLineBytes  一行的长度*/  
iLineWidthReal 720
iLineWidthAlign 720
ptDispOpr->name fb                   /*FrameBuffer  的一些信息*/
ptDispOpr->iXres 240
ptDispOpr->iYres 320
ptDispOpr->iBpp 32                      /*FrameBuffer  采用32bpp */
tDispOpr->iXres * ptDispOpr->iBpp / 8 960
&tPixelDatas 0xBEAE7CBC
&tPixelDatasFB 0xBEAE7C94
tPixelDatas.pucPixelDatas 0xB5C34008
tPixelDatasFB.pucPixelDatas 0xB5CB9000
in PicMerge
ptSmallPic 0xBEAE7CBC
ptBigPic 0xBEAE7C94
ptSmallPic->iWidth 240
ptBigPic->iWidth 240
ptSmallPic->iHeight 320
ptBigPic->iHeight 320
ptSmallPic->iBpp 32
 ptBigPic->iBpp 32
ptSmallPic->pucPixelDatas 0xB5C34008
ptBigPic->pucPixelDatas 0xB5CB9000
ptSmallPic 0xBEAE7CBC
ptBigPic 0xBEAE7C94
ptSmallPic 0xBEAE7CBC
pucSrc 0xB5C34008
pucDest 0xB5CB9000
emd PicMerge
in PicMerge
ptSmallPic 0xBEAE7CA8
ptBigPic 0xBEAE7C94
ptSmallPic->iWidth 120
ptBigPic->iWidth 240
ptSmallPic->iHeight 160
ptBigPic->iHeight 320
ptSmallPic->iBpp 32
 ptBigPic->iBpp 32
ptSmallPic->pucPixelDatas 0x19130
ptBigPic->pucPixelDatas 0xB5CB9000
ptSmallPic 0xBEAE7CA8
ptBigPic 0xBEAE7C94
ptSmallPic 0xBEAE7CA8
pucSrc 0x19130
pucDest 0xB5CD7200
emd PicMerge
/project1/14th_digital_photo_frame_origin #

dream890527

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
数码相框——显示图片(缩放功能)

BMP基本知识参考：http://redwolf.blog.51cto.com/427621/229096一、 bmp.c#if 1#include #include #include #include /*对于结构体一定注意自己对齐*/#pragma pack(push) /*±£´æ¶ÔÆë×´Ì¬ */#pragma pack(1) /*Éè¶¨Îª4×
复制链接

扫一扫

专栏目录