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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
test_basic_prediction.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：6k
源码类别：

VC书籍

开发平台：

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. }