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

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

VC书籍

开发平台：

Visual C++

DECORE.C：源码内容
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. #if ( (defined (WIN32)) && (! defined (_DECORE)) )
  7. #include <string.h>
  8. #include <io.h>
  9. #include <fcntl.h>
  10. #endif
  12. #include "gen_usetime.h"
  13. #include "debug.h"
  14. #include "mp4_vars.h"
  15. #include "getbits.h"
  16. #include "yuv2rgb.h"
  17. #include "decore.h"
  19. /**
  20.  *
  21. **/
  23. /***/
  25. static int flag_firstpicture = 1;
  27. /***/
  29. //解码器初始化
  30. int STDCALL decore(unsigned long handle, unsigned long dec_opt,
  31. void *param1, void *param2)
  32. {
  33. if (handle) 
  34. {
  35. switch (dec_opt)
  36. {
  37. case DEC_OPT_MEMORY_REQS:
  38. {
  39. DEC_PARAM *dec_param = (DEC_PARAM *)param1;
  40. DEC_MEM_REQS *dec_mem_reqs = (DEC_MEM_REQS *)param2;
  42. int coded_y_size = ((dec_param->x_dim + 64) * (dec_param->y_dim + 64));
  43. int coded_c_size = (((dec_param->x_dim>>1) + 64) * ((dec_param->y_dim>>1) + 64));
  44. int display_y_size = (dec_param->x_dim * dec_param->y_dim);
  45. int display_c_size = ((dec_param->x_dim * dec_param->y_dim) >> 2);
  46. int edged_size = coded_y_size + (2 * coded_c_size);
  47. int display_size = display_y_size + (2 * display_c_size);
  49. dec_mem_reqs->mp4_edged_ref_buffers_size = edged_size;
  50. dec_mem_reqs->mp4_edged_for_buffers_size = edged_size;
  51. dec_mem_reqs->mp4_display_buffers_size = display_size;
  52. dec_mem_reqs->mp4_state_size = sizeof(MP4_STATE);
  53. dec_mem_reqs->mp4_tables_size = sizeof(MP4_TABLES);
  54. dec_mem_reqs->mp4_stream_size = sizeof(MP4_STREAM);
  56. return DEC_OK;
  57. }
  58. case DEC_OPT_INIT:
  59. {
  60. DEC_PARAM *dec_param = (DEC_PARAM *) param1;
  62. // 初始化解码器的资源
  63. decore_init(dec_param->x_dim, dec_param->y_dim, dec_param->output_format,
  64. dec_param->time_incr, dec_param->buffers); 
  66. return DEC_OK;
  67. }
  68. break; 
  69. case DEC_OPT_RELEASE:
  70. {
  71. decore_release();
  73. return DEC_OK;
  74. }
  75. break;
  76. case DEC_OPT_SETPP:
  77. {
  78. DEC_SET *dec_set = (DEC_SET *) param1;
  79. int postproc_level = dec_set->postproc_level;
  81. if ((postproc_level < 0) | (postproc_level > 100))
  82. return DEC_BAD_FORMAT;
  84. if (postproc_level < 1) {
  85. mp4_state->post_flag = 0;
  86. return DEC_OK;
  87. }
  88. else 
  89. {
  90. mp4_state->post_flag = 1;
  92. if (postproc_level < 10) {
  93. mp4_state->pp_options = PP_DEBLOCK_Y_H;
  94. }
  95. else if (postproc_level < 20) {
  96. mp4_state->pp_options = PP_DEBLOCK_Y_H | PP_DEBLOCK_Y_V;
  97. }
  98. else if (postproc_level < 30) {
  99. mp4_state->pp_options = PP_DEBLOCK_Y_H | PP_DEBLOCK_Y_V | PP_DERING_Y;
  100. }
  101. else if (postproc_level < 40) {
  102. mp4_state->pp_options = PP_DEBLOCK_Y_H | PP_DEBLOCK_Y_V | PP_DERING_Y | PP_DEBLOCK_C_H;
  103. }
  104. else if (postproc_level < 50) {
  105. mp4_state->pp_options = PP_DEBLOCK_Y_H | PP_DEBLOCK_Y_V | PP_DERING_Y | 
  106. PP_DEBLOCK_C_H | PP_DEBLOCK_C_V;
  107. }
  108. else {
  109. mp4_state->pp_options = PP_DEBLOCK_Y_H | PP_DEBLOCK_Y_V | PP_DERING_Y | 
  110. PP_DEBLOCK_C_H | PP_DEBLOCK_C_V | PP_DERING_C;
  111. }
  112. }
  114. return DEC_OK;
  115. }
  116. break;
  117. case DEC_OPT_SETOUT:
  118. {
  119. DEC_PARAM *dec_param = (DEC_PARAM *) param1;
  121. decore_setoutput(dec_param->output_format);
  123. return DEC_OK;
  124. }
  125. break;
  126. default:
  127. {
  128. DEC_FRAME *dec_frame = (DEC_FRAME *) param1;
  130. if (decore_frame(dec_frame->bitstream, dec_frame->length, 
  131. dec_frame->bmp, dec_frame->stride, dec_frame->render_flag))
  132. return DEC_OK;
  133. else 
  134. return DEC_EXIT;
  135. }
  136. break;
  137. }
  138. }
  139. return DEC_BAD_FORMAT;
  140. }
  142. /***/
  144. int decore_alloc(DEC_BUFFERS buffers);
  147. // 初始化解码器的资源
  148. static int decore_init(int hor_size, int ver_size, int output_format,
  149.  int time_inc, DEC_BUFFERS buffers)
  150. {
  151. mp4_state = (MP4_STATE *) buffers.mp4_state;
  152. mp4_tables = (MP4_TABLES *) buffers.mp4_tables;
  153. ld = (MP4_STREAM *) buffers.mp4_stream;
  155. #ifndef _DECORE
  156. // 打开输入文件
  157. if ((ld->infile = open (mp4_state->infilename, O_RDONLY | O_BINARY)) < 0) {
  158. _Print ("Input file %s not foundn", mp4_state->infilename);
  159. exit(91);
  160. }
  161. initbits (NULL, 0);
  162. mp4_state->juice_flag = 0;
  163. #else 
  164. mp4_state->juice_flag = 1;
  165. #endif // _DECORE
  167. mp4_state->post_flag = 0;
  169. // 读第一次的vol和vop
  170. mp4_state->hdr.width = hor_size;
  171. mp4_state->hdr.height = ver_size;
  173. mp4_state->hdr.quant_precision = 5;
  174. mp4_state->hdr.bits_per_pixel = 8;
  176. mp4_state->hdr.quant_type = 0;
  178. if (flag_firstpicture == 1) {
  179. mp4_state->hdr.time_increment_resolution = 15;
  180. flag_firstpicture = 0;
  181. }
  182. mp4_state->hdr.complexity_estimation_disable = 1;
  184. decore_alloc (buffers);
  185. decore_setoutput (output_format);
  187. return 1;
  188. }
  190. /***/
  192. //解码器分配存储空间
  193. int decore_alloc(DEC_BUFFERS buffers)
  194. {
  195. mp4_state->hdr.picnum = 0;
  196. mp4_state->hdr.mb_xsize = mp4_state->hdr.width / 16;
  197. mp4_state->hdr.mb_ysize = mp4_state->hdr.height / 16;
  198. mp4_state->hdr.mba_size = mp4_state->hdr.mb_xsize * mp4_state->hdr.mb_ysize;
  200. // 设置图形维全局参数
  201. {
  202. mp4_state->horizontal_size = mp4_state->hdr.width;
  203. mp4_state->vertical_size = mp4_state->hdr.height;
  205. mp4_state->mb_width = mp4_state->horizontal_size / 16;
  206. mp4_state->mb_height = mp4_state->vertical_size / 16;
  208. mp4_state->coded_picture_width = mp4_state->horizontal_size + 64;
  209. mp4_state->coded_picture_height = mp4_state->vertical_size + 64;
  210. mp4_state->chrom_width = mp4_state->coded_picture_width >> 1;
  211. mp4_state->chrom_height = mp4_state->coded_picture_height >> 1;
  212. }
  214. // 初始化解码器
  215. initdecoder (buffers);
  217. return 1;
  218. }
  220. /***/
  222. // 解码帧
  223. int decore_frame(unsigned char *stream, int length, unsigned char *bmp, 
  224. unsigned int stride, int render_flag)
  225. {
  226. #ifndef _DECORE
  227. mp4_state->juice_flag = 0;
  228. _SetPrintCond(0, 1000, 0, 1000);
  229. _Print("- Picture %dr", mp4_state->hdr.picnum);
  230. #else
  231. initbits (stream, length);
  232. #endif // _DECORE
  234. getvolhdr();
  235. getgophdr();
  237. if (! getvophdr()) // 读取视频对象平面的头
  238. return 0;
  240. get_mp4picture(bmp, stride, render_flag); // 解码vop
  241. mp4_state->hdr.picnum++;
  243. return 1;
  244. }
  246. /***/
  248. // 解码器释放
  249. static int decore_release()
  250. {
  252. #ifndef _DECORE
  253. close (ld->infile);
  254. #endif // _DECORE
  256. return 1;
  257. }
  259. /***/
  261. // 解码器输出设置
  262. int decore_setoutput(int output_format)
  263. {
  264. mp4_state->flag_invert = +1;
  266. switch (output_format)
  267. {
  268. case DEC_RGB32:
  269. mp4_state->convert_yuv = yuv2rgb_32;
  270. mp4_state->flag_invert = -1;
  271. break;
  272. case DEC_RGB32_INV:
  273. mp4_state->convert_yuv = yuv2rgb_32;
  274. mp4_state->flag_invert = +1;
  275. break;
  276. case DEC_RGB24:
  277. mp4_state->convert_yuv = yuv2rgb_24;
  278. mp4_state->flag_invert = -1;
  279. break;
  280. case DEC_RGB24_INV:
  281. mp4_state->convert_yuv = yuv2rgb_24;
  282. mp4_state->flag_invert = +1;
  283. break;
  284. case DEC_RGB555:
  285. mp4_state->convert_yuv = yuv2rgb_555;
  286. mp4_state->flag_invert = -1;
  287. break;
  288. case DEC_RGB555_INV:
  289. mp4_state->convert_yuv = yuv2rgb_555;
  290. mp4_state->flag_invert = +1;
  291. break;
  292. case DEC_RGB565:
  293. mp4_state->convert_yuv = yuv2rgb_565;
  294. mp4_state->flag_invert = -1;
  295. break;
  296. case DEC_RGB565_INV:
  297. mp4_state->convert_yuv = yuv2rgb_565;
  298. mp4_state->flag_invert = +1;
  299. break;
  300. case DEC_420:
  301. mp4_state->convert_yuv = yuv12_out;
  302. break;
  303. case DEC_YUV2:
  304. mp4_state->convert_yuv = yuy2_out;
  305. break;
  306. case DEC_UYVY:
  307. mp4_state->convert_yuv = uyvy_out;
  308. break;
  309. }
  311. return 1;
  312. }
  314. /**
  315.  * for a console application
  316. **/
  318. #ifndef _DECORE
  320. /***/
  322. static int dec_reinit();
  324. static void options (int *argcp, char **argvp[]);
  325. static void optionhelp (int *argcp);
  329. int main (int argc, char *argv[])
  330. {
  331.   char * infilename = argv[1];
  332. char outputfilename[256] = "Test.yuv";
  334. DEC_MEM_REQS decMemReqs;
  335. DEC_PARAM decParam;
  337. decParam.x_dim = 352;
  338. decParam.y_dim = 288;
  339. decParam.output_format = 0;
  340. decParam.time_incr = 0;
  342. decore(1, DEC_OPT_MEMORY_REQS, &decParam, &decMemReqs);
  344. decParam.buffers.mp4_edged_ref_buffers = malloc(decMemReqs.mp4_edged_ref_buffers_size);
  345. decParam.buffers.mp4_edged_for_buffers = malloc(decMemReqs.mp4_edged_for_buffers_size);
  346. decParam.buffers.mp4_display_buffers = malloc(decMemReqs.mp4_display_buffers_size);
  347. decParam.buffers.mp4_state = malloc(decMemReqs.mp4_state_size);
  348. decParam.buffers.mp4_tables = malloc(decMemReqs.mp4_tables_size);
  349. decParam.buffers.mp4_stream = malloc(decMemReqs.mp4_stream_size);
  351. memset(decParam.buffers.mp4_state, 0, decMemReqs.mp4_state_size);
  352. memset(decParam.buffers.mp4_tables, 0, decMemReqs.mp4_tables_size);
  353. memset(decParam.buffers.mp4_stream, 0, decMemReqs.mp4_stream_size);
  355. ((MP4_STATE *) decParam.buffers.mp4_state)->infilename = infilename;
  356. ((MP4_STATE *) decParam.buffers.mp4_state)->outputname = outputfilename;
  358. decore(1, DEC_OPT_INIT, &decParam, NULL);
  360. startTimer();
  362. // 解码帧
  363. {
  364. DEC_FRAME decFrame;
  366. decFrame.bitstream = NULL;
  367. decFrame.bmp = NULL;
  368. decFrame.length = 0;
  369. decFrame.render_flag = 0;
  371. while ( decore(1, 0, &decFrame, NULL) == DEC_OK )
  372. ;
  373. }
  375. stopTimer();
  376. displayTimer(mp4_state->hdr.picnum);
  378. return 1;
  379. }
  381. /***/
  383. static void options (int *argcp, char **argvp[])
  384. {
  385. (*argvp)++;
  386. (*argcp)--;
  388.   while (*argcp > 1 && (*argvp)[1][0] == '-')
  389.   {
  390.     switch (toupper ((*argvp)[1][1]))
  391.     {
  392.       case 'O':
  393. mp4_state->output_flag = 1;
  394.         mp4_state->outputname = (*argvp)[2];
  395. (*argvp) += 2;
  396. (*argcp) -= 2;
  397. break;
  398. case 'J':
  399. mp4_state->juice_flag = 1;
  400. mp4_state->juice_hor = atoi ((*argvp)[2]);
  401. mp4_state->juice_ver = atoi ((*argvp)[3]);
  402.     (*argvp) += 3;
  403. (*argcp) -= 3;
  404. break;
  405.       default:
  406.         printf ("Error: Undefined option -%c ignoredn", (*argvp)[1][1]);
  407.     }
  408.   }
  409. }
  411. /***/
  413. static void optionhelp(int *argcp)
  414. {
  415.   if (*argcp < 2)
  416.   {
  417.     _Print ("Usage: opendivx_dec bitstream {options} n");
  418. _Print ("Options: -o {outputfilename} YUV concatenated file outputn");
  419. _Print ("         -j {hor_size ver_size} juice stream and its picture formatn");
  420.     exit (0);
  421.   }
  422. }
  426. int dec_reinit()
  427. {
  428.   if (ld->infile != 0)
  429.     lseek (ld->infile, 0l, 0);
  430.   initbits (NULL, 0);
  432. return 1;
  433. }
  435. /***/
  437. #endif // !_DECORE