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

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

多媒体编程

开发平台：

Visual C++

test_basic_prediction.c：源码内容
  1. /*
  3.  test_basic_prediction.c
  5.  Test program for basic_prediction.  Tests for accuracy and can also be used for
  6.  testing the speed of this module.
  8.  Version 0.1
  10.  John Funnell, 18 March 2001
  12.  (C) 2001 Project Mayo
  14.  */
  17. #include <stdio.h>
  18. #include <stdlib.h>
  20. #include "basic_prediction.h"
  22. /*
  23.  comment out the next line if you know your functions produce the correct 
  24.  results and you are only interested in speed.
  25.  */
  26. #define CHECK_RESULTS
  28. #define WIDTH             640
  29. #define HEIGHT            480
  31. #define ITERATIONS        100
  36. #define INTERPOLATE2(A, B, R) (((int)(A) + (int)(B) + 1 - (R)) >> 1)
  37. #define INTERPOLATE4(A, B, C, D, R) (((int)(A) + (int)(B) + (int)(C) + (int)(D) + 2 - (R)) >> 2)
  42. int main(int argc, char **argv) {
  43. unsigned char *source, *dest, *Src, *Dst, pel;
  44. int x, y, i, sx, sy, dx, dy, blocksize, mode, rounding_control;
  46. /* allocate memory */
  47. source = malloc(WIDTH * HEIGHT);
  48. dest   = malloc(WIDTH * HEIGHT);
  49. if (!source || !dest) return -1;
  51. /* create random images */
  52. for(y=0; y<HEIGHT; y++) {
  53. for(x=0; x<WIDTH; x++) {
  54. source[WIDTH*y + x] = rand();
  55. dest  [WIDTH*y + x] = rand();
  56. }
  57. }
  59. printf("testing basic_prediction functions.....n");
  60. #ifdef CHECK_RESULTS
  61. printf("[not checking b-frame functions]n");
  62. #endif
  64. /* run the test */
  65. for (i=0; i<ITERATIONS; i++) {
  67. blocksize = i%2 ? 8 : 16; /* alternate block/macroblock with every frame */
  69. for(y=0; y<HEIGHT; y+=blocksize) {
  70. for(x=0; x<WIDTH; x+=blocksize) {
  71. sx = x + (rand() & 0x3f) - 0x20;
  72. sy = y + (rand() & 0x3f) - 0x20; 
  73. sx = sx < 0 ? 0 : sx;
  74. sy = sy < 0 ? 0 : sy;
  75. sx = sx+blocksize+1 > WIDTH  ? WIDTH- blocksize-1 : sx;
  76. sy = sy+blocksize+1 > HEIGHT ? HEIGHT-blocksize-1 : sy;
  77. Src = &(source[WIDTH*sy+sx]);
  78. Dst = &(  dest[WIDTH* y+ x]);
  79. mode = (x/blocksize)%8;
  80. rounding_control = (y/blocksize)%2;
  81. if (blocksize == 8) {
  82. if (rounding_control == 0) {
  83. /* no rounding versions */
  84. switch(mode) {
  85. case 0:
  86. CopyBlock(Src, Dst, WIDTH);
  87. break;
  88. case 1:
  89. CopyBlockHor(Src, Dst, WIDTH);
  90. break;
  91. case 2:
  92. CopyBlockVer(Src, Dst, WIDTH);
  93. break;
  94. case 3:
  95. CopyBlockHorVer(Src, Dst, WIDTH);
  96. break;
  97. /*
  98. case 4:
  99. BCopyBlock(Src, Dst, WIDTH);
  100. break;
  101. case 5:
  102. BCopyBlockHor(Src, Dst, WIDTH);
  103. break;
  104. case 6:
  105. BCopyBlockVer(Src, Dst, WIDTH);
  106. break;
  107. case 7:
  108. BCopyBlockHorVer(Src, Dst, WIDTH);
  109. break;*/
  111. }
  112. } else {
  113. /* rounding versions */
  114. switch(mode) {
  115. case 0:
  116. CopyBlock(Src, Dst, WIDTH);
  117. break;
  118. case 1:
  119. CopyBlockHorRound(Src, Dst, WIDTH);
  120. break;
  121. case 2:
  122. CopyBlockVerRound(Src, Dst, WIDTH);
  123. break;
  124. case 3:
  125. CopyBlockHorVerRound(Src, Dst, WIDTH);
  126. break;
  127. /*
  128. case 4:
  129. BCopyBlock(Src, Dst, WIDTH);
  130. break;
  131. case 5:
  132. BCopyBlockHor(Src, Dst, WIDTH);
  133. break;
  134. case 6:
  135. BCopyBlockVer(Src, Dst, WIDTH);
  136. break;
  137. case 7:
  138. BCopyBlockHorVer(Src, Dst, WIDTH);
  139. break;*/
  141. }
  142. }
  143. } else { /* blocksize == 16 */
  144. if (rounding_control == 0) {
  145. /* no rounding versions */
  146. switch(mode) {
  147. case 0:
  148. CopyMBlock(Src, Dst, WIDTH);
  149. break;
  150. case 1:
  151. CopyMBlockHor(Src, Dst, WIDTH);
  152. break;
  153. case 2:
  154. CopyMBlockVer(Src, Dst, WIDTH);
  155. break;
  156. case 3:
  157. CopyMBlockHorVer(Src, Dst, WIDTH);
  158. break;
  159. /*
  160. case 4:
  161. BCopyMBlock(Src, Dst, WIDTH);
  162. break;
  163. case 5:
  164. BCopyMBlockHor(Src, Dst, WIDTH);
  165. break;
  166. case 6:
  167. BCopyMBlockVer(Src, Dst, WIDTH);
  168. break;
  169. case 7:
  170. BCopyMBlockHorVer(Src, Dst, WIDTH);
  171. break;*/
  173. }
  174. } else {
  175. /* rounding versions */
  176. switch(mode) {
  177. case 0:
  178. CopyMBlock(Src, Dst, WIDTH);
  179. break;
  180. case 1:
  181. CopyMBlockHorRound(Src, Dst, WIDTH);
  182. break;
  183. case 2:
  184. CopyMBlockVerRound(Src, Dst, WIDTH);
  185. break;
  186. case 3:
  187. CopyMBlockHorVerRound(Src, Dst, WIDTH);
  188. break;
  189. /*
  190. case 4:
  191. BCopyMBlock(Src, Dst, WIDTH);
  192. break;
  193. case 5:
  194. BCopyMBlockHor(Src, Dst, WIDTH);
  195. break;
  196. case 6:
  197. BCopyMBlockVer(Src, Dst, WIDTH);
  198. break;
  199. case 7:
  200. BCopyMBlockHorVer(Src, Dst, WIDTH);
  201. break;*/
  203. }
  204. }
  205. }
  207. #ifdef CHECK_RESULTS
  208. /* check results */
  209. for(dy=0; dy<blocksize; dy++) {
  210. for(dx=0; dx<blocksize; dx++) {
  211. switch (mode) {
  212. case 0:
  213. pel = Src[WIDTH*dy+dx];
  214. break;
  215. case 1:
  216. pel = INTERPOLATE2(Src[WIDTH*dy+dx], Src[WIDTH*dy+dx+1], rounding_control);
  217. break;
  218. case 2:
  219. pel = INTERPOLATE2(Src[WIDTH*dy+dx], Src[WIDTH*(dy+1)+dx], rounding_control);
  220. break;
  221. case 3:
  222. pel = INTERPOLATE4(Src[WIDTH*dy+dx], Src[WIDTH*dy+dx+1], Src[WIDTH*(dy+1)+dx], Src[WIDTH*(dy+1)+dx+1], rounding_control);
  223. break;
  224. default:
  225. pel =  Dst[WIDTH*dy+dx];
  226. /* too fiddly to check the results for B frames */
  227. }
  228. if (pel != Dst[WIDTH*dy+dx]) {
  229. printf("failure: blocksize=%d mode=%d rounding_control=%dn", blocksize, mode, rounding_control);
  230. goto getoutofhere;
  231. }
  232. }
  233. }
  234. #endif
  235. }
  236. }
  237. }
  238. printf("completed sucessfullyn");
  240. getoutofhere:
  242. fgetc(stdin);
  243. return 0;
  244. }