mpeg_descriptor.c

dvbsnoop is a DVB/MPEG stream analyzer program. The program can be used to sniff, monitor, debug, d

 store_PidToMem (d.CA_PID);



 out_S2W_NL (4,"CA_system_ID: ",d.CA_system_ID,
     dvbstrCASystem_ID(d.CA_system_ID));
 out_SB_NL  (6,"reserved: ",d.reserved);
 out_SW_NL  (4,"CA_PID: ",d.CA_PID);

 len = d.descriptor_length-4;
 if (len > 0) {
    print_private_data (4, b+6,len);
 }

}






/*
  -- 0x0A ISO 639 Language descriptor
*/

void descriptorMPEG_ISO639_Lang (u_char *b)

{
 /* ISO 13818-1   2.6.19 */

 typedef struct  _descISO639 {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    // N ISO639 desc

 } descISO639;

 typedef struct  _descISO639List {
    u_char      ISO_639_language_code[4];
    u_int      audio_type;
 } descISO639List;


 descISO639      d;
 descISO639List  d2;
 int             len;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 len = d.descriptor_length;
 b  += 2;
 indent (+1);
 while ( len > 0) {
    getISO639_3 (d2.ISO_639_language_code, b);	
    d2.audio_type		= getBits (b,0,24,8);

    b += 4;
    len -= 4;

    out_nl (4,"ISO639_language_code:  %3.3s", d2.ISO_639_language_code);
    out_S2B_NL (4,"Audio_type: ", d2.audio_type,
	dvbstrAudio_TYPE (d2.audio_type));
    out_NL(4);
 }
 indent (-1);

}






/*
  0x0B  System Clock  descriptor 
  ISO 13818-1   2.6.xx
*/

void descriptorMPEG_SystemClock (u_char *b)

{

 typedef struct  _descSysClock {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      external_clock_reference_indicator;
    u_int      reserved_1;
    u_int      clock_accuracy_integer;
    u_int      clock_accuracy_exponent;
    u_int      reserved_2;

 } descSysClock;


 descSysClock d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.external_clock_reference_indicator = getBits (b, 0, 16, 1);
 d.reserved_1			 = getBits (b, 0, 17, 1);
 d.clock_accuracy_integer	 = getBits (b, 0, 18, 6);
 d.clock_accuracy_exponent	 = getBits (b, 0, 24, 3);
 d.reserved_2			 = getBits (b, 0, 27, 5);

 
 out_SB_NL (4,"external_clock_reference_indicatior: ",
	d.external_clock_reference_indicator);
 out_SB_NL (6,"reserved_1: ",d.reserved_1);
 out_SB_NL (4,"clock_accuracy_integer: ",d.clock_accuracy_integer);
 out_SB_NL (4,"clock_accuracy_exponent: ",d.clock_accuracy_exponent);
 out_nl    (4,"    == : %u * 10^(-%u) ",
		d.clock_accuracy_integer,d.clock_accuracy_exponent);
 out_SB_NL (6,"reserved_2: ",d.reserved_2);

}






/*
  0x0C  Multiplex Buffer Utilization  descriptor 
  ISO 13818-1   2.6.xx
*/

void descriptorMPEG_MultiplexBufUtil  (u_char *b)

{

 typedef struct  _descMBU {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      bound_valid_flag;
    u_int      LTW_offset_lower_bound;
    u_int      reserved_1;
    u_int      LTW_offset_upper_bound;

 } descMBU;


 descMBU  d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.bound_valid_flag		 = getBits (b, 0, 16, 1);
 d.LTW_offset_lower_bound	 = getBits (b, 0, 17, 15);
 d.reserved_1			 = getBits (b, 0, 32, 1);
 d.LTW_offset_upper_bound	 = getBits (b, 0, 33, 15);

 
 out_SB_NL (4,"bound_valid_flag: ",d.bound_valid_flag);
 out_S2W_NL (4,"LTW_offset_lower_bound: ",d.LTW_offset_lower_bound,
	"(27 MHz/300 clock periods)");
 out_SB_NL (6,"reserved_1: ",d.reserved_1);
 out_S2W_NL (4,"LTW_offset_upper_bound: ",d.LTW_offset_upper_bound,
	"(27 MHz/300 clock periods)");

}








/*
  0x0D  Copyright  descriptor 
  ISO 13818-1   2.6.xx
*/

void descriptorMPEG_Copyright  (u_char *b)

