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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
utility.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：15k
源码类别：

mpeg/mp3

开发平台：

Visual C++

utility.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  *  T264 AVC CODEC
  4.  *
  5.  *  Copyright(C) 2004-2005 llcc <lcgate1@yahoo.com.cn>
  6.  *               2004-2005 visionany <visionany@yahoo.com.cn>
  7.  *      2005.1.13 CloudWu modify PIA_u_wxh_c() function
  8.  *  This program is free software ; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation ; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program ; if not, write to the Free Software
  20.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21.  *
  22.  ****************************************************************************/
  24. #define Q_BITS          15
  25. #define DQ_BITS         6
  26. #define DQ_ROUND        (1<<(DQ_BITS-1))
  28. #include "stdio.h"
  29. #include "portab.h"
  30. #ifndef CHIP_DM642
  31. #include "malloc.h"
  32. #endif
  33. #include "utility.h"
  34. #ifndef CHIP_DM642
  35. #include "memory.h"
  36. #endif
  37. //
  38. // from xvid
  39. //
  40. void* 
  41. T264_malloc(int32_t size, int32_t alignment)
  42. {
  43.     uint8_t *mem_ptr;
  45.     if (!alignment) {
  47.         /* We have not to satisfy any alignment */
  48.         if ((mem_ptr = (uint8_t *) malloc(size + 1)) != NULL) {
  50.             /* Store (mem_ptr - "real allocated memory") in *(mem_ptr-1) */
  51.             *mem_ptr = (uint8_t)1;
  53.             /* Return the mem_ptr pointer */
  54.             return ((void *)(mem_ptr+1));
  55.         }
  56.     } else {
  57.         uint8_t *tmp;
  59.         /* Allocate the required size memory + alignment so we
  60.         * can realign the data if necessary */
  61.         if ((tmp = (uint8_t *) malloc(size + alignment)) != NULL) {
  63.             /* Align the tmp pointer */
  64.             mem_ptr =
  65.                 (uint8_t *) ((uint32_t) (tmp + alignment - 1) &
  66.                 (~(uint32_t) (alignment - 1)));
  68.             /* Special case where malloc have already satisfied the alignment
  69.             * We must add alignment to mem_ptr because we must store
  70.             * (mem_ptr - tmp) in *(mem_ptr-1)
  71.             * If we do not add alignment to mem_ptr then *(mem_ptr-1) points
  72.             * to a forbidden memory space */
  73.             if (mem_ptr == tmp)
  74.                 mem_ptr += alignment;
  76.             /* (mem_ptr - tmp) is stored in *(mem_ptr-1) so we are able to retrieve
  77.             * the real malloc block allocated and free it in xvid_free */
  78.             *(mem_ptr - 1) = (uint8_t) (mem_ptr - tmp);
  80.             /* Return the aligned pointer */
  81.             return ((void *)mem_ptr);
  82.         }
  83.     }
  85.     return(NULL);
  86. }
  88. void 
  89. T264_free(void* p)
  90. {
  91.     uint8_t *ptr;
  93.     if (p == NULL)
  94.         return;
  96.     /* Aligned pointer */
  97.     ptr = p;
  99.     /* *(ptr - 1) holds the offset to the real allocated block
  100.     * we sub that offset os we free the real pointer */
  101.     ptr -= *(ptr - 1);
  103.     /* Free the memory */
  104.     free(ptr);
  105. }
  107. void
  108. expand8to16_c(uint8_t* src, int32_t src_stride, int32_t quarter_width, int32_t quarter_height, int16_t* dst)
  109. {
  110.     int32_t i, j;
  112.     for(i = 0 ; i < quarter_height * 4 ; i ++)
  113.     {
  114.         for(j = 0 ; j < quarter_width ; j ++)
  115.         {
  116.             dst[i * quarter_width * 4 + j * 4 + 0] = src[0 + j * 4];
  117.             dst[i * quarter_width * 4 + j * 4 + 1] = src[1 + j * 4];
  118.             dst[i * quarter_width * 4 + j * 4 + 2] = src[2 + j * 4];
  119.             dst[i * quarter_width * 4 + j * 4 + 3] = src[3 + j * 4];
  120.         }
  121.         src += src_stride;
  122.     }
  123. }
  125. void
  126. expand8to16sub_c(uint8_t* pred, int32_t quarter_width, int32_t quarter_height, int16_t* dst, uint8_t* src, int32_t src_stride)
  127. {
  128.     int32_t i, j, k;
  129.     uint8_t* start_p;
  130.     uint8_t* start_s;
  131.     
  132.     for(i = 0 ; i < quarter_height ; i ++)
  133.     {
  134.         for(j = 0 ; j < quarter_width ; j ++)
  135.         {
  136.             start_p = pred + i * quarter_width * 4 * 4 + j * 4;
  137.             start_s = src + i * src_stride * 4 + j * 4;
  138.             for(k = 0 ; k < 4 ; k ++)
  139.             {
  140.                 dst[0] = start_s[0] - start_p[0];
  141.                 dst[1] = start_s[1] - start_p[1];
  142.                 dst[2] = start_s[2] - start_p[2];
  143.                 dst[3] = start_s[3] - start_p[3];
  145.                 dst     += 4;
  146.                 start_p += 4 * quarter_width;
  147.                 start_s += src_stride;
  148.             }
  149.         }
  150.     }
  151. }
  153. void
  154. contract16to8_c(int16_t* src, int32_t quarter_width, int32_t quarter_height, uint8_t* dst, int32_t dst_stride)
  155. {
  156.     int32_t i, j;
  158.     for(i = 0 ; i < quarter_height * 4 ; i ++)
  159.     {
  160.         for(j = 0 ; j < quarter_width ; j ++)
  161.         {
  162.             int16_t tmp;
  163.             tmp = src[i * quarter_width * 4 + j * 4 + 0];
  164.             dst[0 + j * 4] = CLIP1(tmp);
  165.             tmp = src[i * quarter_width * 4 + j * 4 + 1];
  166.             dst[1 + j * 4] = CLIP1(tmp);
  167.             tmp = src[i * quarter_width * 4 + j * 4 + 2];
  168.             dst[2 + j * 4] = CLIP1(tmp);
  169.             tmp = src[i * quarter_width * 4 + j * 4 + 3];
  170.             dst[3 + j * 4] = CLIP1(tmp);
  171.         }
  172.         dst += dst_stride;
  173.     }
  174. }
  176. void //assigned
  177. contract16to8add_c(int16_t* src, int32_t quarter_width, int32_t quarter_height, uint8_t* pred, uint8_t* dst, int32_t dst_stride)
  178. {
  179.     int32_t i, j, k;
  180.     uint8_t* start_p;
  181.     uint8_t* start_d;
  183.     for(i = 0 ; i < quarter_height ; i ++)
  184.     {
  185.         for(j = 0 ; j < quarter_width ; j ++)
  186.         {
  187.             start_p = pred + i * quarter_width * 4 * 4 + j * 4;
  188.             start_d = dst + i * dst_stride * 4 + j * 4;
  189.             for(k = 0 ; k < 4 ; k ++)
  190.             {
  191.                 int16_t tmp;
  193.                 tmp = src[0] + start_p[0];
  194.                 start_d[0] = CLIP1(tmp);
  195.                 tmp = src[1] + start_p[1];
  196.                 start_d[1] = CLIP1(tmp);
  197.                 tmp = src[2] + start_p[2];
  198.                 start_d[2] = CLIP1(tmp);
  199.                 tmp = src[3] + start_p[3];
  200.                 start_d[3] = CLIP1(tmp);
  202.                 //tmp = (src[0] + (start_p[0] << DQ_BITS) + DQ_ROUND) >> DQ_BITS;
  203.                 //start_d[0] = CLIP1(tmp);
  204.                 //tmp = (src[1] + (start_p[1] << DQ_BITS) + DQ_ROUND) >> DQ_BITS;
  205.                 //start_d[1] = CLIP1(tmp);
  206.                 //tmp = (src[2] + (start_p[2] << DQ_BITS) + DQ_ROUND) >> DQ_BITS;
  207.                 //start_d[2] = CLIP1(tmp);
  208.                 //tmp = (src[3] + (start_p[3] << DQ_BITS) + DQ_ROUND) >> DQ_BITS;
  209.                 //start_d[3] = CLIP1(tmp);
  211.                 src     += 4;
  212.                 start_p += 4 * quarter_width;
  213.                 start_d += dst_stride;
  214.             }
  215.         }
  216.     }
  217. }
  219. void
  220. memcpy_stride_u_c(void* src, int32_t width, int32_t height, int32_t src_stride, void* dst, int32_t dst_stride)
  221. {
  222.     int32_t i;
  223.     uint8_t* s = src;
  224.     uint8_t* d = dst;
  226.     for(i = 0 ; i < height ; i ++)
  227.     {
  228.         memcpy(d, s, width);
  229.         s += src_stride;
  230.         d += dst_stride;
  231.     }
  232. }
  234. static __inline uint32_t
  235. T264_sad_u_c(uint8_t* src, int32_t src_stride, uint8_t* data, int32_t width, int32_t height, int32_t dst_stride)
  236. {
  237.     int32_t i, j;
  238.     uint32_t sad;
  240.     sad = 0;
  241.     for(i = 0 ; i < height ; i ++)
  242.     {
  243.         for(j = 0 ; j < width ; j ++)
  244.         {
  245.             int32_t tmp = data[j] - src[j];
  246.             sad += ABS(tmp);
  247.         }
  248.         src  += src_stride;
  249.         data += dst_stride;
  250.     }
  252.     return sad;
  253. }
  255. //copied from JM,by cloud wu
  256. static __inline 
  257. uint32_t _satd_4x4_dif_c(int16_t* diff)
  258. {
  259.   int32_t k, satd = 0, m[16], dd, d[16];
  260.     
  261.     /*===== hadamard transform =====*/
  262.     m[ 0] = diff[ 0] + diff[12];
  263.     m[ 4] = diff[ 4] + diff[ 8];
  264.     m[ 8] = diff[ 4] - diff[ 8];
  265.     m[12] = diff[ 0] - diff[12];
  266.     m[ 1] = diff[ 1] + diff[13];
  267.     m[ 5] = diff[ 5] + diff[ 9];
  268.     m[ 9] = diff[ 5] - diff[ 9];
  269.     m[13] = diff[ 1] - diff[13];
  270.     m[ 2] = diff[ 2] + diff[14];
  271.     m[ 6] = diff[ 6] + diff[10];
  272.     m[10] = diff[ 6] - diff[10];
  273.     m[14] = diff[ 2] - diff[14];
  274.     m[ 3] = diff[ 3] + diff[15];
  275.     m[ 7] = diff[ 7] + diff[11];
  276.     m[11] = diff[ 7] - diff[11];
  277.     m[15] = diff[ 3] - diff[15];
  278.     
  279.     d[ 0] = m[ 0] + m[ 4];
  280.     d[ 8] = m[ 0] - m[ 4];
  281.     d[ 4] = m[ 8] + m[12];
  282.     d[12] = m[12] - m[ 8];
  283.     d[ 1] = m[ 1] + m[ 5];
  284.     d[ 9] = m[ 1] - m[ 5];
  285.     d[ 5] = m[ 9] + m[13];
  286.     d[13] = m[13] - m[ 9];
  287.     d[ 2] = m[ 2] + m[ 6];
  288.     d[10] = m[ 2] - m[ 6];
  289.     d[ 6] = m[10] + m[14];
  290.     d[14] = m[14] - m[10];
  291.     d[ 3] = m[ 3] + m[ 7];
  292.     d[11] = m[ 3] - m[ 7];
  293.     d[ 7] = m[11] + m[15];
  294.     d[15] = m[15] - m[11];
  295.     
  296.     m[ 0] = d[ 0] + d[ 3];
  297.     m[ 1] = d[ 1] + d[ 2];
  298.     m[ 2] = d[ 1] - d[ 2];
  299.     m[ 3] = d[ 0] - d[ 3];
  300.     m[ 4] = d[ 4] + d[ 7];
  301.     m[ 5] = d[ 5] + d[ 6];
  302.     m[ 6] = d[ 5] - d[ 6];
  303.     m[ 7] = d[ 4] - d[ 7];
  304.     m[ 8] = d[ 8] + d[11];
  305.     m[ 9] = d[ 9] + d[10];
  306.     m[10] = d[ 9] - d[10];
  307.     m[11] = d[ 8] - d[11];
  308.     m[12] = d[12] + d[15];
  309.     m[13] = d[13] + d[14];
  310.     m[14] = d[13] - d[14];
  311.     m[15] = d[12] - d[15];
  312.     
  313.     d[ 0] = m[ 0] + m[ 1];
  314.     d[ 1] = m[ 0] - m[ 1];
  315.     d[ 2] = m[ 2] + m[ 3];
  316.     d[ 3] = m[ 3] - m[ 2];
  317.     d[ 4] = m[ 4] + m[ 5];
  318.     d[ 5] = m[ 4] - m[ 5];
  319.     d[ 6] = m[ 6] + m[ 7];
  320.     d[ 7] = m[ 7] - m[ 6];
  321.     d[ 8] = m[ 8] + m[ 9];
  322.     d[ 9] = m[ 8] - m[ 9];
  323.     d[10] = m[10] + m[11];
  324.     d[11] = m[11] - m[10];
  325.     d[12] = m[12] + m[13];
  326.     d[13] = m[12] - m[13];
  327.     d[14] = m[14] + m[15];
  328.     d[15] = m[15] - m[14];
  329.     
  330.     /*===== sum up =====*/
  331.     for (dd=d[k=0]; k<16; dd=d[++k])
  332.     {
  333.       satd += (dd < 0 ? -dd : dd);
  334.     }
  335.     satd = ((satd+1)>>1);
  337.     return satd;
  338. }
  340. static __inline uint32_t
  341. T264_satd_u_c(uint8_t* src, int32_t src_stride, uint8_t* data, int32_t width, int32_t height, int32_t dst_stride)
  342. {
  343.     int32_t i, j, n, m;
  344.     uint32_t sad;
  345.     int16_t tmp[16];
  347.     sad = 0;
  348.     for(i = 0 ; i < height ; i += 4)
  349.     {
  350.         for(j = 0 ; j < width ; j += 4)
  351.         {
  352.             uint8_t* tmp_s = src + i * src_stride + j;
  353.             uint8_t* tmp_d = data+ i * dst_stride + j;
  354.             for(n = 0 ; n < 4 ; n ++)
  355.             {
  356.                 for(m = 0 ; m < 4 ; m ++)
  357.                     tmp[n * 4 + m] = tmp_d[m] - tmp_s[m];
  358.                 tmp_d += dst_stride;
  359.                 tmp_s += src_stride;
  360.             }
  362.             sad += _satd_4x4_dif_c(tmp);
  363.         }
  364.     }
  366.     return sad;
  367. }
  370. #define SADFUNC(w, h, base)    
  371. uint32_t                    
  372. T264_##base##_u_##w##x##h##_c(uint8_t* src, int32_t src_stride, uint8_t* data, int32_t dst_stride)  
  373. {   
  374.     return T264_##base##_u_c(src, src_stride, data, w, h, dst_stride); 
  375. }
  377. SADFUNC(16, 16, sad)
  378. SADFUNC(16, 8,  sad)
  379. SADFUNC(8,  16, sad)
  380. SADFUNC(8,  8,  sad)
  381. SADFUNC(8,  4,  sad)
  382. SADFUNC(4,  8,  sad)
  383. SADFUNC(4,  4,  sad)
  385. SADFUNC(16, 16, satd)
  386. SADFUNC(16, 8,  satd)
  387. SADFUNC(8,  16, satd)
  388. SADFUNC(8,  8,  satd)
  389. SADFUNC(8,  4,  satd)
  390. SADFUNC(4,  8,  satd)
  391. SADFUNC(4,  4,  satd)
  393. /**********************************************************************************
  394.  *
  395.  *  Based on the FUNCTION T264_satd_u_c()
  396.  *  use SATD for 16x16 Intra
  397.  *  Thomascatlee@163.com
  398.  *
  399.  *********************************************************************************/
  401. uint32_t
  402. T264_satd_i16x16_u_c(uint8_t* src, int32_t src_stride, uint8_t* data, int32_t dst_stride)
  403. {
  404.     return T264_satd_u_c(src,src_stride,  data, 16,16,dst_stride);    
  405. /*    int32_t i, j, n, m, k;
  406.     uint32_t sad;
  407.     int16_t tmp[16];
  408.     int16_t s_dc[16];
  409.     int16_t s[4];
  411.     sad = 0;
  412.     k = 0;
  413.     for(i = 0 ; i < 16 ; i += 4)
  414.     {
  415.         for(j = 0 ; j < 16 ; j += 4)
  416.         {
  417.             uint8_t* tmp_s = src + i * src_stride + j;
  418.             uint8_t* tmp_d = data+ i * dst_stride + j;
  419.             for(n = 0 ; n < 4 ; n ++)
  420.             {
  421.                 for(m = 0 ; m < 4 ; m ++)
  422.                     tmp[n * 4 + m] = tmp_d[m] - tmp_s[m];
  423.                 tmp_d += dst_stride;
  424.                 tmp_s += src_stride;
  425.             }
  427.             for(n = 0 ; n < 4 ; n ++)
  428.             {
  429.                 s[0] = tmp[0 * 4 + n] + tmp[3 * 4 + n];
  430.                 s[3] = tmp[0 * 4 + n] - tmp[3 * 4 + n];
  431.                 s[1] = tmp[1 * 4 + n] + tmp[2 * 4 + n];
  432.                 s[2] = tmp[1 * 4 + n] - tmp[2 * 4 + n];
  434.                 tmp[0 * 4 + n] = s[0] + s[1];
  435.                 tmp[2 * 4 + n] = s[0] - s[1];
  436.                 tmp[1 * 4 + n] = s[3] + s[2];
  437.                 tmp[3 * 4 + n] = s[3] - s[2];
  438.             }
  439.             
  440.             //  Add for get DC coeff
  441.             n = 0;
  442.             s[0] = tmp[n * 4 + 0] + tmp[n * 4 + 3];
  443.             s[3] = tmp[n * 4 + 0] - tmp[n * 4 + 3];
  444.             s[1] = tmp[n * 4 + 1] + tmp[n * 4 + 2];
  445.             s[2] = tmp[n * 4 + 1] - tmp[n * 4 + 2];
  446.             s_dc[k] = ((s[0] + s[1]) >> 2);
  447.             sad += ABS(s[0] - s[1]);
  448.             sad += ABS(s[3] + s[2]);
  449.             sad += ABS(s[3] - s[2]);
  450.             k++;
  451.             
  452.             for(n = 1 ; n < 4 ; n ++)
  453.             {
  454.                 s[0] = tmp[n * 4 + 0] + tmp[n * 4 + 3];
  455.                 s[3] = tmp[n * 4 + 0] - tmp[n * 4 + 3];
  456.                 s[1] = tmp[n * 4 + 1] + tmp[n * 4 + 2];
  457.                 s[2] = tmp[n * 4 + 1] - tmp[n * 4 + 2];
  458.                 sad += ABS(s[0] + s[1]);
  459.                 sad += ABS(s[0] - s[1]);
  460.                 sad += ABS(s[3] + s[2]);
  461.                 sad += ABS(s[3] - s[2]);
  462.              }
  464.            
  466.         }
  467.     }
  469.     //  Hadamard of DC coeff 
  470.     for(n = 0 ; n < 4 ; n ++)
  471.     {
  472.       s[0] = s_dc[0 * 4 + n] + s_dc[3 * 4 + n];
  473.       s[3] = s_dc[0 * 4 + n] - s_dc[3 * 4 + n];
  474.       s[1] = s_dc[1 * 4 + n] + s_dc[2 * 4 + n];
  475.       s[2] = s_dc[1 * 4 + n] - s_dc[2 * 4 + n];
  476.       
  477.       tmp[0 * 4 + n] = s[0] + s[1];
  478.       tmp[2 * 4 + n] = s[0] - s[1];
  479.       tmp[1 * 4 + n] = s[3] + s[2];
  480.       tmp[3 * 4 + n] = s[3] - s[2];
  481.     }
  482.     for(n = 0 ; n < 4 ; n ++)
  483.     {
  484.       s[0] = tmp[n * 4 + 0] + tmp[n * 4 + 3];
  485.       s[3] = tmp[n * 4 + 0] - tmp[n * 4 + 3];
  486.       s[1] = tmp[n * 4 + 1] + tmp[n * 4 + 2];
  487.       s[2] = tmp[n * 4 + 1] - tmp[n * 4 + 2];
  488.       sad += ABS(s[0] + s[1]);
  489.       sad += ABS(s[0] - s[1]);
  490.       sad += ABS(s[3] + s[2]);
  491.       sad += ABS(s[3] - s[2]);
  492.     }
  494.     return sad >> 1;
  495. */
  496. }
  498. //calculate non-zero counts for an array v[i_count]
  499. int32_t 
  500. array_non_zero_count(int16_t *v, int32_t i_count)
  501. {
  502.     int32_t i;
  503.     int32_t i_nz;
  505.     for( i = 0, i_nz = 0; i < i_count; i++ )
  506.     {
  507.         if( v[i] )
  508.         {
  509.             i_nz++;
  510.         }
  511.     }
  512.     return i_nz;
  513. }