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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
h263pdec.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：29k
源码类别：

Symbian

开发平台：

Visual C++

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