{

 typedef struct  _descCopyright {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_long     copyright_identifier;

    // add. info

 } descCopyright;


 descCopyright d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.copyright_identifier		 = getBits (b, 0, 16, 32);

 
 out_S2L_NL (4,"copyright_identifier: ",d.copyright_identifier,"see: SC29");
 print_databytes (4,"add. info:", b+6, d.descriptor_length -4);

}











/*
  0x0E  Maximum Bitrate  descriptor 
  ISO 13818-1   2.6.xx
*/

void descriptorMPEG_MaxBitrate (u_char *b)

{

 typedef struct  _descMaxBitrate {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      reserved_1;
    u_long     maximum_bitrate;

 } descMaxBitrate;


 descMaxBitrate d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.reserved_1			 = getBits (b, 0, 16, 2);
 d.maximum_bitrate		 = getBits (b, 0, 18, 22);

 
 out_SB_NL (6,"reserved_1: ",d.reserved_1);
 out_nl    (4,"maximum_bitrate: %lu (0x%08lx)  (= %lu Bytes/sec)",
	d.maximum_bitrate, d.maximum_bitrate,
	d.maximum_bitrate * 50);

}




/*
  0x0F  Private Data Indicator descriptor 
  ISO 13818-1   2.6.x
*/

void descriptorMPEG_PrivateDataIndicator  (u_char *b)

{
   descriptor_any (b);
}





/*
  0x10  Smoothing Buffer  descriptor 
  ISO 13818-1   2.6.30
*/

void descriptorMPEG_SmoothingBuf  (u_char *b)

{

 typedef struct  _descSmoothingBuf {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      reserved_1;
    u_long     sb_leak_rate;
    u_int      reserved_2;
    u_long     sb_size;



 } descSmoothingBuf;


 descSmoothingBuf d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.reserved_1			 = getBits (b, 0, 16, 2);
 d.sb_leak_rate			 = getBits (b, 0, 18, 22);
 d.reserved_2			 = getBits (b, 0, 40, 2);
 d.sb_size			 = getBits (b, 0, 42, 22);

 
 out_SB_NL (6,"reserved_1: ",d.reserved_1);
 out_nl    (4,"sb_leak_rate: %lu  (= %lu bits/sec)",
	d.sb_leak_rate,d.sb_leak_rate/400);
 out_SB_NL (6,"reserved_2: ",d.reserved_2);
 out_nl    (4,"sb_size: %lu  bytes", d.sb_size);

}









/*
  0x11  STD    descriptor 
  ISO 13818-1   2.6.32
*/

void descriptorMPEG_STD (u_char *b)

{

 typedef struct  _descSTD {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      reserved_1;
    u_int      leak_valid_flag;

 } descSTD;


 descSTD d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.reserved_1			 = getBits (b, 0, 16, 7);
 d.leak_valid_flag		 = getBits (b, 0, 23, 1);

 
 out_SB_NL (6,"reserved_1: ",d.reserved_1);
 out_SB_NL (4,"leak_valid_flag: ",d.leak_valid_flag);

}










/*
  0x12  IBP  descriptor 
  ISO 13818-1   2.6.34
*/

void descriptorMPEG_IBP  (u_char *b)

{

 typedef struct  _descIBP {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      closed_gop_flag;
    u_int      identical_gop_flag;
    u_int      max_gop_length;

 } descIBP;


 descIBP d;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.closed_gop_flag		 = getBits (b, 0, 16, 1);
 d.identical_gop_flag		 = getBits (b, 0, 17, 1);
 d.max_gop_length		 = getBits (b, 0, 18, 14);

 
 out_SB_NL (4,"Closed_gop_flag: ",d.closed_gop_flag);
 out_SB_NL (4,"Identical_gop_flag: ",d.identical_gop_flag);
 out_SW_NL (4,"Max_gop_length: ",d.max_gop_length);

}




/*
 * ------------------------------------------------------------
 *
 * -- DSM-CC  Descriptors  ISO 13818-6  TR 102 006
 *
 */


/*
  0x13  Carousel Identifier  descriptor 
  ISO 13818-6  / TR 102 006
*/

void descriptorMPEG_Carousel_Identifier (u_char *b)

