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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
headers.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

headers.c：源码内容
  1. #include "../mpeg3private.h"
  2. #include "../mpeg3protos.h"
  3. #include "mpeg3video.h"
  5. #include <stdio.h>
  6. #include <stdlib.h>
  8. int mpeg3video_getseqhdr(mpeg3video_t *video)
  9. {
  10. int i;
  12. int aspect_ratio, picture_rate, vbv_buffer_size;
  13. int constrained_parameters_flag;
  14. int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
  16. video->horizontal_size = mpeg3bits_getbits(video->vstream, 12);
  17. video->vertical_size = mpeg3bits_getbits(video->vstream, 12);
  18. aspect_ratio = mpeg3bits_getbits(video->vstream, 4);
  19. video->framerate_code = mpeg3bits_getbits(video->vstream, 4);
  20. video->bitrate = mpeg3bits_getbits(video->vstream, 18);
  21. mpeg3bits_getbit_noptr(video->vstream); /* marker bit (=1) */
  22. vbv_buffer_size = mpeg3bits_getbits(video->vstream, 10);
  23. constrained_parameters_flag = mpeg3bits_getbit_noptr(video->vstream);
  24. video->frame_rate = mpeg3_frame_rate_table[video->framerate_code];
  26.   load_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
  27.   if(load_intra_quantizer_matrix)
  28. {
  29.      for(i = 0; i < 64; i++)
  30.        video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  31.    }
  32.    else 
  33. {
  34.      for(i = 0; i < 64; i++)
  35.        video->intra_quantizer_matrix[i] = mpeg3_default_intra_quantizer_matrix[i];
  36.    }
  38. load_non_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
  39. if(load_non_intra_quantizer_matrix)
  40. {
  41.      for(i = 0; i < 64; i++)
  42.        video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  43.    }
  44.    else 
  45. {
  46.      for(i = 0; i < 64; i++)
  47.        video->non_intra_quantizer_matrix[i] = 16;
  48.    }
  50. /* copy luminance to chrominance matrices */
  51.    for(i = 0; i < 64; i++)
  52. {
  53.      video->chroma_intra_quantizer_matrix[i] = video->intra_quantizer_matrix[i];
  54.       video->chroma_non_intra_quantizer_matrix[i] = video->non_intra_quantizer_matrix[i];
  55.    }
  57. return 0;
  58. }
  61. /* decode sequence extension */
  63. int mpeg3video_sequence_extension(mpeg3video_t *video)
  64. {
  65. int prof_lev;
  66. int horizontal_size_extension, vertical_size_extension;
  67. int bit_rate_extension, vbv_buffer_size_extension, low_delay;
  68. int frame_rate_extension_n, frame_rate_extension_d;
  69. int pos = 0;
  71. video->mpeg2 = 1;
  72. video->scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  73. prof_lev = mpeg3bits_getbyte_noptr(video->vstream);
  74. video->prog_seq = mpeg3bits_getbit_noptr(video->vstream);
  75. video->chroma_format = mpeg3bits_getbits(video->vstream, 2);
  76. horizontal_size_extension = mpeg3bits_getbits(video->vstream, 2);
  77. vertical_size_extension = mpeg3bits_getbits(video->vstream, 2);
  78. bit_rate_extension = mpeg3bits_getbits(video->vstream, 12);
  79. mpeg3bits_getbit_noptr(video->vstream);
  80. vbv_buffer_size_extension = mpeg3bits_getbyte_noptr(video->vstream);
  81. low_delay = mpeg3bits_getbit_noptr(video->vstream);
  82. frame_rate_extension_n = mpeg3bits_getbits(video->vstream, 2);
  83. frame_rate_extension_d = mpeg3bits_getbits(video->vstream, 5);
  84. video->horizontal_size = (horizontal_size_extension << 12) | (video->horizontal_size & 0x0fff);
  85. video->vertical_size = (vertical_size_extension << 12) | (video->vertical_size & 0x0fff);
  86. return 0;
  87. }
  90. /* decode sequence display extension */
  92. int mpeg3video_sequence_display_extension(mpeg3video_t *video)
  93. {
  94. int colour_primaries = 0, transfer_characteristics = 0;
  95. int display_horizontal_size, display_vertical_size;
  96. int pos = 0;
  97. int video_format = mpeg3bits_getbits(video->vstream, 3);
  98. int colour_description = mpeg3bits_getbit_noptr(video->vstream);
  100. if(colour_description)
  101. {
  102.      colour_primaries = mpeg3bits_getbyte_noptr(video->vstream);
  103.      transfer_characteristics = mpeg3bits_getbyte_noptr(video->vstream);
  104.      video->matrix_coefficients = mpeg3bits_getbyte_noptr(video->vstream);
  105. }
  107. display_horizontal_size = mpeg3bits_getbits(video->vstream, 14);
  108. mpeg3bits_getbit_noptr(video->vstream);
  109. display_vertical_size = mpeg3bits_getbits(video->vstream, 14);
  110. return 0;
  111. }
  114. /* decode quant matrix entension */
  116. int mpeg3video_quant_matrix_extension(mpeg3video_t *video)
  117. {
  118. int i;
  119. int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
  120. int load_chroma_intra_quantiser_matrix;
  121. int load_chroma_non_intra_quantiser_matrix;
  122. int pos = 0;
  124. if((load_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
  125. {
  126.        for(i = 0; i < 64; i++)
  127. {
  128.      video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
  129.      = video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
  130.      = mpeg3bits_getbyte_noptr(video->vstream);
  131.        }
  132. }
  134. if((load_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
  135. {
  136.      for (i = 0; i < 64; i++)
  137. {
  138.      video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
  139.      = video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
  140.      = mpeg3bits_getbyte_noptr(video->vstream);
  141.      }
  142. }
  144. if((load_chroma_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
  145. {
  146.      for(i = 0; i < 64; i++)
  147.      video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  148. }
  150. if((load_chroma_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
  151. {
  152.        for(i = 0; i < 64; i++)
  153.      video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  154. }
  155. return 0;
  156. }
  159. /* decode sequence scalable extension */
  161. int mpeg3video_sequence_scalable_extension(mpeg3video_t *video)
  162. {
  163. int layer_id;
  165. video->scalable_mode = mpeg3bits_getbits(video->vstream, 2) + 1; /* add 1 to make SC_DP != SC_NONE */
  166. layer_id = mpeg3bits_getbits(video->vstream, 4);
  168. if(video->scalable_mode == SC_SPAT)
  169. {
  170.      video->llw = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_horizontal_size */
  171.      mpeg3bits_getbit_noptr(video->vstream);
  172.      video->llh = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_vertical_size */
  173.      video->hm = mpeg3bits_getbits(video->vstream, 5);
  174.      video->hn = mpeg3bits_getbits(video->vstream, 5);
  175.      video->vm = mpeg3bits_getbits(video->vstream, 5);
  176.      video->vn = mpeg3bits_getbits(video->vstream, 5);
  177. }
  179. if(video->scalable_mode == SC_TEMP)
  180.        fprintf(stderr, "mpeg3video_sequence_scalable_extension: temporal scalability not implementedn");
  181. return 0;
  182. }
  185. /* decode picture display extension */
  187. int mpeg3video_picture_display_extension(mpeg3video_t *video)
  188. {
  189. int n, i;
  190. short frame_centre_horizontal_offset[3];
  191. short frame_centre_vertical_offset[3];
  195. if(video->prog_seq || video->pict_struct != FRAME_PICTURE)
  196. n = 1;
  197. else 
  198. n = video->repeatfirst ? 3 : 2;
  203. for(i = 0; i < n; i++)
  204. {
  205.      frame_centre_horizontal_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
  206.      mpeg3bits_getbit_noptr(video->vstream);
  207.      frame_centre_vertical_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
  208.      mpeg3bits_getbit_noptr(video->vstream);
  209. }
  210. return 0;
  211. }
  214. /* decode picture coding extension */
  216. int mpeg3video_picture_coding_extension(mpeg3video_t *video)
  217. {
  218. int chroma_420_type, composite_display_flag;
  219. int v_axis = 0, field_sequence = 0, sub_carrier = 0, burst_amplitude = 0, sub_carrier_phase = 0;
  221. video->h_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
  222. video->v_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
  223. video->h_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
  224. video->v_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
  225. video->dc_prec = mpeg3bits_getbits(video->vstream, 2);
  226. video->pict_struct = mpeg3bits_getbits(video->vstream, 2);
  227. video->topfirst = mpeg3bits_getbit_noptr(video->vstream);
  228. video->frame_pred_dct = mpeg3bits_getbit_noptr(video->vstream);
  229. video->conceal_mv = mpeg3bits_getbit_noptr(video->vstream);
  230. video->qscale_type = mpeg3bits_getbit_noptr(video->vstream);
  231. video->intravlc = mpeg3bits_getbit_noptr(video->vstream);
  232. video->altscan = mpeg3bits_getbit_noptr(video->vstream);
  235. video->repeatfirst = mpeg3bits_getbit_noptr(video->vstream);
  238. chroma_420_type = mpeg3bits_getbit_noptr(video->vstream);
  239. video->prog_frame = mpeg3bits_getbit_noptr(video->vstream);
  241. if(video->repeat_count > 100)
  242. video->repeat_count = 0;
  243. video->repeat_count += 100;
  245. video->current_repeat = 0;
  247. if(video->prog_seq)
  248. {
  249. if(video->repeatfirst)
  250. {
  251. if(video->topfirst)
  252. video->repeat_count += 200;
  253. else
  254. video->repeat_count += 100;
  255. }
  256. }
  257. else
  258. if(video->prog_frame)
  259. {
  260. if(video->repeatfirst)
  261. {
  262. video->repeat_count += 50;
  263. }
  264. }
  266. /*printf("mpeg3video_picture_coding_extension %dn", video->repeat_count); */
  267. composite_display_flag = mpeg3bits_getbit_noptr(video->vstream);
  269. if(composite_display_flag)
  270. {
  271.      v_axis = mpeg3bits_getbit_noptr(video->vstream);
  272.      field_sequence = mpeg3bits_getbits(video->vstream, 3);
  273.      sub_carrier = mpeg3bits_getbit_noptr(video->vstream);
  274.      burst_amplitude = mpeg3bits_getbits(video->vstream, 7);
  275.      sub_carrier_phase = mpeg3bits_getbyte_noptr(video->vstream);
  276. }
  277. return 0;
  278. }
  281. /* decode picture spatial scalable extension */
  283. int mpeg3video_picture_spatial_scalable_extension(mpeg3video_t *video)
  284. {
  285. video->pict_scal = 1; /* use spatial scalability in this picture */
  287. video->lltempref = mpeg3bits_getbits(video->vstream, 10);
  288. mpeg3bits_getbit_noptr(video->vstream);
  289. video->llx0 = mpeg3bits_getbits(video->vstream, 15);
  290. if(video->llx0 >= 16384) video->llx0 -= 32768;
  291. mpeg3bits_getbit_noptr(video->vstream);
  292. video->lly0 = mpeg3bits_getbits(video->vstream, 15);
  293. if(video->lly0 >= 16384) video->lly0 -= 32768;
  294. video->stwc_table_index = mpeg3bits_getbits(video->vstream, 2);
  295. video->llprog_frame = mpeg3bits_getbit_noptr(video->vstream);
  296. video->llfieldsel = mpeg3bits_getbit_noptr(video->vstream);
  297. return 0;
  298. }
  301. /* decode picture temporal scalable extension
  302.  *
  303.  * not implemented
  304.  *
  305.  */
  307. int mpeg3video_picture_temporal_scalable_extension(mpeg3video_t *video)
  308. {
  309.    fprintf(stderr, "mpeg3video_picture_temporal_scalable_extension: temporal scalability not supportedn");
  310. return 0;
  311. }
  314. /* decode extension and user data */
  316. int mpeg3video_ext_user_data(mpeg3video_t *video)
  317. {
  318.    int code = mpeg3bits_next_startcode(video->vstream);
  321.    while((code == MPEG3_EXT_START_CODE || code == MPEG3_USER_START_CODE) &&
  322. !mpeg3bits_eof(video->vstream))
  323. {
  324.      mpeg3bits_refill(video->vstream);
  326.      if(code == MPEG3_EXT_START_CODE)
  327. {
  328.        int ext_id = mpeg3bits_getbits(video->vstream, 4);
  329.        switch(ext_id)
  330. {
  331.      case SEQ_ID:
  332. mpeg3video_sequence_extension(video);
  333. break;
  334.      case DISP_ID:
  335. mpeg3video_sequence_display_extension(video);
  336. break;
  337.      case QUANT_ID:
  338. mpeg3video_quant_matrix_extension(video);
  339. break;
  340.      case SEQSCAL_ID:
  341. mpeg3video_sequence_scalable_extension(video);
  342. break;
  343.      case PANSCAN_ID:
  344. mpeg3video_picture_display_extension(video);
  345. break;
  346.      case CODING_ID:
  347. mpeg3video_picture_coding_extension(video);
  348. break;
  349.      case SPATSCAL_ID:
  350. mpeg3video_picture_spatial_scalable_extension(video);
  351. break;
  352.      case TEMPSCAL_ID:
  353. mpeg3video_picture_temporal_scalable_extension(video);
  354. break;
  355.      default:
  356. fprintf(stderr,"mpeg3video_ext_user_data: reserved extension start code ID %dn", ext_id);
  357. break;
  358.        }
  359.     }
  360.     code = mpeg3bits_next_startcode(video->vstream);
  361.    }
  362. return 0;
  363. }
  366. /* decode group of pictures header */
  368. int mpeg3video_getgophdr(mpeg3video_t *video)
  369. {
  370. int drop_flag, closed_gop, broken_link;
  372. //printf("%xn", mpeg3bits_tell(video->vstream));
  373. video->has_gops = 1;
  374. drop_flag = mpeg3bits_getbit_noptr(video->vstream);
  375. video->gop_timecode.hour = mpeg3bits_getbits(video->vstream, 5);
  376. video->gop_timecode.minute = mpeg3bits_getbits(video->vstream, 6);
  377. mpeg3bits_getbit_noptr(video->vstream);
  378. video->gop_timecode.second = mpeg3bits_getbits(video->vstream, 6);
  379. video->gop_timecode.frame = mpeg3bits_getbits(video->vstream, 6);
  380. closed_gop = mpeg3bits_getbit_noptr(video->vstream);
  381. broken_link = mpeg3bits_getbit_noptr(video->vstream);
  383. /*
  384.  * printf("%d:%d:%d:%d %d %d %dn", video->gop_timecode.hour, video->gop_timecode.minute, video->gop_timecode.second, video->gop_timecode.frame, 
  385.  *   drop_flag, closed_gop, broken_link);
  386.  */
  387. return mpeg3bits_error(video->vstream);
  388. }
  390. /* decode picture header */
  392. int mpeg3video_getpicturehdr(mpeg3video_t *video)
  393. {
  394. int temp_ref, vbv_delay;
  396. video->pict_scal = 0; /* unless overwritten by pict. spat. scal. ext. */
  398. temp_ref = mpeg3bits_getbits(video->vstream, 10);
  399. video->pict_type = mpeg3bits_getbits(video->vstream, 3);
  400. vbv_delay = mpeg3bits_getbits(video->vstream, 16);
  402. if(video->pict_type == P_TYPE || video->pict_type == B_TYPE)
  403. {
  404.      video->full_forw = mpeg3bits_getbit_noptr(video->vstream);
  405.      video->forw_r_size = mpeg3bits_getbits(video->vstream, 3) - 1;
  406. }
  408. if(video->pict_type == B_TYPE)
  409. {
  410.      video->full_back = mpeg3bits_getbit_noptr(video->vstream);
  411.      video->back_r_size = mpeg3bits_getbits(video->vstream, 3) - 1;
  412. }
  414. /* get extra bit picture */
  415. while(mpeg3bits_getbit_noptr(video->vstream) &&
  416. !mpeg3bits_eof(video->vstream)) 
  417. mpeg3bits_getbyte_noptr(video->vstream);
  418. return 0;
  419. }
  422. int mpeg3video_get_header(mpeg3video_t *video, int dont_repeat)
  423. {
  424. unsigned int code;
  426. /* a sequence header should be found before returning from `getheader' the */
  427. /* first time (this is to set horizontal/vertical size properly) */
  429. /* Repeat the frame until it's less than 1 count from repeat_count */
  430. if(video->repeat_count - video->current_repeat >= 100 && !dont_repeat)
  431. {
  432. return 0;
  433. }
  435. if(dont_repeat)
  436. {
  437. video->repeat_count = 0;
  438. video->current_repeat = 0;
  439. }
  440. else
  441. video->repeat_count -= video->current_repeat;
  443. //printf("mpeg3video_get_header 1 %d %dn", 
  444. // video->vstream->demuxer->titles[0]->fs->current_byte, 
  445. // video->vstream->demuxer->titles[0]->fs->total_bytes);
  447. while(1)
  448. {
  449. //printf("mpeg3video_get_header 1 %llxn", mpeg3bits_tell(video->vstream));
  450. /* look for startcode */
  451.      code = mpeg3bits_next_startcode(video->vstream);
  454. //printf("mpeg3video_get_header 2 %x %x %08xn", 
  455. // video->vstream->demuxer->titles[0]->fs->current_byte, 
  456. // video->vstream->demuxer->titles[0]->fs->total_bytes,
  457. // code);
  458. //printf("mpeg3video_get_header 2 %dn", mpeg3bits_eof(video->vstream));
  459. if(mpeg3bits_eof(video->vstream)) return 1;
  460. if(code != MPEG3_SEQUENCE_END_CODE) mpeg3bits_refill(video->vstream);
  461.  
  462.      switch(code)
  463. {
  464.      case MPEG3_SEQUENCE_START_CODE:
  465.      video->found_seqhdr = 1;
  466.      mpeg3video_getseqhdr(video);  
  467.      mpeg3video_ext_user_data(video);
  468.      break;
  470.      case MPEG3_GOP_START_CODE:
  471.      mpeg3video_getgophdr(video);
  472.      mpeg3video_ext_user_data(video);
  473.      break;
  475.      case MPEG3_PICTURE_START_CODE:
  476. //printf("%xn", mpeg3bits_tell(video->vstream));
  477.      mpeg3video_getpicturehdr(video);
  478.      mpeg3video_ext_user_data(video);
  479.      if(video->found_seqhdr) return 0;       /* Exit here */
  480.      break;
  482.      case MPEG3_SEQUENCE_END_CODE:
  483. // Continue until the end
  484. mpeg3bits_refill(video->vstream);
  485. break;
  487.      default:
  488.      break;
  489.      }
  490.    }
  491.   return 1;      /* Shouldn't be reached. */
  492. }
  494. int mpeg3video_ext_bit_info(mpeg3_slice_buffer_t *slice_buffer)
  495. {
  496. while(mpeg3slice_getbit(slice_buffer)) mpeg3slice_getbyte(slice_buffer);
  497. return 0;
  498. }
  500. /* decode slice header */
  501. int mpeg3video_getslicehdr(mpeg3_slice_t *slice, mpeg3video_t *video)
  502. {
  503. int slice_vertical_position_extension, intra_slice;
  504. int qs;
  506.    slice_vertical_position_extension = (video->mpeg2 && video->vertical_size > 2800) ? 
  507. mpeg3slice_getbits(slice->slice_buffer, 3) : 0;
  509.    if(video->scalable_mode == SC_DP) slice->pri_brk = mpeg3slice_getbits(slice->slice_buffer, 7);
  511.    qs = mpeg3slice_getbits(slice->slice_buffer, 5);
  512.    slice->quant_scale = video->mpeg2 ? (video->qscale_type ? mpeg3_non_linear_mquant_table[qs] : (qs << 1)) : qs;
  514.    if(mpeg3slice_getbit(slice->slice_buffer))
  515. {
  516.      intra_slice = mpeg3slice_getbit(slice->slice_buffer);
  517.      mpeg3slice_getbits(slice->slice_buffer, 7);
  518.      mpeg3video_ext_bit_info(slice->slice_buffer);
  519.    }
  520.    else 
  521. intra_slice = 0;
  523. return slice_vertical_position_extension;
  524. }