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

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

Symbian

开发平台：

C/C++

loopfilt.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 <stdio.h>
  37. //#include <stdlib.h>
  38. #include "dllindex.h"
  39. #include "h261defs.h"
  40. #include "h261func.h"
  41. #include "loopfilt.h"
  43. extern void loopfilt8( PIXEL input[], int xdim, PIXEL output[] )
  44. {
  45.     union {
  46.         U16     half[8][8]; // 16b take longer than 32b writes on 486/Pentium
  47.         U32     word[8][4];
  48.     } temp;     // Area to hold data after filtering in horizontal dimension
  49.     union {
  50.         PIXEL   * pix;
  51.         U32     * word;
  52.     } out_ptr;  // Access output as bytes or as words
  53.     int row, col, a[7], out;
  54.     
  55.     // Perform horizontal filtering
  56.     for (row = 0; row < 8; row++) {
  57.         a[0] = input[0] + input[1];
  58.         a[1] = input[1] + input[2];
  59.         a[2] = input[2] + input[3];
  60.         a[3] = input[3] + input[4];
  61. #ifdef LITTLE_ENDIAN    // Avoid 16 b. Stores on X86
  62.         temp.word[row][0] = (input[0] << 2) + ((a[1] + a[2]) << 16);    // temp[0], temp[2]
  63.         temp.word[row][2] = a[0] + a[1]  +  ((a[2] + a[3]) << 16);      // temp[1], temp[3]
  64. #elif defined BIG_ENDIAN
  65.         temp.half[row][0] = input[0] << 2;  // temp[0]
  66.         temp.half[row][1] = a[1] + a[2];    // temp[2]
  67.         temp.half[row][4] = a[0] + a[1];    // temp[1]
  68.         temp.half[row][5] = a[2] + a[3];    // temp[3]
  69. #else
  70. #   error
  71. #endif
  72.         a[4] = input[4] + input[5];
  73.         a[5] = input[5] + input[6];
  74.         a[6] = input[6] + input[7];
  75. #ifdef LITTLE_ENDIAN
  76.         temp.word[row][1] = a[3] + a[4]  +  ((a[5] + a[6]) << 16);  // temp[4], temp[6]
  77.         temp.word[row][3] = a[4] + a[5]  +  (input[7] << (16 + 2)); // temp[5], temp[7]
  78. #elif defined BIG_ENDIAN
  79.         temp.half[row][2] = a[3] + a[4];    // temp[4]
  80.         temp.half[row][3] = a[5] + a[6];    // temp[6]
  81.         temp.half[row][6] = a[4] + a[5];    // temp[5]
  82.         temp.half[row][7] = input[7] << 2;  // temp[7]
  83. #else
  84. #   error
  85. #endif
  86.         input += xdim;
  87.     }
  88.     
  89.     // Perform vertical filtering on two columns at a time
  90.     for (col = 0; col < 2; col++) {
  91.         
  92.         // col=0: Filter cols 0 and 2; col=1: Filter cols 4 and 6
  93.         a[0] = temp.word[0][col] + temp.word[1][col];
  94.         a[1] = temp.word[1][col] + temp.word[2][col] + 0x80008L;   // Round;
  95.         a[2] = temp.word[2][col] + temp.word[3][col];
  96.         a[3] = temp.word[3][col] + temp.word[4][col] + 0x80008L;   // Round;
  97.         a[4] = temp.word[4][col] + temp.word[5][col];
  98.         a[5] = temp.word[5][col] + temp.word[6][col] + 0x80008L;   // Round;
  99.         a[6] = temp.word[6][col] + temp.word[7][col];
  100.         out_ptr.pix = output + (col << 2);
  101. #ifdef LITTLE_ENDIAN
  102.         *(out_ptr.word) = (temp.word[0][col] + 0x20002L) >> 2; // Round
  103.         out_ptr.pix += xdim;
  104.         *(out_ptr.word) = (a[0] + a[1]) >> 4;
  105.         out_ptr.pix += xdim;
  106.         *(out_ptr.word) = (a[1] + a[2]) >> 4;
  107.         out_ptr.pix += xdim;
  108.         *(out_ptr.word) = (a[2] + a[3]) >> 4;
  109.         out_ptr.pix += xdim;
  110.         *(out_ptr.word) = (a[3] + a[4]) >> 4;
  111.         out_ptr.pix += xdim;
  112.         *(out_ptr.word) = (a[4] + a[5]) >> 4;
  113.         out_ptr.pix += xdim;
  114.         *(out_ptr.word) = (a[5] + a[6]) >> 4;
  115.         out_ptr.pix += xdim;
  116.         *(out_ptr.word) = (temp.word[7][col] + 0x20002L) >> 2; // Round
  117. #elif defined BIG_ENDIAN
  118.         *(out_ptr.word) = (temp.word[0][col] + 0x20002L) << 6; // Round
  119.         out_ptr.pix += xdim;
  120.         *(out_ptr.word) = (a[0] + a[1]) << 4;
  121.         out_ptr.pix += xdim;
  122.         *(out_ptr.word) = (a[1] + a[2]) << 4;
  123.         out_ptr.pix += xdim;
  124.         *(out_ptr.word) = (a[2] + a[3]) << 4;
  125.         out_ptr.pix += xdim;
  126.         *(out_ptr.word) = (a[3] + a[4]) << 4;
  127.         out_ptr.pix += xdim;
  128.         *(out_ptr.word) = (a[4] + a[5]) << 4;
  129.         out_ptr.pix += xdim;
  130.         *(out_ptr.word) = (a[5] + a[6]) << 4;
  131.         out_ptr.pix += xdim;
  132.         *(out_ptr.word) = (temp.word[7][col] + 0x20002L) << 6; // Round
  133. #else
  134. #   error
  135. #endif
  136.         
  137.         // col=0: Filter cols 1 and 3; col=1: Filter cols 5 and 7
  138.         a[0] = temp.word[0][col+2] + temp.word[1][col+2];
  139.         a[1] = temp.word[1][col+2] + temp.word[2][col+2] + 0x80008L;   // Round;
  140.         a[2] = temp.word[2][col+2] + temp.word[3][col+2];
  141.         a[3] = temp.word[3][col+2] + temp.word[4][col+2] + 0x80008L;   // Round;
  142.         a[4] = temp.word[4][col+2] + temp.word[5][col+2];
  143.         a[5] = temp.word[5][col+2] + temp.word[6][col+2] + 0x80008L;   // Round;
  144.         a[6] = temp.word[6][col+2] + temp.word[7][col+2];
  145.         out_ptr.pix = output + (col << 2) + 1;
  146.         out = (temp.word[0][col+2] + 0x20002L) >> 2;    // Round
  147. #ifdef LITTLE_ENDIAN       
  148.         *(out_ptr.pix) = out;
  149.         *(out_ptr.pix + 2) = out >> 16;
  150.         
  151.         out_ptr.pix += xdim;
  152.         out = (a[0] + a[1]) >> 4;
  153.         *(out_ptr.pix) = out;
  154.         *(out_ptr.pix + 2) = out >> 16;
  155.         
  156.         out_ptr.pix += xdim;
  157.         out = (a[1] + a[2]) >> 4;
  158.         *(out_ptr.pix) = out;
  159.         *(out_ptr.pix + 2) = out >> 16;
  160.         
  161.         out_ptr.pix += xdim;
  162.         out = (a[2] + a[3]) >> 4;
  163.         *(out_ptr.pix) = out;
  164.         *(out_ptr.pix + 2) = out >> 16;
  165.         
  166.         out_ptr.pix += xdim;
  167.         out = (a[3] + a[4]) >> 4;
  168.         *(out_ptr.pix) = out;
  169.         *(out_ptr.pix + 2) = out >> 16;
  170.         
  171.         out_ptr.pix += xdim;
  172.         out = (a[4] + a[5]) >> 4;
  173.         *(out_ptr.pix) = out;
  174.         *(out_ptr.pix + 2) = out >> 16;
  175.         
  176.         out_ptr.pix += xdim;
  177.         out = (a[5] + a[6]) >> 4;
  178.         *(out_ptr.pix) = out;
  179.         *(out_ptr.pix + 2) = out >> 16;
  180.         
  181.         out_ptr.pix += xdim;
  182.         out = (temp.word[7][col+2] + 0x20002L) >> 2; // Round
  183.         *(out_ptr.pix) = out;
  184.         *(out_ptr.pix + 2) = out >> 16;
  185. #elif defined BIG_ENDIAN
  186.         *(out_ptr.pix + 2) = out;
  187.         *(out_ptr.pix) = out >> 16;
  188.         
  189.         out_ptr.pix += xdim;
  190.         out = (a[0] + a[1]) >> 4;
  191.         *(out_ptr.pix + 2) = out;
  192.         *(out_ptr.pix) = out >> 16;
  193.         
  194.         out_ptr.pix += xdim;
  195.         out = (a[1] + a[2]) >> 4;
  196.         *(out_ptr.pix + 2) = out;
  197.         *(out_ptr.pix) = out >> 16;
  198.         
  199.         out_ptr.pix += xdim;
  200.         out = (a[2] + a[3]) >> 4;
  201.         *(out_ptr.pix + 2) = out;
  202.         *(out_ptr.pix) = out >> 16;
  203.         
  204.         out_ptr.pix += xdim;
  205.         out = (a[3] + a[4]) >> 4;
  206.         *(out_ptr.pix + 2) = out;
  207.         *(out_ptr.pix) = out >> 16;
  208.         
  209.         out_ptr.pix += xdim;
  210.         out = (a[4] + a[5]) >> 4;
  211.         *(out_ptr.pix + 2) = out;
  212.         *(out_ptr.pix) = out >> 16;
  213.         
  214.         out_ptr.pix += xdim;
  215.         out = (a[5] + a[6]) >> 4;
  216.         *(out_ptr.pix + 2) = out;
  217.         *(out_ptr.pix) = out >> 16;
  218.         
  219.         out_ptr.pix += xdim;
  220.         out = (temp.word[7][col+2] + 0x20002L) >> 2; // Round
  221.         *(out_ptr.pix + 2) = out;
  222.         *(out_ptr.pix) = out >> 16;
  223. #else
  224. #   error
  225. #endif
  226.     }
  227.     return;
  228. }
  231. //  LoopFilter - assumes same line offset for input and output
  232. extern int  LoopFilter( MACROBLOCK_DESCR *mb, PICTURE *prev_pic, PICTURE *pic )
  233. {
  234.     int     row, col, status, cx, cy, pic_offset, prev_offset;
  235.     PIXEL   * source, * dest;
  237.     status = OK;
  238.     // Wrap motion vectors to allowed range
  239.     while (mb->mv_x < MV_MIN) {
  240.         mb->mv_x += MV_WRAP;
  241.     }
  242.     while (mb->mv_x > MV_MAX) {
  243.         mb->mv_x -= MV_WRAP;
  244.     }
  245.     while (mb->mv_y < MV_MIN) {
  246.         mb->mv_y += MV_WRAP;
  247.     }
  248.     while (mb->mv_y > MV_MAX) {
  249.         mb->mv_y -= MV_WRAP;
  250.     }
  251.     // Compute pointers
  252.     col = 16 * mb->x;
  253.     row = 16 * mb->y;
  254.     if (col == 0  &&  mb->mv_x < 0) {    // Pointing left of first col?
  255.         mb->mv_x = 0, status = H261_ERROR;
  256.     }
  257.     if (col == pic->y.nhor - 16  &&  mb->mv_x > 0) {  // Right of last col?
  258.         mb->mv_x = 0, status = H261_ERROR;
  259.     }
  260.     if (row == 0  &&  mb->mv_y < 0) {    // Pointing above first row?
  261.         mb->mv_y = 0, status = H261_ERROR;
  262.     }
  263.     if (row == pic->y.nvert - 16  &&  mb->mv_y > 0) {  // Below last row?
  264.         mb->mv_y = 0, status = H261_ERROR;
  265.     }
  266.     dest = pic->y.ptr + col + row * pic->y.hoffset;
  267.     source = prev_pic->y.ptr + col + mb->mv_x
  268.                     + (row + mb->mv_y) * pic->y.hoffset;
  269.     // Filter luminance
  270.     loopfilt8( source, (int)pic->y.hoffset, dest );
  271.     loopfilt8( source + 8, (int)pic->y.hoffset, dest + 8);
  272.     source += pic->y.hoffset << 3;  // Advance 8 lines
  273.     dest += pic->y.hoffset << 3;
  274.     loopfilt8( source, (int)pic->y.hoffset, dest );
  275.     loopfilt8( source + 8, (int)pic->y.hoffset, dest + 8);
  276.     // Filter chrominance
  277.     if (pic->color) {
  278.         col = 8 * mb->x;
  279.         row = 8 * mb->y;
  280.         // Truncate motion vectors for chroma towards zero
  281.         if (mb->mv_x < 0) {
  282.             cx = (mb->mv_x + 1) >> 1;
  283.         } else {
  284.             cx = mb->mv_x >> 1;
  285.         }
  286.         if (mb->mv_y < 0) {
  287.             cy = (mb->mv_y + 1) >> 1;
  288.         } else {
  289.             cy = mb->mv_y >> 1;
  290.         }
  291.         // Assuming same offset for Cr and Cb
  292.         pic_offset = col + row * pic->cb.hoffset;
  293.         prev_offset = col + cx + (row + cy) * pic->cb.hoffset;
  294.         dest = pic->cb.ptr + pic_offset;
  295.         source = prev_pic->cb.ptr + prev_offset;
  296.         loopfilt8( source, (int)pic->cb.hoffset, dest );
  297.         dest = pic->cr.ptr + pic_offset;
  298.         source = prev_pic->cr.ptr + prev_offset;
  299.         loopfilt8( source, (int)pic->cr.hoffset, dest );
  300.     }
  301.     return (status);
  302. }