gethdr.c

DirectFB-1.0.1可用于linux的嵌入式GUI

                    default:
                         fprintf(stderr,"reserved extension start code ID %d\n",ext_ID);
                         break;
               }
               MPEG2_next_start_code(dec);
          }
          else {
               MPEG2_Flush_Buffer32(dec);
               user_data(dec);
          }
     }
}


/* decode sequence extension */

/* ISO/IEC 13818-2 section 6.2.2.3 */
static void
sequence_extension(MPEG2_Decoder *dec)
{
     int horizontal_size_extension;
     int vertical_size_extension;
     int bit_rate_extension;
     int vbv_buffer_size_extension;

     /* derive bit position for trace */
     dec->MPEG2_Flag = 1;

     dec->profile_and_level_indication = MPEG2_Get_Bits(dec, 8);
     dec->progressive_sequence         = MPEG2_Get_Bits(dec, 1);
     dec->chroma_format                = MPEG2_Get_Bits(dec, 2);
     horizontal_size_extension    = MPEG2_Get_Bits(dec, 2);
     vertical_size_extension      = MPEG2_Get_Bits(dec, 2);
     bit_rate_extension           = MPEG2_Get_Bits(dec, 12);
     MPEG2_marker_bit(dec, "sequence_extension");
     vbv_buffer_size_extension    = MPEG2_Get_Bits(dec, 8);
     dec->low_delay                    = MPEG2_Get_Bits(dec, 1);
     dec->frame_rate_extension_n       = MPEG2_Get_Bits(dec, 2);
     dec->frame_rate_extension_d       = MPEG2_Get_Bits(dec, 5);

     dec->frame_rate = frame_rate_Table[dec->frame_rate_code] *
                  ((dec->frame_rate_extension_n+1)/(dec->frame_rate_extension_d+1));

     /* special case for 422 profile & level must be made */
     if ((dec->profile_and_level_indication>>7) & 1) {  /* escape bit of profile_and_level_indication set */

          /* 4:2:2 Profile @ Main Level */
          if ((dec->profile_and_level_indication&15)==5) {
               dec->profile = PROFILE_422;
               dec->level   = MAIN_LEVEL;  
          }
     }
     else {
          dec->profile = dec->profile_and_level_indication >> 4;  /* Profile is upper nibble */
          dec->level   = dec->profile_and_level_indication & 0xF;  /* Level is lower nibble */
     }


     dec->horizontal_size = (horizontal_size_extension<<12) | (dec->horizontal_size&0x0fff);
     dec->vertical_size = (vertical_size_extension<<12) | (dec->vertical_size&0x0fff);


     /* ISO/IEC 13818-2 does not define bit_rate_value to be composed of
      * both the original bit_rate_value parsed in sequence_header() and
      * the optional bit_rate_extension in sequence_extension_header(). 
      * However, we use it for bitstream verification purposes. 
      */

     dec->bit_rate_value += (bit_rate_extension << 18);
     dec->bit_rate = ((double) dec->bit_rate_value) * 400.0;
     dec->vbv_buffer_size += (vbv_buffer_size_extension << 10);
}


/* decode sequence display extension */

static void
sequence_display_extension(MPEG2_Decoder *dec)
{
     int pos;

     pos = dec->Bitcnt;
     dec->video_format      = MPEG2_Get_Bits(dec, 3);
     dec->color_description = MPEG2_Get_Bits(dec, 1);

     if (dec->color_description) {
          dec->color_primaries          = MPEG2_Get_Bits(dec, 8);
          dec->transfer_characteristics = MPEG2_Get_Bits(dec, 8);
          dec->matrix_coefficients      = MPEG2_Get_Bits(dec, 8);
     }

     dec->display_horizontal_size = MPEG2_Get_Bits(dec, 14);
     MPEG2_marker_bit(dec, "sequence_display_extension");
     dec->display_vertical_size   = MPEG2_Get_Bits(dec, 14);

}


