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

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

Windows CE

开发平台：

C/C++

mpeg_decode.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: mpeg_decode.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.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "mpeg1.h"
  26. #include "mpeg_decode.h"
  27. #include "mpeg_stream.h"
  29. static _CONST uint8_t zigzag[64] = 
  30. {
  31.  0,  1,  8, 16,  9,  2,  3, 10, 
  32. 17, 24, 32, 25, 18, 11,  4,  5,
  33. 12, 19, 26, 33, 40, 48, 41, 34, 
  34. 27, 20, 13,  6,  7, 14, 21, 28, 
  35. 35, 42, 49, 56, 57, 50, 43, 36, 
  36. 29, 22, 15, 23, 30, 37, 44, 51, 
  37. 58, 59, 52, 45, 38, 31, 39, 46, 
  38. 53, 60, 61, 54, 47, 55, 62, 63
  39. };
  41. static int UpdateSize(mpeg_decode* dec)
  42. {
  43. if (dec->Codec.IDCT.Width > (MB_X-1)*16 || dec->Codec.IDCT.Height > (MB_Y-1)*16)
  44. {
  45. if (!dec->ErrorShowed)
  46. {
  47. dec->ErrorShowed = 1;
  48. ShowError(dec->Codec.Node.Class,VOUT_CLASS,VOUT_ERROR_SIZE,(MB_X-1)*16,(MB_Y-1)*16);
  49. }
  50. return ERR_NOT_SUPPORTED;
  51. }
  53. dec->mb_xsize = (dec->Codec.IDCT.Width + 15) / 16; 
  54. dec->mb_ysize = (dec->Codec.IDCT.Height + 15) / 16;
  55. dec->pos_end = dec->mb_ysize * MB_X;
  56. return ERR_NONE;
  57. }
  59. static int Discontinuity( mpeg_decode* dec )
  60. {
  61. dec->Frame = 0;
  62. return ERR_NONE;
  63. }
  65. static int Flush( mpeg_decode* dec )
  66. {
  67. dec->StartState = -1;
  68. dec->SliceFound = 0;
  69. return ERR_NONE;
  70. }
  72. static int UpdateInput( mpeg_decode* dec )
  73. {
  74. int Result = ERR_NONE;
  76. IDCT_BLOCK_PREPARE(dec,dec->blockptr);
  77. dec->mb_xsize = 0; 
  78. dec->mb_ysize = 0;
  79. dec->pos_end = 0;
  80. dec->refframe = 0;
  81. dec->Frame = 0;
  82. dec->ValidSeq = 0;
  83. dec->ErrorShowed = 0;
  84. dec->OnlyIVOP = 1;
  85. memcpy(dec->zigzag,zigzag,sizeof(zigzag));
  87. if (dec->Codec.In.Format.Type == PACKET_VIDEO)
  88. Result = CodecIDCTSetFormat(&dec->Codec,PF_YUV420,dec->Codec.In.Format.Format.Video.Width,dec->Codec.In.Format.Format.Video.Height,
  89.                 dec->Codec.In.Format.Format.Video.Width,dec->Codec.In.Format.Format.Video.Height,
  90.   dec->Codec.In.Format.Format.Video.Aspect);
  91. return Result;
  92. }
  94. static bool_t FindNext( mpeg_decode* dec )
  95. {
  96. const uint8_t* Ptr = dec->Codec.Buffer.Data;
  97. int Len = dec->Codec.Buffer.WritePos;
  98. int Pos = dec->Codec.FrameEnd;
  99. int32_t v = dec->StartState;
  101. for (;Pos<Len;++Pos)
  102. {
  103. v = (v<<8) | Ptr[Pos];
  104. if ((v & ~0xFF) == 0x100)
  105. {
  106.             if (v < SLICE_MIN_START_CODE || v > SLICE_MAX_START_CODE)
  107. {
  108. if (dec->SliceFound)
  109. {
  110. dec->Codec.FrameEnd = Pos-3;
  111. dec->SliceFound = 0;
  112. dec->StartState = -1;
  113. return 1;
  114. }
  115. }
  116. else
  117. dec->SliceFound=1;
  118. }
  119. }
  121. dec->Codec.FrameEnd = Pos;
  122. dec->StartState = v;
  123. return 0;
  124. }
  126. static _CONST int FrameRate[16] = 
  127. {
  128.         0, 24000, 24024, 25025,
  129.     30000, 30030, 50050, 60000,
  130.     60060, 15015,  5005, 10010,
  131.     12012, 15015, 25025, 25025,
  132. };
  134. static _CONST int8_t MPEG1_IntraMatrix[64] = 
  135. {
  136. 8,  16, 19, 22, 26, 27, 29, 34,
  137. 16, 16, 22, 24, 27, 29, 34, 37,
  138. 19, 22, 26, 27, 29, 34, 34, 38,
  139. 22, 22, 26, 27, 29, 34, 37, 40,
  140. 22, 26, 27, 29, 32, 35, 40, 48,
  141. 26, 27, 29, 32, 35, 40, 48, 58,
  142. 26, 27, 29, 34, 38, 46, 56, 69,
  143. 27, 29, 35, 38, 46, 56, 69, 83
  144. };
  146. static void initbits(mpeg_decode* dec,const uint8_t *stream, int len)
  147. {
  148. dec->bits = 0;
  149. dec->bitpos = 32;
  150. dec->bitptr = stream;
  151. dec->bitend = stream+len+4;
  152. }
  154. static void loadbits( mpeg_decode* dec )
  155. {
  156. int bitpos = dec->bitpos;
  157. loadbits_pos(dec,bitpos);
  158. dec->bitpos = bitpos;
  159. }
  161. #ifndef NDEBUG
  162. static int showbitslarge( mpeg_decode* dec, int n )
  163. {
  164. int i = showbits(dec,n);
  165. i |= *dec->bitptr >> (40-n-dec->bitpos);
  166. return i;
  167. }
  168. #endif
  170. static void Sequence( mpeg_decode* dec )
  171. {
  172. int i;
  174. loadbits(dec);
  175. dec->width = getbits(dec,12);
  176. dec->height = getbits(dec,12);
  178. loadbits(dec);
  179.     dec->aspect = getbits(dec,4);
  181. dec->Codec.In.Format.PacketRate.Den = 1001;
  182. dec->Codec.In.Format.PacketRate.Num = FrameRate[getbits(dec,4)];
  183. dec->Codec.FrameTime = Scale(TICKSPERSEC,dec->Codec.In.Format.PacketRate.Den,dec->Codec.In.Format.PacketRate.Num);
  185. loadbits(dec);
  186.     dec->Codec.In.Format.ByteRate = getbits(dec,18) * 50;
  187. if (dec->Codec.In.Format.ByteRate > 8*1024*1024)
  188. dec->Codec.In.Format.ByteRate = 0;
  190.     flushbits(dec,1); // marker
  191.     flushbits(dec,10); // vbv_buffer_size
  192.     flushbits(dec,1);
  194. loadbits(dec);
  195.     if (getbits1(dec)) 
  196. {
  197.         for (i=0;i<64;i++) 
  198. {
  199. loadbits(dec);
  200.             dec->IntraMatrix[i] = (uint8_t)getbits(dec,8);
  201.         }
  202.     } 
  203. else 
  204. {
  205.         for (i=0;i<64;i++) 
  206.             dec->IntraMatrix[i] = MPEG1_IntraMatrix[dec->zigzag[i]];
  207.     }
  209.     if (getbits1(dec)) 
  210. {
  211.         for (i=0;i<64;i++) 
  212. {
  213. loadbits(dec);
  214.             dec->InterMatrix[i] = (uint8_t)getbits(dec, 8);
  215.         }
  216.     } 
  217. else 
  218. {
  219.         for (i=0;i<64;i++) 
  220.             dec->InterMatrix[i] = 16;
  221.     }
  223. dec->ValidSeq = 1;
  224. }
  226. static void Picture( mpeg_decode* dec )
  227. {
  228. static const int16_t aspect[16] = 
  229. {
  230.     0,10000, 6735, 7031,
  231.  7615, 8055, 8437, 8935,
  232.  9157, 9815,10255,10695,
  233. 10950,11575,12015,    0,
  234. };
  236. if (!dec->Codec.In.Format.Format.Video.Aspect && aspect[dec->aspect])
  237. dec->Codec.In.Format.Format.Video.Aspect = Scale(ASPECT_ONE,10000,aspect[dec->aspect]);
  239. CodecIDCTSetFormat(&dec->Codec,PF_YUV420,dec->width,dec->height,dec->width,dec->height,dec->Codec.In.Format.Format.Video.Aspect);
  241.     flushbits(dec,10); // temporal ref
  243.     loadbits(dec);
  244. dec->prediction_type = getbits(dec,3);
  246.     flushbits(dec,16); // non constant bit rate
  248. loadbits(dec);
  249.     if (dec->prediction_type == P_VOP || dec->prediction_type == B_VOP)
  250. {
  251.         dec->full_pixel[0] = getbits(dec,1);
  252.         dec->fcode[0] = getbits(dec,3)-1;
  253.     }
  255.     if (dec->prediction_type == B_VOP) 
  256. {
  257.         dec->full_pixel[1] = getbits(dec,1);
  258.         dec->fcode[1] = getbits(dec,3)-1;
  259.     }
  261.     dec->frame_state = 1;
  263. DEBUG_MSG1(DEBUG_VCODEC,T("MPEG Picture:%d"),dec->prediction_type);
  264. }
  266. static int StartFrame( mpeg_decode* dec )
  267. {
  268. int result = ERR_NONE;
  270. switch (dec->prediction_type) 
  271. {
  272. case P_VOP:
  273. if (dec->Frame < 1)
  274. {
  275. if (dec->Codec.Dropping)
  276. dec->Codec.IDCT.Ptr->Null(dec->Codec.IDCT.Ptr,NULL,0);
  277. return ERR_INVALID_DATA;
  278. }
  280. // no break
  282. case I_VOP:
  284. dec->refframe ^= 1;
  286. if (dec->OnlyIVOP && dec->Codec.State.DropLevel)
  287. {
  288. dec->Codec.IDCT.Ptr->Null(dec->Codec.IDCT.Ptr,NULL,0);
  289. return ERR_NONE;
  290. }
  292. if (dec->Codec.IDCT.Count>=3)
  293. dec->Codec.State.DropLevel = 0;
  295. if (dec->Codec.IDCT.Count<3 || dec->Frame==0)
  296. dec->Codec.Show = dec->refframe; // show this refframe
  297. else
  298. dec->Codec.Show = dec->refframe ^ 1; // show last refframe 
  300. if (dec->prediction_type == I_VOP)
  301. {
  302. result = dec->Codec.IDCT.Ptr->FrameStart(dec->Codec.IDCT.Ptr,dec->Frame,&dec->bufframe,dec->refframe,-1,-1,dec->Codec.Show,0);
  303. }
  304. else 
  305. {
  306. dec->OnlyIVOP = 0;
  307. result = dec->Codec.IDCT.Ptr->FrameStart(dec->Codec.IDCT.Ptr,dec->Frame,&dec->bufframe,dec->refframe,dec->refframe^1,-1,dec->Codec.Show,dec->Codec.State.DropLevel);
  308. }
  310. if (result != ERR_NONE)
  311. dec->Codec.Show = -1;
  312. break;
  314. case B_VOP:
  316. if (dec->Frame < 2)
  317. {
  318. if (dec->Codec.Dropping)
  319. dec->Codec.IDCT.Ptr->Null(dec->Codec.IDCT.Ptr,NULL,0);
  320. return ERR_INVALID_DATA;
  321. }
  323. if (dec->Codec.State.DropLevel)
  324. {
  325. dec->Codec.IDCT.Ptr->Null(dec->Codec.IDCT.Ptr,NULL,0);
  326. return ERR_NONE;
  327. }
  329. if (dec->Codec.IDCT.Count<3)
  330. {
  331. CodecIDCTSetCount(&dec->Codec,3);
  332. if (dec->Codec.IDCT.Count<3)
  333. {
  334. dec->Codec.IDCT.Ptr->Null(dec->Codec.IDCT.Ptr,NULL,0);
  335. return ERR_INVALID_DATA;
  336. }
  337. }
  339. dec->OnlyIVOP = 0;
  340. dec->Codec.Show = 2;
  341. result = dec->Codec.IDCT.Ptr->FrameStart(dec->Codec.IDCT.Ptr,-dec->Frame,&dec->bufframe,2,dec->refframe^1,dec->refframe,2,0);
  342. break;
  344. default:
  345. result = ERR_INVALID_DATA;
  346. break;
  347. }
  349. return result;
  350. }
  352. // max 9 bits
  353. static INLINE int getDCsizeLum( mpeg_decode* dec )
  354. {
  355. int i,code;
  357. if (!getbits1(dec))
  358. return getbits(dec,1)+1;
  360. if (!getbits1(dec))
  361. return getbits(dec,1)*3;
  363. code = showbits(dec,7);
  365. for (i=1;i<8;i++,code<<=1)
  366. if (!(code & 64))
  367. {
  368. flushbits(dec,i);
  369. return i+3;
  370. }
  372. flushbits(dec,7);
  373. return 11;
  374. }
  376. // max 10 bits
  377. static INLINE int getDCsizeChr( mpeg_decode* dec )
  378. {
  379. int i,code;
  381. if (!getbits1(dec))
  382. return getbits(dec,1);
  384. code = showbits(dec,9);
  386. for (i=1;i<10;i++,code<<=1)
  387. if (!(code & 256))
  388. {
  389. flushbits(dec,i);
  390. return i+1;
  391. }
  393. flushbits(dec,9);
  394. return 11;
  395. }
  397. // max 11bits
  398. static INLINE int getDCdiff(int dct_dc_size, mpeg_decode* dec)
  399. {
  400. int code = showbits(dec,32); //we need only dct_dc_size bits (but in the higher bits)
  401. int adj = 0;
  402. flushbits(dec,dct_dc_size);
  403. if (code >= 0)
  404. adj = (-1 << dct_dc_size) + 1;
  405. return adj + ((uint32_t)code >> (32-dct_dc_size));
  406. }
  408. #define TABLE_1 0
  409. #define TABLE_2 252
  410. #define TABLE_3 252+112
  411. #define TABLE_END 252+112+112
  413. static _CONST uint16_t vld_mpeg1[252+112+112] = 
  414. {
  415. 0x403e,0x403e,0x403e,0x403e,0x5082,0x5082,0x5241,0x5241,
  416. 0x5004,0x5004,0x5201,0x5201,0x41c1,0x41c1,0x41c1,0x41c1,
  417. 0x4181,0x4181,0x4181,0x4181,0x4042,0x4042,0x4042,0x4042,
  418. 0x4141,0x4141,0x4141,0x4141,0x6341,0x6006,0x6301,0x62c1,
  419. 0x60c2,0x6043,0x6005,0x6281,0x3003,0x3003,0x3003,0x3003,
  420. 0x3003,0x3003,0x3003,0x3003,0x3101,0x3101,0x3101,0x3101,
  421. 0x3101,0x3101,0x3101,0x3101,0x30c1,0x30c1,0x30c1,0x30c1,
  422. 0x30c1,0x30c1,0x30c1,0x30c1,0x2002,0x2002,0x2002,0x2002,
  423. 0x2002,0x2002,0x2002,0x2002,0x2002,0x2002,0x2002,0x2002,
  424. 0x2002,0x2002,0x2002,0x2002,0x2081,0x2081,0x2081,0x2081,
  425. 0x2081,0x2081,0x2081,0x2081,0x2081,0x2081,0x2081,0x2081,
  426. 0x2081,0x2081,0x2081,0x2081,0x1041,0x1041,0x1041,0x1041,
  427. 0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,
  428. 0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,
  429. 0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,
  430. 0x1041,0x1041,0x1041,0x1041,0x003f,0x003f,0x003f,0x003f,
  431. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  432. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  433. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  434. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  435. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  436. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  437. 0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,0x003f,
  438. 0x003f,0x003f,0x003f,0x003f,0x0001,0x0001,0x0001,0x0001,
  439. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  440. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  441. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  442. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  443. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  444. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  445. 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
  446. 0x0001,0x0001,0x0001,0x0001,0xb282,0xb242,0xb143,0xb0c4,
  447. 0xb085,0xb047,0xb046,0xb00f,0xb00e,0xb00d,0xb00c,0xb681,
  448. 0xb641,0xb601,0xb5c1,0xb581,0xa00b,0xa00b,0xa202,0xa202,
  449. 0xa103,0xa103,0xa00a,0xa00a,0xa084,0xa084,0xa1c2,0xa1c2,
  450. 0xa541,0xa541,0xa501,0xa501,0xa009,0xa009,0xa4c1,0xa4c1,
  451. 0xa481,0xa481,0xa045,0xa045,0xa0c3,0xa0c3,0xa008,0xa008,
  452. 0xa182,0xa182,0xa441,0xa441,0x8401,0x8401,0x8401,0x8401,
  453. 0x8401,0x8401,0x8401,0x8401,0x8142,0x8142,0x8142,0x8142,
  454. 0x8142,0x8142,0x8142,0x8142,0x8007,0x8007,0x8007,0x8007,
  455. 0x8007,0x8007,0x8007,0x8007,0x8083,0x8083,0x8083,0x8083,
  456. 0x8083,0x8083,0x8083,0x8083,0x8044,0x8044,0x8044,0x8044,
  457. 0x8044,0x8044,0x8044,0x8044,0x83c1,0x83c1,0x83c1,0x83c1,
  458. 0x83c1,0x83c1,0x83c1,0x83c1,0x8381,0x8381,0x8381,0x8381,
  459. 0x8381,0x8381,0x8381,0x8381,0x8102,0x8102,0x8102,0x8102,
  460. 0x8102,0x8102,0x8102,0x8102,0xe052,0xe051,0xe050,0xe04f,
  461. 0xe183,0xe402,0xe3c2,0xe382,0xe342,0xe302,0xe2c2,0xe7c1,
  462. 0xe781,0xe741,0xe701,0xe6c1,0xd028,0xd028,0xd027,0xd027,
  463. 0xd026,0xd026,0xd025,0xd025,0xd024,0xd024,0xd023,0xd023,
  464. 0xd022,0xd022,0xd021,0xd021,0xd020,0xd020,0xd04e,0xd04e,
  465. 0xd04d,0xd04d,0xd04c,0xd04c,0xd04b,0xd04b,0xd04a,0xd04a,
  466. 0xd049,0xd049,0xd048,0xd048,0xc01f,0xc01f,0xc01f,0xc01f,
  467. 0xc01e,0xc01e,0xc01e,0xc01e,0xc01d,0xc01d,0xc01d,0xc01d,
  468. 0xc01c,0xc01c,0xc01c,0xc01c,0xc01b,0xc01b,0xc01b,0xc01b,
  469. 0xc01a,0xc01a,0xc01a,0xc01a,0xc019,0xc019,0xc019,0xc019,
  470. 0xc018,0xc018,0xc018,0xc018,0xc017,0xc017,0xc017,0xc017,
  471. 0xc016,0xc016,0xc016,0xc016,0xc015,0xc015,0xc015,0xc015,
  472. 0xc014,0xc014,0xc014,0xc014,0xc013,0xc013,0xc013,0xc013,
  473. 0xc012,0xc012,0xc012,0xc012,0xc011,0xc011,0xc011,0xc011,
  474. 0xc010,0xc010,0xc010,0xc010
  475. };
  477. // size:4 run:6 level:6 
  478. // size:4 escape    62
  479. // size:4 end 63
  481. #define vld_code
  482. code = showbits_pos(dec,bitpos,16);
  483. if (code >> 10)
  484. code = (code >> 8) - 4 + TABLE_1;
  485. else if (code >> 7)
  486. code = (code >> 3) - 16 + TABLE_2;
  487. else /* if (code >= 16)  but we don't care about invalid huffman codes */ 
  488. code = code - 16 + TABLE_3;
  489. code = table[code];
  490. flushbits_pos(dec,bitpos,2+(code >> 12));
  492. static void blockIntra( mpeg_decode* dec, int pos )
  493. {
  494. int j;
  495. idct_block_t *block;
  496. const uint16_t *table = vld_mpeg1;
  497. int qscale;
  499. dec->Codec.IDCT.Ptr->Process(dec->Codec.IDCT.Ptr,POSX(pos),POSY(pos));
  501. block = dec->blockptr;
  502. qscale = dec->qscale;
  504. for (j=0;j<6;++j)
  505. {
  506. int bitpos;
  507. int len;
  509. ClearBlock(block);
  510. loadbits(dec);
  512. {
  513. int dct_dc_size, dct_dc_diff;
  515. dct_dc_diff = 0;
  516. dct_dc_size = j<4 ? getDCsizeLum(dec) : getDCsizeChr(dec); //max11bit
  518. if (dct_dc_size)
  519. dct_dc_diff = getDCdiff(dct_dc_size,dec);
  521. dct_dc_size = j<4 ? 0 : j-4+1;
  522. DEBUG_MSG2(DEBUG_VCODEC2,T("dc=%d diff=%d"), dec->last_dc[dct_dc_size]+dct_dc_diff, dct_dc_diff );
  523. dct_dc_diff += dec->last_dc[dct_dc_size];
  524. dec->last_dc[dct_dc_size] = dct_dc_diff;
  526. *block = (idct_block_t)(dct_dc_diff << 3);
  527. len = 1;
  528. }
  530. bitpos = dec->bitpos;
  532. for (;;) // event vld
  533. {
  534. int code,level;
  536. loadbits_pos(dec,bitpos);
  537. code = showbits_pos(dec,bitpos,16);
  539. vld_code;
  540. level = code & 63;
  541. if (level < 62) 
  542. {
  543. level *= qscale;
  544. code >>= 6;
  545. code &= 63;
  546. len += code; // run
  547. if (len >= 64)
  548. break;
  550. code = dec->zigzag[len];
  551. level *= dec->IntraMatrix[len];
  552. level >>= 3;
  553. level = (level-1)|1;
  555. if (getbits1_pos(dec,bitpos)) 
  556. level = -level;
  558. block[code] = (idct_block_t)level;
  559. ++len;
  560. } 
  561. else 
  562. {
  563. if (level==63)
  564. break;
  566. // this value is escaped
  567. loadbits_pos(dec,bitpos);
  569. len += showbits_pos(dec,bitpos,6); flushbits_pos(dec,bitpos,6);
  570. if (len >= 64)
  571. break;
  573. code = showbits_pos(dec,bitpos,8); flushbits_pos(dec,bitpos,8);
  574. level = (code << 24) >> 24; //sign extend the lower 8 bits
  575. code = dec->zigzag[len];
  577. if (level == -128)
  578. {
  579. level = showbits_pos(dec,bitpos,8)-256; flushbits_pos(dec,bitpos,8);
  580. }
  581. else 
  582. if (level == 0)
  583. {
  584. level = showbits_pos(dec,bitpos,8); flushbits_pos(dec,bitpos,8);
  585. }
  587. if (level<0)
  588. {
  589. level= -level;
  590. level *= qscale * dec->IntraMatrix[len];
  591. level >>= 3;
  592. level= (level-1)|1;
  593. level= -level;
  595. block[code] = (idct_block_t)level;
  596. ++len;
  597. }
  598. else
  599. {
  600. level *= qscale * dec->IntraMatrix[len];
  601. level >>= 3;
  602. level = (level-1)|1;
  604. block[code] = (idct_block_t)level;
  605. ++len;
  606. }
  607. }
  609. DEBUG_MSG2(DEBUG_VCODEC2,T("intra_block[%i] %i"), code, level );
  610. }
  612. dec->bitpos = bitpos;
  614. dec->Codec.IDCT.Ptr->Intra8x8(dec->Codec.IDCT.Ptr,block,len,IDCTSCAN_ZIGZAG);
  615. }
  617. dec->fmv[0] = dec->bmv[0] = 0;
  618. }
  620. static INLINE int readqscale( mpeg_decode* dec )
  621. {
  622.     return getbits(dec,5);
  623. }
  625. static _CONST uint8_t mcbp_p[32*2+128*2] = 
  626. {
  627. 0x00,0x00,0x08,0x39,0x08,0x2b,0x08,0x29,0x07,0x22,0x07,0x21,0x06,0x3f,0x06,0x24,
  628. 0x05,0x3e,0x05,0x02,0x05,0x3d,0x05,0x01,0x05,0x38,0x05,0x34,0x05,0x2c,0x05,0x1c,
  629. 0x05,0x28,0x05,0x14,0x05,0x30,0x05,0x0c,0x04,0x20,0x04,0x20,0x04,0x10,0x04,0x10,
  630. 0x04,0x08,0x04,0x08,0x04,0x04,0x04,0x04,0x03,0x3c,0x03,0x3c,0x03,0x3c,0x03,0x3c,
  631. 0x00,0x00,0x00,0x00,0x09,0x27,0x09,0x1b,0x09,0x3b,0x09,0x37,0x09,0x2f,0x09,0x1f,
  632. 0x08,0x3a,0x08,0x3a,0x08,0x36,0x08,0x36,0x08,0x2e,0x08,0x2e,0x08,0x1e,0x08,0x1e,
  633. 0x08,0x39,0x08,0x39,0x08,0x35,0x08,0x35,0x08,0x2d,0x08,0x2d,0x08,0x1d,0x08,0x1d,
  634. 0x08,0x26,0x08,0x26,0x08,0x1a,0x08,0x1a,0x08,0x25,0x08,0x25,0x08,0x19,0x08,0x19,
  635. 0x08,0x2b,0x08,0x2b,0x08,0x17,0x08,0x17,0x08,0x33,0x08,0x33,0x08,0x0f,0x08,0x0f,
  636. 0x08,0x2a,0x08,0x2a,0x08,0x16,0x08,0x16,0x08,0x32,0x08,0x32,0x08,0x0e,0x08,0x0e,
  637. 0x08,0x29,0x08,0x29,0x08,0x15,0x08,0x15,0x08,0x31,0x08,0x31,0x08,0x0d,0x08,0x0d,
  638. 0x08,0x23,0x08,0x23,0x08,0x13,0x08,0x13,0x08,0x0b,0x08,0x0b,0x08,0x07,0x08,0x07,
  639. 0x07,0x22,0x07,0x22,0x07,0x22,0x07,0x22,0x07,0x12,0x07,0x12,0x07,0x12,0x07,0x12,
  640. 0x07,0x0a,0x07,0x0a,0x07,0x0a,0x07,0x0a,0x07,0x06,0x07,0x06,0x07,0x06,0x07,0x06,
  641. 0x07,0x21,0x07,0x21,0x07,0x21,0x07,0x21,0x07,0x11,0x07,0x11,0x07,0x11,0x07,0x11,
  642. 0x07,0x09,0x07,0x09,0x07,0x09,0x07,0x09,0x07,0x05,0x07,0x05,0x07,0x05,0x07,0x05,
  643. 0x06,0x3f,0x06,0x3f,0x06,0x3f,0x06,0x3f,0x06,0x3f,0x06,0x3f,0x06,0x3f,0x06,0x3f,
  644. 0x06,0x03,0x06,0x03,0x06,0x03,0x06,0x03,0x06,0x03,0x06,0x03,0x06,0x03,0x06,0x03,
  645. 0x06,0x24,0x06,0x24,0x06,0x24,0x06,0x24,0x06,0x24,0x06,0x24,0x06,0x24,0x06,0x24,
  646. 0x06,0x18,0x06,0x18,0x06,0x18,0x06,0x18,0x06,0x18,0x06,0x18,0x06,0x18,0x06,0x18
  647. };
  649. static _CONST uint8_t mb_type_p[64] =
  650. {
  651. 0x00,0xd1,0xa9,0xa9,0xab,0xab,0xb0,0xb0,0x62,0x62,0x62,0x62,0x62,0x62,0x62,0x62,
  652. 0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48,
  653. 0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
  654. 0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a
  655. };
  657. static _CONST uint8_t mb_type_b[64] =
  658. {
  659. 0x00,0xd1,0xcd,0xcb,0xaf,0xaf,0xb0,0xb0,0x82,0x82,0x82,0x82,0x8a,0x8a,0x8a,0x8a,
  660. 0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,
  661. 0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,0x46,
  662. 0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e
  663. };
  665. #define SKIP_1  0
  666. #define SKIP_2  16
  667. #define SKIP_3  (16+8)
  668. #define SKIP_END (16+8+64)
  670. static _CONST uint8_t skip[SKIP_END*2] = 
  671. {
  672. 0x0a,0x22,0x07,0x0c,0x04,0x06,0x04,0x05,0x03,0x04,0x03,0x04,0x03,0x03,0x03,0x03,
  673. 0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x01,0x02,0x01,0x02,0x01,0x02,0x01,
  674. 0x07,0x0c,0x07,0x0b,0x07,0x0a,0x07,0x09,0x06,0x08,0x06,0x08,0x06,0x07,0x06,0x07,
  675. 0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,
  676. 0x0a,0x21,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,
  677. 0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,0x0a,0x22,
  678. 0x0a,0x20,0x0a,0x1f,0x0a,0x1e,0x0a,0x1d,0x0a,0x1c,0x0a,0x1b,0x0a,0x1a,0x0a,0x19,
  679. 0x0a,0x18,0x0a,0x17,0x0a,0x16,0x0a,0x15,0x09,0x14,0x09,0x14,0x09,0x13,0x09,0x13,
  680. 0x09,0x12,0x09,0x12,0x09,0x11,0x09,0x11,0x09,0x10,0x09,0x10,0x09,0x0f,0x09,0x0f,
  681. 0x07,0x0e,0x07,0x0e,0x07,0x0e,0x07,0x0e,0x07,0x0e,0x07,0x0e,0x07,0x0e,0x07,0x0e,
  682. 0x07,0x0d,0x07,0x0d,0x07,0x0d,0x07,0x0d,0x07,0x0d,0x07,0x0d,0x07,0x0d,0x07,0x0d
  683. };
  685. static INLINE void readskip( mpeg_decode* dec )
  686. {
  687. int i;
  688. dec->skip = 0;
  690. while (!getbits1(dec))
  691. {
  692. inlineloadbits(dec);
  693. i = showbits(dec,10);
  695. if (i >> 7)
  696. i = (i >> 6) + SKIP_1;
  697. else
  698. if (i >> 6)
  699. i = (i >> 3)-8 + SKIP_2;
  700. else
  701. i = i + SKIP_3;
  703. i <<= 1;
  704. flushbits(dec,skip[i]);
  705. i = skip[i+1];
  707. if (i<33)
  708. {
  709. dec->skip += i;
  710. break;
  711. }
  712. if (i==33)
  713. dec->skip += 33;
  715. if (eofbits(dec))
  716. break;
  717. }
  718. }
  720. static _CONST uint8_t mv_tab[64] = 
  721. {
  722. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x84,0x7c,0x74,0x6c,
  723. 0x64,0x5c,0x53,0x53,0x4b,0x4b,0x43,0x43,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,
  724. 0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x29,0x29,0x29,0x29,0x29,0x29,0x29,0x29,
  725. 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20
  726. };
  728. #define GetMVData( dec, table, shift, shift2, last, bitpos )
  729. {
  730. int code,v;
  731. loadbits_pos(dec,bitpos);
  732. code = showbits_pos(dec,bitpos,10);
  733. if (code >= 512)
  734. {
  735. flushbits_pos(dec,bitpos,1);
  736. }
  737. else
  738. {
  739. if (code >= 64)
  740. {
  741. v = 4;
  742. if (code >= 128) --v;
  743. if (code >= 256) --v;
  744. flushbits_pos(dec,bitpos,v);
  745. code = v-1;
  746. }
  747. else
  748. {
  749. code = table[code];
  750. v = (code & 7)+6;
  751. flushbits_pos(dec,bitpos,v);
  752. code >>= 3;
  753. }
  754. /* 14bits left */
  755. v = showbits_pos(dec,bitpos,1);
  756. flushbits_pos(dec,bitpos,1);
  757. if (shift) /* max 6bits */
  758. {
  759. code = (code - 1) << shift;
  760. code |= showbits_pos(dec,bitpos,shift);
  761. flushbits_pos(dec,bitpos,shift);
  762. code++;
  763. }
  764. if (v)
  765. code = -code;
  766. last += code;
  767. last = ((last + shift2) & (shift2*2-1)) - shift2;
  768. }
  769. }
  771. static void GetMV(int fcode, int* mv, int full, mpeg_decode* dec )
  772. {
  773. int mv_x = ((int16_t*)mv)[MVXIDX];
  774. int mv_y = ((int16_t*)mv)[MVYIDX];
  775. int bitpos = dec->bitpos;
  776. int fcode2 = 1 << (fcode+4);
  777. _CONST uint8_t* tab = mv_tab;
  779. GetMVData(dec,tab,fcode,fcode2,mv_x,bitpos);
  780. GetMVData(dec,tab,fcode,fcode2,mv_y,bitpos);
  782. dec->bitpos = bitpos;
  784. ((int16_t*)mv)[MVXIDX] = (int16_t)mv_x;
  785. ((int16_t*)mv)[MVYIDX] = (int16_t)mv_y;
  787. if (full)
  788. {
  789. mv_x <<= 1;
  790. mv_y <<= 1;
  791. }
  793. mv_x &= 0xFFFF;
  794. mv_y <<= 16;
  795. mv_y |= mv_x;
  797. mv[1] = mv_y;
  798. mv[2] = mv_y;
  799. mv[3] = mv_y;
  800. mv[4] = mv_y;
  802. mv_y >>= 1; //shift
  803. mv_y &= ~0x8000; //replace dx sign bit with old signed bit
  804. mv_x &= 0x8000;
  805. mv_y |= mv_x;
  807. mv[5] = mv_y;
  808. mv[6] = mv_y;
  809. }
  811. static int decodeInter( mpeg_decode* dec )
  812. {
  813. idct_block_t *block = dec->blockptr;
  814. const uint16_t *table = vld_mpeg1;
  815. int qscale;
  817. int bitpos;
  818. int len;
  819. int code,level;
  821. ClearBlock(block);
  823. bitpos = dec->bitpos;
  824. loadbits_pos(dec,bitpos);
  826. len = 0;
  827. qscale = dec->qscale;
  829. // special case for first
  830. code = showbits_pos(dec,bitpos,2);
  831.     if (code & 2) 
  832. {
  833. flushbits_pos(dec,bitpos,2);
  835.         level= (3 * qscale * dec->InterMatrix[0]) >> 4;
  836.         level= (level-1)|1;
  837.         if (code & 1)
  838. level= -level;
  839.         block[0] = (idct_block_t)level;
  840. DEBUG_MSG2(DEBUG_VCODEC2,T("inter_block[%i] %i"), 0, level );
  841.         ++len;
  842.     }
  844. for (;;) // event vld
  845. {
  846. loadbits_pos(dec,bitpos);
  847. code = showbits_pos(dec,bitpos,16);
  849. vld_code;
  850. level = code & 63;
  851. if (level < 62) 
  852. {
  853. level = level*2+1;
  854. level *= qscale;
  856. code >>= 6;
  857. code &= 63;
  858. len += code; // run
  859. if (len >= 64)
  860. break;
  862. code = dec->zigzag[len];
  863. level *= dec->InterMatrix[len];
  864. level >>= 4;
  865. level = (level-1)|1;
  867. if (getbits1_pos(dec,bitpos)) 
  868. level = -level;
  870. block[code] = (idct_block_t)level;
  871. ++len;
  872. } 
  873. else 
  874. {
  875. if (level==63)
  876. break;
  878. // this value is escaped
  879. loadbits_pos(dec,bitpos);
  881. len += showbits_pos(dec,bitpos,6); flushbits_pos(dec,bitpos,6);
  882. if (len >= 64)
  883. break;
  885. code = showbits_pos(dec,bitpos,8); flushbits_pos(dec,bitpos,8);
  886. level = (code << 24) >> 24; //sign extend the lower 8 bits
  887. code = dec->zigzag[len];
  889. if (level == -128)
  890. {
  891. level = showbits_pos(dec,bitpos,8)-256; flushbits_pos(dec,bitpos,8);
  892. }
  893. else 
  894. if (level == 0)
  895. {
  896. level = showbits_pos(dec,bitpos,8); flushbits_pos(dec,bitpos,8);
  897. }
  899. if (level<0)
  900. {
  901. level= -level;
  902. level = level*2+1;
  903. level *= qscale * dec->InterMatrix[len];
  904. level >>= 4;
  905. level= (level-1)|1;
  906. level= -level;
  908. block[code] = (idct_block_t)level;
  909. ++len;
  910. }
  911. else
  912. {
  913. level = level*2+1;
  914. level *= qscale * dec->InterMatrix[len];
  915. level >>= 4;
  916. level = (level-1)|1;
  918. block[code] = (idct_block_t)level;
  919. ++len;
  920. }
  921. }
  923. DEBUG_MSG2(DEBUG_VCODEC2,T("inter_block[%i] %i"), code, level );
  924. }
  926. dec->bitpos = bitpos;
  927. return len;
  928. }
  930. static void blockInter( mpeg_decode* dec, int mb_type, int pos )
  931. {
  932. int j;
  933. idct* IDCT = dec->Codec.IDCT.Ptr;
  935.   IDCT->Process(IDCT,POSX(pos),POSY(pos));
  936. IDCT->MComp16x16(IDCT,
  937. dec->fmv[1]==NOMV?NULL:dec->fmv+1,
  938. dec->bmv[1]==NOMV?NULL:dec->bmv+1);
  940. if (mb_type & MB_PAT)
  941. {
  942. int len,cbp;
  944. loadbits(dec);
  945. len = showbits(dec,9);
  947. if (len >= 128)
  948. len >>= 4;
  949. else
  950. len += 32;
  952. len <<= 1;
  953. flushbits(dec,mcbp_p[len]);
  954. cbp = mcbp_p[len+1];
  956. for (j = 0; j < 6; j++, cbp+=cbp)
  957. {
  958. len = 0;
  959. if (cbp & 32)
  960. len = decodeInter(dec);
  961. IDCT->Inter8x8(IDCT,dec->blockptr,len);
  962. }
  963. }
  964. else
  965. {
  966. for (j = 0; j < 6; j++)
  967. IDCT->Inter8x8(IDCT,dec->blockptr,0);
  968. }
  970. dec->last_dc[2] =
  971. dec->last_dc[1] =
  972. dec->last_dc[0] = 128;
  973. }
  975. static int IVOP_Slice( mpeg_decode* dec, int pos )
  976. {
  977. dec->lastrefframe = dec->Frame;
  978. dec->mapofs = dec->Frame;
  979. memset(dec->framemap,0,dec->pos_end); // set all block to current frame
  981. for (;pos<dec->pos_end;pos+=MB_X-dec->mb_xsize) 
  982. {
  983. for (;POSX(pos)<dec->mb_xsize;++pos) 
  984. {
  985. if (!getbits1(dec))
  986. {
  987. flushbits(dec,1); // should be 1
  988.             dec->qscale = readqscale(dec);
  989. }
  991. blockIntra(dec, pos);
  993. inlineloadbits(dec);
  994. if (showbits(dec,8)==0) // eof slice
  995. return ERR_NONE;
  997. if (!getbits1(dec))
  998. return ERR_NONE; // skip invalid with IVOP
  999. }
  1000. }
  1002. return ERR_NONE;
  1003. }
  1005. static int PVOP_Slice( mpeg_decode* dec, int pos )
  1006. {
  1007. dec->currframemap = (dec->Frame - dec->mapofs) << 1;
  1008. dec->lastrefframe = dec->Frame;
  1009. dec->bmv[1] = NOMV;
  1011. for (;pos<dec->pos_end;pos+=MB_X-dec->mb_xsize) 
  1012. {
  1013. for (;POSX(pos)<dec->mb_xsize;++pos) 
  1014. {
  1015. if (!dec->skip)
  1016. {
  1017. int mb_type;
  1019. DEBUG_MSG3(DEBUG_VCODEC2,T("macro %d,%d %08x"),POSX(pos),POSY(pos),showbitslarge((loadbits(dec),dec),32));
  1021. dec->framemap[pos] = (uint8_t)dec->currframemap;
  1023. mb_type = mb_type_p[showbits(dec,6)];
  1024. flushbits(dec,mb_type >> 5); // after this 6bits left
  1026. if (mb_type & MB_QUANT)
  1027.             dec->qscale = readqscale(dec);
  1029. if (mb_type & MB_INTRA)
  1030. blockIntra(dec, pos);
  1031. else
  1032. {
  1033. if (mb_type & MB_FOR)
  1034. GetMV(dec->fcode[0],dec->fmv,dec->full_pixel[0],dec);
  1035. else
  1036. dec->fmv[6] = dec->fmv[5] = dec->fmv[4] = dec->fmv[3] = 
  1037. dec->fmv[2] = dec->fmv[1] = dec->fmv[0] = 0;
  1039. DEBUG_MSG3(DEBUG_VCODEC2,T("mv%d %d:%d"),0,MVX(dec->fmv[1]),MVY(dec->fmv[1]));
  1041. blockInter( dec, mb_type, pos );
  1042. }
  1044. inlineloadbits(dec);
  1045. if (showbits(dec,8)==0) // eof slice
  1046. return ERR_NONE;
  1048. readskip(dec); // after this 12bits left
  1049. }
  1050. else
  1051. {
  1052. int n;
  1053. dec->skip--;
  1054. // not coded macroblock
  1055. n = dec->framemap[pos];
  1056. // copy needed or the buffer already has this block?
  1057. if (dec->bufframe < dec->mapofs+(n>>1))
  1058. dec->Codec.IDCT.Ptr->Copy16x16(dec->Codec.IDCT.Ptr,POSX(pos),POSY(pos),0);
  1060. dec->fmv[0] = 0;
  1061. dec->last_dc[2] =
  1062. dec->last_dc[1] =
  1063. dec->last_dc[0] = 128;
  1064. }
  1065. }
  1066. }
  1068. return ERR_NONE;
  1069. }
  1071. static int BVOP_Slice( mpeg_decode* dec, int pos )
  1072. {
  1073. for (;pos<dec->pos_end;pos+=MB_X-dec->mb_xsize) 
  1074. {
  1075. for (;POSX(pos)<dec->mb_xsize;++pos) 
  1076. {
  1077. if (!dec->skip)
  1078. {
  1079. int mb_type;
  1081. DEBUG_MSG3(DEBUG_VCODEC2,T("macro %d,%d %08x"),POSX(pos),POSY(pos),showbitslarge((loadbits(dec),dec),32));
  1083. //dec->framemap[pos] |= 1;
  1085. mb_type = mb_type_b[showbits(dec,6)];
  1086. flushbits(dec,mb_type >> 5); // after this 6bits left
  1088. if (mb_type & MB_QUANT)
  1089.             dec->qscale = readqscale(dec);
  1091. if (mb_type & MB_INTRA)
  1092. blockIntra(dec, pos);
  1093. else
  1094. {
  1095. if (mb_type & MB_FOR)
  1096. {
  1097. GetMV(dec->fcode[0],dec->fmv,dec->full_pixel[0],dec);
  1098. DEBUG_MSG3(DEBUG_VCODEC2,T("mv%d %d:%d"),0,MVX(dec->fmv[1]),MVY(dec->fmv[1]));
  1099. }
  1100. else
  1101. dec->fmv[1] = NOMV;
  1103. if (mb_type & MB_BACK)
  1104. {
  1105. GetMV(dec->fcode[1],dec->bmv,dec->full_pixel[1],dec);
  1106. DEBUG_MSG3(DEBUG_VCODEC2,T("mv%d %d:%d"),1,MVX(dec->bmv[1]),MVY(dec->bmv[1]));
  1107. }
  1108. else
  1109. dec->bmv[1] = NOMV;
  1111. blockInter( dec, mb_type, pos );
  1112. }
  1114. inlineloadbits(dec);
  1115. if (showbits(dec,8)==0) // eof slice
  1116. return ERR_NONE;
  1118. readskip(dec); // after this 12bits left
  1119. }
  1120. else
  1121. {
  1122. // not coded macroblock, use last motion compensation vectors
  1123. dec->skip--;
  1125. if (dec->fmv[1]==0 && dec->bmv[1]==NOMV)
  1126. {
  1127. dec->Codec.IDCT.Ptr->Copy16x16(dec->Codec.IDCT.Ptr,POSX(pos),POSY(pos),0);
  1128. dec->last_dc[2] =
  1129. dec->last_dc[1] =
  1130. dec->last_dc[0] = 128;
  1131. }
  1132. else
  1133. if (dec->bmv[1]==0 && dec->fmv[1]==NOMV)
  1134. {
  1135. dec->Codec.IDCT.Ptr->Copy16x16(dec->Codec.IDCT.Ptr,POSX(pos),POSY(pos),1);
  1136. dec->last_dc[2] =
  1137. dec->last_dc[1] =
  1138. dec->last_dc[0] = 128;
  1139. }
  1140. else
  1141. blockInter(dec, 0, pos );
  1142. }
  1143. }
  1144. }
  1146. return ERR_NONE;
  1147. }
  1149. static int Frame( mpeg_decode* dec, const uint8_t* Ptr, int Len )
  1150. {
  1151. int Result;
  1152. int Code;
  1154. if (Len == 0)
  1155. return ERR_INVALID_DATA;
  1157. initbits(dec,Ptr,Len);
  1159. Result = ERR_NONE;
  1161. DEBUG_MSG1(DEBUG_VCODEC,T("MPEG Frame Length:%d"),Len);
  1163. dec->frame_state = -1;
  1164. do
  1165. {
  1166. bytealign(dec);
  1167. loadbits(dec);
  1168. if (eofbits(dec))
  1169. break;
  1171. Code = showbits(dec,32);
  1172. if ((Code & ~0xFF)==0x100)
  1173. {
  1174. flushbits(dec,32);
  1175. if (Code >= SLICE_MIN_START_CODE && Code <= SLICE_MAX_START_CODE)
  1176. {
  1177. // found a slice
  1179. Code = (Code-1) & 0xFF;
  1180. if (Code >= dec->mb_ysize) 
  1181. {
  1182. Result = ERR_INVALID_DATA;
  1183. break;
  1184. }
  1186. if (dec->frame_state)
  1187. {
  1188. if (dec->frame_state<0 || dec->Codec.IDCT.Count<2)
  1189. {
  1190. Result = ERR_INVALID_DATA; // no picture header
  1191. break;
  1192. }
  1194. Result = StartFrame(dec);
  1195. if (Result != ERR_NONE || dec->Codec.Show < 0)
  1196. break;
  1198. dec->frame_state = 0;
  1199. }
  1201. loadbits(dec);
  1202. dec->qscale = readqscale(dec);
  1204. while (getbits1(dec)) 
  1205. {
  1206. flushbits(dec,8);
  1207. loadbits(dec);
  1208. }
  1210. readskip(dec);
  1211. Code = MB_X*Code + dec->skip;
  1212. dec->skip = 0;
  1214. dec->last_dc[2] =
  1215. dec->last_dc[1] =
  1216. dec->last_dc[0] = 128;
  1217. dec->fmv[0] = dec->bmv[0] = 0;
  1219. loadbits(dec);
  1221. switch (dec->prediction_type) 
  1222. {
  1223. case P_VOP:
  1224. Result = PVOP_Slice(dec,Code);
  1225. break;
  1226. case I_VOP:
  1227. Result = IVOP_Slice(dec,Code);
  1228. break;
  1229. case B_VOP:
  1230. Result = BVOP_Slice(dec,Code);
  1231. break;
  1232. }
  1233. }
  1234. else
  1235. if (Code == PICTURE_START_CODE)
  1236. {
  1237. if (dec->ValidSeq)
  1238. Picture(dec);
  1239. else
  1240. Result = ERR_INVALID_DATA;
  1241. }
  1242. else
  1243. if (Code == SEQ_START_CODE)
  1244. Sequence(dec);
  1245. else
  1246. if (Code == EXT_START_CODE)
  1247. {
  1248. if (!dec->ErrorShowed)
  1249. {
  1250. pin Pin;
  1251. Pin.No = CODECIDCT_INPUT;
  1252. Pin.Node = &dec->Codec.Node;
  1254. dec->ErrorShowed = 1;
  1255. if (!dec->Codec.NotSupported.Node || 
  1256. dec->Codec.NotSupported.Node->Set(dec->Codec.NotSupported.Node,dec->Codec.NotSupported.No,
  1257. &Pin,sizeof(pin))!=ERR_NONE)
  1258. ShowError(dec->Codec.Node.Class,MPEG1_ID,MPEG2_NOT_SUPPORTED);
  1259. else
  1260. Result = ERR_INVALID_DATA;
  1261. }
  1262. }
  1263. }
  1264. else
  1265. flushbits(dec,8);
  1266. }
  1267. while (Result == ERR_NONE);
  1269. if (dec->frame_state==0)
  1270. {
  1271. dec->Codec.IDCT.Ptr->FrameEnd(dec->Codec.IDCT.Ptr);
  1272. dec->Frame++;
  1274. // possible (uint8) framemap overflow?
  1275. if ((dec->Frame - dec->mapofs) >= 128) 
  1276. {
  1277. int pos;
  1278. for (pos=0;pos<dec->pos_end;pos+=MB_X-dec->mb_xsize)
  1279. for (;POSX(pos)<dec->mb_xsize;++pos)
  1280. {
  1281. int i = dec->framemap[pos];
  1282. if (i >= (120<<1))
  1283. i -= 120<<1;
  1284. else
  1285. i &= 1;
  1286. dec->framemap[pos] = (uint8_t)i;
  1287. }
  1289. dec->mapofs += 120;
  1290. }
  1291. }
  1293. return Result;
  1294. }
  1296. static int Create( mpeg_decode* p )
  1297. {
  1298. p->Codec.MinCount = 2;
  1299. p->Codec.DefCount = 3; // default assuming B-frames (avoid reinit when reaching first B-frame)
  1300. p->Codec.FindNext = (codecidctnext)FindNext;
  1301. p->Codec.Frame = (codecidctframe)Frame;
  1302. p->Codec.UpdateSize = (nodefunc)UpdateSize;
  1303. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  1304. p->Codec.Discontinuity = (nodefunc)Discontinuity;
  1305. p->Codec.Flush = (nodefunc)Flush;
  1306. return ERR_NONE;
  1307. }
  1309. static const nodedef MPEG1 =
  1310. {
  1311. sizeof(mpeg_decode),
  1312. MPEG1_ID,
  1313. CODECIDCT_CLASS,
  1314. PRI_DEFAULT,
  1315. (nodecreate)Create,
  1316. NULL,
  1317. };
  1319. void MPEG1_Init()
  1320. {
  1321. NodeRegisterClass(&MPEG1);
  1322. }
  1324. void MPEG1_Done()
  1325. {
  1326. NodeUnRegisterClass(MPEG1_ID);
  1327. }