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

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

VC书籍

开发平台：

Visual C++

encore.c：源码内容
  1. #include "encore.h"
  2. #include "vop_code.h"
  3. #include "text_dct.h"
  4. #include "bitstream.h"
  5. #include "vm_common_defs.h"
  6. #include "rate_ctl.h"
  7. typedef struct _REFERENCE
  8. {
  9. unsigned long handle;
  10. float framerate;
  11. long bitrate;
  12. long rc_period;
  13. long rc_reaction_period;
  14. long rc_reaction_ratio;
  15. long max_key_interval;
  16. int x_dim, y_dim;
  17. int prev_rounding;
  18. int search_range;
  19. int max_quantizer;
  20. int min_quantizer;
  21. long seq;
  22. long curr_run;       
  23. Vop *current;        
  24. Vop *reference;      
  25. Vop *reconstruct;    
  26. Vop *error;          
  27. struct _REFERENCE *pnext;
  28. } REFERENCE;
  29. FILE *ftrace = NULL;
  30. int max_quantizer, min_quantizer;
  31. void init_vol_config(VolConfig *vol_config);
  32. void init_vop(Vop *vop);
  33. Int get_fcode (Int sr);
  34. int PutVoVolHeader(int vol_width, int vol_height, int time_increment_resolution, float frame_rate);
  35. int YUV2YUV (int x_dim, int y_dim, void *yuv, void *y_out, void *u_out, void *v_out);
  36. int encore(unsigned long handle, unsigned long enc_opt, void *param1, void *param2)
  37. {
  38. static REFERENCE *ref = NULL;
  39. static VolConfig *vol_config;
  41. REFERENCE *ref_curr, *ref_last = NULL;
  42. int x_dim, y_dim, size, length;
  43. int headerbits = 0;
  44. Vop *curr;
  45. ref_curr = ref_last = ref;
  46. while (ref_curr != NULL)
  47. {
  48. if (ref_curr->handle == handle) break;
  49. ref_last = ref_curr;
  50. ref_curr = ref_last->pnext;
  51. }
  53. if (ref_curr == NULL)
  54. {
  55. if (enc_opt & ENC_OPT_RELEASE) return ENC_OK;
  56. ref_curr = (REFERENCE *)malloc(sizeof(REFERENCE));
  57. ref_curr->handle = handle;
  58. ref_curr->seq = 0;
  59. ref_curr->curr_run = 0;
  60. ref_curr->pnext = NULL;
  61. if (ref) ref_last->pnext = ref_curr;
  62. else ref = ref_curr;
  63. }
  65. if (enc_opt & ENC_OPT_INIT)
  66. {
  67. #ifdef _RC_
  68. ftrace = fopen("trace.txt", "w");
  69. fflush(ftrace);
  70. #endif
  71. init_fdct_enc();
  72. init_idct_enc();
  74. ref_curr->framerate = ((ENC_PARAM *)param1)->framerate;
  75. ref_curr->bitrate = ((ENC_PARAM *)param1)->bitrate;
  76. ref_curr->rc_period = ((ENC_PARAM *)param1)->rc_period;
  77. ref_curr->rc_reaction_period = ((ENC_PARAM *)param1)->rc_reaction_period;
  78. ref_curr->rc_reaction_ratio = ((ENC_PARAM *)param1)->rc_reaction_ratio;
  79. ref_curr->x_dim = ((ENC_PARAM *)param1)->x_dim;
  80. ref_curr->y_dim = ((ENC_PARAM *)param1)->y_dim;
  81. ref_curr->max_key_interval = ((ENC_PARAM *)param1)->max_key_interval;
  82. ref_curr->search_range = ((ENC_PARAM *)param1)->search_range;
  83. ref_curr->max_quantizer = ((ENC_PARAM *)param1)->max_quantizer;
  84. ref_curr->min_quantizer = ((ENC_PARAM *)param1)->min_quantizer;
  85. ref_curr->current = AllocVop(ref_curr->x_dim, ref_curr->y_dim);
  86. ref_curr->reference = AllocVop(ref_curr->x_dim + 2 * 16, 
  87. ref_curr->y_dim + 2 * 16);
  88. ref_curr->reconstruct = AllocVop(ref_curr->x_dim, ref_curr->y_dim);
  89. ref_curr->error = AllocVop(ref_curr->x_dim, ref_curr->y_dim);
  90. init_vop(ref_curr->current);
  91. init_vop(ref_curr->reference);
  92. init_vop(ref_curr->reconstruct);
  93. init_vop(ref_curr->error);
  94. ref_curr->reference->hor_spat_ref = -16;
  95. ref_curr->reference->ver_spat_ref = -16;
  96. SetConstantImage(ref_curr->reference->y_chan, 0);
  97. vol_config = (VolConfig *)malloc(sizeof(VolConfig));
  98. init_vol_config(vol_config);
  99. vol_config->frame_rate = ref_curr->framerate;
  100. vol_config->bit_rate = ref_curr->bitrate;
  101. RateCtlInit(8 , vol_config->bit_rate / vol_config->frame_rate,
  102. ref_curr->rc_period, ref_curr->rc_reaction_period, ref_curr->rc_reaction_ratio);
  103. return ENC_OK;
  104. }
  106. if (enc_opt & ENC_OPT_RELEASE)
  107. {
  108. if (ref_curr == ref) ref = NULL;
  109. else ref_last->pnext = ref_curr->pnext;
  110. if (ref_curr->current) FreeVop(ref_curr->current);
  111. if (ref_curr->reference) FreeVop(ref_curr->reference);
  112. if (ref_curr->reconstruct) FreeVop(ref_curr->reconstruct);
  113. if (ref_curr->error) FreeVop(ref_curr->error);
  114. free(ref_curr);
  115. free(vol_config);
  116. if (ftrace) {
  117. fclose(ftrace);
  118. ftrace = NULL;
  119. };
  120. return ENC_OK;
  121. }
  123. max_quantizer = ref_curr->max_quantizer;
  124. min_quantizer = ref_curr->min_quantizer;
  125. x_dim = ref_curr->x_dim;
  126. y_dim = ref_curr->y_dim;
  127. size = x_dim * y_dim;
  128. curr = ref_curr->current;
  129. curr->width = x_dim;
  130. curr->height = y_dim;
  131. curr->sr_for = ref_curr->search_range;
  132. curr->fcode_for = get_fcode(curr->sr_for);
  135. YUV2YUV(x_dim, y_dim, ((ENC_FRAME *)param1)->image,
  136. curr->y_chan->f, curr->u_chan->f, curr->v_chan->f);
  138. curr->rounding_type = 1 - ref_curr->prev_rounding;
  139. Bitstream_Init((void *)(((ENC_FRAME *)param1)->bitstream));
  140. if (ref_curr->seq == 0) {
  141. headerbits = PutVoVolHeader(x_dim, y_dim, curr->time_increment_resolution, ref_curr->framerate);
  142. }
  144. #ifdef _RC_
  145. fflush(ftrace);
  146. fprintf(ftrace, "nCoding frame #%dn", ref_curr->seq);
  147. #endif
  148. if (ref_curr->curr_run % ref_curr->max_key_interval == 0) {
  149. curr->prediction_type = I_VOP;
  150. #ifdef _RC_
  151. fprintf(ftrace, "This frame is forced to be coded in INTRA.n");
  152. fprintf(ftrace, "It has been %d frame since the last INTRA.n", ref_curr->curr_run);
  153. #endif
  154. }
  155. else curr->prediction_type = P_VOP;
  157. VopCode(curr,
  158. ref_curr->reference,
  159. ref_curr->reconstruct,
  160. ref_curr->error,
  161. 1, 
  162. (float)ref_curr->seq/ref_curr->framerate,  
  163. vol_config);
  164. length = Bitstream_Close();
  165. ((ENC_FRAME *)param1)->length = length;
  167. RateCtlUpdate(length * 8);
  168. ref_curr->prev_rounding = curr->rounding_type;
  169. ref_curr->seq ++;
  170. ref_curr->curr_run ++;
  171. if (curr->prediction_type == I_VOP) {
  172. ((ENC_RESULT *)param2)->isKeyFrame = 1;
  173. ref_curr->curr_run = 1;
  174. } else 
  175. ((ENC_RESULT *)param2)->isKeyFrame = 0;
  176. return ENC_OK;
  177. }
  178. void init_vol_config(VolConfig *vol_config)
  179. {
  181. vol_config->M = 1;
  182. vol_config->frame_skip = 1;
  183. vol_config->quantizer = 8;
  184. vol_config->intra_quantizer = 8;
  185. vol_config->modulo_time_base[0] =0;
  186. vol_config->modulo_time_base[1] =0;
  187. vol_config->frame_rate = 30;
  188. vol_config->bit_rate = 800000;
  189. }
  190. void init_vop(Vop *vop)
  191. {
  193. vop->quant_precision = 5;
  194. vop->bits_per_pixel = 8;
  195. vop->time_increment_resolution = 30000;
  196. vop->intra_acdc_pred_disable = 0;
  197. vop->intra_dc_vlc_thr = 0;
  198. vop->sr_for = 512;
  199. vop->fcode_for = get_fcode(512);
  200. vop->y_chan->type = SHORT_TYPE;
  201. vop->u_chan->type = SHORT_TYPE;
  202. vop->v_chan->type = SHORT_TYPE;
  203. vop->hor_spat_ref = 0;
  204. vop->ver_spat_ref = 0;
  205. }
  206. Int get_fcode (Int sr)
  207. {
  208. if (sr<=16) return 1;
  209. else if (sr<=32) return 2;
  210. else if (sr<=64) return 3;
  211. else if (sr<=128) return 4;
  212. else if (sr<=256) return 5;
  213. else if (sr<=512) return 6;
  214. else if (sr<=1024) return 7;
  215. else return (-1);
  216. }
  217. int PutVoVolHeader(int vol_width, int vol_height, int time_increment_resolution, float frame_rate)
  218. {
  219. int written = 0;
  220. int bits, fixed_vop_time_increment;
  221. Bitstream_PutBits(VO_START_CODE_LENGTH, VO_START_CODE);
  222. Bitstream_PutBits(5, 0);
  223. written += VO_START_CODE_LENGTH + 5;
  224. Bitstream_PutBits(VOL_START_CODE_LENGTH, VOL_START_CODE);
  225. Bitstream_PutBits(4, 0);
  226. written += VOL_START_CODE_LENGTH + 4;
  227. Bitstream_PutBits(1, 0);
  228. Bitstream_PutBits(8, 1);
  229. Bitstream_PutBits(1, 1);
  230. Bitstream_PutBits(4, 2);
  231. Bitstream_PutBits(3, 1);
  232. written += 1 + 8 + 1 + 4 + 3;
  233. Bitstream_PutBits(4, 1);
  234. Bitstream_PutBits(1, 0);
  235. Bitstream_PutBits(2, 0);
  236. Bitstream_PutBits(1, 1);
  237. written += 4 + 1 + 2 + 1;
  238. Bitstream_PutBits(16, time_increment_resolution);
  239. Bitstream_PutBits(1, 1);
  240. Bitstream_PutBits(1, 1);
  241. bits = (int)ceil(log((double)time_increment_resolution)/log(2.0));
  242.     if (bits<1) bits=1;
  243. fixed_vop_time_increment = (int)(time_increment_resolution / frame_rate + 0.1);
  244. Bitstream_PutBits(bits, fixed_vop_time_increment);
  245. Bitstream_PutBits(1, 1);
  246. written += 16 + 1 + 1 + bits + 1;
  247. Bitstream_PutBits(13, vol_width);
  248. Bitstream_PutBits(1, 1);
  249. Bitstream_PutBits(13, vol_height);
  250. Bitstream_PutBits(1, 1);
  251. written += 13 + 1 + 13 + 1;
  252. Bitstream_PutBits(1, 0);
  253. Bitstream_PutBits(1, 1);
  254. Bitstream_PutBits(2, 0);
  255. Bitstream_PutBits(1, 0);
  256. written += 1 + 1 + 2 + 1;
  257. Bitstream_PutBits(1, 0);
  258. Bitstream_PutBits(1, 0);
  259. Bitstream_PutBits(1, 1);
  260. Bitstream_PutBits(1, 1);
  261. Bitstream_PutBits(1, 0);
  262. Bitstream_PutBits(1, 0);
  263. written += 1 + 1 + 1 + 1 + 1 + 1;
  264. written += Bitstream_NextStartCode();
  265. return(written);
  266. }
  267. int YUV2YUV (int x_dim, int y_dim, void *yuv, void *y_out, void *u_out, void *v_out)
  268. {
  271. unsigned char *in;
  272. short int *out;
  273. long size;
  274. in = yuv;
  276. out = y_out;
  277. size = x_dim * y_dim;
  278. while (size --) *(out ++) = *(in ++);
  279. out = u_out;
  280. size = x_dim * y_dim / 4;
  281. while (size --) *(out ++) = *(in ++);
  282. out = v_out;
  283. size = x_dim * y_dim / 4;
  284. while (size --) *(out ++) = *(in ++);
  285. return 0;
  286. }