/* decode quant matrix entension */
/* ISO/IEC 13818-2 section 6.2.3.2 */
static void
quant_matrix_extension(MPEG2_Decoder *dec)
{
     int i;
     int pos;

     pos = dec->Bitcnt;

     if ((dec->load_intra_quantizer_matrix = MPEG2_Get_Bits(dec, 1))) {
          for (i=0; i<64; i++) {
               dec->chroma_intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]]
               = dec->intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]]
                 = MPEG2_Get_Bits(dec, 8);
          }
     }

     if ((dec->load_non_intra_quantizer_matrix = MPEG2_Get_Bits(dec, 1))) {
          for (i=0; i<64; i++) {
               dec->chroma_non_intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]]
               = dec->non_intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]]
                 = MPEG2_Get_Bits(dec, 8);
          }
     }

     if ((dec->load_chroma_intra_quantizer_matrix = MPEG2_Get_Bits(dec, 1))) {
          for (i=0; i<64; i++)
               dec->chroma_intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]] = MPEG2_Get_Bits(dec, 8);
     }

     if ((dec->load_chroma_non_intra_quantizer_matrix = MPEG2_Get_Bits(dec, 1))) {
          for (i=0; i<64; i++)
               dec->chroma_non_intra_quantizer_matrix[MPEG2_scan[ZIG_ZAG][i]] = MPEG2_Get_Bits(dec, 8);
     }
}


/* decode sequence scalable extension */
/* ISO/IEC 13818-2   section 6.2.2.5 */
static void
sequence_scalable_extension(MPEG2_Decoder *dec)
{
     MPEG2_Error(dec, "scalability not implemented\n");
}


/* decode picture display extension */
/* ISO/IEC 13818-2 section 6.2.3.3. */
static void
picture_display_extension(MPEG2_Decoder *dec)
{
     int i;
     int number_of_frame_center_offsets;
     int pos;

     pos = dec->Bitcnt;
     /* based on ISO/IEC 13818-2 section 6.3.12 
       (November 1994) Picture display extensions */

     /* derive number_of_frame_center_offsets */
     if (dec->progressive_sequence) {
          if (dec->repeat_first_field) {
               if (dec->top_field_first)
                    number_of_frame_center_offsets = 3;
               else
                    number_of_frame_center_offsets = 2;
          }
          else {
               number_of_frame_center_offsets = 1;
          }
     }
     else {
          if (dec->picture_structure!=FRAME_PICTURE) {
               number_of_frame_center_offsets = 1;
          }
          else {
               if (dec->repeat_first_field)
                    number_of_frame_center_offsets = 3;
               else
                    number_of_frame_center_offsets = 2;
          }
     }


     /* now parse */
     for (i=0; i<number_of_frame_center_offsets; i++) {
          dec->frame_center_horizontal_offset[i] = MPEG2_Get_Bits(dec, 16);
          MPEG2_marker_bit(dec, "picture_display_extension, first marker bit");

          dec->frame_center_vertical_offset[i]   = MPEG2_Get_Bits(dec, 16);
          MPEG2_marker_bit(dec, "picture_display_extension, second marker bit");
     }
}


