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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
text_code_mb.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：7k
源码类别：

多媒体编程

开发平台：

Visual C++

text_code_mb.c：源码内容
  1. #include "text_code.h"
  2. #include "text_dct.h"
  3. #define BLOCK_SIZE 8
  4. Void   BlockPredict (SInt *curr, 
  5. Int x_pos, Int y_pos, UInt width, Int fblock[][8]);
  6. Void   BlockRebuild (SInt *rec_curr, SInt *comp, Int pred_type, Int max,
  7. Int x_pos, Int y_pos, UInt width, UInt edge, Int fblock[][8]);
  8. Void   BlockQuantH263 (Int *coeff, Int QP, Int mode, Int type,
  9. Int *qcoeff, Int maxDC, Int image_type);
  10. Void   BlockDequantH263 (Int *qcoeff, Int QP, Int mode, Int type,
  11. Int *rcoeff, Int image_type, Int short_video_header, Int bits_per_pixel);
  12. Void CodeMB(Vop *curr, Vop *rec_curr, Vop *comp, Int x_pos, Int y_pos, UInt width,
  13. Int QP, Int Mode, Int *qcoeff)
  14. {
  15. Int k;
  16. Int fblock[6][8][8];
  17. Int coeff[384];
  18. Int *coeff_ind;
  19. Int *qcoeff_ind;
  20. Int* rcoeff_ind;
  21. Int x, y;
  22. SInt *current, *recon, *compensated = NULL;
  23. UInt xwidth;
  24. Int iblock[6][8][8];
  25. Int rcoeff[6*64];
  26. Int i, j;
  27. Int type;   
  28. SInt tmp[64];
  29. Int s;
  30. int operation = curr->prediction_type;
  32. Int max = GetVopBrightWhite(curr);
  34. coeff_ind = coeff;
  35. qcoeff_ind = qcoeff;
  36. rcoeff_ind = rcoeff;
  37. for (k = 0; k < 6; k++)
  38. {
  39. switch (k)
  40. {
  41. case 0:
  42. x = x_pos;
  43. y = y_pos;
  44. xwidth = width;
  45. current = (SInt *) GetImageData (GetVopY (curr));
  46. break;
  47. case 1:
  48. x = x_pos + 8;
  49. y = y_pos;
  50. xwidth = width;
  51. current = (SInt *) GetImageData (GetVopY (curr));
  52. break;
  53. case 2:
  54. x = x_pos;
  55. y = y_pos + 8;
  56. xwidth = width;
  57. current = (SInt *) GetImageData (GetVopY (curr));
  58. break;
  59. case 3:
  60. x = x_pos + 8;
  61. y = y_pos + 8;
  62. xwidth = width;
  63. current = (SInt *) GetImageData (GetVopY (curr));
  64. break;
  65. case 4:
  66. x = x_pos / 2;
  67. y = y_pos / 2;
  68. xwidth = width / 2;
  69. current = (SInt *) GetImageData (GetVopU (curr));
  70. break;
  71. case 5:
  72. x = x_pos / 2;
  73. y = y_pos / 2;
  74. xwidth = width / 2;
  75. current = (SInt *) GetImageData (GetVopV (curr));
  76. break;
  77. default:
  78. break;
  79. }
  80. BlockPredict (current, x, y, xwidth, fblock[k]);
  81. }
  82. for (k = 0; k < 6; k++)
  83. {
  84. s = 0;
  85. for (i = 0; i < 8; i++)
  86. for (j = 0; j < 8; j++)
  87. tmp[s++] = (SInt) fblock[k][i][j];
  88. #ifndef _MMX_
  89. fdct_enc(tmp);
  90. #else
  91. fdct_mm32(tmp);
  92. #endif
  93. for (s = 0; s < 64; s++)
  94. coeff_ind[s] = (Int) tmp[s];
  95. if (k < 4) type = 1;
  96. else type = 2;
  98. BlockQuantH263(coeff_ind,QP,Mode,type,qcoeff_ind,
  99. GetVopBrightWhite(curr),1);
  100. BlockDequantH263(qcoeff_ind,QP,Mode,type,rcoeff_ind,1, 0, GetVopBitsPerPixel(curr));
  101. for (s = 0; s < 64; s++)
  102. tmp[s] = (SInt) rcoeff_ind[s];
  103. #ifndef _MMX_
  104. idct_enc(tmp);
  105. #else
  106. Fast_IDCT(tmp);
  107. #endif
  108. s = 0;
  109. for (i = 0; i < 8; i++)
  110. for (j = 0; j < 8; j++)
  111. iblock[k][i][j] = (Int)tmp[s++];
  112. coeff_ind += 64;
  113. qcoeff_ind += 64;
  114. rcoeff_ind += 64;
  115. if (Mode == MODE_INTRA||Mode==MODE_INTRA_Q)
  116. for (i = 0; i < 8; i++)
  117. for (j = 0; j < 8; j ++)
  118. iblock[k][i][j] = MIN (GetVopBrightWhite(curr), MAX (0, iblock[k][i][j]));
  119. switch (k)
  120. {
  121. case 0:
  122. case 1:
  123. case 2:
  124. continue;
  125. case 3:
  126. recon = (SInt *) GetImageData (GetVopY (rec_curr));
  127. if (operation == P_VOP) compensated = (SInt *) GetImageData (GetVopY (comp));
  128. BlockRebuild (recon, compensated, operation, max, x_pos,     y_pos,     width, 16, iblock[0]);
  129. BlockRebuild (recon, compensated, operation, max, x_pos + 8, y_pos,     width, 16, iblock[1]);
  130. BlockRebuild (recon, compensated, operation, max, x_pos,     y_pos + 8, width, 16, iblock[2]);
  131. BlockRebuild (recon, compensated, operation, max, x_pos + 8, y_pos + 8, width, 16, iblock[3]);
  132. continue;
  133. case 4:
  134. recon = (SInt *) GetImageData (GetVopU (rec_curr));
  135. if (operation == P_VOP) compensated = (SInt *) GetImageData (GetVopU (comp));
  136. BlockRebuild (recon, compensated, operation, max,
  137. x_pos/2, y_pos/2, width/2, 8, iblock[4]);
  138. continue;
  139. case 5:
  140. recon = (SInt *) GetImageData (GetVopV (rec_curr));
  141. if (operation == P_VOP) compensated = (SInt *) GetImageData (GetVopV (comp));
  142. BlockRebuild (recon, compensated, operation, max,
  143. x_pos/2, y_pos/2, width/2, 8, iblock[5]);
  144. continue;
  145. }
  146. }
  147. return;
  148. }
  149. Void
  150. BlockPredict (SInt *curr,  Int x_pos, Int y_pos,
  151. UInt width, Int fblock[][8])
  152. {
  153. Int i, j;
  154. for (i = 0; i < 8; i++)
  155. {
  156. for (j = 0; j < 8; j++)
  157. {
  158. fblock[i][j] = curr[(y_pos+i)*width + x_pos+j];
  159. }
  160. }
  161. }
  162. Void
  163. BlockRebuild (SInt *rec_curr, SInt *comp, Int pred_type, Int max,
  164. Int x_pos, Int y_pos, UInt width, UInt edge, Int fblock[][8])
  165. {
  167. Int i, j;
  168. SInt *rec;
  169. Int padded_width;
  171. padded_width = width + 2 * edge;
  172. rec = rec_curr + edge * padded_width + edge;
  173. if (pred_type == I_VOP)
  174. {
  175. SInt *p;
  176. p  = rec + y_pos * padded_width + x_pos;
  177. for (i = 0; i < 8; i++) 
  178. {
  179. for (j = 0; j < 8; j++)
  180. {
  181. SInt temp = fblock[i][j];
  182. *(p++) = CLIP(temp, 0, max);
  183. }
  184. p += padded_width - 8;
  185. }
  186. }
  187. else if (pred_type == P_VOP)
  188. {
  189. SInt *p, *pc; 
  190. p  = rec + y_pos * padded_width + x_pos;
  191. pc = comp     + y_pos * width + x_pos;
  192. for (i = 0; i < 8; i++)
  193. {
  194. for (j = 0; j < 8; j++)
  195. {
  196. SInt temp = *(pc++) + fblock[i][j];
  197. *(p++) = CLIP(temp, 0, max);
  198. }
  199. p += padded_width - 8;
  200. pc += width - 8;
  201. }
  202. }
  203. }
  204. Void
  205. BlockQuantH263 (Int *coeff, Int QP, Int mode, Int type, Int *qcoeff, Int maxDC, Int image_type)
  206. {
  207. Int i;
  208. Int level, result;
  209. Int step, offset;
  210. Int dc_scaler;
  211. if (!(QP > 0 && (QP < 32*image_type))) return;
  212. if (!(type == 1 || type == 2)) return;
  213. if (mode == MODE_INTRA || mode == MODE_INTRA_Q)
  214. {   
  215. dc_scaler = cal_dc_scaler(QP,type);
  216. qcoeff[0] = MAX(1,MIN(maxDC-1, (coeff[0] + dc_scaler/2)/dc_scaler));
  217. step = 2 * QP;
  218. for (i = 1; i < 64; i++)
  219. {
  220. level = (abs(coeff[i]))  / step;
  221. result = (coeff[i] >= 0) ? level : -level;
  222. qcoeff[i] =  MIN(2047, MAX(-2048, result));
  223. }
  224. }
  225. else
  226. {   
  227. step = 2 * QP;
  228. offset = QP / 2;
  229. for (i = 0; i < 64; i++)
  230. {
  231. level = (abs(coeff[i]) - offset)  / step;
  232. result = (coeff[i] >= 0) ? level : -level;
  233. qcoeff[i] =  MIN(2047, MAX(-2048, result));
  234. }
  235. }
  236. return;
  237. }
  238. Void
  239. BlockDequantH263 (Int *qcoeff, Int QP, Int mode, Int type, Int *rcoeff,
  240. Int image_type, Int short_video_header, Int bits_per_pixel)
  241. {
  242. Int i;
  243. Int dc_scaler;
  244. Int lim;
  245. lim = (1 << (bits_per_pixel + 3));
  246. if (QP)
  247. {
  248. for (i = 0; i < 64; i++)
  249. {
  250. if (qcoeff[i])
  251. {
  253. qcoeff[i] =  MIN(2047, MAX(-2048, qcoeff[i] ));
  254. if ((QP % 2) == 1)
  255. rcoeff[i] = QP * (2*ABS(qcoeff[i]) + 1);
  256. else
  257. rcoeff[i] = QP * (2*ABS(qcoeff[i]) + 1) - 1;
  258. rcoeff[i] = SIGN(qcoeff[i]) * rcoeff[i];
  259. }
  260. else
  261. rcoeff[i] = 0;
  262. }
  263. if (mode == MODE_INTRA || mode == MODE_INTRA_Q)
  264. {   
  265. MOMCHECK(QP > 0 && (QP < 32*image_type));
  266. MOMCHECK(type == 1 || type == 2);
  267. if (short_video_header)
  268. dc_scaler = 8;
  269. else
  270. dc_scaler = cal_dc_scaler(QP,type);
  271. rcoeff[0] = qcoeff[0] * dc_scaler;
  272. }
  273. }
  274. else
  275. {
  277. for (i = 0; i < 64; i++)
  278. {
  279. rcoeff[i] = qcoeff[i];
  280. }
  281. if (mode == MODE_INTRA || mode == MODE_INTRA_Q)
  282. {   
  283. rcoeff[0] = qcoeff[0]*8;
  284. }
  285. }
  286. for (i=0;i<64;i++)
  287. if (rcoeff[i]>(lim-1)) rcoeff[i]=(lim-1);
  288. else if (rcoeff[i]<(-lim)) rcoeff[i]=(-lim);
  289. return;
  290. }