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

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

Windows CE

开发平台：

C/C++

mjpeg.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: mjpeg.c 603 2006-01-19 13:00:33Z 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 "mjpeg.h"
  27. #define WEBMJEG_READSIZE 2048
  28. #define VLC_BITS 9
  30. typedef struct blockindex
  31. {
  32. uint8_t quant;
  33. uint8_t comp;
  34. uint8_t ac;
  35. uint8_t dc;
  36. } blockindex;
  38. typedef struct mjpeg 
  39. {
  40. codecidct Codec;
  42. bool_t error;
  43. int sos_no;
  44. int restart_interval;
  45. int restart_count;
  46. idct_block_t* blockptr;
  48. // bitstream
  49. bitstream s;
  50. vlc* v[2][4];
  51. int vsize[2][4];
  52.     uint8_t quant[4][64];
  54. int hblock[4];
  55. int vblock[4];
  56. int compid[4];
  57. int quantidx[4];
  59. int Ss;
  60. int Se;
  61. int Al;
  62. int Ah;
  64. int blocks;
  65. int mb_width;
  66. int mb_height;
  67. int last_dc[4];
  68. int comp;
  69. bool_t progressive;
  70. int startstate;
  72. blockindex *indexend;
  73. blockindex index[4*2*2];
  74. uint8_t zigzag[64];
  75. IDCT_BLOCK_DECLARE
  77. } mjpeg;
  79. static const uint8_t zigzag[64] = 
  80. {
  81.  0,  1,  8, 16,  9,  2,  3, 10, 
  82. 17, 24, 32, 25, 18, 11,  4,  5,
  83. 12, 19, 26, 33, 40, 48, 41, 34, 
  84. 27, 20, 13,  6,  7, 14, 21, 28, 
  85. 35, 42, 49, 56, 57, 50, 43, 36, 
  86. 29, 22, 15, 23, 30, 37, 44, 51, 
  87. 58, 59, 52, 45, 38, 31, 39, 46, 
  88. 53, 60, 61, 54, 47, 55, 62, 63
  89. };
  91. static const uint8_t dc_luminance[] =
  92. { 
  93. 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 
  94. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
  95. };
  96. static const uint8_t dc_chrominance[] =
  97. { 
  98. 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 
  99. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 
  100. };
  101. static const uint8_t ac_luminance[] =
  102. { 
  103. 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125, 
  104. 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  105. 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  106. 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  107. 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  108. 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  109. 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  110. 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  111. 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  112. 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  113. 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  114. 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  115. 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  116. 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  117. 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  118. 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  119. 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
  120. 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
  121. 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
  122. 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
  123. 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  124. 0xf9, 0xfa 
  125. };
  127. static const uint8_t ac_chrominance[] =
  128. { 
  129. 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119,
  130. 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
  131. 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
  132. 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
  133. 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
  134. 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
  135. 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
  136. 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
  137. 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  138. 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
  139. 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
  140. 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
  141. 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  142. 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
  143. 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
  144. 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
  145. 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
  146. 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
  147. 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
  148. 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
  149. 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  150. 0xf9, 0xfa 
  151. };
  153. static const uint8_t* const default_dht[4] =
  154. {
  155. dc_luminance,
  156. dc_chrominance,
  157. ac_luminance,
  158. ac_chrominance
  159. };
  161. DECLARE_BITINIT
  162. DECLARE_BITLOAD
  164. #undef bitload_pos
  165. #define bitload_pos(p, bitpos)
  166. bitpos -= 8;
  167. if (bitpos >= 0) {
  168. int bits = (p)->bits;
  169. const uint8_t* bitptr = (p)->bitptr;
  170. do {
  171. bits = (bits << 8) | *bitptr;
  172. if (*bitptr++ == 0xFF)
  173. {
  174. while (*bitptr==0xFF && bitptr<(p)->bitend) 
  175. bitptr++;
  176. if (*bitptr==0)
  177. ++bitptr;
  178. }
  179. bitpos -= 8;
  180. } while (bitpos>=0);
  181. (p)->bits = bits;
  182. (p)->bitptr = bitptr;
  183. }
  184. bitpos += 8;
  187. static NOINLINE int NotSupported(mjpeg* p)
  188. {
  189. if (!p->error)
  190. {
  191. p->error = 1;
  192. ShowError(p->Codec.Node.Class,MJPEG_ID,MJPEG_NOT_SUPPORTED);
  193. }
  194. return ERR_NOT_SUPPORTED;
  195. }
  197. static NOINLINE bool_t VLC(vlc** tab, int* size, const uint8_t *data) 
  198. {
  199. uint32_t huffcode[256];
  200. uint16_t huffdata[256];
  201. int i,j,k,n,code;
  203. code = 0;
  204. k = 0;
  205. for (i=1;i<=16;i++) 
  206. {
  207. n = data[i];
  208. for (j=0;j<n;j++) 
  209. {
  210. huffcode[k] = ((code++)<<5)|i;
  211. huffdata[k] = data[k+17];
  212. ++k;
  213. }
  214. code <<= 1;
  215. }
  217.     return vlcinit(tab,size,huffcode,4,huffdata,k,0,VLC_BITS);
  218. }
  220. static int DQT(mjpeg* p)
  221. {
  222.     int len = bitget(&p->s,16) - 2;
  223.     while (len >= 65 && !biteof(&p->s)) 
  224. {
  225. int comp,i;
  227. bitload(&p->s);
  228.         if (bitget(&p->s,4) != 0)
  229. return NotSupported(p); // 16bit prec
  231.         comp = bitget(&p->s, 4);
  232.         if (comp >= 4)
  233.             return ERR_INVALID_DATA;
  235.         for (i=0;i<64;i++) 
  236. {
  237. bitload(&p->s);
  238. p->quant[comp][i] = (uint8_t)bitget(&p->s,8);
  239. }
  241.         len -= 65;
  242.     }
  243.     
  244.     return ERR_NONE;
  245. }
  247. static int DHT(mjpeg* p)
  248. {
  249.     uint8_t data[17+256];
  250.     int len = bitget(&p->s,16)-2;
  252.     while (len>=17 && !biteof(&p->s)) 
  253. {
  254. int n,i;
  255. int comp,idx;
  257. bitload(&p->s);
  258.         comp = bitget(&p->s,4);
  259.         if (comp >= 2)
  260. break;
  262.         idx = bitget(&p->s,4);
  263.         if (idx >= 4)
  264. break;
  266.         n = 0;
  267.         for (i=1;i<=16;i++) 
  268. {
  269. bitload(&p->s);
  270.             data[i] = (uint8_t) bitget(&p->s,8);
  271.             n += data[i];
  272.         }
  274.         len -= 17+n;
  275.         if (len<0 || n>256)
  276. break;
  278.         for (i=0;i<n;i++) 
  279. {
  280. bitload(&p->s);
  281.             data[17+i] = (uint8_t) bitget(&p->s,8);
  282. }
  284. if (!VLC(&p->v[comp][idx],&p->vsize[comp][idx],data))
  285. return ERR_NONE;
  286.     }
  287. return ERR_NONE;
  288. }
  290. static int DRI(mjpeg* p)
  291. {
  292.     if (bitget(&p->s,16) == 4)
  293. {
  294. bitload(&p->s);
  295.     p->restart_interval = bitget(&p->s,16);
  296. }
  297. return ERR_NONE;
  298. }
  300. static int SOF(mjpeg* p,bool_t progressive)
  301. {
  302.     int len,i,width,height,mode;
  304. p->progressive = progressive;
  306.     len = bitget(&p->s,16);
  308. bitload(&p->s);
  309.     if (bitget(&p->s,8) != 8) // 8bit/component
  310. return NotSupported(p);
  311.     
  312.     height = bitget(&p->s,16);
  313. bitload(&p->s);
  314.     width = bitget(&p->s,16);
  315.     p->comp = bitget(&p->s,8);
  317.     if (p->comp != 3 && p->comp != 1) // 3 or 1 components
  318. return NotSupported(p);
  320. if (len != 8+3*p->comp)
  321. return ERR_INVALID_DATA;
  323. p->blocks = 0;
  324.     for (i=0;i<p->comp;i++) 
  325. {
  326. bitload(&p->s);
  328.         p->compid[i] = bitget(&p->s,8);
  329.         p->hblock[i] = bitget(&p->s,4);
  330.         p->vblock[i] = bitget(&p->s,4);
  331.         p->quantidx[i] = bitget(&p->s,8);
  332.         if (p->quantidx[i] >= 4)
  333.             return ERR_INVALID_DATA;
  334. if (i>0 && (p->hblock[i]!=1 || p->vblock[i]!=1))
  335. return NotSupported(p);
  336. p->blocks += p->hblock[i] * p->vblock[i];
  337.     }
  339. p->indexend = p->index + p->blocks;
  341. switch (16*p->vblock[0]+p->hblock[0])
  342. {
  343. case 0x11:
  344. mode = PF_YUV444;
  345. p->mb_width  = (width + 7) >> 3;
  346. p->mb_height = (height + 7) >> 3;
  347. break;
  348. case 0x12:
  349. mode = PF_YUV422;
  350. p->mb_width  = (width + 15) >> 4;
  351. p->mb_height = (height + 7) >> 3;
  352. break;
  353. case 0x22:
  354. mode = PF_YUV420;
  355. p->mb_width  = (width + 15) >> 4;
  356. p->mb_height = (height + 15) >> 4;
  357. break;
  358. default:
  359. return NotSupported(p);
  360. }
  362. return CodecIDCTSetFormat(&p->Codec,mode|PF_YUV_PC,width,height,width,height,p->Codec.In.Format.Format.Video.Aspect);
  363. }
  365. static NOINLINE void scan(mjpeg* p)
  366. {
  367. idct* IDCT = p->Codec.IDCT.Ptr;
  368.     int x,y,bitpos;
  369. blockindex* i; 
  371. p->restart_count = p->restart_interval;
  372. bitpos = p->s.bitpos;
  374.     for (y=0;y<p->mb_height;++y)
  375.         for (x=0;x<p->mb_width;++x)
  376. {
  377. IDCT->Process(IDCT,x,y);
  379.             for (i=p->index;i!=p->indexend;i++)
  380. {
  381. int len,val,n;
  382. idct_block_t* block = p->blockptr; 
  383. uint8_t* quant = p->quant[i->quant];
  384. vlc* tab = p->v[0][i->dc]; 
  386. if (biteof(&p->s))
  387. break;
  389. ClearBlock(block);
  391. vlcget2_pos(val,tab,&p->s,bitpos,n,255,VLC_BITS);
  392. if (val)
  393. {
  394. bitload_pos(&p->s,bitpos);
  395. bitgetx_pos(&p->s,bitpos,val,n);
  396. }
  398. val = val * quant[0] + p->last_dc[i->comp];
  399. p->last_dc[i->comp] = val;
  400. block[0] = (idct_block_t)val;
  402. tab = p->v[1][i->ac];
  403. len = 1;
  404. for (;;)
  405. {
  406. vlcget2_pos(val,tab,&p->s,bitpos,n,255,VLC_BITS);
  407. if (!val)
  408. break;
  409. if (val == 0xF0) 
  410. {
  411. len += 16;
  412. if (len>=64)
  413. break;
  414. }
  415. else
  416. {
  417. n = val >> 4;
  418. val &= 15;
  419. len += n;
  420. bitload_pos(&p->s,bitpos);
  421. bitgetx_pos(&p->s,bitpos,val,n);
  422. n = len & 63;
  423. val *= quant[n];
  424. n = p->zigzag[n];
  425. block[n] = (idct_block_t)val;
  426. if (++len>=64)
  427. break;
  428. }
  429. }
  431. IDCT->Intra8x8(IDCT,block,len,IDCTSCAN_ZIGZAG);
  432.             }
  434. if (p->comp == 1)
  435. {
  436. idct_block_t* block = p->blockptr; 
  438. ClearBlock(block);
  439. block[0] = 1024;
  440. IDCT->Intra8x8(IDCT,block,1,IDCTSCAN_ZIGZAG);
  442. ClearBlock(block);
  443. block[0] = 1024;
  444. IDCT->Intra8x8(IDCT,block,1,IDCTSCAN_ZIGZAG);
  445. }
  447.             if (p->restart_interval && !--p->restart_count) 
  448. {
  449.                 p->restart_count = p->restart_interval;
  450. p->last_dc[0] = p->last_dc[1] = p->last_dc[2] = 1024;
  452.                 bitbytealign_pos(&p->s,bitpos);
  453. bitflush_pos(&p->s,bitpos,16);
  454. bitload_pos(&p->s,bitpos);
  455.             }
  456.         }
  458. p->s.bitpos = bitpos;
  459. }
  461. static int SOS(mjpeg* p)
  462. {
  463. const uint8_t *pos;
  464. int i,j,comp,len,result;
  466.     len = bitget(&p->s,16);
  467.     comp = bitget(&p->s,8);
  468.     if (len != 6+2*comp)
  469. return ERR_INVALID_DATA;
  471. if (p->comp != comp)
  472. return NotSupported(p);
  474. j=0;
  475.     for (i=0;i<comp;i++) 
  476. {
  477. int n,dc,ac;
  478. bitload(&p->s);
  480.         if (p->compid[i] != bitget(&p->s,8))
  481. return NotSupported(p);
  483.         dc = bitget(&p->s,4);
  484.         ac = bitget(&p->s,4);
  486. if (dc >= 4 || ac >= 4)
  487. return ERR_INVALID_DATA;
  489. for (n=p->hblock[i]*p->vblock[i];n;--n,++j)
  490. {
  491. p->index[j].quant=(uint8_t)p->quantidx[i];
  492. p->index[j].comp=(uint8_t)i;
  493. p->index[j].ac=(uint8_t)ac;
  494. p->index[j].dc=(uint8_t)dc;
  495. }
  496.     }
  498. bitload(&p->s);
  499.     p->Ss = bitget(&p->s,8); // Ss
  500.     p->Se = bitget(&p->s,8); // Se
  502. bitload(&p->s);
  503.     p->Ah = bitget(&p->s,4); // Ah
  504.     p->Al = bitget(&p->s,4); // Al
  506. p->last_dc[0] = p->last_dc[1] = p->last_dc[2] = 1024;
  508. if (!p->sos_no)
  509. {
  510. result = p->Codec.IDCT.Ptr->FrameStart(p->Codec.IDCT.Ptr,0,NULL,0,-1,-1,0,0);
  511. if (result != ERR_NONE)
  512. return result;
  513. p->Codec.Show = 0;
  514. }
  516. pos = bitbytepos(&p->s);
  517. bitinit(&p->s,pos,bitendptr(&p->s)-pos);
  519. ++p->sos_no;
  520.     scan(p);
  522. return ERR_NONE;
  523. }
  525. static int APP(mjpeg* p)
  526. {
  527.     int n = bitget(&p->s,16);
  528.     if (n>6)
  529.     bitflush(&p->s,n*8-16);
  530. return ERR_NONE;
  531. }
  533. static int Frame(mjpeg* p, const uint8_t* ptr, int num)
  534. {
  535. int Result = ERR_NONE;
  536. int code,v;
  538. if (p->Codec.State.DropLevel)
  539. return p->Codec.IDCT.Ptr->Null(p->Codec.IDCT.Ptr,NULL,0);
  541. p->sos_no = 0;
  542. p->progressive = 0;
  544. do
  545. {
  546. for (;;)
  547. {
  548. if (num < 2) 
  549. {
  550. code = 0xD9;
  551. break;
  552. }
  554. v = *ptr++;
  555. --num;
  556. if ((v == 0xFF) && (*ptr >= 0xC0) && (*ptr <= 0xFE)) 
  557. {
  558. code = *ptr++;
  559. --num;
  560. break;
  561. }
  562. }
  564. if (code == 0xD9)  // end of image
  565. break;
  567. bitinit(&p->s,ptr,num);
  568. bitload(&p->s);
  569.         switch(code) 
  570. {
  571.         case 0xD8: // start of image
  572.     p->restart_interval = 0;
  573. break;
  574. case 0xDD: // define restart interval
  575.     Result = DRI(p);
  576.     break;
  577.         case 0xDB: // define quantization tables
  578. Result = DQT(p);
  579. break;
  580. case 0xC4: // define huffman tables
  581. Result = DHT(p);
  582. break;
  583. case 0xC0: // baseline, huffman
  584.             Result = SOF(p,0);
  585. break;
  586. case 0xC2: // progressive, huffman
  587. if (!p->error)
  588. {
  589. p->error = 1;
  590. ShowError(p->Codec.Node.Class,MJPEG_ID,MJPEG_PROGRESSIVE);
  591. }
  592. Result = ERR_NOT_SUPPORTED;
  593. //todo... Result = SOF(p,1);
  594. break;
  595. case 0xDA:  // start of scan
  596. if (!p->sos_no || p->progressive)
  597.             Result = SOS(p);
  598. continue;
  600. case 0xE0:
  601. case 0xE1:
  602. case 0xE2:
  603. case 0xE3:
  604. case 0xE4:
  605. case 0xE5:
  606. case 0xE6:
  607. case 0xE7:
  608. case 0xE8:
  609. case 0xE9:
  610. case 0xEA:
  611. case 0xEB:
  612. case 0xEC:
  613. case 0xED:
  614. case 0xEE:
  615. case 0xEF:
  616. Result = APP(p);
  617. break;
  619. case 0xC1: // extended sequential, huffman
  620. case 0xC3: // lossless, huffman
  621. case 0xC5: // differential sequential, huffman
  622. case 0xC6: // differential progressive, huffman
  623. case 0xC7: // differential lossless, huffman
  624. case 0xC9: // extended sequential, arithmetic
  625. case 0xCA: // progressive, arithmetic
  626. case 0xCB: // lossless, arithmetic
  627. case 0xCD: // differential sequential, arithmetic
  628. case 0xCE: // differential progressive, arithmetic
  629. case 0xCF: // differential lossless, arithmetic
  630. case 0xC8: // reserved
  631. Result = NotSupported(p);
  632. break;
  633.         }
  635. v = bitbytepos(&p->s) - ptr;
  636. ptr += v;
  637. num -= v;
  638.     }
  639. while (Result == ERR_NONE);
  641. if (p->sos_no)
  642. p->Codec.IDCT.Ptr->FrameEnd(p->Codec.IDCT.Ptr);
  644. return Result;
  645. }
  647. static int Flush(mjpeg* p)
  648. {
  649. p->startstate = 0;
  650. return ERR_NONE;
  651. }
  653. static bool_t FindNext(mjpeg* p)
  654. {
  655. const uint8_t* Ptr = p->Codec.Buffer.Data;
  656. int Len = p->Codec.Buffer.WritePos;
  657. int Pos = p->Codec.FrameEnd;
  659. for (;Pos<Len;++Pos)
  660. {
  661. uint8_t ch = Ptr[Pos];
  662. bool_t Valid;
  664. switch (p->startstate)
  665. {
  666. case -1:
  667. Valid = 0;
  668. break;
  669. case 1:
  670. Valid = ch == 0xD8;
  671. break;
  672. case 3:
  673. Valid = (ch >= 0xC0) && (ch <= 0xFE);
  674. break;
  675. default:
  676. Valid = ch == 0xFF;
  677. break;
  678. }
  679. if (!Valid)
  680. p->startstate = 0;
  681. else
  682. if (++p->startstate == 4)
  683. {
  684. p->Codec.FrameEnd = Pos-3;
  685. p->startstate = -1;
  686. return 1;
  687. }
  688. }
  690. p->Codec.FrameEnd = Pos;
  691. return 0;
  692. }
  694. static int UpdateInput(mjpeg* p)
  695. {
  696. int i,j;
  697. int Result = ERR_NONE;
  699. p->error = 0;
  700. IDCT_BLOCK_PREPARE(p,p->blockptr);
  701. memcpy(p->zigzag,zigzag,sizeof(zigzag));
  703. for (i=0;i<2;++i)
  704. for (j=0;j<4;++j)
  705. vlcdone(&p->v[i][j],&p->vsize[i][j]);
  707. if (p->Codec.In.Format.Type == PACKET_VIDEO)
  708. {
  709. Result = CodecIDCTSetFormat(&p->Codec,PF_YUV422|PF_YUV_PC,p->Codec.In.Format.Format.Video.Width,p->Codec.In.Format.Format.Video.Height,
  710.               p->Codec.In.Format.Format.Video.Width,p->Codec.In.Format.Format.Video.Height,
  711. p->Codec.In.Format.Format.Video.Aspect);
  712. if (Result == ERR_NONE)
  713. {
  714. for (i=0;i<2;++i)
  715. for (j=0;j<2;++j)
  716. if (!VLC(&p->v[i][j],&p->vsize[i][j],default_dht[i*2+j]))
  717. Result = ERR_OUT_OF_MEMORY;
  719. if (p->Codec.In.Format.PacketRate.Num>0)
  720. p->Codec.FrameTime = Scale(TICKSPERSEC,p->Codec.In.Format.PacketRate.Den,p->Codec.In.Format.PacketRate.Num);
  721. else
  722. p->Codec.FrameTime = 0;
  723. }
  724. }
  726. return Result;
  727. }
  729. static int Create(mjpeg* p)
  730. {
  731. p->Codec.MinCount = 1;
  732. p->Codec.Frame = (codecidctframe)Frame;
  733. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  734. p->Codec.FindNext = (codecidctnext)FindNext;
  735. p->Codec.Flush = (nodefunc)Flush;
  736. return ERR_NONE;
  737. }
  739. static const nodedef MJPEG =
  740. {
  741. sizeof(mjpeg),
  742. MJPEG_ID,
  743. CODECIDCT_CLASS,
  744. PRI_DEFAULT,
  745. (nodecreate)Create,
  746. NULL,
  747. };
  749. //-------------------------------------------------------------------------------------------
  751. static const nodedef JPEG =
  752. {
  753. 0, // parent size
  754. JPEG_ID,
  755. RAWIMAGE_CLASS,
  756. PRI_DEFAULT,
  757. };
  759. //---------------------------------------------------------------------------------------------
  761. typedef struct webmjpeg
  762. {
  763. format_base Format;
  765. } webmjpeg;
  767. static int WEBMJPEGInit(rawaudio* p)
  768. {
  769. format_stream* s = Format_AddStream(&p->Format,sizeof(format_stream));
  770. if (s)
  771. {
  772. PacketFormatClear(&s->Format);
  773. s->Format.Type = PACKET_VIDEO;
  774. s->Format.Format.Video.Pixel.Flags = PF_FOURCC|PF_FRAGMENTED;
  775. s->Format.Format.Video.Pixel.FourCC = FOURCC('J','P','E','G');
  776. s->PacketBurst = 1;
  777. s->Fragmented = 1;
  778. s->DisableDrop = 1;
  779. Format_PrepairStream(&p->Format,s);
  780. }
  781. p->Format.HeaderLoaded = 1;
  782. p->Format.ProcessMinBuffer = 0;
  783. p->Format.ReadSize = WEBMJEG_READSIZE;
  784. return ERR_NONE;
  785. }
  787. static int WEBMJPEGPacket(rawaudio* p, format_reader* Reader, format_packet* Packet)
  788. {
  789. format_stream* Stream = p->Format.Streams[0];
  791. if (Reader->FilePos<=0)
  792. Packet->RefTime = 0;
  793. else
  794. Packet->RefTime = TIME_UNKNOWN;
  795. Packet->Data = Reader->ReadAsRef(Reader,-WEBMJEG_READSIZE);
  796. Packet->Stream = Stream;
  798. if (Stream->LastTime < TIME_UNKNOWN)
  799. Stream->LastTime = TIME_UNKNOWN;
  801. return ERR_NONE;
  802. }
  804. static int WEBMJPEGSeek(rawaudio* p, tick_t Time, filepos_t FilePos,bool_t PrevKey)
  805. {
  806. if (Time==0 || FilePos==0)
  807. p->Format.Reader->Seek(p->Format.Reader,0,SEEK_SET);
  808. return ERR_NONE;
  809. }
  811. static int WEBMJPEGCreate(rawaudio* p)
  812. {
  813. p->Format.Init = (fmtfunc)WEBMJPEGInit;
  814. p->Format.Seek = (fmtseek)WEBMJPEGSeek;
  815. p->Format.ReadPacket = (fmtreadpacket)WEBMJPEGPacket;
  816. return ERR_NONE;
  817. }
  819. static const nodedef WEBMJPEG =
  820. {
  821. sizeof(webmjpeg),
  822. WEB_MJPEG_ID,
  823. FORMATBASE_CLASS,
  824. PRI_DEFAULT,
  825. (nodecreate)WEBMJPEGCreate,
  826. NULL,
  827. };
  829. //---------------------------------------------------------------------------------------------
  831. void MJPEG_Init()
  832. {
  833. NodeRegisterClass(&MJPEG);
  834. NodeRegisterClass(&JPEG);
  835. NodeRegisterClass(&WEBMJPEG);
  836. }
  838. void MJPEG_Done()
  839. {
  840. NodeUnRegisterClass(MJPEG_ID);
  841. NodeUnRegisterClass(JPEG_ID);
  842. NodeUnRegisterClass(WEB_MJPEG_ID);
  843. }