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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
gethdr.c
资源名称：DirectShowcode.rar　[点击查看]
上传用户：hhs829
上传日期：2022-06-17
资源大小：586k
文件大小：13k
源码类别：

DirextX编程

开发平台：

Visual C++

gethdr.c：源码内容
  1. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  28. #include "global.h"
  29. #include "getbit.h"
  31. static double frame_rate_Table[16] = 
  32. {
  33. 0.0,
  34. ((24.0*1000.0)/1001.0),
  35. 24.0,
  36. 25.0,
  37. ((30.0*1000.0)/1001.0),
  38. 30.0,
  39. 50.0,
  40. ((60.0*1000.0)/1001.0),
  41. 60.0,
  43. -1, // reserved
  44. -1,
  45. -1,
  46. -1,
  47. -1,
  48. -1,
  49. -1
  50. };
  52. static char *AspectRatio[5] = {
  53. "", "1 : 1", "4 : 3", "16 : 9", "2.21 : 1"
  54. };
  56. __forceinline static void group_of_pictures_header(void);
  57. __forceinline static void picture_header(void);
  59. static void sequence_extension(void);
  60. static void sequence_display_extension(void);
  61. static void quant_matrix_extension(void);
  62. static void picture_display_extension(void);
  63. static void picture_coding_extension(void);
  64. static void copyright_extension(void);
  65. static int  extra_bit_information(void);
  66. static void extension_and_user_data(void);
  68. /* decode headers from one input stream */
  69. int Get_Hdr()
  70. {
  71. for (;;)
  72. {
  73. /* look for next_start_code */
  74. next_start_code();
  75. if (Fault_Flag)
  76. {
  77. return 0;
  78. }
  80. switch (Get_Bits(32))
  81. {
  82. case SEQUENCE_HEADER_CODE:
  83. sequence_header();
  84. break;
  86. case GROUP_START_CODE:
  87. group_of_pictures_header();
  88. break;
  90. case PICTURE_START_CODE:
  91. picture_header();
  92. return 1;
  93. }
  94. }
  95. }
  97. /* align to start of next next_start_code */
  98. void next_start_code()
  99. {
  100. Flush_Buffer(BitsLeft & 7);
  102. while (Show_Bits(24) != 1 && !Fault_Flag)
  103. Flush_Buffer(8);
  104. }
  106. /* decode sequence header */
  107. void sequence_header()
  108. {
  109. int constrained_parameters_flag;
  110. int bit_rate_value;
  111. int vbv_buffer_size;
  112. int i;
  114. horizontal_size             = Get_Bits(12);
  115. vertical_size               = Get_Bits(12);
  116. aspect_ratio_information    = Get_Bits(4);
  117. frame_rate_code             = Get_Bits(4);
  118. bit_rate_value              = Get_Bits(18);
  119. Flush_Buffer(1); // marker bit
  120. vbv_buffer_size             = Get_Bits(10);
  121. constrained_parameters_flag = Get_Bits(1);
  123. if (load_intra_quantizer_matrix = Get_Bits(1))
  124. {
  125. for (i=0; i<64; i++)
  126. intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  127. }
  128. else
  129. {
  130. for (i=0; i<64; i++)
  131. intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  132. }
  134. if (load_non_intra_quantizer_matrix = Get_Bits(1))
  135. {
  136. for (i=0; i<64; i++)
  137. non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  138. }
  139. else
  140. {
  141. for (i=0; i<64; i++)
  142. non_intra_quantizer_matrix[i] = 16;
  143. }
  145. /* copy luminance to chrominance matrices */
  146. for (i=0; i<64; i++)
  147. {
  148. chroma_intra_quantizer_matrix[i] = intra_quantizer_matrix[i];
  149. chroma_non_intra_quantizer_matrix[i] = non_intra_quantizer_matrix[i];
  150. }
  151. extension_and_user_data();
  152. }
  154. /* decode group of pictures header */
  155. /* ISO/IEC 13818-2 section 6.2.2.6 */
  156. static void group_of_pictures_header()
  157. {
  158. int gop_hour;
  159. int gop_minute;
  160. int gop_sec;
  161. int gop_frame;
  163. int drop_flag;
  164. int closed_gop;
  165. int broken_link;
  167. drop_flag   = Get_Bits(1);
  168. gop_hour    = Get_Bits(5);
  169. gop_minute  = Get_Bits(6);
  170. Flush_Buffer(1); // marker bit
  171. gop_sec     = Get_Bits(6);
  172. gop_frame = Get_Bits(6);
  173. closed_gop  = Get_Bits(1);
  174. broken_link = Get_Bits(1);
  176. extension_and_user_data();
  177. }
  179. /* decode picture header */
  180. /* ISO/IEC 13818-2 section 6.2.3 */
  181. static void picture_header()
  182. {
  183. int vbv_delay;
  184. int full_pel_forward_vector;
  185. int forward_f_code;
  186. int full_pel_backward_vector;
  187. int backward_f_code;
  188. int Extra_Information_Byte_Count;
  190. temporal_reference  = Get_Bits(10);
  191. picture_coding_type = Get_Bits(3);
  193. //------------------------------------------------------------------------------------
  194. d2v_current.type = picture_coding_type;
  196. if (d2v_current.type==I_TYPE)
  197. {
  198. /* d2v_current.lba = process.startloc/BUFFER_SIZE - 2;
  200. if (d2v_current.lba < 0)
  201. {
  202. if (d2v_current.file > 0)
  203. {
  204. d2v_current.file --;
  205. d2v_current.lba = process.length[d2v_current.file]/BUFFER_SIZE - 1;
  206. }
  207. else
  208. d2v_current.lba = 0;
  209. }
  211. if (process.locate==LOCATE_RIP)
  212. {
  213. process.file = d2v_current.file;
  214. process.lba = d2v_current.lba;
  215. }*/
  216. }
  217. //-----------------------------------------------------------------------------------
  219. vbv_delay = Get_Bits(16);
  221. if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
  222. {
  223. full_pel_forward_vector = Get_Bits(1);
  224. forward_f_code = Get_Bits(3);
  225. }
  227. if (picture_coding_type==B_TYPE)
  228. {
  229. full_pel_backward_vector = Get_Bits(1);
  230. backward_f_code = Get_Bits(3);
  231. }
  233. Extra_Information_Byte_Count = extra_bit_information();
  234. extension_and_user_data();
  235. }
  237. /* decode slice header */
  238. /* ISO/IEC 13818-2 section 6.2.4 */
  239. int slice_header()
  240. {
  241. int slice_vertical_position_extension;
  242. int quantizer_scale_code;
  243. int slice_picture_id_enable = 0;
  244. int slice_picture_id = 0;
  245. int extra_information_slice = 0;
  247. slice_vertical_position_extension = vertical_size>2800 ? Get_Bits(3) : 0;
  249. quantizer_scale_code = Get_Bits(5);
  250. quantizer_scale = q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1;
  252. /* slice_id introduced in March 1995 as part of the video corridendum
  253.    (after the IS was drafted in November 1994) */
  254. if (Get_Bits(1))
  255. {
  256. Get_Bits(1); // intra slice
  258. slice_picture_id_enable = Get_Bits(1);
  259. slice_picture_id = Get_Bits(6);
  261. extra_information_slice = extra_bit_information();
  262. }
  264. return slice_vertical_position_extension;
  265. }
  267. /* decode extension and user data */
  268. /* ISO/IEC 13818-2 section 6.2.2.2 */
  269. static void extension_and_user_data()
  270. {
  271. int code, ext_ID;
  273. next_start_code();
  275. while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE)
  276. {
  277. if (code==EXTENSION_START_CODE)
  278. {
  279. Flush_Buffer(32);
  280. ext_ID = Get_Bits(4);
  282. switch (ext_ID)
  283. {
  284. case SEQUENCE_EXTENSION_ID:
  285. sequence_extension();
  286. break;
  287. case SEQUENCE_DISPLAY_EXTENSION_ID:
  288. sequence_display_extension();
  289. break;
  290. case QUANT_MATRIX_EXTENSION_ID:
  291. quant_matrix_extension();
  292. break;
  293. case PICTURE_DISPLAY_EXTENSION_ID:
  294. picture_display_extension();
  295. break;
  296. case PICTURE_CODING_EXTENSION_ID:
  297. picture_coding_extension();
  298. break;
  299. case COPYRIGHT_EXTENSION_ID:
  300. copyright_extension();
  301. break;
  302. }
  303. next_start_code();
  304. }
  305. else
  306. {
  307. Flush_Buffer(32); // ISO/IEC 13818-2  sections 6.3.4.1 and 6.2.2.2.2
  308. next_start_code(); // skip user data
  309. }
  310. }
  311. }
  313. /* decode sequence extension */
  314. /* ISO/IEC 13818-2 section 6.2.2.3 */
  315. static void sequence_extension()
  316. {
  317. int profile_and_level_indication;
  318. int low_delay;
  319. int frame_rate_extension_n;
  320. int frame_rate_extension_d;
  322. int horizontal_size_extension;
  323. int vertical_size_extension;
  324. int bit_rate_extension;
  325. int vbv_buffer_size_extension;
  327. profile_and_level_indication = Get_Bits(8);
  328. progressive_sequence         = Get_Bits(1);
  329. chroma_format                = Get_Bits(2);
  330. horizontal_size_extension    = Get_Bits(2);
  331. vertical_size_extension      = Get_Bits(2);
  332. bit_rate_extension           = Get_Bits(12);
  333. Flush_Buffer(1); // marker bit
  334. vbv_buffer_size_extension    = Get_Bits(8);
  335. low_delay                    = Get_Bits(1);
  336.  
  337. frame_rate_extension_n       = Get_Bits(2);
  338. frame_rate_extension_d       = Get_Bits(5);
  339. frame_rate = (float)(frame_rate_Table[frame_rate_code] * (frame_rate_extension_n+1)/(frame_rate_extension_d+1));
  341. horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  342. vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
  343. }
  345. /* decode sequence display extension */
  346. static void sequence_display_extension()
  347. {
  348. int video_format;  
  349. int color_description;
  350. int color_primaries;
  351. int transfer_characteristics;
  352. int matrix_coefficients;
  353. int display_horizontal_size;
  354. int display_vertical_size;
  356. video_format      = Get_Bits(3);
  357. color_description = Get_Bits(1);
  359. if (color_description)
  360. {
  361. color_primaries          = Get_Bits(8);
  362. transfer_characteristics = Get_Bits(8);
  363. matrix_coefficients      = Get_Bits(8);
  364. }
  366. display_horizontal_size = Get_Bits(14);
  367. Flush_Buffer(1); // marker bit
  368. display_vertical_size   = Get_Bits(14);
  369. }
  371. /* decode quant matrix entension */
  372. /* ISO/IEC 13818-2 section 6.2.3.2 */
  373. static void quant_matrix_extension()
  374. {
  375. int i;
  377. if (load_intra_quantizer_matrix = Get_Bits(1))
  378. for (i=0; i<64; i++)
  379. chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  380. = intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  382. if (load_non_intra_quantizer_matrix = Get_Bits(1))
  383. for (i=0; i<64; i++)
  384. chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  385. = non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  387. if (load_chroma_intra_quantizer_matrix = Get_Bits(1))
  388. for (i=0; i<64; i++)
  389. chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  391. if (load_chroma_non_intra_quantizer_matrix = Get_Bits(1))
  392. for (i=0; i<64; i++)
  393. chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  394. }
  396. /* decode picture display extension */
  397. /* ISO/IEC 13818-2 section 6.2.3.3. */
  398. static void picture_display_extension()
  399. {
  400. int frame_center_horizontal_offset[3];
  401. int frame_center_vertical_offset[3];
  403. int i;
  404. int number_of_frame_center_offsets;
  406. /* based on ISO/IEC 13818-2 section 6.3.12 
  407.    (November 1994) Picture display extensions */
  409. /* derive number_of_frame_center_offsets */
  410. if (progressive_sequence)
  411. {
  412. if (repeat_first_field)
  413. {
  414. if (top_field_first)
  415. number_of_frame_center_offsets = 3;
  416. else
  417. number_of_frame_center_offsets = 2;
  418. }
  419. else
  420. number_of_frame_center_offsets = 1;
  421. }
  422. else
  423. {
  424. if (picture_structure!=FRAME_PICTURE)
  425. number_of_frame_center_offsets = 1;
  426. else
  427. {
  428. if (repeat_first_field)
  429. number_of_frame_center_offsets = 3;
  430. else
  431. number_of_frame_center_offsets = 2;
  432. }
  433. }
  435. /* now parse */
  436. for (i=0; i<number_of_frame_center_offsets; i++)
  437. {
  438. frame_center_horizontal_offset[i] = Get_Bits(16);
  439. Flush_Buffer(1); // marker bit
  441. frame_center_vertical_offset[i] = Get_Bits(16);
  442. Flush_Buffer(1); // marker bit
  443. }
  444. }
  446. /* decode picture coding extension */
  447. static void picture_coding_extension()
  448. {
  449. int chroma_420_type;
  450. int composite_display_flag;
  451. int v_axis;
  452. int field_sequence;
  453. int sub_carrier;
  454. int burst_amplitude;
  455. int sub_carrier_phase;
  457. f_code[0][0] = Get_Bits(4);
  458. f_code[0][1] = Get_Bits(4);
  459. f_code[1][0] = Get_Bits(4);
  460. f_code[1][1] = Get_Bits(4);
  462. intra_dc_precision = Get_Bits(2);
  463. picture_structure = Get_Bits(2);
  464. top_field_first = Get_Bits(1);
  465. frame_pred_frame_dct = Get_Bits(1);
  466. concealment_motion_vectors = Get_Bits(1);
  467. q_scale_type = Get_Bits(1);
  468. intra_vlc_format = Get_Bits(1);
  469. alternate_scan = Get_Bits(1);
  470. repeat_first_field = Get_Bits(1);
  471. chroma_420_type = Get_Bits(1);
  472. progressive_frame = Get_Bits(1);
  473. composite_display_flag = Get_Bits(1);
  475. d2v_current.pf = progressive_frame;
  476. d2v_current.trf = (top_field_first<<1) + repeat_first_field;
  478. if (composite_display_flag)
  479. {
  480. v_axis            = Get_Bits(1);
  481. field_sequence    = Get_Bits(3);
  482. sub_carrier       = Get_Bits(1);
  483. burst_amplitude   = Get_Bits(7);
  484. sub_carrier_phase = Get_Bits(8);
  485. }
  486. }
  488. /* decode extra bit information */
  489. /* ISO/IEC 13818-2 section 6.2.3.4. */
  490. static int extra_bit_information()
  491. {
  492. int Byte_Count = 0;
  494. while (Get_Bits(1))
  495. {
  496. Flush_Buffer(8);
  497. Byte_Count++;
  498. }
  500. return(Byte_Count);
  501. }
  503. /* Copyright extension */
  504. /* ISO/IEC 13818-2 section 6.2.3.6. */
  505. /* (header added in November, 1994 to the IS document) */
  506. static void copyright_extension()
  507. {
  508. int copyright_flag;
  509. int copyright_identifier;
  510. int original_or_copy;
  511. int copyright_number_1;
  512. int copyright_number_2;
  513. int copyright_number_3;
  515. int reserved_data;
  517. copyright_flag =       Get_Bits(1); 
  518. copyright_identifier = Get_Bits(8);
  519. original_or_copy =     Get_Bits(1);
  520.   
  521. /* reserved */
  522. reserved_data = Get_Bits(7);
  524. Flush_Buffer(1); // marker bit
  525. copyright_number_1 =   Get_Bits(20);
  526. Flush_Buffer(1); // marker bit
  527. copyright_number_2 =   Get_Bits(22);
  528. Flush_Buffer(1); // marker bit
  529. copyright_number_3 =   Get_Bits(22);
  530. }