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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
h263pdec.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：28k
源码类别：

Symbian

开发平台：

C/C++

h263pdec.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. //#include <string.h>
  37. #include "dllindex.h"
  38. #include "h261defs.h"
  39. #include "h261func.h"
  40. #include "h263plus.h"
  42. #include <stdio.h>
  43. #include "assert.h"
  45. #ifdef _MACINTOSH
  46. #include <string.h> // for memset
  47. #endif
  49. #ifdef COMPILE_MMX
  50. #include "mmxcpuid.h"
  51. #endif
  52. //#define VVPROFILER
  53. #define REPLACE_MACROS
  55. extern void ApplyVerticalDeblockingFilter( PIXEL * left, PIXEL * right, int offset);
  56. extern void ApplyVerticalDeblockingFilterMMX( PIXEL * left, PIXEL * right, int offset);
  57. extern void ApplyHorizontalDeblockingFilter( PIXEL * top, PIXEL * bottom, int offset);
  58. extern void ApplyHorizontalDeblockingFilterMMX( PIXEL * top, PIXEL * bottom, int offset);
  61. #ifdef VVPROFILER
  62. #include "hvdebtim.h"
  63. extern struct CVvDebugTimer * pVvProf[];
  64. #endif
  67. void PredBframePlus( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  68.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  69.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  70.                         PICTURE * Bpic          // Output picture where pred is placed
  71.                         );
  73. //  PredBframePlus - Form prediction for B-frame a la H.263+
  74. void PredBframePlus( MACROBLOCK_DESCR * mb,  // Macroblock to be predicted
  75.                         PICTURE * prevPic,      // Prev. picture (forward pred)
  76.                         PICTURE * nextPic,      // Next P-picture (backward pred)
  77.                         PICTURE * Bpic          // Output picture where pred is placed
  78.                         )
  79. {
  80.     if(BFRAME_IS_BIDIRECTIONAL(mb))
  81.     {
  82.         PredBframe(mb,prevPic,nextPic,Bpic);
  83.     }
  84.     else
  85.     {
  86.         S8 saveMvX = mb->mv_x; 
  87.         S8 saveMvY = mb->mv_y;
  88.         U8 saveType = mb->mtype;
  89.         mb->mv_x = mb->mvdB_x; 
  90.         mb->mv_y = mb->mvdB_y;
  91.         mb->mtype = MTYPE263_INTER;
  92.         MotionComp263( mb, prevPic, Bpic );
  93.         mb->mv_x = saveMvX;
  94.         mb->mv_y = saveMvY;
  95.         mb->mtype = saveType;
  97.     }
  98. }
  101. //////////////////////////////////////////////////////////////////////////
  102. // Deblocking Filter Mode Functions
  103. //
  105. static U8 ClipTableBase[288];
  106. static U8 * ClipTable=NULL;
  108. static void InitializeClipTable()
  109. {
  110.     int i;
  112.     if(ClipTable) {
  113.         return;
  114.     } else {
  115.         ClipTable = ClipTableBase + 16;
  116.     }
  117.     for(i = -16; i<=0; i++) ClipTable[i] = 0x00;
  118.     for(i=1 ; i<256; i++) ClipTable[i] = (U8) i;
  119.     for(i=256 ; i<272; i++) ClipTable[i] = 0xFF;
  120. }
  122. static S8 DiffCutoffTableBase[351]; // Range [-175, 175]
  123. static S8 * DiffCutoffTable=NULL;
  125. #ifdef COMPILE_MMX
  126. #define SHORTMAX 32767
  127. __int64 g_qp = 0;
  128. // max - qp
  129. __int64 g_max_qp =   ((__int64) SHORTMAX)
  130. | (((__int64) SHORTMAX)<<16) 
  131. | (((__int64) SHORTMAX)<<32) 
  132. | (((__int64) SHORTMAX)<<48);
  133. // max - 2 * (qp)
  134. __int64 g_max_2qp =   ((__int64) SHORTMAX )
  135. | (((__int64) SHORTMAX)<<16) 
  136. | (((__int64) SHORTMAX)<<32) 
  137. | (((__int64) SHORTMAX)<<48);
  138. #endif
  140. static void InitializeDiffCutoffTable(S32 qp)
  141. {
  142.     static DiffTableQuantCache=0;
  143.     int d, d2;
  145.     if(DiffCutoffTable==NULL) {
  146.         memset(DiffCutoffTableBase, 0, 351);
  147.         DiffCutoffTable = DiffCutoffTableBase + 175;
  148.     }
  150.     if(DiffTableQuantCache == qp) return;
  152.     for(d=0, d2=0; d2<=qp; d++, d2+=2) {
  153.         DiffCutoffTable[d] = d;
  154.         DiffCutoffTable[-d] = -d;
  155.     }
  157.     for(;d<=qp;d++) {
  158.         DiffCutoffTable[d] = qp - d;
  159.         DiffCutoffTable[-d] = -qp + d;
  160.     }
  162.     for(;d<=DiffTableQuantCache;d++) {
  163.         DiffCutoffTable[d] = 0;
  164.         DiffCutoffTable[-d] = 0;
  165.     }
  167.     DiffTableQuantCache = qp;
  168. #ifdef COMPILE_MMX
  169. {
  170. short max_qp, max_2pq;
  171. max_qp = (short)SHORTMAX - (short) qp; // max - pq/2
  172. max_2pq = (short)SHORTMAX - 2*(short)qp; // max - 2 * (pq/2)
  173.     
  174. g_qp = (((__int64) qp)) 
  175. | (((__int64) qp)<<16)
  176. | (((__int64) qp)<<32)
  177. | (((__int64) qp)<<48);
  178. g_max_qp = (((__int64) max_qp)) 
  179. | (((__int64) max_qp)<<16)
  180. | (((__int64) max_qp)<<32)
  181. | (((__int64) max_qp)<<48);
  182. g_max_2qp = (((__int64) max_2pq)) 
  183. | (((__int64) max_2pq)<<16) 
  184. | (((__int64) max_2pq)<<32) 
  185. | (((__int64) max_2pq)<<48);
  186. }
  188. #endif
  193. }
  195. #ifdef _DEBUG
  196. static PIXEL * MACROBLOCK_LUMA_PTR(PICTURE * p,MACROBLOCK_DESCR * mb) 
  197. {
  198.     return ((p)->y.ptr + 16*(mb)->x + 16*(mb)->y*(p)->y.hoffset);
  199. }
  201. static PIXEL * BlockLumaPtr(PICTURE * pic, MACROBLOCK_DESCR * mb, int blk)
  202. {
  203.     switch(blk)
  204.     {
  205.     case 0:
  206.         return MACROBLOCK_LUMA_PTR(pic,mb);
  207.     case 1:
  208.         return MACROBLOCK_LUMA_PTR(pic,mb) + 8;
  209.     case 2:
  210.         return MACROBLOCK_LUMA_PTR(pic,mb) + 8*pic->y.hoffset;
  211.     default:
  212.         return MACROBLOCK_LUMA_PTR(pic,mb) + 8*(pic->y.hoffset + 1);
  213.     }
  214. }
  216. static PIXEL * MacroBlockCrPtr(PICTURE * pic, MACROBLOCK_DESCR * mb)
  217. {
  218.     return pic->cr.ptr + 8*mb->x + 8*mb->y*pic->cr.hoffset;
  219. }
  221. static PIXEL * MacroBlockCbPtr(PICTURE * pic, MACROBLOCK_DESCR * mb)
  222. {
  223.     return pic->cb.ptr + 8*mb->x + 8*mb->y*pic->cb.hoffset;
  224. }
  225. #else
  227. #define MACROBLOCK_LUMA_PTR(p, mb) 
  228.     ((p)->y.ptr + 16*(mb)->x + 16*(mb)->y*(p)->y.hoffset)
  230. #define BlockLumaPtr(pic, mb, blk) 
  231.     (MACROBLOCK_LUMA_PTR((pic),(mb)) + 4*((blk)&2)*(pic)->y.hoffset + 8*((blk)&1))
  233. #define MacroBlockCrPtr(pic, mb) 
  234.     ((pic)->cr.ptr + 8*(mb)->x + 8*(mb)->y*(pic)->cr.hoffset)
  236. #define MacroBlockCbPtr(pic, mb) 
  237.     ((pic)->cb.ptr + 8*(mb)->x + 8*(mb)->y*(pic)->cb.hoffset)
  239. #endif
  242. /******************************************************************************************/
  243. void ApplyVerticalDeblockingFilter( PIXEL * left, PIXEL * right, int offset)
  244. {
  245.     int i;
  246.     left += 7;
  247.     for(i=0; i<8; i++) {
  248. //8-bit arithmetic might overflow, changing to 32-bit
  249.         S32 d = DiffCutoffTable[(3*(S32) left[-1] - 8*(S32)left[0] + 8*(S32)right[0] - 3*(S32)right[1])>>4];        
  250.         *left = ClipTable[*left + d];
  251.         *right = ClipTable[*right - d];
  253.         left += offset;
  254.         right += offset;
  255.     }
  256. }
  258. /*
  259. PIXEL *left01, *right01, *left02, *right02;
  260. static void ApplyVerticalDeblockingFilter( PIXEL * left, PIXEL * right, int offset)
  261. {
  262. int result, ii;
  264. left01 = left;
  265. right01 = right;
  266. left02 = ((PIXEL *)calloc((8*offset)+8, sizeof(*left)));
  267. //left02 += 7;
  268. right02 = ((PIXEL *)calloc((8*offset)+8, sizeof(*right)));
  269. if(!left02 || !right02) return;
  271. //left[-1, 0, -1+offset, 0+offset, ..., -1+7*offset, 0+8*offset]
  272. //right[0, +1, 0+offset, +1+offset, ..., 0+7*offset, +1+8*offset]
  273. for(ii=0; ii<8; ii++) {
  274. left02[-1+ii*offset+7] = left[-1+ii*offset+7];
  275. left02[ 0+ii*offset+7] = left[ 0+ii*offset+7];
  276. right02[ 0+ii*offset] = right[ 0+ii*offset];
  277. right02[+1+ii*offset] = right[+1+ii*offset];
  278. }
  282. //call deblocking filter
  283. ApplyVerticalDeblockingFilterMMX(left01, right01, offset);
  284. ApplyVerticalDeblockingFilterInt(left02, right02, offset);
  286. //compare output
  287. for(ii=0; ii<8; ii++) {
  288. if(
  289. (left02[-1+ii*offset+7] != left01[-1+ii*offset+7])
  290. || (left02[ 0+ii*offset+7] != left01[ 0+ii*offset+7])
  291. || (right02[ 0+ii*offset] != right01[ 0+ii*offset])
  292. || (right02[+1+ii*offset] != right01[+1+ii*offset])
  293. ) {
  294. result = ii;
  295. }
  296. }
  297. free(left02);
  298. free(right02);
  299. }
  300. */
  302. /******************************************************************************************/
  303. void ApplyHorizontalDeblockingFilter( PIXEL * top, PIXEL * bottom, int offset)
  304. {
  305. int i;
  306.     PIXEL *next_to_top;
  307.     PIXEL *next_after_bottom;
  308. top += 7*offset;
  309.     next_to_top = top - offset;
  310.     next_after_bottom = bottom + offset;
  312.     for(i=0; i<8; i++) {
  313. //8-bit arithmetic might overflow, changing to 32-bit
  314.         S32 d = DiffCutoffTable[(3*(S32)next_to_top[0] - 8*(S32)top[0] + 8*(S32)bottom[0] - 3*(S32)next_after_bottom[0])>>4];
  315.         
  316.         *top = ClipTable[*top + d];
  317.         *bottom = ClipTable[*bottom - d];
  319.         top += 1;
  320.         next_to_top += 1;
  321.         bottom += 1;
  322.         next_after_bottom += 1;
  323.     }
  324. }
  326. /*
  327. PIXEL *top01=0, *bottom01=0;
  328. PIXEL *top02=0, *bottom02=0;
  329. static void ApplyHorizontalDeblockingFilter( PIXEL * top, PIXEL * bottom, int offset)
  330. {
  331. int result;
  333. top01 = top;
  334. bottom01 = bottom;
  335. top02 = calloc((7*offset)+8, sizeof(*top));
  336. bottom02 = calloc(offset+8, sizeof(*bottom));
  337. if(!top02 || !bottom02) return;
  339. //top+7*offset [0...7]
  340. //top+6*offset [0...7]
  341. memcpy(top02 + (7*offset), top + (7*offset), 8*sizeof(*top));
  342. memcpy(top02 + (6*offset), top + (6*offset), 8*sizeof(*top));
  344. //bottom[0...7]
  345. //bottom+offset[0...7]
  346. memcpy(bottom02, bottom, 8*sizeof(*bottom));
  347. memcpy(bottom02 + offset, bottom + offset, 8*sizeof(*bottom));
  349. //call deblocking filter
  350. ApplyHorizontalDeblockingFilterMMX(top02, bottom02, offset);
  351. ApplyHorizontalDeblockingFilterInt(top, bottom, offset);
  353. //compare output
  354. if((result = memcmp(top02 + (7*offset), top + (7*offset), 8*sizeof(*top))) != 0) {
  355. PIXEL *point =  top + (7*offset);
  356. PIXEL *point02 =  top02 + (7*offset);
  357. }
  358. if((result = memcmp(top02 + (6*offset), top + (6*offset), 8*sizeof(*top))) != 0) {
  359. PIXEL *point =  top + (6*offset);
  360. PIXEL *point02 =  top02 + (6*offset);
  361. }
  362. if((result = memcmp(bottom02, bottom, 8*sizeof(*bottom))) != 0) {
  363. PIXEL *point =  bottom;
  364. PIXEL *point02 =  bottom02;
  365. }
  366. if((result = memcmp(bottom02 + offset, bottom + offset, 8*sizeof(*bottom))) != 0) {
  367. PIXEL *point =  bottom + offset;
  368. PIXEL *point02 =  bottom02 + offset;
  369. }
  371. free(top02);
  372. free(bottom02);
  373. }
  374. */
  377. /******************************************************************************************/
  379. // This routine applies the H.263+ deblocking filter to a decoded picture.  Note
  380. // That this routine is NOT H.263+ compliant because it applies the filter after the
  381. // reconstructed picture has already been clipped to 0,255
  382. void ApplyDeblockingFilter( PICTURE * pic, MACROBLOCK_DESCR * mb, S32 Bframe)
  383. {
  384.     int i,h,v;
  385.     int numhor=pic->y.nhor>>4; // number of mb per row
  386.     int numvert=pic->y.nvert>>4; // number of mb per col
  387.     int nummb = numhor*numvert;
  388.     int off = pic->y.hoffset;
  390. #ifdef REPLACE_MACROS
  391. PIXEL *pLuma, *pCb, *pCr;
  392. #endif
  394. void (*pApplyHorizontalDeblockingFilter)(PIXEL *, PIXEL *, int); 
  395. void (*pApplyVerticalDeblockingFilter)(PIXEL *, PIXEL *, int); 
  397. #if defined(COMPILE_MMX)
  398. #if (_MSC_VER>=1100)
  399. if(cpuid_is_mmx_deblo_on()) {
  400. //do mmx if compiler switch AND initialized AND detected
  401. pApplyHorizontalDeblockingFilter = ApplyHorizontalDeblockingFilterMMX;
  402. pApplyVerticalDeblockingFilter = ApplyVerticalDeblockingFilterMMX;
  403. } else 
  404. #else
  405. #pragma message("need MSVC 5.0 or higher to compile MMX - MMX disabled")
  406. #endif
  407. #endif
  408. {
  409. pApplyHorizontalDeblockingFilter = ApplyHorizontalDeblockingFilter;
  410. pApplyVerticalDeblockingFilter = ApplyVerticalDeblockingFilter;
  411. }
  414. #ifdef VVPROFILER
  415. S32 ret;
  416. S32 nVvProfNb = 6;
  417. if(!pVvProf[nVvProfNb]) pVvProf[nVvProfNb] = newCVvDebugTimer();//memory leak on destruction
  418. StartTime(pVvProf[nVvProfNb]);
  419. #endif
  421. #ifdef REPLACE_MACROS
  422. //aw using pointers instead of macros
  423. pLuma = pic->y.ptr;
  424. pCb = pic->cb.ptr;
  425. pCr = pic->cr.ptr;
  426. assert(off==16*numhor);
  427. #endif
  428.     if(ClipTable==NULL) InitializeClipTable();
  430.     for(i=0,v=0; v<numvert; v++
  431. #ifdef REPLACE_MACROS
  432. , pLuma += 15*off, 
  433.  pCb += 7*pic->cb.hoffset + pic->cb.hoffset/2, 
  434.  pCr += 7*pic->cr.hoffset + pic->cr.hoffset/2
  435. #endif
  436.  ) {
  437.         for(h=0; h<numhor; h++, i++
  438. #ifdef REPLACE_MACROS
  439. , pLuma+=16, pCb+=8, pCr+=8
  440. #endif
  441. ) {
  442.             int qp;
  443.             if(mb[i].mtype == MTYPE_SKIP) {
  444.                 // Here we check to see if the macroblock below us is coded.  If it is then we need to
  445.                 // filter our bottom horizontal edges.   Note that we need to use the quant value of the
  446.                 // block below
  447.                 if(v<numvert-1 && mb[i+numhor].mtype != MTYPE_SKIP) {
  448.                     qp = Bframe ? mb[i+numhor].Bquant : mb[i+numhor].quant;
  449.                     InitializeDiffCutoffTable(qp);
  450. #ifndef REPLACE_MACROS
  451. pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],2), BlockLumaPtr(pic,&mb[i+numhor],0), off);
  452.                     pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],3), BlockLumaPtr(pic,&mb[i+numhor],1), off);
  453.                     pApplyHorizontalDeblockingFilter(MacroBlockCbPtr(pic, &mb[i]), MacroBlockCbPtr(pic,&mb[i+numhor]), pic->cb.hoffset);
  454.                     pApplyHorizontalDeblockingFilter(MacroBlockCrPtr(pic, &mb[i]), MacroBlockCrPtr(pic,&mb[i+numhor]), pic->cr.hoffset);
  455. #else
  456. assert(BlockLumaPtr(pic,&mb[i],2) == pLuma + 8*off);assert(BlockLumaPtr(pic,&mb[i+numhor],0) == pLuma + 16*off);
  457. assert(BlockLumaPtr(pic,&mb[i],3) == pLuma + 8*off +8);assert(BlockLumaPtr(pic,&mb[i+numhor],1) == pLuma + 16*off +8);
  458. assert(MacroBlockCbPtr(pic, &mb[i]) == pCb);assert(MacroBlockCbPtr(pic,&mb[i+numhor]) == pCb + 8*pic->cb.hoffset);
  459. assert(MacroBlockCrPtr(pic, &mb[i]) == pCr);assert(MacroBlockCrPtr(pic,&mb[i+numhor]) == pCr + 8*pic->cr.hoffset);
  460.                     pApplyHorizontalDeblockingFilter(pLuma + 8*off, pLuma + 16*off, off);
  461.                     pApplyHorizontalDeblockingFilter(pLuma + 8*off +8, pLuma + 16*off +8, off);
  462.                     pApplyHorizontalDeblockingFilter(pCb, pCb + 8*pic->cb.hoffset, pic->cb.hoffset);
  463.                     pApplyHorizontalDeblockingFilter(pCr, pCr + 8*pic->cr.hoffset, pic->cr.hoffset);
  464. #endif
  465.                 }
  467.                 // Here we check to see if the macroblock to the left of us is coded. If so do our left vertical
  468.                 // edges
  469.                 if(h && mb[i-1].mtype != MTYPE_SKIP) {
  470.                     qp = Bframe ? mb[i-1].Bquant : mb[i-1].quant;
  471.                     InitializeDiffCutoffTable(qp);
  472. #ifndef REPLACE_MACROS
  473.                     pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i-1],1), BlockLumaPtr(pic,&mb[i],0), off);
  474.                     pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i-1],3), BlockLumaPtr(pic,&mb[i],2), off);
  475.                     pApplyVerticalDeblockingFilter(MacroBlockCbPtr(pic, &mb[i-1]), MacroBlockCbPtr(pic,&mb[i]), pic->cb.hoffset);
  476.                     pApplyVerticalDeblockingFilter(MacroBlockCrPtr(pic, &mb[i-1]), MacroBlockCrPtr(pic,&mb[i]), pic->cr.hoffset);
  477. #else
  478. assert(BlockLumaPtr(pic,&mb[i-1],1) == pLuma -8);assert(BlockLumaPtr(pic,&mb[i],0) == pLuma);
  479. assert(BlockLumaPtr(pic,&mb[i-1],3) == pLuma + 8*off -8);assert(BlockLumaPtr(pic,&mb[i],2) == pLuma + 8*off);
  480. assert(MacroBlockCbPtr(pic, &mb[i-1]) == pCb -8);assert(MacroBlockCbPtr(pic,&mb[i]) == pCb);
  481. assert(MacroBlockCrPtr(pic, &mb[i-1]) == pCr -8);assert(MacroBlockCrPtr(pic,&mb[i]) == pCr);
  482.                     pApplyVerticalDeblockingFilter(pLuma -8, pLuma, off);
  483. pApplyVerticalDeblockingFilter(pLuma + 8*off -8, pLuma + 8*off, off);
  484.                     pApplyVerticalDeblockingFilter(pCb -8, pCb, pic->cb.hoffset);
  485. pApplyVerticalDeblockingFilter(pCr -8, pCr, pic->cr.hoffset);
  486. #endif
  487.                 }
  489.             } else {
  491.                 qp = Bframe ? mb[i].Bquant : mb[i].quant;
  492.                 InitializeDiffCutoffTable(qp);
  495.                 // First do the first two horizontal edges
  496. #ifndef REPLACE_MACROS
  497. pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],0), BlockLumaPtr(pic,&mb[i],2), off);
  498.                 pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],1), BlockLumaPtr(pic,&mb[i],3), off);
  499. #else
  500. assert(BlockLumaPtr(pic,&mb[i],0) == pLuma);assert(BlockLumaPtr(pic,&mb[i],2) == pLuma + 8*off);
  501. assert(BlockLumaPtr(pic,&mb[i],1) == pLuma +8);assert(BlockLumaPtr(pic,&mb[i],3) == pLuma + 8*off +8);
  502.                 pApplyHorizontalDeblockingFilter(pLuma, pLuma + 8*off, off);
  503. pApplyHorizontalDeblockingFilter(pLuma +8, pLuma + 8*off +8, off);
  504. #endif
  505.                 // Now do the first two vertical edges; don't filter if the left edge is a picture edge
  506.                 if(h) {
  507. #ifndef REPLACE_MACROS
  508. pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i-1],1), BlockLumaPtr(pic,&mb[i],0), off);
  509. #else
  510. assert(BlockLumaPtr(pic,&mb[i-1],1) == pLuma -8);assert(BlockLumaPtr(pic,&mb[i],0) == pLuma);
  511. pApplyVerticalDeblockingFilter(pLuma -8, pLuma, off);
  512. #endif
  513.                 }
  514. #ifndef REPLACE_MACROS
  515.                 pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i],0), BlockLumaPtr(pic,&mb[i],1), off);
  516. #else
  517. assert(BlockLumaPtr(pic,&mb[i],0) == pLuma);assert(BlockLumaPtr(pic,&mb[i],1) == pLuma +8);
  518. pApplyVerticalDeblockingFilter(pLuma, pLuma +8, off);
  519. #endif
  521.                 // Now do the bottom two horizontal edges; don't filter if we are at a bottom edge of the picture
  522.                 if(v < numvert-1) {
  523.                     // Use quantization parameter for lower macroblock if it was coded
  524.                     if(mb[i+numhor].mtype != MTYPE_SKIP) {
  525.                         InitializeDiffCutoffTable(Bframe ? mb[i+numhor].Bquant : mb[i+numhor].quant);
  526.                     }
  527. #ifndef REPLACE_MACROS
  528.                     pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],2), BlockLumaPtr(pic,&mb[i+numhor],0), 
  529.                         off);
  530.                     pApplyHorizontalDeblockingFilter(BlockLumaPtr(pic,&mb[i],3), BlockLumaPtr(pic,&mb[i+numhor],1), 
  531.                         off);
  532. #else
  533. assert(BlockLumaPtr(pic,&mb[i],2) == pLuma + 8*off);assert(BlockLumaPtr(pic,&mb[i+numhor],0) == pLuma + 16*off);
  534. assert(BlockLumaPtr(pic,&mb[i],3) == pLuma + 8*off +8);assert(BlockLumaPtr(pic,&mb[i+numhor],1) == pLuma + 16*off +8);
  535.                     pApplyHorizontalDeblockingFilter(pLuma + 8*off, pLuma + 16*off, off);
  536.                     pApplyHorizontalDeblockingFilter(pLuma + 8*off +8, pLuma + 16*off +8, off);
  537. #endif
  538.                     
  539.                     // restore quantization parameter of current macroblock
  540.                     InitializeDiffCutoffTable(qp);
  541.                 }
  543.                 // Lastly do the lower two vertical edges; don't filter if the left edge is a picture edge
  544.                 if(h) {
  545. #ifndef REPLACE_MACROS
  546. pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i-1],3), BlockLumaPtr(pic,&mb[i],2), off);
  547. #else
  548. assert(BlockLumaPtr(pic,&mb[i-1],3) == pLuma + 8*off - 8);assert(BlockLumaPtr(pic,&mb[i],2) == pLuma +8*off);
  549. pApplyVerticalDeblockingFilter(pLuma + 8*off - 8, pLuma +8*off, off);
  550. #endif
  551.                 }
  552. #ifndef REPLACE_MACROS
  553. pApplyVerticalDeblockingFilter(BlockLumaPtr(pic,&mb[i],2), BlockLumaPtr(pic,&mb[i],3), off);
  554. #else
  555. assert(BlockLumaPtr(pic,&mb[i],2) == pLuma + 8*off);assert(BlockLumaPtr(pic,&mb[i],3) == pLuma + 8*off +8);
  556. pApplyVerticalDeblockingFilter(pLuma + 8*off, pLuma + 8*off +8, off);
  557. #endif
  560.                 // Now apply the filters to the chroma
  561.                 if(v < numvert-1) {
  562. #ifndef REPLACE_MACROS
  563.                     pApplyHorizontalDeblockingFilter(MacroBlockCbPtr(pic, &mb[i]), MacroBlockCbPtr(pic,&mb[i+numhor]), pic->cb.hoffset);
  564.                     pApplyHorizontalDeblockingFilter(MacroBlockCrPtr(pic, &mb[i]), MacroBlockCrPtr(pic,&mb[i+numhor]), pic->cr.hoffset);
  565. #else
  566. assert(MacroBlockCbPtr(pic, &mb[i]) == pCb);assert(MacroBlockCbPtr(pic,&mb[i+numhor]) == pCb +8*pic->cb.hoffset);
  567. assert(MacroBlockCrPtr(pic, &mb[i]) == pCr);assert(MacroBlockCrPtr(pic,&mb[i+numhor]) == pCr +8*pic->cr.hoffset);
  568. pApplyHorizontalDeblockingFilter(pCb, pCb +8*pic->cb.hoffset, pic->cb.hoffset);
  569.                     pApplyHorizontalDeblockingFilter(pCr, pCr +8*pic->cr.hoffset, pic->cr.hoffset);
  570. #endif
  571.                 }
  572.                 if(h) {
  573. #ifndef REPLACE_MACROS
  574.                     pApplyVerticalDeblockingFilter(MacroBlockCbPtr(pic, &mb[i-1]), MacroBlockCbPtr(pic,&mb[i]), pic->cb.hoffset);
  575.                     pApplyVerticalDeblockingFilter(MacroBlockCrPtr(pic, &mb[i-1]), MacroBlockCrPtr(pic,&mb[i]), pic->cr.hoffset);
  576. #else
  577. assert(MacroBlockCbPtr(pic, &mb[i-1]) == pCb -8);assert(MacroBlockCbPtr(pic,&mb[i]) == pCb);
  578. assert(MacroBlockCrPtr(pic, &mb[i-1]) == pCr -8);assert(MacroBlockCrPtr(pic,&mb[i]) == pCr);
  579. pApplyVerticalDeblockingFilter(pCb -8, pCb, pic->cb.hoffset);
  580.                     pApplyVerticalDeblockingFilter(pCr -8, pCr, pic->cr.hoffset);
  581. #endif
  582.                 }
  583.             }
  584.         }
  585.     }
  586. //clear the mmx state
  587. #if defined(COMPILE_MMX)
  588. #if (_MSC_VER>=1100)
  589. if(cpuid_is_mmx_deblo_on()) {
  590. __asm emms
  591. }
  592. #endif
  593. #endif
  594. #ifdef VVPROFILER
  595. StopAndAccuTime(pVvProf[nVvProfNb]);
  596. #endif
  598. }
  601. /******************************************************************************************/
  602. //////////////////////////////////////////////////////////////////////////////
  603. //  Deblocking filter for Reduced Resolution Update mode
  604. //
  606. static void vertFilterRRUmode( PIXEL * right, int offset, int len )
  607. {
  608.     int i, valLeft, valRight;
  610.     for(i=0; i < len; i++) {
  611.         valLeft = right[-1];
  612.         valRight = right[0];
  613.         right[-1] = (3 * valLeft + 1 * valRight + 2) >> 2;
  614.         right[0]  = (1 * valLeft + 3 * valRight + 2) >> 2;
  615.         right += offset;
  616.     }
  617. }
  619. static void horFilterRRUmode( PIXEL * bottom, int offset, int len )
  620. {
  621.     int i, valTop, valBottom;
  622.     PIXEL *top;
  623.         
  624.     top = bottom - offset;
  625.     for(i=0; i < len; i++) {
  626.         valTop = top[0];
  627.         valBottom = bottom[0];
  628.         top[0]    = (3 * valTop + 1 * valBottom + 2) >> 2;
  629.         bottom[0] = (1 * valTop + 3 * valBottom + 2) >> 2;
  630.         top += 1;
  631.         bottom += 1;
  632.     }
  633. }
  637. // This routine applies the Reduced-res. Update mode deblocking filter to a decoded picture.
  638. extern void ReducedResDeblockingFilter( PICTURE * pic, MACROBLOCK_DESCR * mb )
  639. {
  640.     int i,h,v;
  641.     int numhor = (pic->y.nhor + 16) >> 5;   // number of mb per row
  642.     int numvert= (pic->y.nvert+ 16) >> 5;   // number of mb per col
  643.     int nummb = numhor*numvert;
  644.     int off = pic->y.hoffset;
  645.     PIXEL   *luma0;
  646.     int     hSize, vSize, cOffset;
  647.    
  648.     for(i=0,v=0; v<numvert; v++) {
  649.         vSize = 32;
  650.         if (32 * v + 16 >= pic->y.nvert)
  651.             vSize = 16;     // MB is truncated at the bottom
  652.         for(h=0; h<numhor; h++, i++) {
  653.             hSize = 32;
  654.             if (32 * h + 16 >= pic->y.nhor)
  655.                 hSize = 16; // MB is truncated at the right
  656.             luma0 = pic->y.ptr + 32 * h + 32 * v * off;
  657.             cOffset = 16 * h + 16 * v * pic->cb.hoffset;
  659.             // Filter horizontal edge inside block
  660.             if (mb[i].mtype != MTYPE_SKIP  &&  vSize == 32) {
  661.                 horFilterRRUmode( luma0 + 16*off, off, hSize );
  662.             }
  663.             // Filter horizontal edge at the bottom of the block
  664.             if (v < numvert-1  &&  
  665.                 (mb[i].mtype != MTYPE_SKIP  ||  mb[i+numhor].mtype != MTYPE_SKIP)) {
  666.                 horFilterRRUmode( luma0 + 32*off, off, hSize );
  667.                 horFilterRRUmode( pic->cb.ptr + cOffset + 16*pic->cb.hoffset,
  668.                                   pic->cb.hoffset, hSize>>1 );
  669.                 horFilterRRUmode( pic->cr.ptr + cOffset + 16*pic->cr.hoffset,
  670.                                   pic->cr.hoffset, hSize>>1 );
  671.             }
  672.             // Filter vertical edge at the left of the block
  673.             if (h > 0  &&
  674.                 (mb[i].mtype != MTYPE_SKIP  ||  mb[i-1].mtype != MTYPE_SKIP)) {
  675.                 vertFilterRRUmode( luma0, off, vSize );
  676.                 vertFilterRRUmode( pic->cb.ptr + cOffset,
  677.                                   pic->cb.hoffset, vSize>>1 );
  678.                 vertFilterRRUmode( pic->cr.ptr + cOffset,
  679.                                   pic->cr.hoffset, vSize>>1 );
  680.             }
  681.             // Filter vertical edge inside block
  682.             if (mb[i].mtype != MTYPE_SKIP  &&  hSize == 32) {
  683.                 vertFilterRRUmode( luma0 + 16, off, vSize );
  684.             }
  685.         }
  686.     }
  687. }
  690. // Alternate Horizontal Scan Order
  691. static int alt_hor_scan[64] = {  0, 1, 2, 3,10,11,12,13,
  692.                                  4, 5, 8, 9,17,16,15,14,
  693.                                  6, 7,19,18,26,27,28,29,
  694.                                 20,21,24,25,30,31,32,33,
  695.                                 22,23,34,35,42,43,44,45,
  696.                                 36,37,40,41,46,47,48,49,
  697.                                 38,39,50,51,56,57,58,59,
  698.                                 52,53,54,55,60,61,62,63};
  700. // Alternate Vertical (MPEG-2) Scan Order
  701. static int alt_ver_scan[64] = {  0, 4, 6,20,22,36,38,52,
  702.                                  1, 5, 7,21,23,37,39,53,
  703.                                  2, 8,19,24,34,40,50,54,
  704.                                  3, 9,18,25,35,41,51,55,
  705.                                 10,17,26,30,42,46,56,60,
  706.                                 11,16,27,31,43,47,57,61,
  707.                                 12,15,28,32,44,48,58,62,
  708.                                 13,14,29,33,45,49,59,63};
  711. static int MyZigZag[64] = {  0,  1,  5,  6,  14, 15, 27, 28,
  712.                             2,  4,  7,  13, 16, 26, 29, 42,
  713.                             3,  8,  12, 17, 25, 30, 41, 43,
  714.                             9,  11, 18, 24, 31, 40, 44, 53,
  715.                             10, 19, 23, 32, 39, 45, 52, 54,
  716.                             20, 22, 33, 38, 46, 51, 55, 60,
  717.                             21, 34, 37, 47, 50, 56, 59, 61,
  718.                             35, 36, 48, 49, 57, 58, 62, 63
  719. };
  720. static int reorder[8] = {0,4,2,7, 1,5,3,6};
  721. int ireorder[8] = {0,4,2,6, 1,5,7,3};
  723. int inv_alt_hor_scan[64];
  724. int inv_alt_hor_scan_no_reorder[64];
  725. int alt_hor_to_zigzag[64];
  726. int inv_alt_ver_scan[64];
  727. int inv_alt_ver_scan_no_reorder[64];
  728. int alt_ver_to_zigzag[64];
  729. int zigzag_to_zigzag[64];
  731. void InitAdvancedIntraTables()
  732. {
  733.     static int initialized=0;
  734.     int index,i,j;
  736.     if(initialized) return;
  737.     initialized = 1;
  738.     // Generate inverse scan order vectors
  739.     for (index = 0; index < 64; index++) {
  740.         i = reorder[index % 8];
  741.         j = reorder[index / 8];
  742.         inv_alt_ver_scan[ alt_ver_scan[index] ] = i*8 + j;
  743.         inv_alt_hor_scan[ alt_hor_scan[index] ] = i*8 + j;
  745.         inv_alt_ver_scan_no_reorder[ alt_ver_scan[index] ] = index;
  746.         inv_alt_hor_scan_no_reorder[ alt_hor_scan[index] ] = index;
  747.     }
  749.     // Now do the scan's from alt hor and alt ver to zigzag.
  750.     // We need to be careful because the above tables take into
  751.     // account the reorderings that come from our DCT.  We don't
  752.     // want to take that into account, so we apply the ireorder
  753.     for(index = 0; index < 64; index++) {
  754.         i = ireorder[ inv_alt_ver_scan[index]&7 ];
  755.         j = ireorder[ inv_alt_ver_scan[index]>>3 ];
  757.         alt_ver_to_zigzag[ index ] = MyZigZag[ i*8 + j ];
  758.         
  759.         i = ireorder[ inv_alt_hor_scan[index]&7 ];
  760.         j = ireorder[ inv_alt_hor_scan[index]>>3 ];
  762.         alt_hor_to_zigzag[ index ] = MyZigZag[ i*8 + j ];
  764.         zigzag_to_zigzag[ index ] = index;
  765.     }
  766. }