开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
png.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：9k
源码类别：

Windows CE

开发平台：

C/C++

png.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: png.c 313 2005-10-29 15:15:47Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  23.  
  24. #include "../common/common.h"
  25. #include "../common/zlib/zlib.h"
  26. #include "png.h"
  28. typedef struct png
  29. {
  30. codec Codec;
  31. buffer Buffer;
  32. bool_t ErrorShowed;
  34. const uint8_t* Ptr;
  36. } png;
  38. static int UpdateInput(png* p)
  39. {
  40. p->ErrorShowed = 0;
  41. BufferClear(&p->Buffer);
  42. if (p->Codec.In.Format.Type == PACKET_VIDEO)
  43. {
  44. PacketFormatCopy(&p->Codec.Out.Format,&p->Codec.In.Format);
  45. p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_RGB;
  46. p->Codec.Out.Format.Format.Video.Pixel.BitCount = 24;
  47. p->Codec.Out.Format.Format.Video.Pixel.BitMask[0] = 0xFF;
  48. p->Codec.Out.Format.Format.Video.Pixel.BitMask[1] = 0xFF00;
  49. p->Codec.Out.Format.Format.Video.Pixel.BitMask[2] = 0xFF0000;
  50. DefaultPitch(&p->Codec.Out.Format.Format.Video);
  51. }
  52. return ERR_NONE;
  53. }
  55. static NOINLINE int NotSupported(png* p)
  56. {
  57. if (!p->ErrorShowed)
  58. {
  59. p->ErrorShowed = 1;
  60. ShowError(p->Codec.Node.Class,PNG_ID,PNG_NOT_SUPPORTED);
  61. }
  62. return ERR_NOT_SUPPORTED;
  63. }
  65. static NOINLINE int Read32(png* p)
  66. {
  67. int v = LOAD32BE(p->Ptr);
  68. p->Ptr += 4;
  69. return v;
  71. }
  73. static int Predictor(int Left,int Up,int Corner)
  74. {
  75. int i = Left+Up-Corner;
  76. int a = abs(i-Left);
  77. int b = abs(i-Up);
  78. int c = abs(i-Corner);
  79. return (a<=b && a<=c)?Left:((b<=c)?Up:Corner);
  80. }
  82. static void Filter(int Mode,const uint8_t* Src,const uint8_t* DstLast,uint8_t* Dst,int Ch,int BytesPerRow)
  83. {
  84. const uint8_t* DstPrev;
  85. const uint8_t* DstLastPrev;
  86. int i;
  88. DstLastPrev = DstLast;
  89. DstPrev = Dst;
  91. if (!DstLast)
  92. {
  93. if (Mode==2) Mode=0;
  94. if (Mode==4) Mode=1;
  95. }
  97. switch (Mode)
  98. {
  99. case 1: // subtraction filter
  100. for (i=0;i<Ch;++i)
  101. *(Dst++) = *(Src++);
  103. for (BytesPerRow-=Ch;BytesPerRow>0;--BytesPerRow)
  104. *(Dst++) = (uint8_t)(*(Src++) + *(DstPrev++));
  106. break;
  108. case 2: // up filter
  109. for (;BytesPerRow>0;--BytesPerRow)
  110. *(Dst++) = (uint8_t)(*(Src++) + *(DstLast++));
  111. break;
  113. case 3: // average filter
  114. if (DstLast)
  115. {
  116. for (i=0;i<Ch;++i)
  117. *(Dst++) = (uint8_t)(*(Src++) + (*(DstLast++)>>1));
  119. for (BytesPerRow-=Ch;BytesPerRow>0;--BytesPerRow)
  120. *(Dst++) = (uint8_t)(*(Src++) + ((*(DstPrev++)+*(DstLast++))>>1));
  121. }
  122. else
  123. {
  124. for (i=0;i<Ch;++i)
  125. *(Dst++) = *(Src++);
  127. for (BytesPerRow-=Ch;BytesPerRow>0;--BytesPerRow)
  128. *(Dst++) = (uint8_t)(*(Src++) + (*(DstPrev++)>>1));
  129. }
  130. break
  131. ;
  132. case 4: // paeth prediction
  133. for (i=0;i<Ch;++i)
  134. *(Dst++) = (uint8_t)(*(Src++) + Predictor(0,*(DstLast++),0));
  136. for (BytesPerRow-=Ch;BytesPerRow>0;--BytesPerRow)
  137. *(Dst++) = (uint8_t)(*(Src++) + Predictor(*(DstPrev++),*(DstLast++),*(DstLastPrev++)));
  139. break;
  141. default: // copy
  142. memmove(Dst,Src,BytesPerRow);
  143. break;
  144. }
  145. }
  147. static int Process(png* p, const packet* Packet, const flowstate* State)
  148. {
  149. static const uint8_t Magic[8] = {0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
  150. rgb Pal[256];
  151. const uint8_t* PtrEnd;
  152. uint8_t* LastRow = NULL;
  153. int Ch = 0;
  154. video Video;
  155. int BytesPerRow=0,Left=0,Row=0;
  156. z_stream Inflate;
  158. if (!Packet)
  159. return ERR_NEED_MORE_DATA;
  161. p->Ptr = Packet->Data[0];
  162. PtrEnd = p->Ptr + Packet->Length;
  164. if (Packet->Length<16 || memcmp(p->Ptr,Magic,8)!=0)
  165. return ERR_INVALID_DATA;
  166. p->Ptr += 8;
  168. memset(&Video,0,sizeof(Video));
  169. BufferDrop(&p->Buffer);
  171. while (p->Ptr+8<=PtrEnd)
  172. {
  173. int i;
  174. int Len = Read32(p);
  175. int Id = Read32(p);
  176. const uint8_t* Next = p->Ptr+Len+4; //dword CRC
  177. if (Next > PtrEnd)
  178. break;
  180. switch (Id)
  181. {
  182. case FOURCCBE('I','H','D','R'):
  183. if (Len<13)
  184. return ERR_INVALID_DATA;
  186. Video.Width = Read32(p);
  187. Video.Height = Read32(p);
  188. Video.Pixel.BitCount = p->Ptr[0];
  189. Video.Aspect = ASPECT_ONE; //todo
  191. if (p->Ptr[2] != 0 || // compression
  192. p->Ptr[3] != 0 || // filter mode
  193. p->Ptr[4] != 0)   // interlaced
  194. return NotSupported(p);
  196. if (Video.Pixel.BitCount != 8)
  197. return NotSupported(p);
  199. if (p->Ptr[1] & 1)
  200. {
  201. if (p->Ptr[1] & 4)
  202. return NotSupported(p); //todo
  204. Video.Pixel.Flags |= PF_PALETTE;
  205. Ch = 1;
  206. }
  207. else
  208. if (p->Ptr[1] & 2)
  209. {
  210. Video.Pixel.Flags |= PF_RGB;
  211. Video.Pixel.BitMask[0] = 0xFF;
  212. Video.Pixel.BitMask[1] = 0xFF00;
  213. Video.Pixel.BitMask[2] = 0xFF0000;
  215. Ch = 3;
  216. if (p->Ptr[1] & 4)
  217. ++Ch; // alpha
  218. }
  219. else
  220. {
  221. if (p->Ptr[1] & 4)
  222. return NotSupported(p); //todo
  224. Video.Pixel.Flags |= PF_PALETTE|PF_GRAYSCALE;
  225. Ch = 1;
  226. }
  228. for (i=0;i<256;++i)
  229. Pal[i].v = CRGB(i,i,i);
  231. BytesPerRow = Ch * ((Video.Width * Video.Pixel.BitCount)>>3)+1;
  232. Left = BytesPerRow;
  233. Row = Video.Height;
  234. LastRow = NULL;
  236. Video.Pixel.BitCount *= Ch;
  237. DefaultPitch(&Video);
  239. if (!BufferAlloc(&p->Buffer,Video.Pitch*Video.Height,4096))
  240. return ERR_OUT_OF_MEMORY;
  242. memset(&Inflate,0,sizeof(Inflate));
  243.     if (inflateInit2(&Inflate, MAX_WBITS) != Z_OK)
  244. return ERR_OUT_OF_MEMORY;
  246. break;
  248. case FOURCCBE('P','L','T','E'):
  249. for (i=0;i<256 && Len>=3;++i,Len-=3,p->Ptr+=3)
  250. {
  251. Pal[i].c.r = p->Ptr[0];
  252. Pal[i].c.g = p->Ptr[1];
  253. Pal[i].c.b = p->Ptr[2];
  254. }
  255. break;
  257. case FOURCCBE('I','D','A','T'):
  259. if (!BytesPerRow || Row<=0)
  260. break;
  262. if (!EqVideo(&Video,&p->Codec.Out.Format.Format.Video))
  263. {
  264. if ((Video.Pixel.Flags & PF_PALETTE) && PacketFormatExtra(&p->Codec.Out.Format,sizeof(Pal)))
  265. {
  266. memcpy(p->Codec.Out.Format.Extra,Pal,sizeof(Pal));
  267. Video.Pixel.Palette = p->Codec.Out.Format.Extra;
  268. }
  269. p->Codec.In.Format.Format.Video.Width = Video.Width;
  270. p->Codec.In.Format.Format.Video.Height = Video.Height;
  271. p->Codec.Out.Format.Format.Video = Video;
  272. ConnectionUpdate(&p->Codec.Node,CODEC_OUTPUT,p->Codec.Out.Pin.Node,p->Codec.Out.Pin.No);
  273. }
  275. Inflate.next_in = (Bytef*)p->Ptr;
  276. Inflate.avail_in = Len;
  277. Inflate.next_out = p->Buffer.Data + p->Buffer.WritePos;
  278. Inflate.avail_out = Left;
  280. do
  281. {
  282. if (Inflate.avail_out<=0)
  283. {
  284. uint8_t* CurrRow = p->Buffer.Data + p->Buffer.WritePos - BytesPerRow;
  285. Filter(CurrRow[0],CurrRow+1,LastRow,CurrRow,Ch,BytesPerRow-1);
  286. LastRow = CurrRow;
  288. p->Buffer.WritePos += Video.Pitch - BytesPerRow;
  289. Inflate.next_out += Video.Pitch - BytesPerRow;
  290. Inflate.avail_out = Left = BytesPerRow;
  291. if (--Row<=0)
  292. break;
  293. }
  295. if (Inflate.avail_in<=0)
  296. break;
  297. i = inflate(&Inflate, Z_SYNC_FLUSH);
  299. p->Buffer.WritePos += Left - Inflate.avail_out;
  300. Left = Inflate.avail_out;
  302. if (i==Z_STREAM_END)
  303. Inflate.avail_in = 0;
  305. } while (i>=0);
  307. break;
  309. case FOURCCBE('I','E','N','D'):
  310. Next = PtrEnd;
  311. break;
  312. }
  314. p->Ptr = Next;
  315. }
  317. if (BytesPerRow)
  318. inflateEnd(&Inflate);
  320. if (p->Buffer.WritePos<=0)
  321. return ERR_INVALID_DATA;
  323. p->Codec.Packet.RefTime = Packet->RefTime;
  324. p->Codec.Packet.Length = p->Buffer.WritePos;
  325. p->Codec.Packet.Data[0] = p->Buffer.Data;
  326. return ERR_NONE;
  327. }
  329. static int Resend(png* p)
  330. {
  331. int Result = ERR_INVALID_DATA;
  332. if (p->Buffer.WritePos)
  333. {
  334. packet Packet;
  335. flowstate State;
  337. State.CurrTime = TIME_RESEND;
  338. State.DropLevel = 0;
  340. memset(&Packet,0,sizeof(Packet));
  341. Packet.RefTime = TIME_UNKNOWN;
  342. Packet.Length = p->Buffer.WritePos;
  343. Packet.Data[0] = p->Buffer.Data;
  345. Result = p->Codec.Out.Process(p->Codec.Out.Pin.Node,&Packet,&State);
  346. }
  347. return Result;
  348. }
  350. static int Flush(png* p)
  351. {
  352. BufferDrop(&p->Buffer);
  353. return ERR_NONE;
  354. }
  356. static int Create(png* p)
  357. {
  358. p->Codec.Process = (packetprocess)Process;
  359. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  360. p->Codec.ReSend = (nodefunc)Resend;
  361. p->Codec.Flush = (nodefunc)Flush;
  362. return ERR_NONE;
  363. }
  365. static const nodedef PNG =
  366. {
  367. sizeof(png),
  368. PNG_ID,
  369. CODEC_CLASS,
  370. PRI_DEFAULT,
  371. (nodecreate)Create,
  372. NULL,
  373. };
  375. //-------------------------------------------------------------------------------------------
  377. static const nodedef PNGFile =
  378. {
  379. 0, // parent size
  380. PNG_FILE_ID,
  381. RAWIMAGE_CLASS,
  382. PRI_DEFAULT,
  383. };
  384. //---------------------------------------------------------------------------------------------
  386. void PNG_Init()
  387. {
  388. NodeRegisterClass(&PNG);
  389. NodeRegisterClass(&PNGFile);
  390. }
  392. void PNG_Done()
  393. {
  394. NodeUnRegisterClass(PNG_ID);
  395. NodeUnRegisterClass(PNG_FILE_ID);
  396. }