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

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

Windows CE

开发平台：

C/C++

tiff.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: tiff.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 "tiff.h"
  28. DECLARE_BITINIT
  29. DECLARE_BITLOAD
  31. typedef struct tiff
  32. {
  33. codec Codec;
  34. buffer Buffer;
  36. bool_t ErrorShowed;
  37. bool_t BigEndian;
  38. const uint8_t* Ptr;
  40. int BitCount;
  41. int BytesPerRow;
  42. int BytesPerRow2;
  43. int Planar;
  44. int Channels;
  45. int Left;
  46. bool_t Reverse;
  48. } tiff;
  50. static int UpdateInput(tiff* p)
  51. {
  52. p->ErrorShowed = 0;
  53. BufferClear(&p->Buffer);
  54. if (p->Codec.In.Format.Type == PACKET_VIDEO)
  55. {
  56. PacketFormatCopy(&p->Codec.Out.Format,&p->Codec.In.Format);
  57. p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_RGB;
  58. p->Codec.Out.Format.Format.Video.Pixel.BitCount = 24;
  59. p->Codec.Out.Format.Format.Video.Pixel.BitMask[0] = 0xFF;
  60. p->Codec.Out.Format.Format.Video.Pixel.BitMask[1] = 0xFF00;
  61. p->Codec.Out.Format.Format.Video.Pixel.BitMask[2] = 0xFF0000;
  62. DefaultPitch(&p->Codec.Out.Format.Format.Video);
  63. }
  64. return ERR_NONE;
  65. }
  67. static NOINLINE int Read32(tiff* p)
  68. {
  69. int v;
  70. if (p->BigEndian)
  71. v = LOAD32BE(p->Ptr);
  72. else
  73. v = LOAD32LE(p->Ptr);
  74. p->Ptr += 4;
  75. return v;
  76. }
  78. static NOINLINE int Read16(tiff* p)
  79. {
  80. int v;
  81. if (p->BigEndian)
  82. v = LOAD16BE(p->Ptr);
  83. else
  84. v = LOAD16LE(p->Ptr);
  85. p->Ptr += 2;
  86. return v;
  87. }
  89. static NOINLINE int ReadVal(tiff* p,int Type)
  90. {
  91. switch (Type)
  92. {
  93. case 1: return *(p->Ptr++);
  94. case 3: return Read16(p);
  95. case 4: return Read32(p);
  96. }
  97. return 0;
  98. }
  100. static NOINLINE int NotSupported(tiff* p)
  101. {
  102. if (!p->ErrorShowed)
  103. {
  104. p->ErrorShowed = 1;
  105. ShowError(p->Codec.Node.Class,TIFF_ID,TIFF_NOT_SUPPORTED);
  106. }
  107. return ERR_NOT_SUPPORTED;
  108. }
  110. static NOINLINE void Write(tiff* p,const uint8_t* Data,int Size)
  111. {
  112. int n,i,j;
  113. if (p->Planar == 1)
  114. {
  115. while (Size>0)
  116. {
  117. if (!p->Left)
  118. p->Left = p->BytesPerRow;
  119. n = min(p->Left,Size);
  120. Size -= n;
  121. p->Left -= n;
  122. switch (p->BitCount)
  123. {
  124. case 1:
  125. j = n*8;
  126. if (!p->Left)
  127. j -= 8*p->BytesPerRow - p->BytesPerRow2;
  128. for (i=0;i<j;++i)
  129. p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>3] >> (7-(i&7))) & 1);
  130. break;
  131. case 2:
  132. j = n*4;
  133. if (!p->Left)
  134. j -= 4*p->BytesPerRow - p->BytesPerRow2;
  135. for (i=0;i<j;++i)
  136. p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>2] >> (6-2*(i&3))) & 3);
  137. break;
  138. case 4:
  139. j = n*2;
  140. if (!p->Left)
  141. j -= 2*p->BytesPerRow - p->BytesPerRow2;
  142. for (i=0;i<j;++i)
  143. p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>1] >> (4-4*(i&1))) & 15);
  144. break;
  145. default:
  146. memcpy(p->Buffer.Data + p->Buffer.WritePos,Data,n);
  147. p->Buffer.WritePos += n;
  148. break;
  149. }
  150. Data += n;
  151. if (!p->Left)
  152. p->Buffer.WritePos += p->Codec.Out.Format.Format.Video.Pitch - p->BytesPerRow2;
  153. }
  154. }
  155. else
  156. {
  157. while (Size>0)
  158. {
  159. if (!p->Left)
  160. p->Left = p->BytesPerRow;
  161. n = min(p->Left,Size);
  162. Size -= n;
  163. p->Left -= n;
  164. while (--n>=0)
  165. {
  166. p->Buffer.Data[p->Buffer.WritePos] = *(++Data);
  167. p->Buffer.WritePos += p->Channels;
  168. }
  169. if (!p->Left)
  170. p->Buffer.WritePos += p->Codec.Out.Format.Format.Video.Pitch - p->BytesPerRow*p->Channels;
  171. }
  172. }
  173. }
  175. static void Inflate(tiff *p,const uint8_t* Data,int Size,int Total)
  176. {
  177. int i,n;
  178. z_stream Inflate;
  179. uint8_t Buffer[4096];
  181. memset(&Inflate,0,sizeof(Inflate));
  182.     if (inflateInit2(&Inflate, MAX_WBITS) == Z_OK)
  183. {
  184. Inflate.next_in = (Bytef*)Data;
  185. Inflate.avail_in = Size;
  187. do
  188. {
  189. Inflate.next_out = Buffer;
  190. Inflate.avail_out = sizeof(Buffer);
  192. i = inflate(&Inflate, Z_SYNC_FLUSH);
  194. n = sizeof(Buffer) - Inflate.avail_out;
  195. if (n>Total)
  196. n=Total;
  197. Write(p,Buffer,n);
  198. Total -= n;
  200. } while (i>=0 && i!=Z_STREAM_END && Total>0);
  202. inflateEnd(&Inflate);
  203. }
  204. }
  206. /*
  207. static void Fax3(tiff *p,const uint8_t* Data,int Size,int Total)
  208. {
  209. //todo
  210. }
  211. */
  213. static void LZW(tiff *p,const uint8_t* Data,int Size)
  214. {
  215. bitstream bs;
  216. uint16_t Prefix[4096];
  217. uint8_t Suffix[4096];
  218. uint8_t Stack[4096];
  219. uint8_t FirstChar;
  220. int ClearCode = 256;
  221. int EOICode = ClearCode+1;
  222. int FreeCode = ClearCode+2;
  223. int OldCode = -1;
  224. int CodeSize = 9;
  225. int i;
  227. for (i=0;i<ClearCode;++i)
  228. Suffix[i] = (uint8_t)i;
  230. FirstChar = 0;
  231. bitinit(&bs,Data,Size);
  233. while (!biteof(&bs))
  234. {
  235. uint8_t* StackPtr;
  236. int Code;
  237. bitload(&bs);
  238. Code = bitget(&bs,CodeSize);
  240. if (Code == EOICode)
  241. break;
  243. if (Code == ClearCode)
  244. {
  245. CodeSize = 9;
  246. FreeCode = ClearCode + 2;
  247. OldCode = -1;
  248. continue;
  249. }
  251. if (Code > FreeCode)
  252. break;
  254. if (OldCode<0)
  255. {
  256. FirstChar = Suffix[Code];
  257. Write(p,&FirstChar,1);
  258. OldCode = Code;
  259. continue;
  260. }
  262. StackPtr = Stack+sizeof(Stack);
  263. i = Code;
  265. if (i == FreeCode)
  266. {
  267. *(--StackPtr) = FirstChar;
  268. i = OldCode;
  269. }
  271. while (i>ClearCode)
  272. {
  273. *(--StackPtr) = Suffix[i];
  274. i = Prefix[i];
  275. }
  277. FirstChar = Suffix[i];
  278. *(--StackPtr) = FirstChar;
  280. Prefix[FreeCode] = (uint16_t)OldCode;
  281. Suffix[FreeCode] = FirstChar;
  282. if (FreeCode < 4096) ++FreeCode;
  284. if (CodeSize<12 && FreeCode == (1<<CodeSize)-1)
  285. ++CodeSize;
  287. OldCode = Code;
  288. Write(p,StackPtr,Stack+sizeof(Stack)-StackPtr);
  289. }
  290. }
  292. static int Process(tiff* p, const packet* Packet, const flowstate* State)
  293. {
  294. int n,Compress;
  295. size_t IFD;
  296. int RowPerStrip;
  297. video Video;
  298. const uint8_t *Strips;
  299. rgb Pal[256];
  300. int StripsType,StripsLen;
  301. int Bits[3];
  302. int BitCount;
  303. int h,ch;
  304. int i,j,k;
  306. if (!Packet)
  307. return ERR_NEED_MORE_DATA;
  309. p->Ptr = Packet->Data[0];
  311. if (Packet->Length<8)
  312. return ERR_INVALID_DATA;
  314. if (p->Ptr[0]=='M' && p->Ptr[1]=='M')
  315. p->BigEndian = 1;
  316. else
  317. if (p->Ptr[0]=='I' && p->Ptr[1]=='I')
  318. p->BigEndian = 0;
  319. else
  320. return ERR_INVALID_DATA;
  321. p->Ptr += 2;
  323. if (Read16(p) != 42)
  324. return ERR_INVALID_DATA;
  326. IFD = Read32(p);
  327. if (IFD<8 || IFD+2+4 >= Packet->Length)
  328. return ERR_INVALID_DATA;
  330. p->Reverse = 0;
  331. RowPerStrip = MAX_INT;
  332. memset(&Video,0,sizeof(Video));
  333. p->Planar = 1;
  334. p->Channels = 0;
  335. Compress = 1;
  336. Strips = NULL;
  337. StripsType = 0;
  338. StripsLen = 0;
  339. BitCount = 0;
  340. Video.Pixel.Flags = PF_RGB;
  341. Video.Aspect = ASPECT_ONE; //todo
  343. for (i=0;i<256;++i)
  344. Pal[i].v = CRGB(i,i,i);
  346. p->Ptr = (const uint8_t*)Packet->Data[0]+IFD;
  347. n = Read16(p);
  348. while (--n>=0)
  349. {
  350. const uint8_t* Save = p->Ptr+12;
  351. int Tag = Read16(p);
  352. int Type = Read16(p);
  353. int Len = Read32(p);
  354. size_t Pos = Read32(p);
  356. switch (Type)
  357. {
  358. case 1: 
  359. case 2: i=1; break;
  360. case 3: i=2; break;
  361. case 4: i=4; break;
  362. case 5: i=8; break;
  363. default: i=0; break;
  364. }
  366. i *= Len;
  367. if (i<=4)
  368. p->Ptr -= 4;
  369. else
  370. {
  371. if (Pos > Packet->Length-i)
  372. continue;
  373. p->Ptr = (const uint8_t*)Packet->Data[0]+Pos;
  374. }
  376. // read integer
  377. i = 0;
  378. if (Len==1) 
  379. switch (Type)
  380. {
  381. case 1: i=p->Ptr[0]; break;
  382. case 3: i=Read16(p); p->Ptr-=2; break;
  383. case 4: i=Read32(p); p->Ptr-=4; break;
  384. }
  387. switch (Tag)
  388. {
  389. case 0x100:
  390. Video.Width = i;
  391. break;
  393. case 0x101:
  394. Video.Height = i;
  395. break;
  397. case 0x102: 
  398. if (Len>3)
  399. return NotSupported(p);
  401. p->Channels = Len;
  402. BitCount = 0;
  403. for (i=0;i<Len;++i)
  404. {
  405. Bits[i] = ReadVal(p,Type);
  406. Video.Pixel.BitMask[i] = ((1 << Bits[i])-1) << BitCount;
  407. BitCount += Bits[i];
  408. }
  409. p->BitCount = BitCount;
  410. Video.Pixel.BitCount = BitCount;
  411. if (Video.Pixel.BitCount==1 ||
  412. Video.Pixel.BitCount==2 ||
  413. Video.Pixel.BitCount==4)
  414. {
  415. int n = 1<<BitCount;
  416. for (i=0;i<n;++i)
  417. {
  418. int j = (255*i)/(n-1);
  419. Pal[i].v = CRGB(j,j,j);
  420. }
  421. Video.Pixel.BitCount=8;
  422. }
  424. if (Video.Pixel.BitCount & 7) // only 1,2,4,8,16,24,32 bitdepth supported
  425. return NotSupported(p);
  426. break;
  428. case 0x103:
  429. Compress = i;
  430. break;
  432. case 0x106:
  433. switch (i)
  434. {
  435. case 0: // invert grayscale
  436. Video.Pixel.Flags = PF_GRAYSCALE|PF_PALETTE;
  437. for (i=0;i<256;++i)
  438. Pal[i].v ^= CRGB(255,255,255);
  439. break;
  440. case 1: // grayscale
  441. Video.Pixel.Flags = PF_GRAYSCALE|PF_PALETTE;
  442. break;
  443. case 2: // rgb
  444. Video.Pixel.Flags = PF_RGB;
  445. break;
  446. case 3: // palette
  447. Video.Pixel.Flags = PF_PALETTE;
  448. break;
  449. }
  450. break;
  452. case 0x10A: // fill order
  453. p->Reverse = i==2;
  454. break;
  456. case 0x111: // strip offsets
  457. Strips = p->Ptr;
  458. StripsType = Type;
  459. StripsLen = Len;
  460. break;
  462. case 0x116: 
  463. RowPerStrip = i; 
  464. break;
  466. case 0x11C:
  467. p->Planar = i;
  468. if (i != 1 && BitCount != p->Channels*8) // only 24,32 supported
  469. return NotSupported(p);
  470. break;
  472. case 0x15B:
  473. // jpeg tables
  474. break;
  476. case 0x140:
  477. Video.Pixel.Flags = PF_PALETTE;
  478. k = 1<<BitCount;
  479. if (Len >= 3*k)
  480. for (j=0;j<3;++j)
  481. for (i=0;i<k;++i)
  482. Pal[i].ch[j] = (uint8_t)(ReadVal(p,Type)>>8);
  483. break;
  484. }
  486. p->Ptr = Save;
  487. }
  489. if (!Strips || !Video.Width || !Video.Height || !p->Channels) 
  490. return ERR_INVALID_DATA; 
  492. if ((Video.Pixel.Flags & PF_PALETTE) && (p->Channels!=1 || Video.Pixel.BitCount!=8))
  493. return NotSupported(p);
  495. DefaultPitch(&Video);
  497. if (!EqVideo(&Video,&p->Codec.Out.Format.Format.Video))
  498. {
  499. if ((Video.Pixel.Flags & PF_PALETTE) && PacketFormatExtra(&p->Codec.Out.Format,sizeof(Pal)))
  500. {
  501. memcpy(p->Codec.Out.Format.Extra,Pal,sizeof(Pal));
  502. Video.Pixel.Palette = p->Codec.Out.Format.Extra;
  503. }
  504. p->Codec.In.Format.Format.Video.Width = Video.Width;
  505. p->Codec.In.Format.Format.Video.Height = Video.Height;
  506. p->Codec.Out.Format.Format.Video = Video;
  507. ConnectionUpdate(&p->Codec.Node,CODEC_OUTPUT,p->Codec.Out.Pin.Node,p->Codec.Out.Pin.No);
  508. }
  510. BufferDrop(&p->Buffer);
  511. if (!BufferAlloc(&p->Buffer,Video.Pitch*Video.Height,4096))
  512. return ERR_OUT_OF_MEMORY;
  514. p->Ptr = Strips;
  515. p->Left = 0;
  517. ch = 0;
  518. h = Video.Height;
  520. for (n=0;n<StripsLen && h>0;++n)
  521. {
  522. int Len,Pos,y;
  523. const uint8_t* Src;
  525. Pos = ReadVal(p,StripsType);
  526. Len = Packet->Length - Pos;
  527. if (Len <= 0)
  528. break;
  530. Src = (const uint8_t*)Packet->Data[0]+Pos;
  532. y = min(RowPerStrip,h);
  533. h -= y;
  535. if (p->Planar == 1)
  536. {
  537. p->BytesPerRow = ((BitCount*Video.Width + 7) >> 3);
  538. p->BytesPerRow2 = ((Video.Pixel.BitCount*Video.Width + 7) >> 3);
  539. }
  540. else
  541. p->BytesPerRow2 = p->BytesPerRow = ((Bits[ch] * Video.Width + 7) >> 3);
  543. switch (Compress)
  544. {
  545. case 1:
  546. Write(p,Src,p->BytesPerRow*y);
  547. break;
  549. // case 2: //rle
  550. // break;
  552. // case 3: //fax3
  553. // Fax3(p,Src,Len,p->BytesPerRow*y);
  554. // break;
  556. // case 4: //fax4
  557. // break;
  559. case 5:
  560. LZW(p,Src,Len);
  561. break; 
  563. case 8:
  564. case 32946: //zlib
  565. Inflate(p,Src,Len,p->BytesPerRow*y);
  566. break;
  568. default:
  569. return NotSupported(p);
  570. }
  572. if (p->Planar != 1 && h==0)
  573. {
  574. // next plane
  575. if (ch == p->Channels) break;
  576. h = Video.Height;
  577. p->Left = 0;
  578. p->Buffer.WritePos = ++ch;
  579. }
  580. }
  582. p->Codec.Packet.RefTime = Packet->RefTime;
  583. p->Codec.Packet.Length = p->Buffer.WritePos;
  584. p->Codec.Packet.Data[0] = p->Buffer.Data;
  585. return ERR_NONE;
  586. }
  588. static int Resend(tiff* p)
  589. {
  590. int Result = ERR_INVALID_DATA;
  591. if (p->Buffer.WritePos)
  592. {
  593. packet Packet;
  594. flowstate State;
  596. State.CurrTime = TIME_RESEND;
  597. State.DropLevel = 0;
  599. memset(&Packet,0,sizeof(Packet));
  600. Packet.RefTime = TIME_UNKNOWN;
  601. Packet.Length = p->Buffer.WritePos;
  602. Packet.Data[0] = p->Buffer.Data;
  604. Result = p->Codec.Out.Process(p->Codec.Out.Pin.Node,&Packet,&State);
  605. }
  606. return Result;
  607. }
  609. static int Flush(tiff* p)
  610. {
  611. BufferDrop(&p->Buffer);
  612. return ERR_NONE;
  613. }
  615. static int Create(tiff* p)
  616. {
  617. p->Codec.Process = (packetprocess)Process;
  618. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  619. p->Codec.ReSend = (nodefunc)Resend;
  620. p->Codec.Flush = (nodefunc)Flush;
  621. return ERR_NONE;
  622. }
  624. static const nodedef TIFF =
  625. {
  626. sizeof(tiff),
  627. TIFF_ID,
  628. CODEC_CLASS,
  629. PRI_DEFAULT,
  630. (nodecreate)Create,
  631. NULL,
  632. };
  634. //-------------------------------------------------------------------------------------------
  636. static const nodedef TIFFFile =
  637. {
  638. 0, // parent size
  639. TIFF_FILE_ID,
  640. RAWIMAGE_CLASS,
  641. PRI_DEFAULT,
  642. };
  643. //---------------------------------------------------------------------------------------------
  645. void TIFF_Init()
  646. {
  647. NodeRegisterClass(&TIFF);
  648. NodeRegisterClass(&TIFFFile);
  649. }
  651. void TIFF_Done()
  652. {
  653. NodeUnRegisterClass(TIFF_ID);
  654. NodeUnRegisterClass(TIFF_FILE_ID);
  655. }