/* decode picture coding extension */
static void
picture_coding_extension(MPEG2_Decoder *dec)
{
     int pos;

     pos = dec->Bitcnt;

     dec->f_code[0][0] = MPEG2_Get_Bits(dec, 4);
     dec->f_code[0][1] = MPEG2_Get_Bits(dec, 4);
     dec->f_code[1][0] = MPEG2_Get_Bits(dec, 4);
     dec->f_code[1][1] = MPEG2_Get_Bits(dec, 4);

     dec->intra_dc_precision         = MPEG2_Get_Bits(dec, 2);
     dec->picture_structure          = MPEG2_Get_Bits(dec, 2);
     dec->top_field_first            = MPEG2_Get_Bits(dec, 1);
     dec->frame_pred_frame_dct       = MPEG2_Get_Bits(dec, 1);
     dec->concealment_motion_vectors = MPEG2_Get_Bits(dec, 1);
     dec->q_scale_type               = MPEG2_Get_Bits(dec, 1);
     dec->intra_vlc_format           = MPEG2_Get_Bits(dec, 1);
     dec->alternate_scan             = MPEG2_Get_Bits(dec, 1);
     dec->repeat_first_field         = MPEG2_Get_Bits(dec, 1);
     dec->chroma_420_type            = MPEG2_Get_Bits(dec, 1);
     dec->progressive_frame          = MPEG2_Get_Bits(dec, 1);
     dec->composite_display_flag     = MPEG2_Get_Bits(dec, 1);

     if (dec->composite_display_flag) {
          dec->v_axis            = MPEG2_Get_Bits(dec, 1);
          dec->field_sequence    = MPEG2_Get_Bits(dec, 3);
          dec->sub_carrier       = MPEG2_Get_Bits(dec, 1);
          dec->burst_amplitude   = MPEG2_Get_Bits(dec, 7);
          dec->sub_carrier_phase = MPEG2_Get_Bits(dec, 8);
     }
}


/* decode picture spatial scalable extension */
/* ISO/IEC 13818-2 section 6.2.3.5. */
static void
picture_spatial_scalable_extension(MPEG2_Decoder *dec)
{
     MPEG2_Error(dec, "picture spatial scalable extension not supported\n");
}


/* decode picture temporal scalable extension
 *
 * not implemented
 */
/* ISO/IEC 13818-2 section 6.2.3.4. */
static void
picture_temporal_scalable_extension(MPEG2_Decoder *dec)
{
     MPEG2_Error(dec, "temporal scalability not supported\n");
}


/* decode extra bit information */
/* ISO/IEC 13818-2 section 6.2.3.4. */
static int
extra_bit_information(MPEG2_Decoder *dec)
{
     int Byte_Count = 0;

     while (MPEG2_Get_Bits1(dec)) {
          MPEG2_Flush_Buffer(dec, 8);
          Byte_Count++;
     }

     return(Byte_Count);
}



/* ISO/IEC 13818-2 section 5.3 */
/* Purpose: this function is mainly designed to aid in bitstream conformance
   testing.  A simple MPEG2_Flush_Buffer(1) would do */
void
MPEG2_marker_bit(MPEG2_Decoder *dec, char *text)
{
     int marker;

     marker = MPEG2_Get_Bits(dec, 1);
}


/* ISO/IEC 13818-2  sections 6.3.4.1 and 6.2.2.2.2 */
static void
user_data(MPEG2_Decoder *dec)
{
     /* skip ahead to the next start code */
     MPEG2_next_start_code(dec);
}



/* Copyright extension */
/* ISO/IEC 13818-2 section 6.2.3.6. */
/* (header added in November, 1994 to the IS document) */


static void
copyright_extension(MPEG2_Decoder *dec)
{
     int pos;
     int reserved_data;

     pos = dec->Bitcnt;


     dec->copyright_flag =       MPEG2_Get_Bits(dec, 1); 
     dec->copyright_identifier = MPEG2_Get_Bits(dec, 8);
     dec->original_or_copy =     MPEG2_Get_Bits(dec, 1);

     /* reserved */
     reserved_data = MPEG2_Get_Bits(dec, 7);

     MPEG2_marker_bit(dec, "copyright_extension(), first marker bit");
     dec->copyright_number_1 =   MPEG2_Get_Bits(dec, 20);
     MPEG2_marker_bit(dec, "copyright_extension(), second marker bit");
     dec->copyright_number_2 =   MPEG2_Get_Bits(dec, 22);
     MPEG2_marker_bit(dec, "copyright_extension(), third marker bit");
     dec->copyright_number_3 =   MPEG2_Get_Bits(dec, 22);
}