{

 typedef struct  _descCarouselIdentifier {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_long     carousel_id;
    u_int      format_id;

    // -- optional
    // FormatSpecifier
    u_int      module_version;
    u_int      module_id;
    u_int      block_size;
    u_int      module_size;
    u_long     CompressionMethod;
    u_int      original_size;
    u_long     timeout;
    u_int      object_key_length;
       // N...
    u_int      object_key_data;

    // private data
 } descCarouselIdentifier;


 descCarouselIdentifier d;
 int			len;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.carousel_id			 = getBits (b, 0, 16, 32);
 d.format_id			 = getBits (b, 0, 48,  8);
 b  += 7;
 len = d.descriptor_length - 5;


 out_SL_NL (4,"Carousel_id: ",d.carousel_id);
 out_SB_NL (4,"format_id: ",d.format_id);		/* $$$$ ??? */


 indent (+1);
 if (d.format_id == 0x01) {
	// -- TR 101 202   4.7.xx
	// -- FormatSpecifier
	
	d.module_version		 = getBits (b, 0,  0,  8);
	d.module_id			 = getBits (b, 0,  8, 16);
	d.block_size			 = getBits (b, 0, 24, 16);
	d.module_size			 = getBits (b, 0, 40, 32);
	d.CompressionMethod		 = getBits (b, 0, 72,  8);
	d.original_size			 = getBits (b, 0, 80, 32);
	d.timeout 			 = getBits (b, 0,112,  8);
	d.object_key_length		 = getBits (b, 0,120,  8);
	b   += 16;
	len -= 16;

 	out_SB_NL (4,"Module_version: ",d.module_version);		/* $$$$ Tables? */
 	out_SW_NL (4,"Module_id: ",d.module_version);
 	out_SW_NL (4,"Block_size: ",d.block_size);
 	out_SL_NL (4,"Module_size: ",d.module_size);
 	out_SB_NL (4,"Compression_method: ",d.CompressionMethod);
 	out_SL_NL (4,"Original_size: ",d.original_size);
 	out_SB_NL (4,"Timeout: ",d.timeout);
 	out_SB_NL (4,"Object_key_length: ",d.object_key_length);

 	print_databytes (4,"Object_key_data:", b, d.object_key_length);
		b   += d.object_key_length;
		len -= d.object_key_length;
 }
 indent (-1);

 print_private_data (4, b, len);

}





/*
  0x14  association tag  descriptor 
  ISO 13818-6  / TR 102 006
*/

void descriptorMPEG_Association_tag (u_char *b)

{

 typedef struct  _descAssociationTag {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      association_tag;
    u_int      use;

    u_int      selector_length;
    // -- optional
    //         selector_length;
    u_long     transaction_id;
    u_long     timeout;

    // -- optional
    //         selector_length;

    // -- optional
    //         selector_length;
    //         selector_bytes;

 } descAssociationTag;


 descAssociationTag  d;
 int                 len;



 d.descriptor_tag		 = b[0];
 d.descriptor_length       	 = b[1];

 d.association_tag		 = getBits (b, 0, 16, 16);
 d.use                           = getBits (b, 0, 32, 16);
 d.selector_length		 = getBits (b, 0, 40,  8); /* normally in the opt branches... */
 b  += 7;
 len = d.descriptor_length - 5;


 out_SW_NL (4,"Association_tag: ",d.association_tag);		/* $$$$ Tables? */
 out_SW_NL (4,"Use: ",d.use);
 out_SB_NL (4,"Selector_length: ",d.selector_length);

 if (d.use == 0x0000) {

 	d.transaction_id 	 = getBits (b, 0,  0, 32);
 	d.timeout		 = getBits (b, 0, 32, 32);
	b   += 8;
	len -= 8;
 	out_SL_NL (4,"Transaction_ID: ",d.transaction_id);
 	out_SL_NL (4,"Timeout: ",d.timeout);

 } else if (d.use == 0x0001) {

	 /* selector length == 0x00; */

 } else {
	print_databytes (4,"Selector bytes:", b, d.selector_length);
 }

 print_private_data (4, b, len);

}







/*
  0x15  deferred association tag  descriptor 
  ISO 13818-6  / TR 102 006
*/

void descriptorMPEG_Deferred_Association_tags (u_char *b)

{

 typedef struct  _descDefAssocTags {
    u_int      descriptor_tag;
    u_int      descriptor_length;		

    u_int      association_tags_loop_length;
    // association tag loop
    u_int	association_tag;

    u_int      transport_stream_id;
    u_int      program_number;
    u_int      org_network_id;

    // private bytes

 } descDefAssocTags;


 descDefAssocTags  d;
 int               len,i;