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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
getpic.c
资源名称：DirectShowcode.rar　[点击查看]
上传用户：hhs829
上传日期：2022-06-17
资源大小：586k
文件大小：43k
源码类别：

DirextX编程

开发平台：

Visual C++

getpic.c：源码内容
  1. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  28. #include "global.h"
  29. #include "getbit.h"
  31. static int cc_table[12] = {
  32. 0, 0, 0, 0, 1, 2, 1, 2, 1, 2, 1, 2
  33. };
  35. /* private prototypes*/
  36. __forceinline static void Update_Picture_Buffers(void);
  37. __forceinline static void picture_data(void);
  38. __forceinline static int slice(int MBAmax);
  39. __forceinline static void macroblock_modes(int *pmacroblock_type, int *pmotion_type,
  40. int *pmotion_vector_count, int *pmv_format, int *pdmv, int *pmvscale, int *pdct_type);
  41. __forceinline static void Clear_Block(int count);
  42. __forceinline static void Add_Block(int count, int bx, int by, int dct_type, int addflag);
  43. __forceinline static void motion_compensation(int MBA, int macroblock_type, int motion_type,
  44. int PMV[2][2][2], int motion_vertical_field_select[2][2], int dmvector[2], int dct_type);
  45. __forceinline static void skipped_macroblock(int dc_dct_pred[3], int PMV[2][2][2], 
  46. int *motion_type, int motion_vertical_field_select[2][2], int *macroblock_type);
  47. __forceinline static int start_of_slice(int *MBA, int *MBAinc, int dc_dct_pred[3], int PMV[2][2][2]);
  48. __forceinline static int decode_macroblock(int *macroblock_type, int *motion_type, int *dct_type,
  49. int PMV[2][2][2], int dc_dct_pred[3], int motion_vertical_field_select[2][2], int dmvector[2]);
  50. __forceinline static void Decode_MPEG2_Intra_Block(int comp, int dc_dct_pred[]);
  51. __forceinline static void Decode_MPEG2_Non_Intra_Block(int comp);
  53. __forceinline static int Get_macroblock_type(void);
  54. __forceinline static int Get_I_macroblock_type(void);
  55. __forceinline static int Get_P_macroblock_type(void);
  56. __forceinline static int Get_B_macroblock_type(void);
  57. __forceinline static int Get_D_macroblock_type(void);
  58. __forceinline static int Get_coded_block_pattern(void);
  59. __forceinline static int Get_macroblock_address_increment(void);
  60. __forceinline static int Get_Luma_DC_dct_diff(void);
  61. __forceinline static int Get_Chroma_DC_dct_diff(void);
  63. __forceinline static void form_predictions(int bx, int by, int macroblock_type, int motion_type, int PMV[2][2][2], 
  64. int motion_vertical_field_select[2][2], int dmvector[2]);
  65. static void form_prediction(unsigned char *src[], int sfield, unsigned char *dst[], int dfield, 
  66. int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag);
  67. __forceinline static void form_component_prediction(unsigned char *src, unsigned char *dst,
  68. int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag);
  70. /* decode one frame */
  71. int Decode_Picture()
  72. {
  73. gIsPictureDecoding = TRUE;
  75. if (picture_structure==FRAME_PICTURE && Second_Field)
  76. Second_Field = 0;
  78. if (picture_coding_type!=B_TYPE)
  79. {
  80. d2v_forward = d2v_backward;
  81. d2v_backward = d2v_current;
  82. }
  84. /* update picture buffer pointers */
  85. Update_Picture_Buffers();
  87. /* decode picture data ISO/IEC 13818-2 section 6.2.3.7 */
  88. picture_data();
  90. /* write or display current or previously decoded reference frame */
  91. /* ISO/IEC 13818-2 section 6.1.1.11: Frame reordering */
  92. if (Frame_Number && (picture_structure==FRAME_PICTURE || Second_Field))
  93. {
  94. if (picture_coding_type==B_TYPE)
  95. Write_Frame(auxframe, d2v_current, Frame_Number-1);
  96. else
  97. Write_Frame(forward_reference_frame, d2v_forward, Frame_Number-1);
  98. }
  99. else if (picture_structure==FRAME_PICTURE || Second_Field)
  100. {
  101. Write_Frame(backward_reference_frame, d2v_backward, 0);
  102. }
  104. if (picture_structure!=FRAME_PICTURE)
  105. Second_Field = !Second_Field;
  107. if (!Second_Field)
  108. Frame_Number++;
  110. gIsPictureDecoding = FALSE;
  112. if (Fault_Flag)
  113. return 0; // Indicating decoding failure
  114. return 1;
  115. }
  117. /* reuse old picture buffers as soon as they are no longer needed */
  118. static void Update_Picture_Buffers()
  119. {
  120. int cc;              /* color component index */
  121. unsigned char *tmp;  /* temporary swap pointer */
  123. for (cc=0; cc<3; cc++)
  124. {
  125. /* B pictures do not need to be save for future reference */
  126. if (picture_coding_type==B_TYPE)
  127. current_frame[cc] = auxframe[cc];
  128. else
  129. {
  130. if (!Second_Field)
  131. {
  132. /* only update at the beginning of the coded frame */
  133. tmp = forward_reference_frame[cc];
  135. /* the previously decoded reference frame is stored coincident with the 
  136.    location where the backward reference frame is stored (backwards 
  137.    prediction is not needed in P pictures) */
  138. forward_reference_frame[cc] = backward_reference_frame[cc];
  140. /* update pointer for potential future B pictures */
  141. backward_reference_frame[cc] = tmp;
  142. }
  144. /* can erase over old backward reference frame since it is not used
  145.    in a P picture, and since any subsequent B pictures will use the 
  146.    previously decoded I or P frame as the backward_reference_frame */
  147. current_frame[cc] = backward_reference_frame[cc];
  148. }
  150.     if (picture_structure==BOTTOM_FIELD)
  151. current_frame[cc] += (cc==0) ? Coded_Picture_Width : Chroma_Width;
  152. }
  153. }
  155. /* decode all macroblocks of the current picture */
  156. /* stages described in ISO/IEC 13818-2 section 7 */
  157. static void picture_data()
  158. {
  159. int MBAmax;
  161. /* number of macroblocks per picture */
  162. MBAmax = mb_width*mb_height;
  164. if (picture_structure!=FRAME_PICTURE)
  165. MBAmax>>=1;
  167. for (;;)
  168. if (slice(MBAmax)<0) // If return -1, terminate slice decoding
  169. return;
  170. }
  172. /* decode all macroblocks of the current picture */
  173. /* ISO/IEC 13818-2 section 6.3.16 */
  174. /* return 0 : go to next slice */
  175. /* return -1: go to next picture */
  176. static int slice(int MBAmax)
  177. {
  178. int MBA = 0, MBAinc =0, macroblock_type, motion_type, dct_type, ret;
  179. int dc_dct_pred[3], PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
  181. if ((ret=start_of_slice(&MBA, &MBAinc, dc_dct_pred, PMV)) != 1)
  182. return ret;
  184. for (;;)
  185. {
  186. /* this is how we properly exit out of picture */
  187. if (MBA>=MBAmax) return -1; // all macroblocks decoded
  189. if (MBAinc==0)
  190. {
  191. if (!Show_Bits(23) || Fault_Flag) // next_start_code or fault
  192. {
  193. resync:
  194. if (Fault_Flag == ERROR_FLUSH)
  195. return -1; // exit because flushing
  197. Fault_Flag = 0;
  198. return 0; // trigger: go to next slice
  199. }
  200. else /* neither next_start_code nor Fault_Flag */
  201. {
  202. /* decode macroblock address increment */
  203. MBAinc = Get_macroblock_address_increment();
  204. if (Fault_Flag) goto resync;
  205. }
  206. }
  208. if (MBAinc==1) /* not skipped */
  209. {
  210. if (!decode_macroblock(&macroblock_type, &motion_type, &dct_type, PMV,
  211. dc_dct_pred, motion_vertical_field_select, dmvector))
  212. goto resync;
  213. }
  214. else /* MBAinc!=1: skipped macroblock */
  215. /* ISO/IEC 13818-2 section 7.6.6 */
  216. skipped_macroblock(dc_dct_pred, PMV, &motion_type, motion_vertical_field_select, &macroblock_type);
  218. /* ISO/IEC 13818-2 section 7.6 */
  219. motion_compensation(MBA, macroblock_type, motion_type, PMV,
  220. motion_vertical_field_select, dmvector, dct_type);
  222. __asm emms;
  224. /* advance to next macroblock */
  225. MBA++; MBAinc--;
  227. if (MBA>=MBAmax) return -1; // all macroblocks decoded
  228. }
  229. }
  231. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  232. static void macroblock_modes(int *pmacroblock_type, int *pmotion_type,
  233.  int *pmotion_vector_count, int *pmv_format,
  234.  int *pdmv, int *pmvscale, int *pdct_type)
  235. {
  236. int macroblock_type, motion_type, motion_vector_count;
  237. int mv_format, dmv, mvscale, dct_type;
  239. /* get macroblock_type */
  240. macroblock_type = Get_macroblock_type();
  241. if (Fault_Flag) return;
  243. /* get frame/field motion type */
  244. if (macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
  245. {
  246. if (picture_structure==FRAME_PICTURE)
  247. motion_type = frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
  248. else
  249. motion_type = Get_Bits(2);
  250.     }
  251. else if ((macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  252. motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  254. /* derive motion_vector_count, mv_format and dmv, (table 6-17, 6-18) */
  255. if (picture_structure==FRAME_PICTURE)
  256. {
  257. motion_vector_count = (motion_type==MC_FIELD) ? 2 : 1;
  258. mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  259. }
  260. else
  261. {
  262. motion_vector_count = (motion_type==MC_16X8) ? 2 : 1;
  263. mv_format = MV_FIELD;
  264. }
  266. dmv = (motion_type==MC_DMV); /* dual prime */
  268. /*
  269.    field mv predictions in frame pictures have to be scaled
  270.    ISO/IEC 13818-2 section 7.6.3.1 Decoding the motion vectors
  271. */
  272. mvscale = (mv_format==MV_FIELD && picture_structure==FRAME_PICTURE);
  274. /* get dct_type (frame DCT / field DCT) */
  275. dct_type = picture_structure==FRAME_PICTURE && !frame_pred_frame_dct
  276. && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)) ? Get_Bits(1) : 0;
  278. /* return values */
  279. *pmacroblock_type = macroblock_type;
  280. *pmotion_type = motion_type;
  281. *pmotion_vector_count = motion_vector_count;
  282. *pmv_format = mv_format;
  283. *pdmv = dmv;
  284. *pmvscale = mvscale;
  285. *pdct_type = dct_type;
  286. }
  288. /* move/add 8x8-Block from block[comp] to backward_reference_frame */
  289. /* copy reconstructed 8x8 block from block[comp] to current_frame[]
  290.    ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data
  291.    This stage also embodies some of the operations implied by:
  292.    - ISO/IEC 13818-2 section 7.6.7: Combining predictions
  293.    - ISO/IEC 13818-2 section 6.1.3: Macroblock
  294. */
  295. static void Add_Block(int count, int bx, int by, int dct_type, int addflag)
  296. {
  297. static const __int64 mmmask_128 = 0x0080008000800080;
  299. int comp, cc, iincr, bxh, byh;
  300. unsigned char *rfp;
  301. short *Block_Ptr;
  303. for (comp=0; comp<count; comp++)
  304. {
  305. Block_Ptr = block[comp];
  306. cc = cc_table[comp];
  308. if (cc==0)
  309. {
  310. if (picture_structure==FRAME_PICTURE)
  311. {
  312. if (dct_type)
  313. {
  314. rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
  315. iincr = Coded_Picture_Width<<1;
  316. }
  317. else
  318. {
  319. rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  320. iincr = Coded_Picture_Width;
  321. }
  322. }
  323. else
  324. {
  325. rfp = current_frame[0] + (Coded_Picture_Width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  326. iincr = Coded_Picture_Width<<1;
  327. }
  328. }
  329. else
  330. {
  331. if (chroma_format!=CHROMA444)
  332. bxh = bx >> 1;
  333. if (chroma_format==CHROMA420)
  334. byh = by >> 1;
  336. if (picture_structure==FRAME_PICTURE)
  337. {
  338. if (dct_type && chroma_format!=CHROMA420)
  339. {
  340. /* field DCT coding */
  341. rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)>>1)) + bxh + (comp&8);
  342. iincr = Chroma_Width<<1;
  343. }
  344. else
  345. {
  346. /* frame DCT coding */
  347. rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)<<2)) + bxh + (comp&8);
  348. iincr = Chroma_Width;
  349. }
  350. }
  351. else
  352. {
  353. /* field picture */
  354. rfp = current_frame[cc] + (Chroma_Width<<1)*(byh+((comp&2)<<2)) + bxh + (comp&8);
  355. iincr = Chroma_Width<<1;
  356. }
  357. }
  359. if (addflag)
  360. {
  361. __asm
  362. {
  363. pxor mm0, mm0
  364. mov eax, [rfp]
  365. mov ebx, [Block_Ptr]
  366. mov edi, 8
  367. addon:
  368. movq mm2, [ebx+8]
  370. movq mm3, [eax]
  371. movq mm4, mm3
  373. movq mm1, [ebx]
  374. punpckhbw mm3, mm0
  376. paddsw mm3, mm2
  377. packuswb mm3, mm0
  379. punpcklbw mm4, mm0
  380. psllq mm3, 32
  382. paddsw mm4, mm1
  383. packuswb mm4, mm0
  385. por mm3, mm4
  386. add ebx, 16
  388. sub edi, 0x01
  389. movq [eax], mm3
  391. add eax, [iincr]
  392. cmp edi, 0x00
  393. jg addon
  394. }
  395. }
  396. else
  397. {
  398. __asm
  399. {
  400. mov eax, [rfp]
  401. mov ebx, [Block_Ptr]
  402. mov edi, 8
  404. pxor mm0, mm0
  405. movq mm7, [mmmask_128]
  406. addoff:
  407. movq mm3, [ebx+8]
  408. movq mm4, [ebx]
  410. paddsw mm3, mm7
  411. paddsw mm4, mm7
  413. packuswb mm3, mm0
  414. packuswb mm4, mm0
  416. psllq mm3, 32
  417. por mm3, mm4
  419. add ebx, 16
  420. sub edi, 0x01
  422. movq [eax], mm3
  424. add eax, [iincr]
  425. cmp edi, 0x00
  426. jg addoff
  427. }
  428. }
  429. }
  430. }
  432. /* set scratch pad macroblock to zero */
  433. static void Clear_Block(int count)
  434. {
  435. int comp;
  436. short *Block_Ptr;
  438. for (comp=0; comp<count; comp++)
  439. {
  440. Block_Ptr = block[comp];
  442. __asm
  443. {
  444. mov eax, [Block_Ptr];
  445. pxor mm0, mm0;
  446. movq [eax+0 ], mm0;
  447. movq [eax+8 ], mm0;
  448. movq [eax+16], mm0;
  449. movq [eax+24], mm0;
  450. movq [eax+32], mm0;
  451. movq [eax+40], mm0;
  452. movq [eax+48], mm0;
  453. movq [eax+56], mm0;
  454. movq [eax+64], mm0;
  455. movq [eax+72], mm0;
  456. movq [eax+80], mm0;
  457. movq [eax+88], mm0;
  458. movq [eax+96], mm0;
  459. movq [eax+104],mm0;
  460. movq [eax+112],mm0;
  461. movq [eax+120],mm0;
  462. }
  463. }
  465. __asm emms;
  466. }
  468. /* ISO/IEC 13818-2 section 7.6 */
  469. static void motion_compensation(int MBA, int macroblock_type, int motion_type, 
  470. int PMV[2][2][2], int motion_vertical_field_select[2][2],
  471. int dmvector[2], int dct_type)
  472. {
  473. int bx, by;
  474. int comp;
  476. /* derive current macroblock position within picture */
  477. /* ISO/IEC 13818-2 section 6.3.1.6 and 6.3.1.7 */
  478. bx = 16*(MBA%mb_width);
  479. by = 16*(MBA/mb_width);
  481. /* motion compensation */
  482. if (!(macroblock_type & MACROBLOCK_INTRA))
  483. form_predictions(bx, by, macroblock_type, motion_type, PMV,
  484.  motion_vertical_field_select, dmvector);
  486. switch (iDCT_Flag)
  487. {
  488. case IDCT_MMX:
  489. for (comp=0; comp<block_count; comp++)
  490. MMX_IDCT(block[comp]);
  491. break;
  493. case IDCT_FPU:
  494. __asm emms;
  495. for (comp=0; comp<block_count; comp++)
  496. FPU_IDCT(block[comp]);
  497. break;
  499. case IDCT_REF:
  500. __asm emms;
  501. for (comp=0; comp<block_count; comp++)
  502. REF_IDCT(block[comp]);
  503. break;
  504. }
  506. Add_Block(block_count, bx, by, dct_type, (macroblock_type & MACROBLOCK_INTRA)==0);
  507. }
  509. /* ISO/IEC 13818-2 section 7.6.6 */
  510. static void skipped_macroblock(int dc_dct_pred[3], int PMV[2][2][2], int *motion_type, 
  511.    int motion_vertical_field_select[2][2], int *macroblock_type)
  512. {
  513. Clear_Block(block_count);
  515. /* reset intra_dc predictors */
  516. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  517. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  519. /* reset motion vector predictors */
  520. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  521. if (picture_coding_type==P_TYPE)
  522. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  524. /* derive motion_type */
  525. if (picture_structure==FRAME_PICTURE)
  526. *motion_type = MC_FRAME;
  527. else
  528. {
  529. *motion_type = MC_FIELD;
  530. motion_vertical_field_select[0][0] = motion_vertical_field_select[0][1] = 
  531. (picture_structure==BOTTOM_FIELD);
  532. }
  534. /* clear MACROBLOCK_INTRA */
  535. *macroblock_type&= ~MACROBLOCK_INTRA;
  536. }
  538. /* return==-1 means go to next picture */
  539. /* the expression "start of slice" is used throughout the normative
  540.    body of the MPEG specification */
  541. static int start_of_slice(int *MBA, int *MBAinc,
  542.   int dc_dct_pred[3], int PMV[2][2][2])
  543. {
  544. unsigned int code;
  545. int slice_vert_pos_ext;
  547. next_start_code();
  548. code = Get_Bits(32);
  550. if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
  551. {
  552. // only slice headers are allowed in picture_data
  553. Fault_Flag = 10;
  554. return -1;
  555. }
  557. /* decode slice header (may change quantizer_scale) */
  558. slice_vert_pos_ext = slice_header();
  560. /* decode macroblock address increment */
  561. *MBAinc = Get_macroblock_address_increment();
  562. if (Fault_Flag) return -1;
  564. /* set current location */
  565. /* NOTE: the arithmetic used to derive macroblock_address below is
  566.    equivalent to ISO/IEC 13818-2 section 6.3.17: Macroblock */
  567. *MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *MBAinc - 1;
  568. *MBAinc = 1; // first macroblock in slice: not skipped
  570. /* reset all DC coefficient and motion vector predictors */
  571. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  572. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  573.   
  574. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  575. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  576. PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  578. /* successfull: trigger decode macroblocks in slice */
  579. return 1;
  580. }
  582. /* ISO/IEC 13818-2 sections 7.2 through 7.5 */
  583. static int decode_macroblock(int *macroblock_type, int *motion_type, int *dct_type,
  584.  int PMV[2][2][2], int dc_dct_pred[3], 
  585.  int motion_vertical_field_select[2][2], int dmvector[2])
  586. {
  587. int quantizer_scale_code, comp, motion_vector_count, mv_format; 
  588. int dmv, mvscale, coded_block_pattern;
  590. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  591. macroblock_modes(macroblock_type, motion_type, &motion_vector_count, &mv_format,
  592.  &dmv, &mvscale, dct_type);
  593. if (Fault_Flag) return 0; // trigger: go to next slice
  595. if (*macroblock_type & MACROBLOCK_QUANT)
  596. {
  597. quantizer_scale_code = Get_Bits(5);
  599. /* ISO/IEC 13818-2 section 7.4.2.2: Quantizer scale factor */
  600. quantizer_scale = q_scale_type ?
  601. Non_Linear_quantizer_scale[quantizer_scale_code] : (quantizer_scale_code << 1);
  602. }
  604. /* ISO/IEC 13818-2 section 6.3.17.2: Motion vectors */
  605. /* decode forward motion vectors */
  606. if ((*macroblock_type & MACROBLOCK_MOTION_FORWARD) 
  607. || ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors))
  608. motion_vectors(PMV, dmvector, motion_vertical_field_select, 0,
  609. motion_vector_count, mv_format, f_code[0][0]-1, f_code[0][1]-1, dmv, mvscale);
  610. if (Fault_Flag) return 0; // trigger: go to next slice
  612. /* decode backward motion vectors */
  613. if (*macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  614. motion_vectors(PMV, dmvector, motion_vertical_field_select, 1,
  615. motion_vector_count,mv_format, f_code[1][0]-1, f_code[1][1]-1, 0, mvscale);
  616. if (Fault_Flag) return 0;  // trigger: go to next slice
  618. if ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  619. Flush_Buffer(1); // marker bit
  621. /* macroblock_pattern */
  622. /* ISO/IEC 13818-2 section 6.3.17.4: Coded block pattern */
  623. if (*macroblock_type & MACROBLOCK_PATTERN)
  624. {
  625. coded_block_pattern = Get_coded_block_pattern();
  627. if (chroma_format==CHROMA422)
  628. coded_block_pattern = (coded_block_pattern<<2) | Get_Bits(2);
  629. else if (chroma_format==CHROMA444)
  630. coded_block_pattern = (coded_block_pattern<<6) | Get_Bits(6);
  631. }
  632. else
  633.     coded_block_pattern = (*macroblock_type & MACROBLOCK_INTRA) ? (1<<block_count)-1 : 0;
  635. if (Fault_Flag) return 0; // trigger: go to next slice
  637. Clear_Block(block_count);
  639. /* decode blocks */
  640. for (comp=0; comp<block_count; comp++)
  641. {
  642. if (coded_block_pattern & (1<<(block_count-1-comp)))
  643. {
  644. if (*macroblock_type & MACROBLOCK_INTRA)
  645. Decode_MPEG2_Intra_Block(comp, dc_dct_pred);
  646. else
  647. Decode_MPEG2_Non_Intra_Block(comp);
  649. if (Fault_Flag) return 0; // trigger: go to next slice
  650. }
  651. }
  653. /* reset intra_dc predictors */
  654. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  655. if (!(*macroblock_type & MACROBLOCK_INTRA))
  656. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  658. /* reset motion vector predictors */
  659. if ((*macroblock_type & MACROBLOCK_INTRA) && !concealment_motion_vectors)
  660. {
  661. /* intra mb without concealment motion vectors */
  662. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  663. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  664. PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  665. }
  667. /* special "No_MC" macroblock_type case */
  668. /* ISO/IEC 13818-2 section 7.6.3.5: Prediction in P pictures */
  669. if (picture_coding_type==P_TYPE && !(*macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
  670. {
  671. /* non-intra mb without forward mv in a P picture */
  672. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  673. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  675. /* derive motion_type */
  676. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes, frame_motion_type */
  677. if (picture_structure==FRAME_PICTURE)
  678. *motion_type = MC_FRAME;
  679. else
  680. {
  681. *motion_type = MC_FIELD;
  682. motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
  683. }
  684. }
  685. /* successfully decoded macroblock */
  686. return 1 ;
  687. }
  689. /* decode one intra coded MPEG-2 block */
  690. static void Decode_MPEG2_Intra_Block(int comp, int dc_dct_pred[])
  691. {
  692. int val, i, j, sign, *qmat;
  693. unsigned int code;
  694. DCTtab *tab;
  695. short *bp;
  697. bp = block[comp];
  698. qmat = (comp<4 || chroma_format==CHROMA420) 
  699. ? intra_quantizer_matrix : chroma_intra_quantizer_matrix;
  701. /* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
  702. switch (cc_table[comp])
  703. {
  704. case 0:
  705. val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
  706. break;
  708. case 1:
  709. val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
  710. break;
  712. case 2:
  713. val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
  714. break;
  715. }
  717. bp[0] = val << (3-intra_dc_precision);
  719. /* decode AC coefficients */
  720. for (i=1; ; i++)
  721. {
  722. code = Show_Bits(16);
  724. if (code>=16384 && !intra_vlc_format)
  725. tab = &DCTtabnext[(code>>12)-4];
  726. else if (code>=1024)
  727. {
  728. if (intra_vlc_format)
  729. tab = &DCTtab0a[(code>>8)-4];
  730. else
  731. tab = &DCTtab0[(code>>8)-4];
  732. }
  733. else if (code>=512)
  734. {
  735. if (intra_vlc_format)
  736. tab = &DCTtab1a[(code>>6)-8];
  737. else
  738. tab = &DCTtab1[(code>>6)-8];
  739. }
  740. else if (code>=256)
  741. tab = &DCTtab2[(code>>4)-16];
  742. else if (code>=128)
  743. tab = &DCTtab3[(code>>3)-16];
  744. else if (code>=64)
  745. tab = &DCTtab4[(code>>2)-16];
  746. else if (code>=32)
  747. tab = &DCTtab5[(code>>1)-16];
  748. else if (code>=16)
  749. tab = &DCTtab6[code-16];
  750. else
  751. {
  752. Fault_Flag = 1;
  753. return;
  754. }
  756. Flush_Buffer(tab->len);
  758. if (tab->run<64)
  759. {
  760. i+= tab->run;
  761. val = tab->level;
  762. sign = Get_Bits(1);
  763. }
  764. else if (tab->run==64) /* end_of_block */
  765. return;
  766. else /* escape */
  767. {
  768. i+= Get_Bits(6);
  769. val = Get_Bits(12);
  771. if (sign = (val>=2048))
  772. val = 4096 - val;
  773. }
  775. j = scan[alternate_scan][i];
  777. val = (val * quantizer_scale * qmat[j]) >> 4;
  778. bp[j] = sign ? -val : val;
  779. }
  780. }
  782. /* decode one non-intra coded MPEG-2 block */
  783. static void Decode_MPEG2_Non_Intra_Block(int comp)
  784. {
  785. int val, i, j, sign, *qmat;
  786. unsigned int code;
  787. DCTtab *tab;
  788. short *bp;
  790. bp = block[comp];
  791. qmat = (comp<4 || chroma_format==CHROMA420) 
  792. ? non_intra_quantizer_matrix : chroma_non_intra_quantizer_matrix;
  794. /* decode AC coefficients */
  795. for (i=0; ; i++)
  796. {
  797. code = Show_Bits(16);
  799. if (code>=16384)
  800. {
  801. if (i==0)
  802. tab = &DCTtabfirst[(code>>12)-4];
  803. else
  804. tab = &DCTtabnext[(code>>12)-4];
  805. }
  806. else if (code>=1024)
  807. tab = &DCTtab0[(code>>8)-4];
  808. else if (code>=512)
  809. tab = &DCTtab1[(code>>6)-8];
  810. else if (code>=256)
  811. tab = &DCTtab2[(code>>4)-16];
  812. else if (code>=128)
  813. tab = &DCTtab3[(code>>3)-16];
  814. else if (code>=64)
  815. tab = &DCTtab4[(code>>2)-16];
  816. else if (code>=32)
  817. tab = &DCTtab5[(code>>1)-16];
  818. else if (code>=16)
  819. tab = &DCTtab6[code-16];
  820. else
  821. {
  822. Fault_Flag = 1;
  823. return;
  824. }
  826. Flush_Buffer(tab->len);
  828. if (tab->run<64)
  829. {
  830. i+= tab->run;
  831. val = tab->level;
  832. sign = Get_Bits(1);
  833. }
  834. else if (tab->run==64) /* end_of_block */
  835. return;
  836. else /* escape */
  837. {
  838. i+= Get_Bits(6);
  839. val = Get_Bits(12);
  841. if (sign = (val>=2048))
  842. val = 4096 - val;
  843. }
  845. j = scan[alternate_scan][i];
  847. val = (((val<<1)+1) * quantizer_scale * qmat[j]) >> 5;
  848. bp[j] = sign ? -val : val;
  849. }
  850. }
  852. static int Get_macroblock_type()
  853. {
  854. int macroblock_type;
  856. switch (picture_coding_type)
  857. {
  858. case I_TYPE:
  859. macroblock_type = Get_I_macroblock_type();
  860. break;
  862. case P_TYPE:
  863. macroblock_type = Get_P_macroblock_type();
  864. break;
  866. case B_TYPE:
  867. macroblock_type = Get_B_macroblock_type();
  868. break;
  869. }
  871. return macroblock_type;
  872. }
  874. static int Get_I_macroblock_type()
  875. {
  876. if (Get_Bits(1))
  877. return 1;
  879. if (!Get_Bits(1))
  880. Fault_Flag = 2;
  882. return 17;
  883. }
  885. static int Get_P_macroblock_type()
  886. {
  887. int code;
  889. if ((code = Show_Bits(6))>=8)
  890. {
  891. code >>= 3;
  892. Flush_Buffer(PMBtab0[code].len);
  894. return PMBtab0[code].val;
  895. }
  897. if (code==0)
  898. {
  899. Fault_Flag = 2;
  900. return 0;
  901. }
  903. Flush_Buffer(PMBtab1[code].len);
  905. return PMBtab1[code].val;
  906. }
  908. static int Get_B_macroblock_type()
  909. {
  910. int code;
  912. if ((code = Show_Bits(6))>=8)
  913. {
  914. code >>= 2;
  915. Flush_Buffer(BMBtab0[code].len);
  917. return BMBtab0[code].val;
  918. }
  920. if (code==0)
  921. {
  922. Fault_Flag = 2;
  923. return 0;
  924. }
  926. Flush_Buffer(BMBtab1[code].len);
  928. return BMBtab1[code].val;
  929. }
  931. static int Get_coded_block_pattern()
  932. {
  933. int code;
  935. if ((code = Show_Bits(9))>=128)
  936. {
  937. code >>= 4;
  938. Flush_Buffer(CBPtab0[code].len);
  940. return CBPtab0[code].val;
  941. }
  943. if (code>=8)
  944. {
  945. code >>= 1;
  946. Flush_Buffer(CBPtab1[code].len);
  948. return CBPtab1[code].val;
  949. }
  951. if (code<1)
  952. {
  953. Fault_Flag = 3;
  954. return 0;
  955. }
  957. Flush_Buffer(CBPtab2[code].len);
  959. return CBPtab2[code].val;
  960. }
  962. static int Get_macroblock_address_increment()
  963. {
  964. int code, val;
  966. val = 0;
  968. while ((code = Show_Bits(11))<24)
  969. {
  970. if (code!=15) /* if not macroblock_stuffing */
  971. {
  972. if (code==8) /* if macroblock_escape */
  973. val+= 33;
  974. else
  975. {
  976. Fault_Flag = 4;
  977. return 1;
  978. }
  979. }
  980. Flush_Buffer(11);
  981. }
  983. /* macroblock_address_increment == 1 */
  984. /* ('1' is in the MSB position of the lookahead) */
  985. if (code>=1024)
  986. {
  987. Flush_Buffer(1);
  988. return val + 1;
  989. }
  991. /* codes 00010 ... 011xx */
  992. if (code>=128)
  993. {
  994. /* remove leading zeros */
  995. code >>= 6;
  996. Flush_Buffer(MBAtab1[code].len);
  997.     
  998. return val + MBAtab1[code].val;
  999. }
  1000.   
  1001. /* codes 00000011000 ... 0000111xxxx */
  1002. code-= 24; /* remove common base */
  1003. Flush_Buffer(MBAtab2[code].len);
  1005. return val + MBAtab2[code].val;
  1006. }
  1008. /*
  1009.    parse VLC and perform dct_diff arithmetic.
  1010.    MPEG-2:  ISO/IEC 13818-2 section 7.2.1 
  1012.    Note: the arithmetic here is presented more elegantly than
  1013.    the spec, yet the results, dct_diff, are the same.
  1014. */
  1015. static int Get_Luma_DC_dct_diff()
  1016. {
  1017. int code, size, dct_diff;
  1019. /* decode length */
  1020. code = Show_Bits(5);
  1022. if (code<31)
  1023. {
  1024. size = DClumtab0[code].val;
  1025. Flush_Buffer(DClumtab0[code].len);
  1026. }
  1027. else
  1028. {
  1029. code = Show_Bits(9) - 0x1f0;
  1030. size = DClumtab1[code].val;
  1031. Flush_Buffer(DClumtab1[code].len);
  1032. }
  1034. if (size==0)
  1035. dct_diff = 0;
  1036. else
  1037. {
  1038. dct_diff = Get_Bits(size);
  1040. if ((dct_diff & (1<<(size-1)))==0)
  1041. dct_diff-= (1<<size) - 1;
  1042. }
  1044. return dct_diff;
  1045. }
  1047. static int Get_Chroma_DC_dct_diff()
  1048. {
  1049. int code, size, dct_diff;
  1051. /* decode length */
  1052. code = Show_Bits(5);
  1054. if (code<31)
  1055. {
  1056. size = DCchromtab0[code].val;
  1057. Flush_Buffer(DCchromtab0[code].len);
  1058. }
  1059. else
  1060. {
  1061. code = Show_Bits(10) - 0x3e0;
  1062. size = DCchromtab1[code].val;
  1063. Flush_Buffer(DCchromtab1[code].len);
  1064. }
  1066. if (size==0)
  1067. dct_diff = 0;
  1068. else
  1069. {
  1070. dct_diff = Get_Bits(size);
  1072. if ((dct_diff & (1<<(size-1)))==0)
  1073. dct_diff-= (1<<size) - 1;
  1074. }
  1076. return dct_diff;
  1077. }
  1079. static void form_predictions(int bx, int by, int macroblock_type, int motion_type,
  1080.   int PMV[2][2][2], int motion_vertical_field_select[2][2],
  1081.   int dmvector[2])
  1082. {
  1083. static int currentfield;
  1084. static unsigned char **predframe;
  1085. static int DMV[2][2];
  1086. static int stw;
  1088. stw = 0;
  1090. if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) || picture_coding_type==P_TYPE)
  1091. {
  1092. if (picture_structure==FRAME_PICTURE)
  1093. {
  1094. if (motion_type==MC_FRAME || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  1095. {
  1096. /* frame-based prediction (broken into top and bottom halves
  1097.    for spatial scalability prediction purposes) */
  1098. form_prediction(forward_reference_frame, 0, current_frame, 0, Coded_Picture_Width, 
  1099. Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
  1101. form_prediction(forward_reference_frame, 1, current_frame, 1, Coded_Picture_Width, 
  1102. Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
  1103. }
  1104. else if (motion_type==MC_FIELD) /* field-based prediction */
  1105. {
  1106. /* top field prediction */
  1107. form_prediction(forward_reference_frame, motion_vertical_field_select[0][0], 
  1108. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1109. bx, by>>1, PMV[0][0][0], PMV[0][0][1]>>1, stw);
  1111. /* bottom field prediction */
  1112. form_prediction(forward_reference_frame, motion_vertical_field_select[1][0], 
  1113. current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1114. bx, by>>1, PMV[1][0][0], PMV[1][0][1]>>1, stw);
  1115. }
  1116. else if (motion_type==MC_DMV) /* dual prime prediction */
  1117. {
  1118. /* calculate derived motion vectors */
  1119. Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]>>1);
  1121. /* predict top field from top field */
  1122. form_prediction(forward_reference_frame, 0, current_frame, 0, 
  1123. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  1124. PMV[0][0][0], PMV[0][0][1]>>1, 0);
  1126. /* predict and add to top field from bottom field */
  1127. form_prediction(forward_reference_frame, 1, current_frame, 0,
  1128. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  1129. DMV[0][0], DMV[0][1], 1);
  1131. /* predict bottom field from bottom field */
  1132. form_prediction(forward_reference_frame, 1, current_frame, 1,
  1133. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  1134. PMV[0][0][0], PMV[0][0][1]>>1, 0);
  1136. /* predict and add to bottom field from top field */
  1137. form_prediction(forward_reference_frame, 0, current_frame, 1,
  1138. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  1139. DMV[1][0], DMV[1][1], 1);
  1140. }
  1141. else
  1142. Fault_Flag = 5;
  1143. }
  1144. else
  1145. {
  1146. /* field picture */
  1147. currentfield = (picture_structure==BOTTOM_FIELD);
  1149. /* determine which frame to use for prediction */
  1150. if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[0][0])
  1151. predframe = backward_reference_frame;
  1152. else
  1153. predframe = forward_reference_frame;
  1155. if (motion_type==MC_FIELD || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  1156. {
  1157. form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0, 
  1158. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  1159. PMV[0][0][0], PMV[0][0][1], stw);
  1160. }
  1161. else if (motion_type==MC_16X8)
  1162. {
  1163. form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0, 
  1164. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by,
  1165. PMV[0][0][0], PMV[0][0][1], stw);
  1167. if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[1][0])
  1168. predframe = backward_reference_frame;
  1169. else
  1170. predframe = forward_reference_frame;
  1172. form_prediction(predframe, motion_vertical_field_select[1][0], current_frame, 
  1173. 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by+8,
  1174. PMV[1][0][0], PMV[1][0][1], stw);
  1175. }
  1176. else if (motion_type==MC_DMV)
  1177. {
  1178. if (Second_Field)
  1179. predframe = backward_reference_frame;
  1180. else
  1181. predframe = forward_reference_frame;
  1183. /* calculate derived motion vectors */
  1184. Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]);
  1186. /* predict from field of same parity */
  1187. form_prediction(forward_reference_frame, currentfield, current_frame, 0, 
  1188. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  1189. PMV[0][0][0], PMV[0][0][1], 0);
  1191. /* predict from field of opposite parity */
  1192. form_prediction(predframe, !currentfield, current_frame, 0,
  1193. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  1194. DMV[0][0], DMV[0][1], 1);
  1195. }
  1196. else
  1197. Fault_Flag = 5;
  1198. }
  1200. stw = 1;
  1201. }
  1203. if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  1204. {
  1205. if (picture_structure==FRAME_PICTURE)
  1206. {
  1207. if (motion_type==MC_FRAME)
  1208. {
  1209. /* frame-based prediction */
  1210. form_prediction(backward_reference_frame, 0, current_frame, 0,
  1211. Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
  1212. PMV[0][1][0], PMV[0][1][1], stw);
  1214. form_prediction(backward_reference_frame, 1, current_frame, 1,
  1215. Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
  1216. PMV[0][1][0], PMV[0][1][1], stw);
  1217. }
  1218. else /* field-based prediction */
  1219. {
  1220. /* top field prediction */
  1221. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1], 
  1222. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1223. bx, by>>1, PMV[0][1][0], PMV[0][1][1]>>1, stw);
  1225. /* bottom field prediction */
  1226. form_prediction(backward_reference_frame, motion_vertical_field_select[1][1], 
  1227. current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1228. bx, by>>1, PMV[1][1][0], PMV[1][1][1]>>1, stw);
  1229. }
  1230. }
  1231. else
  1232. {
  1233. /* field picture */
  1234. if (motion_type==MC_FIELD)
  1235. {
  1236. /* field-based prediction */
  1237. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1], 
  1238. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16,
  1239. bx, by, PMV[0][1][0], PMV[0][1][1], stw);
  1240. }
  1241. else if (motion_type==MC_16X8)
  1242. {
  1243. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1],
  1244. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1245. bx, by, PMV[0][1][0], PMV[0][1][1], stw);
  1247. form_prediction(backward_reference_frame, motion_vertical_field_select[1][1],
  1248. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  1249. bx, by+8, PMV[1][1][0], PMV[1][1][1], stw);
  1250. }
  1251. else
  1252. Fault_Flag = 5;
  1253. }
  1254. }
  1255. }
  1257. static void form_prediction(unsigned char *src[], int sfield, unsigned char *dst[],
  1258. int dfield, int lx, int lx2, int w, int h, int x, int y,
  1259. int dx, int dy, int average_flag)
  1260. {
  1261. form_component_prediction(src[0]+(sfield?lx2>>1:0), dst[0]+(dfield?lx2>>1:0),
  1262. lx, lx2, w, h, x, y, dx, dy, average_flag);
  1264. if (chroma_format!=CHROMA444)
  1265. {
  1266. lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
  1267. }
  1269. if (chroma_format==CHROMA420)
  1270. {
  1271. h>>=1; y>>=1; dy/=2;
  1272. }
  1274. /* Cb */
  1275. form_component_prediction(src[1]+(sfield?lx2>>1:0), dst[1]+(dfield?lx2>>1:0),
  1276. lx, lx2, w, h, x, y, dx, dy, average_flag);
  1278. /* Cr */
  1279. form_component_prediction(src[2]+(sfield?lx2>>1:0), dst[2]+(dfield?lx2>>1:0),
  1280. lx, lx2, w, h, x, y, dx, dy, average_flag);
  1281. }
  1283. /* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
  1284. static void form_component_prediction(unsigned char *src, unsigned char *dst,
  1285.   int lx, int lx2, int w, int h, int x, int y,
  1286.   int dx, int dy, int average_flag)
  1287. {
  1288. static const __int64 mmmask_0001 = 0x0001000100010001;
  1289. static const __int64 mmmask_0002 = 0x0002000200020002;
  1290. static const __int64 mmmask_0003 = 0x0003000300030003;
  1291. static const __int64 mmmask_0006 = 0x0006000600060006;
  1293. unsigned char *s = src + lx * (y + (dy>>1)) + x + (dx>>1);
  1294. unsigned char *d = dst + lx * y + x;
  1295. int flag = (average_flag<<2) + ((dx & 1)<<1) + (dy & 1);
  1297. switch (flag)
  1298. {
  1299. case 0:
  1300. // d[i] = s[i];
  1301. __asm
  1302. {
  1303. mov eax, [s]
  1304. mov ebx, [d]
  1305. mov esi, 0x00
  1306. mov edi, [h]
  1307. mc0:
  1308. movq mm1, [eax+esi]
  1309. add esi, 0x08
  1310. cmp esi, [w]
  1311. movq [ebx+esi-8], mm1
  1312. jl mc0
  1314. add eax, [lx2]
  1315. add ebx, [lx2]
  1316. sub edi, 0x01
  1317. mov esi, 0x00
  1318. cmp edi, 0x00
  1319. jg mc0
  1320. }
  1321. break;
  1323. case 1:
  1324. // d[i] = (s[i]+s[i+lx]+1)>>1;
  1325. __asm
  1326. {
  1327. pxor mm0, mm0
  1328. movq mm7, [mmmask_0001]
  1329. mov eax, [s]
  1330. mov ebx, [d]
  1331. mov ecx, eax
  1332. add ecx, [lx]
  1333. mov esi, 0x00
  1334. mov edi, [h]
  1335. mc1:
  1336. movq mm1, [eax+esi]
  1337. movq mm2, [ecx+esi]
  1339. movq mm3, mm1
  1340. movq mm4, mm2
  1342. punpcklbw mm1, mm0
  1343. punpckhbw mm3, mm0
  1344. punpcklbw mm2, mm0
  1345. punpckhbw mm4, mm0
  1347. paddsw mm1, mm2
  1348. paddsw mm3, mm4
  1350. paddsw mm1, mm7
  1351. paddsw mm3, mm7
  1353. psrlw mm1, 1
  1354. psrlw mm3, 1
  1356. packuswb mm1, mm0
  1357. packuswb mm3, mm0
  1359. psllq mm3, 32
  1360. por mm1, mm3
  1362. add esi, 0x08
  1363. cmp esi, [w]
  1364. movq [ebx+esi-8], mm1
  1365. jl mc1
  1367. add eax, [lx2]
  1368. add ebx, [lx2]
  1369. add ecx, [lx2]
  1370. sub edi, 0x01
  1371. mov esi, 0x00
  1372. cmp edi, 0x00
  1373. jg mc1
  1374. }
  1375. break;
  1377. case 2:
  1378. // d[i] = (s[i]+s[i+1]+1)>>1;
  1379. __asm
  1380. {
  1381. pxor mm0, mm0
  1382. movq mm7, [mmmask_0001]
  1383. mov eax, [s]
  1384. mov ebx, [d]
  1385. mov esi, 0x00
  1386. mov edi, [h]
  1387. mc2:
  1388. movq mm1, [eax+esi]
  1389. movq mm2, [eax+esi+1]
  1391. movq mm3, mm1
  1392. movq mm4, mm2
  1394. punpcklbw mm1, mm0
  1395. punpckhbw mm3, mm0
  1397. punpcklbw mm2, mm0
  1398. punpckhbw mm4, mm0
  1400. paddsw mm1, mm2
  1401. paddsw mm3, mm4
  1403. paddsw mm1, mm7
  1404. paddsw mm3, mm7
  1406. psrlw mm1, 1
  1407. psrlw mm3, 1
  1409. packuswb mm1, mm0
  1410. packuswb mm3, mm0
  1412. psllq mm3, 32
  1413. por mm1, mm3
  1415. add esi, 0x08
  1416. cmp esi, [w]
  1417. movq [ebx+esi-8], mm1
  1418. jl mc2
  1420. add eax, [lx2]
  1421. add ebx, [lx2]
  1422. sub edi, 0x01
  1423. mov esi, 0x00
  1424. cmp edi, 0x00
  1425. jg mc2
  1426. }
  1427. break;
  1429. case 3:
  1430. // d[i] = (s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
  1431. __asm
  1432. {
  1433. pxor mm0, mm0
  1434. movq mm7, [mmmask_0002]
  1435. mov eax, [s]
  1436. mov ebx, [d]
  1437. mov ecx, eax
  1438. add ecx, [lx]
  1439. mov esi, 0x00
  1440. mov edi, [h]
  1441. mc3:
  1442. movq mm1, [eax+esi]
  1443. movq mm2, [eax+esi+1]
  1444. movq mm3, mm1
  1445. movq mm4, mm2
  1447. punpcklbw mm1, mm0
  1448. punpckhbw mm3, mm0
  1450. punpcklbw mm2, mm0
  1451. punpckhbw mm4, mm0
  1453. paddsw mm1, mm2
  1454. paddsw mm3, mm4
  1456. movq mm5, [ecx+esi]
  1457. paddsw mm1, mm7
  1459. movq mm6, [ecx+esi+1]
  1460. paddsw mm3, mm7
  1462. movq mm2, mm5
  1463. movq mm4, mm6
  1465. punpcklbw mm2, mm0
  1466. punpckhbw mm5, mm0
  1468. punpcklbw mm4, mm0
  1469. punpckhbw mm6, mm0
  1471. paddsw mm2, mm4
  1472. paddsw mm5, mm6
  1474. paddsw mm1, mm2
  1475. paddsw mm3, mm5
  1477. psrlw mm1, 2
  1478. psrlw mm3, 2
  1480. packuswb mm1, mm0
  1481. packuswb mm3, mm0
  1483. psllq mm3, 32
  1484. por mm1, mm3
  1486. add esi, 0x08
  1487. cmp esi, [w]
  1488. movq [ebx+esi-8], mm1
  1489. jl mc3
  1491. add eax, [lx2]
  1492. add ebx, [lx2]
  1493. add ecx, [lx2]
  1494. sub edi, 0x01
  1495. mov esi, 0x00
  1496. cmp edi, 0x00
  1497. jg mc3
  1498. }
  1499. break;
  1501. case 4:
  1502. // d[i] = (s[i]+d[i]+1)>>1;
  1503. __asm
  1504. {
  1505. pxor mm0, mm0
  1506. movq mm7, [mmmask_0001]
  1507. mov eax, [s]
  1508. mov ebx, [d]
  1509. mov esi, 0x00
  1510. mov edi, [h]
  1511. mc4:
  1512. movq mm1, [eax+esi]
  1513. movq mm2, [ebx+esi]
  1514. movq mm3, mm1
  1515. movq mm4, mm2
  1517. punpcklbw mm1, mm0
  1518. punpckhbw mm3, mm0
  1520. punpcklbw mm2, mm0
  1521. punpckhbw mm4, mm0
  1523. paddsw mm1, mm2
  1524. paddsw mm3, mm4
  1526. paddsw mm1, mm7
  1527. paddsw mm3, mm7
  1529. psrlw mm1, 1
  1530. psrlw mm3, 1
  1532. packuswb mm1, mm0
  1533. packuswb mm3, mm0
  1535. psllq mm3, 32
  1536. por mm1, mm3
  1538. add esi, 0x08
  1539. cmp esi, [w]
  1540. movq [ebx+esi-8], mm1
  1541. jl mc4
  1543. add eax, [lx2]
  1544. add ebx, [lx2]
  1545. sub edi, 0x01
  1546. mov esi, 0x00
  1547. cmp edi, 0x00
  1548. jg mc4
  1549. }
  1550. break;
  1552. case 5:
  1553. // d[i] = ((d[i]<<1) + s[i]+s[i+lx] + 3)>>2;
  1554. __asm
  1555. {
  1556. pxor mm0, mm0
  1557. movq mm7, [mmmask_0003]
  1558. mov eax, [s]
  1559. mov ebx, [d]
  1560. mov ecx, eax
  1561. add ecx, [lx]
  1562. mov esi, 0x00
  1563. mov edi, [h]
  1564. mc5:
  1565. movq mm1, [eax+esi]
  1566. movq mm2, [ecx+esi]
  1567. movq mm3, mm1
  1568. movq mm4, mm2
  1570. punpcklbw mm1, mm0
  1571. punpckhbw mm3, mm0
  1573. punpcklbw mm2, mm0
  1574. punpckhbw mm4, mm0
  1576. paddsw mm1, mm2
  1577. paddsw mm3, mm4
  1579. movq mm5, [ebx+esi]
  1581. paddsw mm1, mm7
  1582. paddsw mm3, mm7
  1584. movq mm6, mm5
  1585. punpcklbw mm5, mm0
  1586. punpckhbw mm6, mm0
  1588. psllw mm5, 1
  1589. psllw mm6, 1
  1591. paddsw mm1, mm5
  1592. paddsw mm3, mm6
  1594. psrlw mm1, 2
  1595. psrlw mm3, 2
  1597. packuswb mm1, mm0
  1598. packuswb mm3, mm0
  1600. psllq mm3, 32
  1601. por mm1, mm3
  1603. add esi, 0x08
  1604. cmp esi, [w]
  1605. movq [ebx+esi-8], mm1
  1606. jl mc5
  1608. add eax, [lx2]
  1609. add ebx, [lx2]
  1610. add ecx, [lx2]
  1611. sub edi, 0x01
  1612. mov esi, 0x00
  1613. cmp edi, 0x00
  1614. jg mc5
  1615. }
  1616. break;
  1618. case 6:
  1619. // d[i] = ((d[i]<<1) + s[i]+s[i+1] + 3) >> 2;
  1620. __asm
  1621. {
  1622. pxor mm0, mm0
  1623. movq mm7, [mmmask_0003]
  1624. mov eax, [s]
  1625. mov ebx, [d]
  1626. mov esi, 0x00
  1627. mov edi, [h]
  1628. mc6:
  1629. movq mm1, [eax+esi]
  1630. movq mm2, [eax+esi+1]
  1631. movq mm3, mm1
  1632. movq mm4, mm2
  1634. punpcklbw mm1, mm0
  1635. punpckhbw mm3, mm0
  1637. punpcklbw mm2, mm0
  1638. punpckhbw mm4, mm0
  1640. paddsw mm1, mm2
  1641. paddsw mm3, mm4
  1643. movq mm5, [ebx+esi]
  1645. paddsw mm1, mm7
  1646. paddsw mm3, mm7
  1648. movq mm6, mm5
  1649. punpcklbw mm5, mm0
  1650. punpckhbw mm6, mm0
  1652. psllw mm5, 1
  1653. psllw mm6, 1
  1655. paddsw mm1, mm5
  1656. paddsw mm3, mm6
  1658. psrlw mm1, 2
  1659. psrlw mm3, 2
  1661. packuswb mm1, mm0
  1662. packuswb mm3, mm0
  1664. psllq mm3, 32
  1665. por mm1, mm3
  1667. add esi, 0x08
  1668. cmp esi, [w]
  1669. movq [ebx+esi-8], mm1
  1670. jl mc6
  1672. add eax, [lx2]
  1673. add ebx, [lx2]
  1674. sub edi, 0x01
  1675. mov esi, 0x00
  1676. cmp edi, 0x00
  1677. jg mc6
  1678. }
  1679. break;
  1681. case 7:
  1682. // d[i] = ((d[i]<<2) + s[i]+s[i+1]+s[i+lx]+s[i+lx+1] + 6)>>3;
  1683. __asm
  1684. {
  1685. pxor mm0, mm0
  1686. movq mm7, [mmmask_0006]
  1687. mov eax, [s]
  1688. mov ebx, [d]
  1689. mov ecx, eax
  1690. add ecx, [lx]
  1691. mov esi, 0x00
  1692. mov edi, [h]
  1693. mc7:
  1694. movq mm1, [eax+esi]
  1695. movq mm2, [eax+esi+1]
  1696. movq mm3, mm1
  1697. movq mm4, mm2
  1699. punpcklbw mm1, mm0
  1700. punpckhbw mm3, mm0
  1702. punpcklbw mm2, mm0
  1703. punpckhbw mm4, mm0
  1705. paddsw mm1, mm2
  1706. paddsw mm3, mm4
  1708. movq mm5, [ecx+esi]
  1709. paddsw mm1, mm7
  1711. movq mm6, [ecx+esi+1]
  1712. paddsw mm3, mm7
  1714. movq mm2, mm5
  1715. movq mm4, mm6
  1717. punpcklbw mm2, mm0
  1718. punpckhbw mm5, mm0
  1720. punpcklbw mm4, mm0
  1721. punpckhbw mm6, mm0
  1723. paddsw mm2, mm4
  1724. paddsw mm5, mm6
  1726. paddsw mm1, mm2
  1727. paddsw mm3, mm5
  1729. movq mm6, [ebx+esi]
  1731. movq mm4, mm6
  1732. punpcklbw mm4, mm0
  1733. punpckhbw mm6, mm0
  1735. psllw mm4, 2
  1736. psllw mm6, 2
  1738. paddsw mm1, mm4
  1739. paddsw mm3, mm6
  1741. psrlw mm1, 3
  1742. psrlw mm3, 3
  1744. packuswb mm1, mm0
  1745. packuswb mm3, mm0
  1747. psllq mm3, 32
  1748. por mm1, mm3
  1750. add esi, 0x08
  1751. cmp esi, [w]
  1752. movq [ebx+esi-8], mm1
  1753. jl mc7
  1755. add eax, [lx2]
  1756. add ebx, [lx2]
  1757. add ecx, [lx2]
  1758. sub edi, 0x01
  1759. mov esi, 0x00
  1760. cmp edi, 0x00
  1761. jg mc7
  1762. }
  1763. break;
  1764. }
  1765. }