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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mbtransquant.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：12k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mbtransquant.c：源码内容
  1.  /******************************************************************************
  2.   *                                                                            *
  3.   *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
  4.   *                                                                            *
  5.   *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
  6.   *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
  7.   *  software module in hardware or software products are advised that its     *
  8.   *  use may infringe existing patents or copyrights, and any such use         *
  9.   *  would be at such party's own risk.  The original developer of this        *
  10.   *  software module and his/her company, and subsequent editors and their     *
  11.   *  companies, will have no liability for use of this software or             *
  12.   *  modifications or derivatives thereof.                                     *
  13.   *                                                                            *
  14.   *  XviD is free software; you can redistribute it and/or modify it           *
  15.   *  under the terms of the GNU General Public License as published by         *
  16.   *  the Free Software Foundation; either version 2 of the License, or         *
  17.   *  (at your option) any later version.                                       *
  18.   *                                                                            *
  19.   *  XviD is distributed in the hope that it will be useful, but               *
  20.   *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21.   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  22.   *  GNU General Public License for more details.                              *
  23.   *                                                                            *
  24.   *  You should have received a copy of the GNU General Public License         *
  25.   *  along with this program; if not, write to the Free Software               *
  26.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
  27.   *                                                                            *
  28.   ******************************************************************************/
  30.  /******************************************************************************
  31.   *                                                                            *
  32.   *  mbtransquant.c                                                            *
  33.   *                                                                            *
  34.   *  Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au>                    *
  35.   *  Copyright (C) 2001 - Michael Militzer <isibaar@xvid.org>                  *
  36.   *                                                                            *
  37.   *  For more information visit the XviD homepage: http://www.xvid.org         *
  38.   *                                                                            *
  39.   ******************************************************************************/
  41.  /******************************************************************************
  42.   *                                                                            *
  43.   *  Revision history:                                                         *
  44.   *                                                                            *
  45.   *  29.03.2002 interlacing speedup - used transfer strides instead of
  46.   *             manual field-to-frame conversion
  47.   *  26.03.2002 interlacing support - moved transfers outside loops
  48.   *  22.12.2001 get_dc_scaler() moved to common.h
  49.   *  19.11.2001 introduced coefficient thresholding (Isibaar)                  *
  50.   *  17.11.2001 initial version                                                *
  51.   *                                                                            *
  52.   ******************************************************************************/
  54. #include <string.h>
  56. #include "../portab.h"
  57. #include "mbfunctions.h"
  59. #include "../global.h"
  60. #include "mem_transfer.h"
  61. #include "timer.h"
  62. #include "../dct/fdct.h"
  63. #include "../dct/idct.h"
  64. #include "../quant/quant_mpeg4.h"
  65. #include "../quant/quant_h263.h"
  66. #include "../encoder.h"
  68. #define MIN(X, Y) ((X)<(Y)?(X):(Y))
  69. #define MAX(X, Y) ((X)>(Y)?(X):(Y))
  71. #define TOOSMALL_LIMIT 1 /* skip blocks having a coefficient sum below this value */
  73. /* this isnt pretty, but its better than 20 ifdefs */
  75. void MBTransQuantIntra(const MBParam *pParam,
  76.        MACROBLOCK * pMB,
  77.        const uint32_t x_pos,
  78.        const uint32_t y_pos,
  79.        int16_t data[6*64], 
  80.        int16_t qcoeff[6*64], 
  81.        IMAGE * const pCurrent)
  82.    
  83. {
  85. uint32_t stride = pParam->edged_width;
  86. uint32_t stride2 = stride / 2;
  87. uint32_t next_block = stride * 8;
  88. uint32_t i;
  89. uint32_t iQuant = pParam->quant;
  90. uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
  92. pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
  93. pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
  94. pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
  96. start_timer();
  97. transfer_8to16copy(&data[0*64], pY_Cur, stride);
  98. transfer_8to16copy(&data[1*64], pY_Cur + 8, stride);
  99. transfer_8to16copy(&data[2*64], pY_Cur + next_block, stride);
  100. transfer_8to16copy(&data[3*64], pY_Cur + next_block + 8,stride);
  101. transfer_8to16copy(&data[4*64], pU_Cur, stride2);
  102. transfer_8to16copy(&data[5*64], pV_Cur, stride2);
  103. stop_transfer_timer();
  105. start_timer();
  106. pMB->field_dct = 0;
  107. if (pParam->global_flags & XVID_INTERLACING)
  108. {
  109. pMB->field_dct = MBDecideFieldDCT(data);
  110. }
  111. stop_interlacing_timer();
  113. for(i = 0; i < 6; i++)
  114. {
  115. uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
  117. start_timer();
  118. fdct(&data[i*64]);
  119. stop_dct_timer();
  121. if (pParam->quant_type == H263_QUANT)
  122. {
  123. start_timer();
  124. quant_intra(&qcoeff[i*64], &data[i*64], iQuant, iDcScaler);
  125. stop_quant_timer();
  127. start_timer();
  128. dequant_intra(&data[i*64], &qcoeff[i*64], iQuant, iDcScaler);
  129. stop_iquant_timer();
  130. }
  131. else
  132. {
  133. start_timer();
  134. quant4_intra(&qcoeff[i*64], &data[i*64], iQuant, iDcScaler);
  135. stop_quant_timer();
  137. start_timer();
  138. dequant4_intra(&data[i*64], &qcoeff[i*64], iQuant, iDcScaler);
  139. stop_iquant_timer();
  140. }
  142. start_timer();
  143. idct(&data[i*64]);
  144. stop_idct_timer();
  145. }
  147. if (pMB->field_dct)
  148. {
  149. next_block = stride;
  150. stride *= 2;
  151. }
  153. start_timer();
  154. transfer_16to8copy(pY_Cur,                  &data[0*64], stride);
  155. transfer_16to8copy(pY_Cur + 8,              &data[1*64], stride);
  156. transfer_16to8copy(pY_Cur + next_block,     &data[2*64], stride);
  157. transfer_16to8copy(pY_Cur + next_block + 8, &data[3*64], stride);
  158. transfer_16to8copy(pU_Cur,                  &data[4*64], stride2);
  159. transfer_16to8copy(pV_Cur,                  &data[5*64], stride2);
  160. stop_transfer_timer();
  162. }
  165. uint8_t MBTransQuantInter(const MBParam *pParam, 
  166.   MACROBLOCK * pMB,
  167.   const uint32_t x_pos, const uint32_t y_pos,
  168.   int16_t data[6*64], 
  169.   int16_t qcoeff[6*64], 
  170.   IMAGE * const pCurrent)
  172. {
  174. uint32_t stride = pParam->edged_width;
  175. uint32_t stride2 = stride / 2;
  176. uint32_t next_block = stride * 8;
  177. uint32_t i;
  178. uint32_t iQuant = pParam->quant;
  179. uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
  180. uint8_t cbp = 0;
  181. uint32_t sum;
  182.     
  183. pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
  184. pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
  185. pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
  187. start_timer();
  188. pMB->field_dct = 0;
  189. if (pParam->global_flags & XVID_INTERLACING)
  190. {
  191. pMB->field_dct = MBDecideFieldDCT(data);
  192. }
  193. stop_interlacing_timer();
  195. for(i = 0; i < 6; i++)
  196. {
  197. /* 
  198.  *  no need to transfer 8->16-bit
  199.  * (this is performed already in motion compensation) 
  200.  */
  201. start_timer();
  202. fdct(&data[i*64]);
  203. stop_dct_timer();
  205. if (pParam->quant_type == 0)
  206. {
  207. start_timer();
  208. sum = quant_inter(&qcoeff[i*64], &data[i*64], iQuant);
  209. stop_quant_timer();
  210. }
  211. else
  212. {
  213. start_timer();
  214. sum = quant4_inter(&qcoeff[i*64], &data[i*64], iQuant);
  215. stop_quant_timer();
  216. }
  218. if(sum >= TOOSMALL_LIMIT) { // skip block ?
  220. if (pParam->quant_type == H263_QUANT)
  221. {
  222. start_timer();
  223. dequant_inter(&data[i*64], &qcoeff[i*64], iQuant);
  224. stop_iquant_timer();
  225. }
  226. else
  227. {
  228. start_timer();
  229. dequant4_inter(&data[i*64], &qcoeff[i*64], iQuant);
  230. stop_iquant_timer();
  231. }
  233. cbp |= 1 << (5 - i);
  235. start_timer();
  236. idct(&data[i*64]);
  237. stop_idct_timer();
  238. }
  239. }
  241. if (pMB->field_dct)
  242. {
  243. next_block = stride;
  244. stride *= 2;
  245. }
  247. start_timer();
  248. if (cbp & 32)
  249. transfer_16to8add(pY_Cur,                  &data[0*64], stride);
  250. if (cbp & 16)
  251. transfer_16to8add(pY_Cur + 8,              &data[1*64], stride);
  252. if (cbp & 8)
  253. transfer_16to8add(pY_Cur + next_block,     &data[2*64], stride);
  254. if (cbp & 4)
  255. transfer_16to8add(pY_Cur + next_block + 8, &data[3*64], stride);
  256. if (cbp & 2)
  257. transfer_16to8add(pU_Cur,                  &data[4*64], stride2);
  258. if (cbp & 1)
  259. transfer_16to8add(pV_Cur,                  &data[5*64], stride2);
  260. stop_transfer_timer();
  262. return cbp;
  264. }
  267. /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
  269. #define ABS(X) (X)<0 ? -(X) : (X)
  271. uint32_t MBDecideFieldDCT(int16_t data[6*64])
  272. {
  274. const uint8_t blocks[] = {0*64, 0*64, 0*64, 0*64, 2*64, 2*64, 2*64, 2*64};
  275. const uint8_t lines[]  = {0, 16, 32, 48, 0, 16, 32, 48};
  277. int frame = 0, field = 0;
  278. int i, j;
  280. for (i=0 ; i<7 ; ++i)
  281. {
  282. for (j=0 ; j<8 ; ++j)
  283. {
  284. frame += ABS(data[0*64 + (i+1)*8 + j] - data[0*64 + i*8 + j]);
  285. frame += ABS(data[1*64 + (i+1)*8 + j] - data[1*64 + i*8 + j]);
  286. frame += ABS(data[2*64 + (i+1)*8 + j] - data[2*64 + i*8 + j]);
  287. frame += ABS(data[3*64 + (i+1)*8 + j] - data[3*64 + i*8 + j]);
  289. field += ABS(data[blocks[i+1] + lines[i+1] + j] -
  290.      data[blocks[i  ] + lines[i  ] + j]);
  291. field += ABS(data[blocks[i+1] + lines[i+1] + 8 + j] -
  292.      data[blocks[i  ] + lines[i  ] + 8 + j]);
  293. field += ABS(data[blocks[i+1] + 64 + lines[i+1] + j] -
  294.      data[blocks[i  ] + 64 + lines[i  ] + j]);
  295. field += ABS(data[blocks[i+1] + 64 + lines[i+1] + 8 + j] -
  296.      data[blocks[i  ] + 64 + lines[i  ] + 8 + j]);
  297. }
  298. }
  300. if (frame > field)
  301. {
  302. MBFrameToField(data);
  303. }
  305. return (frame > field);
  306. }
  309. /* deinterlace Y blocks vertically */
  311. #define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
  312. #define LINE(X,Y)    &data[X*64 + Y*8]
  314. void MBFrameToField(int16_t data[6*64])
  315. {
  316. int16_t tmp[8];
  318. /* left blocks */
  320. // 1=2, 2=4, 4=8, 8=1
  321. MOVLINE(tmp, LINE(0,1));
  322. MOVLINE(LINE(0,1), LINE(0,2));
  323. MOVLINE(LINE(0,2), LINE(0,4));
  324. MOVLINE(LINE(0,4), LINE(2,0));
  325. MOVLINE(LINE(2,0), tmp);
  327. // 3=6, 6=12, 12=9, 9=3
  328. MOVLINE(tmp, LINE(0,3));
  329. MOVLINE(LINE(0,3), LINE(0,6));
  330. MOVLINE(LINE(0,6), LINE(2,4));
  331. MOVLINE(LINE(2,4), LINE(2,1));
  332. MOVLINE(LINE(2,1), tmp);
  334. // 5=10, 10=5
  335. MOVLINE(tmp, LINE(0,5));
  336. MOVLINE(LINE(0,5), LINE(2,2));
  337. MOVLINE(LINE(2,2), tmp);
  339. // 7=14, 14=13, 13=11, 11=7
  340. MOVLINE(tmp, LINE(0,7));
  341. MOVLINE(LINE(0,7), LINE(2,6));
  342. MOVLINE(LINE(2,6), LINE(2,5));
  343. MOVLINE(LINE(2,5), LINE(2,3));
  344. MOVLINE(LINE(2,3), tmp);
  346. /* right blocks */
  348. // 1=2, 2=4, 4=8, 8=1
  349. MOVLINE(tmp, LINE(1,1));
  350. MOVLINE(LINE(1,1), LINE(1,2));
  351. MOVLINE(LINE(1,2), LINE(1,4));
  352. MOVLINE(LINE(1,4), LINE(3,0));
  353. MOVLINE(LINE(3,0), tmp);
  355. // 3=6, 6=12, 12=9, 9=3
  356. MOVLINE(tmp, LINE(1,3));
  357. MOVLINE(LINE(1,3), LINE(1,6));
  358. MOVLINE(LINE(1,6), LINE(3,4));
  359. MOVLINE(LINE(3,4), LINE(3,1));
  360. MOVLINE(LINE(3,1), tmp);
  362. // 5=10, 10=5
  363. MOVLINE(tmp, LINE(1,5));
  364. MOVLINE(LINE(1,5), LINE(3,2));
  365. MOVLINE(LINE(3,2), tmp);
  367. // 7=14, 14=13, 13=11, 11=7
  368. MOVLINE(tmp, LINE(1,7));
  369. MOVLINE(LINE(1,7), LINE(3,6));
  370. MOVLINE(LINE(3,6), LINE(3,5));
  371. MOVLINE(LINE(3,5), LINE(3,3));
  372. MOVLINE(LINE(3,3), tmp);
  373. }