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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
gethdr.cc
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：18k
源码类别：

DVD

开发平台：

Unix_Linux

gethdr.cc：源码内容
  1. /*
  2.   File: gethdr.cc
  4. */
  6. #pragma implementation
  8. #include <stdio.h>
  9. #include <fstream.h>
  10. #include <sys/time.h>
  12. #include "athread.hh"
  14. #include "error.hh"
  15. #include "debug.hh"
  16. #include "util.hh"
  18. #include "sync.hh"
  19. #include "mpeg2const.hh"
  20. #include "mpeg2buff.hh"
  22. #include "videoconst.hh"
  23. #include "display.hh"
  24. #include "idct.hh"
  25. #include "vstream.hh"
  26. #include "layerdata.hh"
  27. #include "global.hh"
  29. /* decode headers from one input stream
  30.  * until an End of Sequence or picture start code
  31.  * is found
  32.  */
  34. int LayerData::getheader(){
  35.   unsigned int code;
  36.   static int found_seqhdr=False; 
  37.   // a sequence header should be found before returning from `getheader' the
  38.   // first time (this is to set horizontal/vertical size properly)
  40.   while (1){
  41.     // look for startcode
  42.     code=input->startcode();
  43.     input->flushbits(32);
  44.     switch (code){
  45.     case Sequence_start_code: 
  46.       TRACER("sequence start code");
  47.       found_seqhdr=True;
  48.       getseqhdr();  
  49.       ext_user_data();
  50.       break;
  51.     case Gop_start_code:
  52.       TRACER("gop start code"); 
  53.       getgophdr();
  54.       ext_user_data();
  55.       break;
  56.     case Picture_start_code:
  57.       TRACER("picture start code");
  58.       getpicturehdr();
  59.       ext_user_data();
  60.       if (found_seqhdr) return 1;
  61.       break;
  62.     case Sequence_end_code:
  63.       TRACER("sequence end code");
  64.       return 0;
  65.     default:
  66.       if (!quiet && framerate==0)
  67.         fprintf(stderr,"Unexpected startcode %08x (ignored)n", code);
  68.       break;
  69.     }
  70.   }
  71.   return 0;
  72. }
  74. // decode sequence header
  76. void LayerData::getseqhdr(){
  77.   TRACER("void LayerData::getseqhdr()");
  78.   int i;
  79.   int aspect_ratio, picture_rate, vbv_buffer_size;
  80.   int constrained_parameters_flag;
  81.   int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
  82.   int bit_rate;
  83.   int pos=0;
  84.   if (verbose>0)
  85.     pos = input->getposition();
  87.   horizontal_size = input->getbits(12);
  88.   vertical_size = input->getbits(12);
  89.   aspect_ratio = input->getbits(4);
  90.   picture_rate = input->getbits(4);
  91.   bit_rate = input->getbits(18);
  92.   input->flushbits(1); /* marker bit (=1) */
  93.   vbv_buffer_size = input->getbits(10);
  94.   constrained_parameters_flag = input->getbits(1);
  96.   if ((load_intra_quantizer_matrix=input->getbits(1))!=0){
  97.     for (i=0; i<64; i++)
  98.       intra_quantizer_matrix[zig_zag_scan[i]] = input->getbits(8);
  99.   }
  100.   else {
  101.     for (i=0; i<64; i++)
  102.       intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  103.   }
  105.   if ((load_non_intra_quantizer_matrix=input->getbits(1))!=0){
  106.     for (i=0; i<64; i++)
  107.       non_intra_quantizer_matrix[zig_zag_scan[i]] = input->getbits(8);
  108.   }
  109.   else {
  110.     for (i=0; i<64; i++)
  111.       non_intra_quantizer_matrix[i] = 16;
  112.   }
  114.   /* copy luminance to chrominance matrices */
  115.   for (i=0; i<64; i++){
  116.     chroma_intra_quantizer_matrix[i] =
  117.       intra_quantizer_matrix[i];
  119.     chroma_non_intra_quantizer_matrix[i] =
  120.       non_intra_quantizer_matrix[i];
  121.   }
  122.   if (verbose>0){
  123.     printf("sequence header (byte %d)n",(pos>>3)-4);
  124.     if (verbose>1){
  125.       printf("  horizontal_size=%dn",horizontal_size);
  126.       printf("  vertical_size=%dn",vertical_size);
  127.       printf("  aspect_ratio=%dn",aspect_ratio);
  128.       printf("  picture_rate=%dn",picture_rate);
  129.       printf("  bit_rate=%dn",bit_rate);
  130.       printf("  vbv_buffer_size=%dn",vbv_buffer_size);
  131.       printf("  constrained_parameters_flag=%dn",constrained_parameters_flag);
  132.       printf("  load_intra_quantizer_matrix=%dn",load_intra_quantizer_matrix);
  133.       printf("  load_non_intra_quantizer_matrix=%dn",load_non_intra_quantizer_matrix);
  134.     }
  135.   }
  136. }
  139. /* decode group of pictures header */
  141. void LayerData::getgophdr(){
  142.   int drop_flag, hour, minute, sec, frame, closed_gop, broken_link;
  143.   int pos=0;
  144.   if (verbose>0)
  145.     pos = input->getposition();
  147.   drop_flag = input->getbits(1);
  148.   hour = input->getbits(5);
  149.   minute = input->getbits(6);
  150.   input->flushbits(1);
  151.   sec = input->getbits(6);
  152.   frame = input->getbits(6);
  153.   closed_gop = input->getbits(1);
  154.   broken_link = input->getbits(1);
  156.   if (verbose>0){
  157.     printf("group of pictures (byte %d)n",(pos>>3)-4);
  158.     if (verbose>1){
  159.       printf("  drop_flag=%dn",drop_flag);
  160.       printf("  timecode %d:%02d:%02d:%02dn",hour,minute,sec,frame);
  161.       printf("  closed_gop=%dn",closed_gop);
  162.       printf("  broken_link=%dn",broken_link);
  163.     }
  164.   }
  165. }
  168. /* decode picture header */
  170. void LayerData::getpicturehdr(){
  171.   int temp_ref, vbv_delay;
  172.   int pos=0;
  173.   if (verbose>0)
  174.     pos = input->getposition();
  176.   pict_scal = 0; /* unless overwritten by pict. spat. scal. ext. */
  178.   temp_ref = input->getbits(10);
  179.   pict_type = input->getbits(3);
  180.   vbv_delay = input->getbits(16);
  181.   if (pict_type==P_TYPE || pict_type==B_TYPE){
  182.     full_forw = input->getbits(1);
  183.     forw_r_size = input->getbits(3) - 1;
  184.   }
  185.   if (pict_type==B_TYPE){
  186.     full_back = input->getbits(1);
  187.     back_r_size = input->getbits(3) - 1;
  188.   }
  190.   if (verbose>0){
  191.     printf("picture header (byte %d)n",(pos>>3)-4);
  192.     if (verbose>1){
  193.       printf("  temp_ref=%dn",temp_ref);
  194.       printf("  pict_type=%dn",pict_type);
  195.       printf("  vbv_delay=%dn",vbv_delay);
  196.       if (pict_type==P_TYPE || pict_type==B_TYPE){
  197.         printf("  full_forw=%dn",full_forw);
  198.         printf("  forw_r_size=%dn",forw_r_size);
  199.       }
  200.       if (pict_type==B_TYPE){
  201.         printf("  full_back=%dn",full_back);
  202.         printf("  back_r_size=%dn",back_r_size);
  203.       }
  204.     }
  205.   }
  207.   // get extra bit picture
  208.   while (input->getbits(1)) input->flushbits(8);
  209. }
  211. /* decode slice header */
  213. int LayerData::getslicehdr(){
  214.   int slice_vertical_position_extension, intra_slice;
  215.   int pos=0;
  216.   if (verbose>0)
  217.     pos = input->getposition();
  219.   slice_vertical_position_extension=(mpeg2 && vertical_size>2800) ? input->getbits(3) : 0;
  221.   if (scalable_mode==SC_DP) pri_brk = input->getbits(7);
  223.   int qs = input->getbits(5);
  224.   quant_scale= mpeg2 ? (qscale_type ? non_linear_mquant_table[qs] : qs<<1) : qs;
  226.   if (input->getbits(1)){
  227.     intra_slice = input->getbits(1);
  228.     input->flushbits(7);
  229.     ext_bit_info();
  230.   }
  231.   else intra_slice = 0;
  233.   if (verbose>2){
  234.     printf("slice header (byte %d)n",(pos>>3)-4);
  235.     if (verbose>3){
  236.       if (mpeg2 && vertical_size>2800)
  237.         printf("  slice_vertical_position_extension=%dn",slice_vertical_position_extension);
  238.       if (scalable_mode==SC_DP)
  239.         printf("  priority_breakpoint=%dn",pri_brk);
  240.       printf("  quantizer_scale_code=%dn",qs);
  241.     }
  242.   }
  243.   return slice_vertical_position_extension;
  244. }
  247. /* decode extension and user data */
  249. void LayerData::ext_user_data(){
  250.   int code=input->startcode();
  251.   while (code==Ext_start_code || code==User_start_code){
  252.     input->flushbits(32);  
  253.     if (code==Ext_start_code){
  254.       int ext_ID = input->getbits(4);
  255.       switch (ext_ID){
  256.       case SEQ_ID:
  257.         sequence_extension();
  258.         break;
  259.       case DISP_ID:
  260.         sequence_display_extension();
  261.         break;
  262.       case QUANT_ID:
  263.         quant_matrix_extension();
  264.         break;
  265.       case SEQSCAL_ID:
  266.         sequence_scalable_extension();
  267.         break;
  268.       case PANSCAN_ID:
  269.         picture_display_extension();
  270.         break;
  271.       case CODING_ID:
  272.         picture_coding_extension();
  273.         break;
  274.       case SPATSCAL_ID:
  275.         picture_spatial_scalable_extension();
  276.         break;
  277.       case TEMPSCAL_ID:
  278.         picture_temporal_scalable_extension();
  279.         break;
  280.       default:
  281.         fprintf(stderr,"reserved extension start code ID %dn",ext_ID);
  282.         break;
  283.       }
  284.     }
  285.     else {
  286.       if (verbose) printf("user datan");
  287.     }
  288.     code=input->startcode();
  289.   }
  290. }
  293. /* decode sequence extension */
  295. void LayerData::sequence_extension(){
  296.   int prof_lev;
  297.   int horizontal_size_extension, vertical_size_extension;
  298.   int bit_rate_extension, vbv_buffer_size_extension, low_delay;
  299.   int frame_rate_extension_n, frame_rate_extension_d;
  301.   int pos=0;
  302.   if (verbose>0)
  303.     pos = input->getposition();
  304.   mpeg2 = 1;
  305.   scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  306.   prof_lev = input->getbits(8);
  307.   prog_seq = input->getbits(1);
  308.   chroma_format = input->getbits(2);
  309.   horizontal_size_extension = input->getbits(2);
  310.   vertical_size_extension = input->getbits(2);
  311.   bit_rate_extension = input->getbits(12);
  312.   input->flushbits(1);
  313.   vbv_buffer_size_extension = input->getbits(8);
  314.   low_delay = input->getbits(1);
  315.   frame_rate_extension_n = input->getbits(2);
  316.   frame_rate_extension_d = input->getbits(5);
  318.   horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  319.   vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
  321.   if (verbose>0){
  322.     printf("sequence extension (byte %d)n",(pos>>3)-4);
  323.     if (verbose>1){
  324.       printf("  profile_and_level_indication=%dn",prof_lev);
  325.       if (prof_lev<128){
  326.         printf("    profile=%d, level=%dn",prof_lev>>4,prof_lev&15);
  327.       }
  328.       printf("  progressive_sequence=%dn",prog_seq);
  329.       printf("  chroma_format=%dn",chroma_format);
  330.       printf("  horizontal_size_extension=%dn",horizontal_size_extension);
  331.       printf("  vertical_size_extension=%dn",vertical_size_extension);
  332.       printf("  bit_rate_extension=%dn",bit_rate_extension);
  333.       printf("  vbv_buffer_size_extension=%dn",vbv_buffer_size_extension);
  334.       printf("  low_delay=%dn",low_delay);
  335.       printf("  frame_rate_extension_n=%dn",frame_rate_extension_n);
  336.       printf("  frame_rate_extension_d=%dn",frame_rate_extension_d);
  337.     }
  338.   }
  339. }
  342. /* decode sequence display extension */
  344. void LayerData::sequence_display_extension(){
  345.   int colour_primaries(0), transfer_characteristics(0);
  346.   int display_horizontal_size, display_vertical_size;
  347.   int pos=0;
  348.   if (verbose>0)
  349.      pos = input->getposition();
  350.   
  351.   int video_format = input->getbits(3);
  352.   int colour_description = input->getbits(1);
  354.   if (colour_description){
  355.     colour_primaries = input->getbits(8);
  356.     transfer_characteristics = input->getbits(8);
  357.     matrix_coefficients = input->getbits(8);
  358.   }
  360.   display_horizontal_size = input->getbits(14);
  361.   input->flushbits(1);
  362.   display_vertical_size = input->getbits(14);
  364.   if (verbose>0){
  365.     printf("sequence display extension (byte %d)n",(pos>>3)-4);
  366.     if (verbose>1){
  367.       printf("  video_format=%dn",video_format);
  368.       printf("  colour_description=%dn",colour_description);
  369.       if (colour_description){
  370.         printf("    colour_primaries=%dn",colour_primaries);
  371.         printf("    transfer_characteristics=%dn",transfer_characteristics);
  372.         printf("    matrix_coefficients=%dn",matrix_coefficients);
  373.       }
  374.       printf("  display_horizontal_size=%dn",display_horizontal_size);
  375.       printf("  display_vertical_size=%dn",display_vertical_size);
  376.     }
  377.   }
  378. }
  381. /* decode quant matrix entension */
  383. void LayerData::quant_matrix_extension(){
  384.   int i;
  385.   int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
  386.   int load_chroma_intra_quantiser_matrix;
  387.   int load_chroma_non_intra_quantiser_matrix;
  388.   int pos=0;
  389.   if (verbose>0)
  390.       pos=input->getposition();
  392.   if ((load_intra_quantiser_matrix=input->getbits(1))!=0){
  393.     for (i=0; i<64; i++){
  394.       chroma_intra_quantizer_matrix[zig_zag_scan[i]]
  395.       = intra_quantizer_matrix[zig_zag_scan[i]]
  396.       = input->getbits(8);
  397.     }
  398.   }
  400.   if ((load_non_intra_quantiser_matrix=input->getbits(1))!=0){
  401.     for (i=0; i<64; i++){
  402.       chroma_non_intra_quantizer_matrix[zig_zag_scan[i]]
  403.       = non_intra_quantizer_matrix[zig_zag_scan[i]]
  404.       = input->getbits(8);
  405.     }
  406.   }
  408.   if ((load_chroma_intra_quantiser_matrix=input->getbits(1))!=0){
  409.     for (i=0; i<64; i++)
  410.       chroma_intra_quantizer_matrix[zig_zag_scan[i]] = input->getbits(8);
  411.   }
  413.   if ((load_chroma_non_intra_quantiser_matrix=input->getbits(1))!=0){
  414.     for (i=0; i<64; i++)
  415.       chroma_non_intra_quantizer_matrix[zig_zag_scan[i]] = input->getbits(8);
  416.   }
  418.   if (verbose>0){
  419.     printf("quant matrix extension (byte %d)n",(pos>>3)-4);
  420.     printf("  load_intra_quantiser_matrix=%dn", load_intra_quantiser_matrix);
  421.     printf("  load_non_intra_quantiser_matrix=%dn", load_non_intra_quantiser_matrix);
  422.     printf("  load_chroma_intra_quantiser_matrix=%dn", load_chroma_intra_quantiser_matrix);
  423.     printf("  load_chroma_non_intra_quantiser_matrix=%dn", load_chroma_non_intra_quantiser_matrix);
  424.   }
  425. }
  428. /* decode sequence scalable extension */
  430. void LayerData::sequence_scalable_extension(){
  431.   int pos=0;
  432.   if (verbose>0)
  433.      pos = input->getposition();
  434.   scalable_mode = input->getbits(2) + 1; /* add 1 to make SC_DP != SC_NONE */
  435.   int layer_id = input->getbits(4);
  437.   if (scalable_mode==SC_SPAT){
  438.     llw = input->getbits(14); /* lower_layer_prediction_horizontal_size */
  439.     input->flushbits(1);
  440.     llh = input->getbits(14); /* lower_layer_prediction_vertical_size */
  441.     hm = input->getbits(5);
  442.     hn = input->getbits(5);
  443.     vm = input->getbits(5);
  444.     vn = input->getbits(5);
  445.   }
  447.   if (scalable_mode==SC_TEMP)
  448.     error("temporal scalability not implementedn");
  450.   if (verbose>0){
  451.     printf("sequence scalable extension (byte %d)n",(pos>>3)-4);
  452.     if (verbose>1){
  453.       printf("  scalable_mode=%dn",scalable_mode-1);
  454.       printf("  layer_id=%dn",layer_id);
  455.       if (scalable_mode==SC_SPAT){
  456.         printf("    lower_layer_prediction_horiontal_size=%dn",llw);
  457.         printf("    lower_layer_prediction_vertical_size=%dn",llh);
  458.         printf("    horizontal_subsampling_factor_m=%dn",hm);
  459.         printf("    horizontal_subsampling_factor_n=%dn",hn);
  460.         printf("    vertical_subsampling_factor_m=%dn",vm);
  461.         printf("    vertical_subsampling_factor_n=%dn",vn);
  462.       }
  463.     }
  464.   }
  465. }
  468. /* decode picture display extension */
  470. void LayerData::picture_display_extension(){
  471.   int n;
  472.   short frame_centre_horizontal_offset[3];
  473.   short frame_centre_vertical_offset[3];
  475.   int pos=0;
  476.   if (verbose>0)
  477.     pos=input->getposition();
  479.   if (prog_seq || pict_struct!=FRAME_PICTURE) n = 1;
  480.   else n=repeatfirst ? 3 : 2;
  482.   int i;
  483.   for (i=0; i<n; i++){
  484.     frame_centre_horizontal_offset[i] = (short)input->getbits(16);
  485.     input->flushbits(1);
  486.     frame_centre_vertical_offset[i] = (short)input->getbits(16);
  487.     input->flushbits(1);
  488.   }
  490.   if (verbose>0){
  491.     printf("picture display extension (byte %d)n",(pos>>3)-4);
  492.     if (verbose>1){
  493.       for (i=0; i<n; i++){
  494.         printf("  frame_centre_horizontal_offset[%d]=%dn",i,
  495.           frame_centre_horizontal_offset[i]);
  496.         printf("  frame_centre_vertical_offset[%d]=%dn",i,
  497.           frame_centre_vertical_offset[i]);
  498.       }
  499.     }
  500.   }
  501. }
  504. /* decode picture coding extension */
  506. void LayerData::picture_coding_extension(){
  507.   int chroma_420_type, composite_display_flag;
  508.   int v_axis(0), field_sequence(0), sub_carrier(0), burst_amplitude(0), sub_carrier_phase(0);
  509.   int pos=0;
  510.   if (verbose>0)
  511.     pos=input->getposition();
  513.   h_forw_r_size = input->getbits(4) - 1;
  514.   v_forw_r_size = input->getbits(4) - 1;
  515.   h_back_r_size = input->getbits(4) - 1;
  516.   v_back_r_size = input->getbits(4) - 1;
  517.   dc_prec = input->getbits(2);
  518.   pict_struct = input->getbits(2);
  519.   topfirst = input->getbits(1);
  520.   frame_pred_dct = input->getbits(1);
  521.   conceal_mv = input->getbits(1);
  522.   qscale_type = input->getbits(1);
  523.   intravlc = input->getbits(1);
  524.   altscan = input->getbits(1);
  525.   repeatfirst = input->getbits(1);
  526.   chroma_420_type = input->getbits(1);
  527.   prog_frame = input->getbits(1);
  528.   composite_display_flag = input->getbits(1);
  529.   if (composite_display_flag){
  530.     v_axis = input->getbits(1);
  531.     field_sequence = input->getbits(3);
  532.     sub_carrier = input->getbits(1);
  533.     burst_amplitude = input->getbits(7);
  534.     sub_carrier_phase = input->getbits(8);
  535.   }
  537.   if (verbose>0){
  538.     printf("picture coding extension (byte %d)n",(pos>>3)-4);
  539.     if (verbose>1){
  540.       printf("  forward_horizontal_f_code=%dn",h_forw_r_size+1);
  541.       printf("  forward_vertical_f_code=%dn",v_forw_r_size+1);
  542.       printf("  backward_horizontal_f_code=%dn",h_back_r_size+1);
  543.       printf("  backward_vertical_f_code=%dn",v_back_r_size+1);
  544.       printf("  intra_dc_precision=%dn",dc_prec);
  545.       printf("  picture_structure=%dn",pict_struct);
  546.       printf("  top_field_first=%dn",topfirst);
  547.       printf("  frame_pred_frame_dct=%dn",frame_pred_dct);
  548.       printf("  concealment_motion_vectors=%dn",conceal_mv);
  549.       printf("  q_scale_type=%dn",qscale_type);
  550.       printf("  intra_vlc_format=%dn",intravlc);
  551.       printf("  alternate_scan=%dn",altscan);
  552.       printf("  repeat_first_field=%dn",repeatfirst);
  553.       printf("  chroma_420_type=%dn",chroma_420_type);
  554.       printf("  progressive_frame=%dn",prog_frame);
  555.       printf("  composite_display_flag=%dn",composite_display_flag);
  556.       if (composite_display_flag){
  557.         printf("    v_axis=%dn",v_axis);
  558.         printf("    field_sequence=%dn",field_sequence);
  559.         printf("    sub_carrier=%dn",sub_carrier);
  560.         printf("    burst_amplitude=%dn",burst_amplitude);
  561.         printf("    sub_carrier_phase=%dn",sub_carrier_phase);
  562.       }
  563.     }
  564.   }
  565. }
  568. /* decode picture spatial scalable extension */
  570. void LayerData::picture_spatial_scalable_extension(){
  571.   int pos=0;
  572.   if (verbose>0)
  573.     pos = input->getposition();
  575.   pict_scal = 1; /* use spatial scalability in this picture */
  577.   lltempref = input->getbits(10);
  578.   input->flushbits(1);
  579.   llx0 = input->getbits(15);
  580.   if (llx0>=16384) llx0-= 32768;
  581.   input->flushbits(1);
  582.   lly0 = input->getbits(15);
  583.   if (lly0>=16384) lly0-= 32768;
  584.   stwc_table_index = input->getbits(2);
  585.   llprog_frame = input->getbits(1);
  586.   llfieldsel = input->getbits(1);
  587.   if (verbose>0){
  588.     printf("picture spatial scalable extension (byte %d)n",(pos>>3)-4);
  589.     if (verbose>1){
  590.       printf("  lower_layer_temporal_reference=%dn",lltempref);
  591.       printf("  lower_layer_horizontal_offset=%dn",llx0);
  592.       printf("  lower_layer_vertical_offset=%dn",lly0);
  593.       printf("  spatial_temporal_weight_code_table_index=%dn",
  594.         stwc_table_index);
  595.       printf("  lower_layer_progressive_frame=%dn",llprog_frame);
  596.       printf("  lower_layer_deinterlaced_field_select=%dn",llfieldsel);
  597.     }
  598.   }
  599. }
  602. /* decode picture temporal scalable extension
  603.  *
  604.  * not implemented
  605.  */
  607. void LayerData::picture_temporal_scalable_extension(){
  608.   error("temporal scalability not supportedn");
  609. }