/*
* 0x83: Logical Channel Descriptor
* e-book_ed_2.02 corr-acro.doc
*/
void descriptor_PRIVATE_EictaORG_LogicalChannelDescriptor (u_char *b)
{
unsigned int len = b[1];
unsigned int i;
out_nl(4, "--> eicta.org Logical Channel Descriptor");
b += 2;
indent(+1);
for (i = 0; i < len; i += 4) {
unsigned int service_id = (b[i] << 8) | b[i + 1];
unsigned int visible_service_flag = (b[i + 2] >> 7) & 1;
unsigned int reserved = (b[i + 2] >> 2) & 0x1f;
unsigned int logical_channel_number = ((b[i + 2] << 8) | b[i + 3]) & 0x3ff;
out_NL(5);
out_SW_NL(5, "service_id: ", service_id);
out_SB_NL(5, "visible_service_flag: ", visible_service_flag);
out_SB_NL(5, "reserved: ", reserved);
out_SW_NL(5, "logical_channel_number: ", logical_channel_number);
}
indent(-1);
out_NL(4);
}
void descriptor_PRIVATE_PremiereDE_ContentOrder (u_char *b)
{
int tag, len;
tag = b[0];
len = b[1];
out_nl (4,"--> Premiere Content Order descriptor ");
b+=2;
out_SB_NL (5,"Order_number_length: ", *b);
print_text_468A (4, "Order_number: ", b+1, *b);
b += *b + 1;
out_SB_NL (5,"Order_price_length: ", *b);
print_text_468A (4, "Order_price: ", b+1, *b);
b += *b + 1;
out_SB_NL (5,"Order_phone_number_length: ", *b);
print_text_468A (4, "Order_phone_number: ", b+1, *b);
b += *b + 1;
out_SB_NL (5,"SMS_order_information_length: ", *b);
print_text_468A (4, "SMS_order_information: ", b+1, *b);
b += *b + 1;
out_SB_NL (5,"URL_order_information_length: ", *b);
print_text_468A (4, "URL_order_information: ", b+1, *b);
}
void guess_table (u_char *buf, int len, u_int pid)
{
TABLE_ID_FUNC *t = table_id_func;
u_int table_id;
/* -- scan id table for decode function */
table_id = (u_int) buf[0];
while (t->func) {
if (t->from <= table_id && t->to >= table_id)
break;
t++;
}
out_nl (2,"Guess table from table id...");
if (t->func == NULL) {
out_SB_NL (2,"Unknown, reserved or not (yet) implemented - TableID: ",table_id);
out_nl (2,"--> %s",dvbstrTableID (table_id));
printhex_buf (5,buf,len);
return;
}
(*(t->func))(buf,len); /* exec decode function */
return;
}
/*
0xA0 Logic Channel Descriptor
NorDig-Unified ver 2.0, 01.07.2008
*/
void descriptor_PRIVATE_NordigORG_ContentProtectionDescriptor (u_char *b)
{
unsigned int tag = b[0];
unsigned int len = b[1];
unsigned int protectionLevel = b[2];
out_nl(4, "--> NorDig Content Protection Descriptor ");
b += 2;
indent(+1);
out_NL(4);
out_SB_NL(2, "value: ", protectionLevel);
switch(protectionLevel)
{
default:
case 0x00:
out_nl(4, "Outputs shall not be protected.");
break;
case 0x01:
out_nl(4, "Content protection not required.");
break;
case 0x02:
out_nl(4, "Content protection mandatory for video resolution > 576 lines.");
break;
case 0x03:
out_nl(4, "Content protection mandatory regardless of video format and resolution.");
break;
}
indent(-1);
out_NL(4);
}
void section_EMM_ECM (u_char *b, int len)
{
/* */
typedef struct _EMM_ECM {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
} EMM_ECM;
EMM_ECM e;
//int n;
e.table_id = b[0];
e.section_syntax_indicator = getBits (b, 0, 8, 1);
e.reserved_1 = getBits (b, 0, 9, 1);
e.reserved_2 = getBits (b, 0, 10, 2);
e.section_length = getBits (b, 0, 12, 12);
out_nl (3,"CAMT-decoding....");
out_S2B_NL (3,"Table_ID: ",e.table_id, dvbstrTableID (e.table_id));
out_SB_NL (3,"section_syntax_indicator: ",e.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",e.reserved_1);
out_SB_NL (6,"reserved_2: ",e.reserved_2);
out_SW_NL (5,"Section_length: ",e.section_length);
print_databytes(3,"CA_message_section_data:",b+3,e.section_length);
// !!! decoding the complete ECM/EMM stream may be illegal
// so we don't do this!
// secrets are secrets even if they are openly transmitted!
// you are not allowed to enhance this section!
}
void section_DIT (u_char *b, int len)
{
typedef struct _DIT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
u_int transition_flag;
u_int reserved_3;
} DIT;
DIT d;
d.table_id = b[0];
d.section_syntax_indicator = getBits (b, 0, 8, 1);
d.reserved_1 = getBits (b, 0, 9, 1);
d.reserved_2 = getBits (b, 0, 10, 2);
d.section_length = getBits (b, 0, 12, 12);
d.transition_flag = getBits (b, 0, 24, 1);
d.reserved_3 = getBits (b, 0, 25, 7);
out_nl (3,"DIT-decoding....");
out_S2B_NL (3,"Table_ID: ",d.table_id, dvbstrTableID (d.table_id));
if (d.table_id != 0x7E) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",d.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",d.reserved_1);
out_SB_NL (6,"reserved_2: ",d.reserved_2);
out_SW_NL (5,"Section_length: ",d.section_length);
out_S2B_NL (3,"transition_flag: ",d.transition_flag,
(d.transition_flag) ? "due to change of the originating source"
: "due to change selection only");
out_SB_NL (6,"reserved_3: ",d.reserved_3);
}
void descriptor_PRIVATE_PremiereDE_ParentalInformation (u_char *b)
{
int tag, len;
tag = b[0];
len = b[1];
out_nl (4,"--> Premiere Parental Information descriptor ");
b += 2;
out_SB_NL (5,"rating: ", *b);
out_nl (4,"Controll_time_t1: %02x:%02x:%02x", b[1], b[2], b[3]);
out_nl (4,"Controll_time_t2: %02x:%02x:%02x", b[4], b[5], b[6]);
b += 7;
out_SB_NL (5,"Parental_information_length: ", *b);
print_text_468A (4, "Parental_information: ", b+1, *b);
}
void section_ST (u_char *b, int len)
{
typedef struct _ST {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
// N databytes
} ST;
ST s;
s.table_id = b[0];
s.section_syntax_indicator = getBits (b, 0, 8, 1);
s.reserved_1 = getBits (b, 0, 9, 1);
s.reserved_2 = getBits (b, 0, 10, 2);
s.section_length = getBits (b, 0, 12, 12);
out_nl (3,"ST-decoding....");
out_S2B_NL (3,"Table_ID: ",s.table_id, dvbstrTableID (s.table_id));
if (s.table_id != 0x72) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",s.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",s.reserved_1);
out_SB_NL (6,"reserved_2: ",s.reserved_2);
out_SW_NL (5,"Section_length: ",s.section_length);
b += 3;
print_databytes (3,"Section data:", b, s.section_length);
}
/*
* 0x84: Preferred Name List Descriptor
* e-book_ed_2.02 corr-acro.doc
*/
void descriptor_PRIVATE_EictaORG_PreferredNameListDescriptor (u_char *b)
{
unsigned int len = b[1];
unsigned int i, j;
out_nl(4, "--> eicta.org Preferred Name List Descriptor");
b += 2;
indent(+1);
for (i = 0; i < len; i += 4) {
unsigned int ISO_639_language_code = (b[i] << 16) | (b[i + 1] << 8) | b[i + 2];
unsigned int name_count = b[i + 3];
out_NL(4);
out_SL_NL(4, "ISO_639_language_code: ", ISO_639_language_code);
out_SB_NL(4, "name_count: ", name_count);
indent(+1);
for (j = 0; j < name_count; j++) {
unsigned int name_id = b[i + 4];
unsigned int name_length = b[i + 5];
const char *name = &b[i + 6];
out_NL(4);
out_SB_NL(4, "name_id: ", name_id);
out_SB_NL(4, "name_length: ", name_length);
if (name_length > 0)
out_nl(4, "name: %.s", name_length, name);
i += name_length + 2;
}
indent(-1);
}
indent(-1);
out_NL(4);
}
/*
* 0x86: Eacem Stream Identifier Descriptor
* e-book_ed_2.02 corr-acro.doc
*/
void descriptor_PRIVATE_EictaORG_EacemStreamIdentifierDescriptor (u_char *b)
{
out_nl(4, "--> eicta.org Eacem Stream Identifier Descriptor");
indent(+1);
out_SB_NL(4, "version_byte: ", b[2]);
indent(-1);
out_NL(4);
}
/*
* 0x85: Preferred Name Identifier Descriptor
* e-book_ed_2.02 corr-acro.doc
*/
void descriptor_PRIVATE_EictaORG_PreferredNameIdentifierDescriptor (u_char *b)
{
out_nl(4, "--> eicta.org Preferred Name Identifier Descriptor");
indent(+1);
out_SB_NL(4, "name_id: ", b[2]);
indent(-1);
out_NL(4);
}
void H264_decodeAUD(int v, u_char *b, int len) {
H264_AUD aud = {0,};
uint8_t nal_unit_type = b[3]&0x1F;
bitdata data = {0,};
data.data = (byte*)(b+4);
data.data_len = remove_0x03(b+4, len-4);
data.cur_bit = -1;
read_bits(&data, 3, &aud.primary_pic_type);
out_SB_NL(v, "primary_pic_type: ", aud.primary_pic_type);
}
void H264_decodePPS(int v, u_char *b, int len) {
H264_PPS pps = {0,};
uint8_t nal_unit_type = b[3]&0x1F;
bitdata data = {0,};
data.data = (byte*)(b+4);
data.data_len = remove_0x03(b+4, len-4);
data.cur_bit = -1;
read_exp_golomb(&data, &pps.pic_parameter_set_id);
read_exp_golomb(&data, &pps.seq_parameter_set_id);
read_bit(&data, &pps.entropy_coding_mode_flag);
read_bit(&data, &pps.pic_order_present_flag);
read_exp_golomb(&data, &pps.num_slice_groups_minus1);
if (pps.num_slice_groups_minus1 > 0) {
read_exp_golomb(&data, &pps.slice_group_map_type);
switch (pps.slice_group_map_type) {
case 0: {
uint32_t i;
for (i = 0; i <= pps.num_slice_groups_minus1; ++i) {
uint32_t run_length_minus1;
read_exp_golomb(&data, &run_length_minus1);
}
} break;
case 2: {
uint32_t i;
for (i = 0; i < pps.num_slice_groups_minus1; ++i) {
uint32_t top_left, bottom_right;
read_exp_golomb(&data, &top_left);
read_exp_golomb(&data, &bottom_right);
}
} break;
case 3:
case 4:
case 5: {
read_bit(&data, &pps.slice_group_change_direction_flag);
read_exp_golomb(&data, &pps.slice_group_change_rate_minus1);
} break;
case 6: {
uint32_t i, size = (uint32_t)ceil(log2(pps.num_slice_groups_minus1+1));
read_exp_golomb(&data, &pps.pic_size_in_map_units_minus1);
for (i = 0; i <= pps.pic_size_in_map_units_minus1; ++i) {
uint32_t slice_group_id;
read_bits(&data, size, &slice_group_id);
}
} break;
} // switch (pps.slice_group_map_type)
} // if (pps.num_slice_groups_minus1 > 0)
read_exp_golomb(&data, &pps.num_ref_idx_l0_active_minus1);
read_exp_golomb(&data, &pps.num_ref_idx_l1_active_minus1);
read_bit(&data, &pps.weighted_pred_flag);
read_bits(&data, 2, &pps.weighted_bipred_idc);
read_signed_exp_golomb(&data, &pps.pic_init_qp_minus26);
read_signed_exp_golomb(&data, &pps.pic_init_qs_minus26);
read_signed_exp_golomb(&data, &pps.chroma_qp_index_offset);
read_bit(&data, &pps.deblocking_filter_control_present_flag);
read_bit(&data, &pps.constrained_intra_pred_flag);
read_bit(&data, &pps.redundant_pic_cnt_present_flag);
decoder.pps = pps;
out_SB_NL(v, "pic_parameter_set_id: ", pps.pic_parameter_set_id);
out_SB_NL(v, "seq_parameter_set_id: ", pps.seq_parameter_set_id);
out_SB_NL(v, "entropy_coding_mode_flag: ", pps.entropy_coding_mode_flag);
out_SB_NL(v, "pic_order_present_flag: ", pps.pic_order_present_flag);
out_SB_NL(v, "num_slice_groups_minus1: ", pps.num_slice_groups_minus1);
if (pps.num_slice_groups_minus1 > 0) {
out_SB_NL(v, "slice_group_map_type: ", pps.slice_group_map_type);
switch (pps.slice_group_map_type) {
case 3:
case 4:
case 5:
out_SB_NL(v, "slice_group_change_direction_flag: ", pps.slice_group_change_direction_flag);
out_SB_NL(v, "slice_group_change_rate_minus1: ", pps.slice_group_change_rate_minus1);
break;
case 6:
out_SB_NL(v, "pic_size_in_map_units_minus1: ", pps.pic_size_in_map_units_minus1);
break;
}
}
out_SB_NL(v, "num_ref_idx_l0_active_minus1: ", pps.num_ref_idx_l0_active_minus1);
out_SB_NL(v, "num_ref_idx_l1_active_minus1: ", pps.num_ref_idx_l1_active_minus1);
out_SB_NL(v, "weighted_pred_flag: ", pps.weighted_pred_flag);
out_SB_NL(v, "weighted_bipred_idc: ", pps.weighted_bipred_idc);
out_SLL_NL(v, "pic_init_qp_minus26: ", pps.pic_init_qp_minus26);
out_SLL_NL(v, "pic_init_qs_minus26: ", pps.pic_init_qs_minus26);
out_SLL_NL(v, "chroma_qp_index_offset: ", pps.chroma_qp_index_offset);
out_SB_NL(v, "deblocking_filter_control_present_flag: ", pps.deblocking_filter_control_present_flag);
out_SB_NL(v, "constrained_intra_pred_flag: ", pps.constrained_intra_pred_flag);
out_SB_NL(v, "redundant_pic_cnt_present_flag: ", pps.redundant_pic_cnt_present_flag);
}
void H264_decodeSPS(int v, u_char *b, int len) {
H264_SPS sps = {0,};
sps.chroma_format_idc = 1; // default
uint8_t nal_unit_type = b[3]&0x1F;
bitdata data = {0,};
data.data = (byte*)(b+4);
data.data_len = remove_0x03(b+4, len-4);
data.cur_bit = -1;
read_bits_into_byte(&data, 8, &sps.profile_idc);
read_bit(&data, &sps.constraint_set0_flag);
read_bit(&data, &sps.constraint_set1_flag);
read_bit(&data, &sps.constraint_set2_flag);
read_bit(&data, &sps.constraint_set3_flag);
read_bits_into_byte(&data, 4, &sps.reserved_zero_4bits);
read_bits_into_byte(&data, 8, &sps.level_idc);
read_exp_golomb(&data, &sps.seq_parameter_set_id);
if (sps.profile_idc == 100 || sps.profile_idc == 110
|| sps.profile_idc == 122 || sps.profile_idc == 144) {
read_exp_golomb(&data, &sps.chroma_format_idc);
if (sps.chroma_format_idc == 3) {
read_bit(&data, &sps.separate_colour_plane_flag);
}
read_exp_golomb(&data, &sps.bit_depth_luma_minus8);
read_exp_golomb(&data, &sps.bit_depth_chroma_minus8);
read_bit(&data, &sps.qpprime_y_zero_transform_bypass_flag);
read_bit(&data, &sps.seq_scaling_matrix_present_flag);
if (sps.seq_scaling_matrix_present_flag) {
uint32_t i;
for (i = 0; i < ((sps.chroma_format_idc != 3) ? 8 : 12); ++i) {
uint8_t seq_scaling_list_present_flag;
read_bit(&data, &seq_scaling_list_present_flag);
if(seq_scaling_list_present_flag) {
uint32_t j, last_scale = 8, next_scale = 8;
for(j = 0; j < ((i < 6) ? 16 : 64); ++j) {
if(next_scale != 0) {
int32_t delta_scale;
read_signed_exp_golomb(&data, &delta_scale);
next_scale = (last_scale + delta_scale + 256) % 256;
}
last_scale = (next_scale == 0) ? last_scale : next_scale;
}
}
}
} // if (sps.seq_scaling_matrix_present_flag)
}
read_exp_golomb(&data, &sps.log2_max_frame_num_minus4);
read_exp_golomb(&data, &sps.pic_order_cnt_type);
if (sps.pic_order_cnt_type == 0) {
read_exp_golomb(&data, &sps.log2_max_pic_order_cnt_lsb_minus4);
} else if (sps.pic_order_cnt_type == 1) {
uint32_t i;
read_bit(&data, &sps.delta_pic_order_always_zero_flag);
read_exp_golomb(&data, &sps.offset_for_non_ref_pic);
read_exp_golomb(&data, &sps.offset_for_top_to_bottom_field);
read_exp_golomb(&data, &sps.num_ref_frames_in_pic_order_cnt_cycle);
for (i = 0; i < sps.num_ref_frames_in_pic_order_cnt_cycle; ++i) {
uint32_t offset_for_ref_frame;
read_exp_golomb(&data, &offset_for_ref_frame);
}
} // if (sps.pic_order_cnt_type == 1)
read_exp_golomb(&data, &sps.num_ref_frames);
read_bit(&data, &sps.gaps_in_frame_num_value_allowed_flag);
read_exp_golomb(&data, &sps.pic_width_in_mbs_minus1);
read_exp_golomb(&data, &sps.pic_height_in_map_units_minus1);
read_bit(&data, &sps.frame_mbs_only_flag);
decoder.sps = sps;
out_S2B_NL(v, "profile_idc: ", sps.profile_idc, dvbstrH264_Profile_IDC(sps.profile_idc));
out_SB_NL(v, "constraint_set0_flag: ", sps.constraint_set0_flag);
out_SB_NL(v, "constraint_set1_flag: ", sps.constraint_set1_flag);
out_SB_NL(v, "constraint_set2_flag: ", sps.constraint_set2_flag);
out_SB_NL(v, "constraint_set3_flag: ", sps.constraint_set3_flag);
out_SB_NL(v, "reserved_zero_4bits: ", sps.reserved_zero_4bits);
out_SB_NL(v, "level_idc: ", sps.level_idc);
out_SB_NL(v, "seq_parameter_set_id: ", sps.seq_parameter_set_id);
if (sps.profile_idc == 100 || sps.profile_idc == 110
|| sps.profile_idc == 122 || sps.profile_idc == 144) {
out_SB_NL(v, "chroma_format_idc: ", sps.chroma_format_idc);
if (sps.chroma_format_idc == 3) {
out_SB_NL(v, "separate_colour_plane_flag: ", sps.separate_colour_plane_flag);
}
out_SB_NL(v, "bit_depth_luma_minus8: ", sps.bit_depth_luma_minus8);
out_SB_NL(v, "bit_depth_chroma_minus8: ", sps.bit_depth_chroma_minus8);
out_SB_NL(v, "qpprime_y_zero_transform_bypass_flag: ", sps.qpprime_y_zero_transform_bypass_flag);
out_SB_NL(v, "seq_scaling_matrix_present_flag: ", sps.seq_scaling_matrix_present_flag);
}
out_SB_NL(v, "log2_max_frame_num_minus4: ", sps.log2_max_frame_num_minus4);
out_SB_NL(v, "pic_order_cnt_type: ", sps.pic_order_cnt_type);
if (sps.pic_order_cnt_type == 0) {
out_SB_NL(v, "log2_max_pic_order_cnt_lsb_minus4: ", sps.log2_max_pic_order_cnt_lsb_minus4);
} else if (sps.pic_order_cnt_type == 1) {
out_SB_NL(v, "delta_pic_order_always_zero_flag: ", sps.delta_pic_order_always_zero_flag);
out_SB_NL(v, "offset_for_non_ref_pic: ", sps.offset_for_non_ref_pic);
out_SB_NL(v, "offset_for_top_to_bottom_field: ", sps.offset_for_top_to_bottom_field);
out_SB_NL(v, "num_ref_frames_in_pic_order_cnt_cycle: ", sps.num_ref_frames_in_pic_order_cnt_cycle);
}
out_SB_NL(v, "num_ref_frames: ", sps.num_ref_frames);
out_SB_NL(v, "gaps_in_frame_num_value_allowed_flag: ", sps.gaps_in_frame_num_value_allowed_flag);
out_nl (v , "pic_width_in_mbs_minus1: %d (0x%02x) [= %d]"
, sps.pic_width_in_mbs_minus1
, sps.pic_width_in_mbs_minus1
, 16 * (sps.pic_width_in_mbs_minus1 + 1));
out_nl (v , "pic_height_in_map_units_minus1: %d (0x%02x) [= %d]"
, sps.pic_height_in_map_units_minus1
, sps.pic_height_in_map_units_minus1
, (2 - sps.frame_mbs_only_flag) * (sps.pic_height_in_map_units_minus1 + 1) * 16);
out_SB_NL(v, "frame_mbs_only_flag: ", sps.frame_mbs_only_flag);
}
void section_DSMCC_DATAGRAM (u_char *b, int len)
{
/* EN 301 192 7.x */
// $$$ TODO this differs from ISO/IEC 13818-6:1998 AMD_1_2000_Cor_1_2002
typedef struct _DATAGRAM {
u_int table_id;
u_int section_syntax_indicator;
u_int private_indicator;
u_int reserved_1;
u_int section_length;
u_int MAC_addr6;
u_int MAC_addr5;
u_int reserved_2;
u_int payload_scrambling_control;
u_int address_scrambling_control;
u_int LLC_SNAP_flag;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
u_int MAC_addr4;
u_int MAC_addr3; // MAC-Bits: MSB first order
u_int MAC_addr2;
u_int MAC_addr1;
// conditional
// LLC SNAP according ISO 8802-2
// N ip datagram bytes
u_int ip_datagram_data_bytes;
// conditional
u_int stuffing_bytes;
// conditional
unsigned long crc_checksum;
} DATAGRAM;
DATAGRAM d;
int len1;
d.table_id = b[0];
d.section_syntax_indicator = getBits (b, 0, 8, 1);
d.private_indicator = getBits (b, 0, 9, 1); // $$$ TODO error indicator
d.reserved_1 = getBits (b, 0, 10, 2);
d.section_length = getBits (b, 0, 12, 12);
d.MAC_addr6 = getBits (b, 0, 24, 8);
d.MAC_addr5 = getBits (b, 0, 32, 8);
d.reserved_2 = getBits (b, 0, 40, 2);
d.payload_scrambling_control = getBits (b, 0, 42, 2);
d.address_scrambling_control = getBits (b, 0, 44, 2);
d.LLC_SNAP_flag = getBits (b, 0, 46, 1);
d.current_next_indicator = getBits (b, 0, 47, 1);
d.section_number = getBits (b, 0, 48, 8);
d.last_section_number = getBits (b, 0, 56, 8);
d.MAC_addr4 = getBits (b, 0, 64, 8);
d.MAC_addr3 = getBits (b, 0, 72, 8);
d.MAC_addr2 = getBits (b, 0, 80, 8);
d.MAC_addr1 = getBits (b, 0, 88, 8);
// MAC-Bits: MSB first !
b += 12;
len1 = d.section_length - 9;
out_nl (3,"DSM-CC DATAGRAM-decoding....");
out_S2B_NL (3,"Table_ID: ",d.table_id, dvbstrTableID (d.table_id));
if (d.table_id != 0x3e) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",d.section_syntax_indicator);
out_SB_NL (3,"private_indicator: ",d.private_indicator);
out_SB_NL (6,"reserved_1: ",d.reserved_1);
out_SW_NL (5,"Section_length: ",d.section_length);
out_SB_NL (5,"MACaddrbyte/DevicdID 6: ",d.MAC_addr6);
out_SB_NL (5,"MACaddrbyte/DeviceID 5: ",d.MAC_addr5);
out_SB_NL (6,"reserved_2: ",d.reserved_2);
out_S2B_NL (3,"payload_scrambling_control: ",d.payload_scrambling_control,
dsmccStrPayload_scrambling_control(d.payload_scrambling_control));
out_S2B_NL (3,"address_scrambling_control: ",d.address_scrambling_control,
dsmccStrAddress_scrambling_control(d.address_scrambling_control));
out_SB_NL (3,"LLC_SNAP_flag: ",d.LLC_SNAP_flag);
out_S2B_NL(3,"current_next_indicator: ",d.current_next_indicator, dvbstrCurrentNextIndicator(d.current_next_indicator));
out_SB_NL (3,"Section_number: ",d.section_number);
out_SB_NL (3,"Last_Section_number: ",d.last_section_number);
out_SB_NL (5,"MACaddrbyte/DeviceID 4: ",d.MAC_addr4);
out_SB_NL (5,"MACaddrbyte/DeviceID 3: ",d.MAC_addr3);
out_SB_NL (5,"MACaddrbyte/DeviceID 2: ",d.MAC_addr2);
out_SB (5,"MACaddrbyte/DeviceID 1: ",d.MAC_addr1);
out_nl (3," => MAC-Address/DeviceID: %02x:%02x:%02x:%02x:%02x:%02x",
d.MAC_addr1,d.MAC_addr2,d.MAC_addr3,
d.MAC_addr4,d.MAC_addr5,d.MAC_addr6);
if (d.LLC_SNAP_flag == 0x01) {
/* ISO/IEC 8802-2 */
int k;
k = llc_snap (4, b);
} else {
net_IP_data (4, b, len1-4);
}
b += (len1 - 4);
outBit_Sx_NL (5, (d.section_syntax_indicator)
?"CRC: " :"Checksum: ", b,0,32);
}
void section_NIT (u_char *b, int len)
{
/* EN 300 468 5.2 */
typedef struct _NIT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
u_int network_id;
u_int reserved_3;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
u_int reserved_4;
u_int network_descriptor_length;
// N ... descriptor
u_int reserved_5;
u_int transport_stream_loop_length;
// N1 ... transport stream loop
u_long CRC;
} NIT;
typedef struct _NIT_TSL {
u_int transport_stream_id;
u_int original_network_id;
u_int reserved_1;
u_int transport_descriptor_length;
// N2 ... descriptor
} NIT_TSL;
NIT n;
NIT_TSL nt;
int l1,l2;
n.table_id = b[0];
n.section_syntax_indicator = getBits (b, 0, 8, 1);
n.reserved_1 = getBits (b, 0, 9, 1);
n.reserved_2 = getBits (b, 0, 10, 2);
n.section_length = getBits (b, 0, 12, 12);
n.network_id = getBits (b, 0, 24, 16);
n.reserved_3 = getBits (b, 0, 40, 2);
n.version_number = getBits (b, 0, 42, 5);
n.current_next_indicator = getBits (b, 0, 47, 1);
n.section_number = getBits (b, 0, 48, 8);
n.last_section_number = getBits (b, 0, 56, 8);
n.reserved_4 = getBits (b, 0, 64, 4);
n.network_descriptor_length = getBits (b, 0, 68, 12);
out_nl (3,"NIT-decoding....");
out_S2B_NL (3,"Table_ID: ",n.table_id, dvbstrTableID (n.table_id));
if (n.table_id != 0x40 && n.table_id != 0x41) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",n.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",n.reserved_1);
out_SB_NL (6,"reserved_2: ",n.reserved_2);
out_SW_NL (5,"Section_length: ",n.section_length);
out_S2W_NL (3,"Network_ID: ",n.network_id,
dvbstrNetworkIdent_ID(n.network_id));
out_SB_NL (6,"reserved_3: ",n.reserved_3);
out_SB_NL (3,"Version_number: ",n.version_number);
out_S2B_NL(3,"current_next_indicator: ",n.current_next_indicator, dvbstrCurrentNextIndicator(n.current_next_indicator));
out_SB_NL (3,"Section_number: ",n.section_number);
out_SB_NL (3,"Last_Section_number: ",n.last_section_number);
out_SB_NL (6,"reserved_4: ",n.reserved_4);
out_SW_NL (5,"Network_descriptor_length: ",n.network_descriptor_length);
// get network descriptors
l1 = n.network_descriptor_length;
b += 10;
indent (+1);
while ( l1 > 0 ) {
int x;
x = descriptor (b, DVB_SI);
l1 -= x;
b += x;
}
indent (-1);
out_NL (3);
// get transport stream loop / descriptors...
n.reserved_5 = getBits (b, 0, 0, 4);
n.transport_stream_loop_length = getBits (b, 0, 4, 12);
out_NL (3);
out_SB_NL (6,"reserved_5: ",n.reserved_5);
out_SW_NL (5,"Transport_stream_loop_length: ",n.transport_stream_loop_length);
l1 = n.transport_stream_loop_length;
b += 2;
indent (+1);
while ( l1 > 0 ) {
nt.transport_stream_id = getBits (b, 0, 0, 16);
nt.original_network_id = getBits (b, 0, 16, 16);
nt.reserved_1 = getBits (b, 0, 32, 4);
nt.transport_descriptor_length = getBits (b, 0, 36, 12);
out_NL (3);
out_SW_NL (3,"Transport_stream_ID: ",nt.transport_stream_id);
out_S2W_NL (3,"Original_network_ID: ",nt.original_network_id,
dvbstrOriginalNetwork_ID(nt.original_network_id));
out_SB_NL (6,"reserved_1: ",nt.reserved_1);
out_SW_NL (5,"Transport_descriptor_length: ",
nt.transport_descriptor_length);
// descriptor(s)
b += 6;
l1 -= 6;
l2 = nt.transport_descriptor_length;
indent (+1);
while (l2 > 0) {
int x;
x = descriptor (b, DVB_SI);
b += x;
l2 -= x;
l1 -= x;
}
indent (-1);
out_NL (3);
}
indent(-1);
n.CRC = getBits (b, 0, 0, 32);
out_SL_NL (5,"CRC: ",n.CRC);
}
void section_PAT (u_char *b, int len)
{
/* IS13818-1 S. 62 */
typedef struct _PAT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int section_length;
u_int transport_stream_id;
u_int reserved_2;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
// N pat_list
u_long CRC;
} PAT;
typedef struct _PAT_LIST {
u_int program_number;
u_int reserved;
u_int network_pmt_PID;
} PAT_LIST;
PAT p;
PAT_LIST pl;
int n;
p.table_id = b[0];
p.section_syntax_indicator = getBits (b, 0, 8, 1);
p.reserved_1 = getBits (b, 0, 10, 2);
p.section_length = getBits (b, 0, 12, 12);
p.transport_stream_id = getBits (b, 0, 24, 16);
p.reserved_2 = getBits (b, 0, 40, 2);
p.version_number = getBits (b, 0, 42, 5);
p.current_next_indicator = getBits (b, 0, 47, 1);
p.section_number = getBits (b, 0, 48, 8);
p.last_section_number = getBits (b, 0, 56, 8);
out_nl (3,"PAT-decoding....");
out_S2B_NL (3,"Table_ID: ",p.table_id, dvbstrTableID (p.table_id));
if (p.table_id != 0x00) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",p.section_syntax_indicator);
out_SB_NL (6,"(fixed): ",0);
out_SB_NL (6,"reserved_1: ",p.reserved_1);
out_SW_NL (5,"Section_length: ",p.section_length);
out_SW_NL (3,"Transport_Stream_ID: ",p.transport_stream_id);
out_SB_NL (6,"reserved_2: ",p.reserved_2);
out_SB_NL (3,"Version_number: ",p.version_number);
out_S2B_NL(3,"current_next_indicator: ",p.current_next_indicator, dvbstrCurrentNextIndicator(p.current_next_indicator));
out_SB_NL (3,"Section_number: ",p.section_number);
out_SB_NL (3,"Last_Section_number: ",p.last_section_number);
// PID list...
// n = section_length - CRC - front bytes
// n = len / anzahl bytes pro pid angabe.
// Buffer to start of List
n = p.section_length - 5 - 4;
b = b + 8;
indent (+1);
for (; n>=4; n=n-4) {
pl.program_number = getBits (b, 0, 0, 16);
pl.reserved = getBits (b, 0, 16, 3);
pl.network_pmt_PID = getBits (b, 0, 19, 13);
b += 4;
store_PidToMem (pl.network_pmt_PID);
out_NL (3);
out_SW_NL (3,"Program_number: ",pl.program_number);
out_SB_NL (6,"reserved: ",pl.reserved);
out_SW_NL (3,(pl.program_number) ?"Program_map_PID: " :"Network_PID: ",
pl.network_pmt_PID);
}
indent (-1);
out_NL (3);
p.CRC = getBits (b,0,0,32);
out_SL_NL (5,"CRC: ",p.CRC);
}
void section_SDT (u_char *b, int len)
{
typedef struct _SDT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
u_int transport_stream_id;
u_int reserved_3;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
u_int original_network_id;
u_int reserved_4;
// N... SDT_LIST
u_long CRC;
} SDT;
typedef struct _SDT_LIST {
u_int service_id;
u_int reserved_1;
u_int EIT_schedule_flag;
u_int EIT_present_following_flag;
u_int running_status;
u_int free_CA_mode;
u_int descriptors_loop_length;
// N2 ... descriptors
} SDT_LIST;
SDT s;
SDT_LIST s2;
int len1,len2;
s.table_id = b[0];
s.section_syntax_indicator = getBits (b, 0, 8, 1);
s.reserved_1 = getBits (b, 0, 9, 1);
s.reserved_2 = getBits (b, 0, 10, 2);
s.section_length = getBits (b, 0, 12, 12);
s.transport_stream_id = getBits (b, 0, 24, 16);
s.reserved_3 = getBits (b, 0, 40, 2);
s.version_number = getBits (b, 0, 42, 5);
s.current_next_indicator = getBits (b, 0, 47, 1);
s.section_number = getBits (b, 0, 48, 8);
s.last_section_number = getBits (b, 0, 56, 8);
s.original_network_id = getBits (b, 0, 64, 16);
s.reserved_4 = getBits (b, 0, 80, 8);
out_nl (3,"SDT-decoding....");
out_S2B_NL (3,"Table_ID: ",s.table_id, dvbstrTableID (s.table_id));
if (s.table_id != 0x42 && s.table_id != 0x46) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",s.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",s.reserved_1);
out_SB_NL (6,"reserved_2: ",s.reserved_2);
out_SW_NL (5,"Section_length: ",s.section_length);
out_SW_NL (3,"Transport_Stream_ID: ",s.transport_stream_id);
out_SB_NL (6,"reserved_3: ",s.reserved_3);
out_SB_NL (3,"Version_number: ",s.version_number);
out_S2B_NL(3,"current_next_indicator: ",s.current_next_indicator, dvbstrCurrentNextIndicator(s.current_next_indicator));
out_SB_NL (3,"Section_number: ",s.section_number);
out_SB_NL (3,"Last_Section_number: ",s.last_section_number);
out_S2W_NL (3,"Original_network_ID: ",s.original_network_id,
dvbstrOriginalNetwork_ID(s.original_network_id));
out_SB_NL (6,"reserved_4: ",s.reserved_4);
// len = len - header - CRC
len1 = s.section_length - 11 - 4;
b += 11;
out_NL (3);
indent (+1);
while (len1 > 0 ) {
s2.service_id = getBits (b, 0, 0, 16);
s2.reserved_1 = getBits (b, 0, 16, 6);
s2.EIT_schedule_flag = getBits (b, 0, 22, 1);
s2.EIT_present_following_flag= getBits (b, 0, 23, 1);
s2.running_status = getBits (b, 0, 24, 3);
s2.free_CA_mode = getBits (b, 0, 27, 1);
s2.descriptors_loop_length = getBits (b, 0, 28, 12);
out_NL (3);
out_S2W_NL (3,"Service_id: ",s2.service_id,
" --> refers to PMT program_number");
out_SB_NL (6,"reserved_1: ",s2.reserved_1);
out_SB_NL (3,"EIT_schedule_flag: ",s2.EIT_schedule_flag);
out_SB_NL (3,"EIT_present_following_flag: ",s2.EIT_present_following_flag);
out_S2B_NL (3,"Running_status: ",s2.running_status,
dvbstrRunningStatus_FLAG(s2.running_status));
out_S2B_NL (3,"Free_CA_mode: ",s2.free_CA_mode,
(s2.free_CA_mode) ?"streams [partially] CA controlled" :"unscrambled");
out_SW_NL (5,"Descriptors_loop_length: ",s2.descriptors_loop_length);
b += 5;
len1 -= 5;
len2 = s2.descriptors_loop_length;
indent (+1);
while (len2 > 0) {
int x;
x = descriptor (b, DVB_SI);
len2 -= x;
b += x;
len1 -= x;
}
indent (-1);
out_NL (3);
}
indent (-1);
s.CRC = getBits (b,0,0,32);
out_SL_NL (5,"CRC: ",s.CRC);
}
void section_SIT (u_char *b, int len)
{
typedef struct _SIT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
u_int reserved_3;
u_int reserved_4;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
u_int reserved_5;
u_int transmission_info_loop_length;
// N descriptor
// N1 SIT_LIST2
unsigned long crc;
} SIT;
typedef struct _SIT_LIST2 {
u_int service_id;
u_int reserved_1;
u_int running_status;
u_int service_loop_length;
// N2 descriptor
} SIT_LIST2;
SIT s;
SIT_LIST2 s2;
int len1,len2;
s.table_id = b[0];
s.section_syntax_indicator = getBits (b, 0, 8, 1);
s.reserved_1 = getBits (b, 0, 9, 1);
s.reserved_2 = getBits (b, 0, 10, 2);
s.section_length = getBits (b, 0, 12, 12);
s.reserved_3 = getBits (b, 0, 24, 16);
s.reserved_4 = getBits (b, 0, 40, 2);
s.version_number = getBits (b, 0, 42, 5);
s.current_next_indicator = getBits (b, 0, 47, 1);
s.section_number = getBits (b, 0, 48, 8);
s.last_section_number = getBits (b, 0, 56, 8);
s.reserved_5 = getBits (b, 0, 64, 4);
s.transmission_info_loop_length = getBits (b, 0, 68, 12);
out_nl (3,"SIT-decoding....");
out_S2B_NL (3,"Table_ID: ",s.table_id, dvbstrTableID (s.table_id));
if (s.table_id != 0x7F) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",s.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",s.reserved_1);
out_SB_NL (6,"reserved_2: ",s.reserved_2);
out_SW_NL (5,"Section_length: ",s.section_length);
out_SW_NL (6,"reserved_3: ",s.reserved_3);
out_SB_NL (6,"reserved_4: ",s.reserved_4);
out_SB_NL (3,"Version_number: ",s.version_number);
out_S2B_NL(3,"current_next_indicator: ",s.current_next_indicator, dvbstrCurrentNextIndicator(s.current_next_indicator));
out_SB_NL (3,"Section_number: ",s.section_number);
out_SB_NL (3,"Last_Section_number: ",s.last_section_number);
out_SB_NL (6,"reserved_5: ",s.reserved_5);
out_SW_NL (5,"Transmission_info_loop_length: ",s.transmission_info_loop_length);
// - header data after length value
len1 = s.section_length - 7;
b += 10;
len2 = s.transmission_info_loop_length;
indent (+1);
while (len2 > 0) {
int x;
x = descriptor (b, DVB_SI);
len2 -= x;
b += x;
len1 -= x;
}
indent (-1);
out_NL (3);
indent (+1);
while (len1 > 4) {
s2.service_id = getBits (b, 0, 0, 16);
s2.reserved_1 = getBits (b, 0, 16, 1);
s2.running_status = getBits (b, 0, 17, 3);
s2.service_loop_length = getBits (b, 0, 20, 12);
b += 4;
len1 -= 4;
out_NL (3);
out_S2W_NL (3,"Service_ID: ",s2.service_id,
" --> refers to PMT program_number");
out_SB_NL (6,"reserved_1: ",s2.reserved_1);
out_S2B_NL (3,"Running_status: ",s2.running_status,
dvbstrRunningStatus_FLAG (s2.running_status));
out_SW_NL (5,"Service_loop_length: ",s2.service_loop_length);
len2 = s2.service_loop_length;
indent (+1);
while (len2 > 0) {
int x;
x = descriptor (b, DVB_SI);
len2 -= x;
b += x;
len1 -= x;
}
indent (-1);
out_NL (3);
} // while len1
indent (-1);
s.crc = getBits (b, 0, 0, 32);
out_SL_NL (5,"CRC: ",s.crc);
}
void decodePS_PES_packet (u_char *b, u_int len, int pid)
{
/* IS13818-1 2.4.3.6 */
u_long packet_start_code_prefix; // 24 bit
u_int stream_id;
u_int PES_packet_length;
u_int stream_type;
// -- Get/check packet header prefix (sync bits)
packet_start_code_prefix = getBits (b, 0, 0, 24);
if (packet_start_code_prefix != 0x000001) {
out_nl (3," !!! Packet_Start_CODE [%06lx] is wrong (= no PES/PS [0x000001])!!!\n",
packet_start_code_prefix);
print_databytes (4,"Unknown packet data:", b, len);
return;
}
out_nl (3,"Packet_start_code_prefix: 0x%06lx",packet_start_code_prefix);
stream_id = b[3];
// -- decode PES packet header
if ((stream_id >= 0xC0 && stream_id <= 0xDF) // audio PES
|| (stream_id >= 0xE0 && stream_id <= 0xEF)) { // video PES
PES_packet_length = outBit_Sx_NL (3, "PES_packet_length: ", b, 32, 16);
b += 6;
len -= 6;
if ((PES_packet_length==0) && ((stream_id & 0xF0)==0xE0)) {
out_nl (3," ==> unbound video elementary stream... \n");
}
if (len > 0) {
indent (+1);
PES_decode_std (b, len, stream_id);
indent (-1);
}
return;
}
stream_type = get_StreamFromMem(pid)->stream_type;
//fprintf (stdout, "-># decodePS_PES_packet: len=%u; pid=%d stream_type=%u\n", len, pid, stream_type);
if (stream_type == 0) {
out_nl (3, "!!! Can not find stream type for PID = %d (0x%x) (PMT was not received yet)!!!\n", pid, pid);
return;
}
// -- H.264 NALU
if (stream_type == 0x1B) {
u_char nal_ref_idc = getBits(b, 0, 25, 2);
out_SB_NL(3, "nal_ref_idc: ", nal_ref_idc);
stream_id = outBit_S2x_NL(3,"H.264 NALU: ", b, 27, 5,
(char *(*)(u_long))dvbstrPESH264_NALU_ID );
//b += 4;
//len -= 4;
indent (+1);
switch(stream_id) {
case NAL_IDR:
case NAL_NONIDR:
H264_decodeSlice(4, b, len);
break;
case NAL_AUD:
H264_decodeAUD(4, b, len);
break;
case NAL_SPS:
H264_decodeSPS(4, b, len);
break;
case NAL_PPS:
H264_decodePPS(4, b, len);
break;
case NAL_SEI:
H264_decodeSEI(4, b, len);
break;
}
print_databytes (5, "Bytes (incl. sync + id):", b, len);
indent (-1);
return;
}
// -- PS/PES stream ID
stream_id = outBit_S2x_NL(3,"Stream_id: ", b, 24, 8,
(char *(*)(u_long))dvbstrPESstream_ID );
//
// -- PES Stream ID 0x00 - 0xB8
// -- ISO 13818-2
//
if (stream_id <= 0xB8) {
// $$$ TODO PES Stream ID 0x00 - 0xB8
// reserved B0
// reserved B1
// sequence_error_code B4 (not for streams)
// reserved B6
indent (+1);
switch (stream_id) {
case 0x00: // picture_start_code 00
MPEG2_decodePictureHeader (4, b, len);
break;
case 0xB2: // user_data_start_code B2
MPEG2_decodeUserData (4, b, len);
break;
case 0xB3: // sequence_header_code B3
MPEG2_decodeSequenceHeader (4, b, len);
break;
case 0xB5: // extension_data B5
MPEG2_decodeExtension (4, b, len);
break;
case 0xB7: // sequence_end_code B7
MPEG2_decodeSequenceEnd (4, b, len);
return;
case 0xB8: // group_start_code B8
MPEG2_decodeGroupOfPictures (4, b, len);
break;
default:
// slice_start_code 01 through AF
if (stream_id >= 0x01 && stream_id <= 0xAF) {
MPEG2_decodeSlice (4, b, len);
} else {
// unkown
if (len > 4) { // sync + stream_id = 4 bytes
print_databytes (4,"MPEG2 Data (incl. sync + id):", b, len);
}
}
break;
}
indent (-1);
return;
}
//
// -- PES Stream ID 0xB9 - 0xBB
// -- check PS decoding (ProgramStream)
//
switch (stream_id) {
case 0xB9: // MPEG_program_end
// stream ID already printed, nothing else to do
return;
case 0xBA: // MPEG_pack_header_start
mpeg_pack_header (3, b, -1); // startcode & ID already printed
return;
case 0xBB: // MPEG_system_header_start
mpeg_system_header (3, b, -1); // startcode & ID already printed
return;
}
//
// -- PES decoding ...
// -- StreamID 0xBC..0xFF
//
PES_packet_length = outBit_Sx_NL (3,"PES_packet_length: ", b,32, 16);
b += 6;
len -= 6;
switch (stream_id) {
case 0xBC: // program_stream_map
PES_decodePSM (b, PES_packet_length);
break;
case 0xBE: // padding stream!
print_databytes (3,"Padding_bytes:", b, PES_packet_length);
break;
case 0xF2: // DSMCC stream
PES_decodeDSMCC (b, PES_packet_length);
break;
case 0xFF: // program_stream_directory
PES_decodePSDIR (b, PES_packet_length);
break;
case 0xBF: // private_stream_2 (EN301192-1.3.1 S.10)
case 0xF0: // ECM
case 0xF1: // EMM
case 0xF8: // ITU-T Rec. H.222.1 type E
print_databytes (3,"PES_packet_data_bytes:", b, PES_packet_length);
break;
// case 0xFC: // metadata stream (see: H.222.0 AMD1)
// $$$ TODO
// case 0xBD: // Data Stream, privat_stream_1 (EN301192-1.3.1 S.11)
// case 0xC0-0xDF // ISO/IEC 13818-3 or 11172-3 or 13818-7 or 14496-3 audio stream
// case 0xE0-0xEF // ITU-T Rec. H.262 | ISO/IEC 13818-2 or 11172-2 or 14496-2 video stream
// case 0xF3 // ISO/IEC_13522_stream
// case 0xF4 // ITU-T Rec. H.222.1 type A
// case 0xF5 // ITU-T Rec. H.222.1 type B
// case 0xF6 // ITU-T Rec. H.222.1 type C
// case 0xF7 // ITU-T Rec. H.222.1 type D
// case 0xF9 // ancillary_stream
// case 0xFA // ISO/IEC14496-1_SL-packetized_stream
// case 0xFB // ISO/IEC14496-1_FlexMux_stream
// case 0xFD // extended_stream_id
// case 0xFE // reserved data stream
//default:
// {
// int xlen = PES_packet_length;
// if ((PES_packet_length==0) && ((stream_id & 0xF0)==0xE0)) {
// out_nl (3," ==> unbound video elementary stream... \n");
// xlen = len; // PES len field == 0, use read packet len
// }
// if (xlen > 0) {
// indent (+1);
// PES_decode_std (b, xlen, stream_id);
// indent (-1);
// }
// }
// break;
} // switch
}
void section_RST (u_char *b, int len)
{
typedef struct _RST {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int reserved_2;
u_int section_length;
// N1 RST_LIST2
} RST;
typedef struct _RST_LIST2 {
u_int transport_stream_id;
u_int original_network_id;
u_int service_id;
u_int event_id;
u_int reserved_1;
u_int running_status;
} RST_LIST2;
RST r;
RST_LIST2 r2;
int len1;
r.table_id = b[0];
r.section_syntax_indicator = getBits (b, 0, 8, 1);
r.reserved_1 = getBits (b, 0, 9, 1);
r.reserved_2 = getBits (b, 0, 10, 2);
r.section_length = getBits (b, 0, 12, 12);
out_nl (3,"RST-decoding....");
out_S2B_NL (3,"Table_ID: ",r.table_id, dvbstrTableID (r.table_id));
if (r.table_id != 0x71) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",r.section_syntax_indicator);
out_SB_NL (6,"reserved_1: ",r.reserved_1);
out_SB_NL (6,"reserved_2: ",r.reserved_2);
out_SW_NL (5,"Section_length: ",r.section_length);
len1 = r.section_length - 3;
b += 3;
indent (+1);
while (len1 > 0) {
r2.transport_stream_id = getBits (b, 0, 0, 16);
r2.original_network_id = getBits (b, 0, 16, 16);
r2.service_id = getBits (b, 0, 32, 16);
r2.event_id = getBits (b, 0, 48, 16);
r2.reserved_1 = getBits (b, 0, 64, 5);
r2.running_status = getBits (b, 0, 69, 3);
b += 9;
len1 -= 9;
out_NL (3);
out_SW_NL (3,"Transport_stream_ID: ",r2.transport_stream_id);
out_S2W_NL (3,"Original_network_ID: ",r2.original_network_id,
dvbstrOriginalNetwork_ID(r2.original_network_id));
out_S2W_NL (3,"Service_ID: ",r2.service_id,
" --> refers to PMT program_number");
out_SW_NL (3,"Event_ID: ",r2.event_id);
out_SB_NL (6,"reserved_1: ",r2.reserved_1);
out_S2B_NL (3,"Running_status: ",r2.running_status,
dvbstrRunningStatus_FLAG (r2.running_status));
} // while len1
indent (-1);
}
void section_CAT (u_char *b, int len)
{
/* IS13818-1 S. 63 */
/* see also: ETS 468, ETR 289 */
typedef struct _CAT {
u_int table_id;
u_int section_syntax_indicator;
u_int reserved_1;
u_int section_length;
u_int reserved_2;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
// private section
unsigned long CRC;
} CAT;
CAT c;
int len1;
c.table_id = b[0];
c.section_syntax_indicator = getBits (b, 0, 8, 1);
c.reserved_1 = getBits (b, 0, 10, 2);
c.section_length = getBits (b, 0, 12, 12);
c.reserved_2 = getBits (b, 0, 24, 18);
c.version_number = getBits (b, 0, 42, 5);
c.current_next_indicator = getBits (b, 0, 47, 1);
c.section_number = getBits (b, 0, 48, 8);
c.last_section_number = getBits (b, 0, 56, 8);
out_nl (3,"CAT-decoding....");
out_S2B_NL (3,"Table_ID: ",c.table_id, dvbstrTableID (c.table_id));
if (c.table_id != 0x01) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",c.section_syntax_indicator);
out_SB_NL (6,"(fixed): ",0);
out_SB_NL (6,"reserved_1: ",c.reserved_1);
out_SW_NL (5,"Section_length: ",c.section_length);
out_SB_NL (6,"reserved_2: ",c.reserved_2);
out_SB_NL (3,"Version_number: ",c.version_number);
out_S2B_NL(3,"current_next_indicator: ",c.current_next_indicator, dvbstrCurrentNextIndicator(c.current_next_indicator));
out_SB_NL (3,"Section_number: ",c.section_number);
out_SB_NL (3,"Last_Section_number: ",c.last_section_number);
// buffer + header, len = len - header - CRC
// Descriptor ISO 13818 - 2.6.1
// - header - CRC
len1 = c.section_length - 5;
b += 8;
indent (1);
while (len1 > 4) {
int i;
i = descriptor (b, MPEG);
len1 -= i;
b += i;
}
indent (-1);
out_NL (3);
c.CRC = getBits (b, 0, 0, 32);
out_SL_NL (5,"CRC: ",c.CRC);
}
int print_vps_decode (int v, u_char *b, int len)
{
// warning! Nipples e.g. _2_7 may not be msb...lsb order!
// see: ETSI EN 300 231 for this notation!
u_int pcs;
u_int cni_1_4;
u_int pil;
u_int pty;
u_int day, month, hour, minute;
u_int country_5_8;
u_int npp, npp_0_1, npp_2_7;
out_nl (v,"VPS data:");
print_databytes (8,"Data:", b, len);
indent (+1);
// -- starts at EN 300 231 8.2.2 Fig.9 Table
// -- Byte 3..15 , so byte 3 => [0]
// -- vps_data_block:
// -- Byte 3+4: not relevant to PDC
// -- Info from datasheet SAA4700 (Philips)
outBit_Sx_NL (v,"(program source identification (binary coded)): ", b, 0, 8);
outBit_Sx_NL (v,"(program source identification (ASCII seq)): ", b+1, 0, 8);
// -- PCS
pcs = outBit_S2x_NL (v,"PCS audio: ", b+2, 0, 2,
(char *(*)(u_long)) dvbstrVPS_pcs_audio );
pcs = outBit_Sx_NL (v,"PCS reserved: ", b+2, 2, 2);
cni_1_4 = outBit_Sx (v,"CNI reserved: ", b+2, 4, 4);
if (cni_1_4 == 0x0F) out_nl (4, " [= Unenhanced VPS]");
else out_nl (4, " [= Enhanced VPS]");
// -- Byte 6..10: not relevant to PDC
// -- Info from datasheet SAA4700 (Philips)
outBit_Sx_NL (v,"(program/test picture identification): ", b+3, 0, 8);
outBit_Sx_NL (v,"(internal information exchange): ", b+4, 0, 8);
outBit_Sx_NL (v,"(address assignment of signal distribution): ", b+5, 0, 16);
outBit_Sx_NL (v,"(messages/commands): ", b+7, 0, 8);
pil = getBits (b, 8, 2, 20);
npp_0_1 = getBits (b, 8, 0, 2);
day = getBits (b, 8, 2, 5);
month = getBits (b, 8, 7, 4);
hour = getBits (b, 8, 11, 5);
minute = getBits (b, 8, 16, 6);
country_5_8 = getBits (b, 8, 22, 4);
npp_2_7 = getBits (b, 8, 26, 6);
pty = getBits (b, 8, 32, 8); // byte 15
out_SB_NL (v,"NPP_1: ", npp_0_1);
out_ST (v,"Program Identificaion Label (PIL): ", pil);
if (day != 0x00) {
out_nl (v," [= month=%d day=%d hour=%d min=%d]",
month, day, hour, minute);
} else {
char *s;
switch (pil) {
case 0x07FFF: s = "Timer-control code (TC)"; break;
case 0x07FBF: s = "Record inhibit/Terminate (RI/T)"; break;
case 0x07F7F: s = "Interrruption code (INT)"; break;
case 0x07F3F: s = "Continuation code"; break;
case 0xFFFFF: s = "Program selected by PTY"; break;
default: s = "UNKOWN code"; break;
}
out_nl (v," [= %s]",s);
}
out_S2B_NL (v,"Country: ", country_5_8,
dvbstrVPS_cni_countrycode(1+(country_5_8 << 4)) );
out_SB_NL (v,"NPP_2: ", npp_2_7);
npp = (npp_0_1 << 6) + (npp_2_7); // msb ... lsb
out_S2B_NL (v," ==> Network/Program Provider (NPP): ", npp, dvbstrVPS_npp(npp) );
out_S2B_NL (v,"Program Type (PTY): ", pty, dvbstrVPS_pty(pty) );
indent (-1);
return len;
}
void PES_decodeDATA_SYNC (u_char *b, int len)
{
typedef struct _PES_DATA {
u_int data_identifier;
u_int sub_stream_id;
u_int PTS_extension_flag;
u_int output_data_rate_flag;
u_int reserved;
u_int PES_data_packet_header_length;
// N ... optional data
} PES_DATA;
PES_DATA p;
int len2;
out_nl (4,"Data (synchronous/synchronized):");
indent (+1);
p.data_identifier = getBits (b, 0, 0, 8);
p.sub_stream_id = getBits (b, 0, 8, 8);
p.PTS_extension_flag = getBits (b, 0, 16, 1);
p.output_data_rate_flag = getBits (b, 0, 17, 1);
p.reserved = getBits (b, 0, 18, 2);
p.PES_data_packet_header_length = getBits (b, 0, 20, 4);
b += 3;
len -= 3;
len2 = p.PES_data_packet_header_length;
out_S2B_NL (4,"data_identifier: ", p.data_identifier,
dvbstrPESDataIdentifier (p.data_identifier) );
out_SB_NL (4,"sub_stream_id: ", p.sub_stream_id);
out_SB_NL (4,"PTS_extension_flag: ", p.PTS_extension_flag);
out_SB_NL (4,"output_data_rate_flag: ", p.output_data_rate_flag);
out_SB_NL (6,"reserved_1: ", p.reserved);
out_SB_NL (4,"PES_data_packet_header_length: ", p.PES_data_packet_header_length);
if (p.PTS_extension_flag == 0x01) {
out_nl (4,"PTS_extension:");
indent (+1);
out_SB_NL (6,"reserved: ", getBits (b, 0, 0, 7) );
out_SW_NL (4,"PTS_extension: ", getBits (b, 0, 7, 9) );
/* $$$ TODO PCR extension output in clear text, see ISO 13818-1*/
b += 2;
len -= 2;
len2 -= 2;
indent (-1);
}
if (p.output_data_rate_flag == 0x01) {
out_nl (4,"output_data_rate:");
indent (+1);
out_SB_NL (6,"reserved: ", getBits (b, 0, 0, 4) );
out_SL_NL (4,"output_data_rate: ", getBits (b, 0, 4, 28) );
b += 4;
len -= 4;
len2 -= 4;
indent (-1);
}
print_databytes (4,"PES_data_private_byte:", b, len2);
b += len2;
len -= len2;
print_databytes (4,"PES_data_byte:", b, len);
b += len;
len -= len;
indent (-1);
}
void section_PMT (u_char *b, int len)
{
/* IS13818-1 S. 65 */
typedef struct _PMT {
u_int table_id;
u_int section_syntax_indicator;
u_int b_null;
u_int reserved_1;
int section_length;
u_int program_number;
u_int reserved_2;
u_int version_number;
u_int current_next_indicator;
u_int section_number;
u_int last_section_number;
u_int reserved_3;
u_int pcr_pid;
u_int reserved_4;
int program_info_length;
// N descriptor
// N1 PMT_LIST2
unsigned long crc;
} PMT;
typedef struct _PMT_LIST2 {
u_int stream_type;
u_int reserved_1;
u_int elementary_PID;
u_int reserved_2;
int ES_info_length;
// N2 descriptor
} PMT_LIST2;
PMT p;
PMT_LIST2 p2;
int len1,len2;
p.table_id = b[0];
p.section_syntax_indicator = getBits (b, 0, 8, 1);
p.b_null = getBits (b, 0, 9, 1);
p.reserved_1 = getBits (b, 0, 10, 2);
p.section_length = getBits (b, 0, 12, 12);
p.program_number = getBits (b, 0, 24, 16);
p.reserved_2 = getBits (b, 0, 40, 2);
p.version_number = getBits (b, 0, 42, 5);
p.current_next_indicator = getBits (b, 0, 47, 1);
p.section_number = getBits (b, 0, 48, 8);
p.last_section_number = getBits (b, 0, 56, 8);
p.reserved_3 = getBits (b, 0, 64, 3);
p.pcr_pid = getBits (b, 0, 67, 13);
p.reserved_4 = getBits (b, 0, 80, 4);
p.program_info_length = getBits (b, 0, 84, 12);
out_nl (3,"PMT-decoding....");
out_S2B_NL (3,"Table_ID: ",p.table_id, dvbstrTableID (p.table_id));
if (p.table_id != 0x02) {
out_nl (3,"wrong Table ID");
return;
}
out_SB_NL (3,"section_syntax_indicator: ",p.section_syntax_indicator);
out_SB_NL (6,"(fixed '0'): ",p.b_null);
out_SB_NL (6,"reserved_1: ",p.reserved_1);
out_SW_NL (5,"Section_length: ",p.section_length);
out_SW_NL (3,"Program_number: ",p.program_number);
out_SB_NL (6,"reserved_2: ",p.reserved_2);
out_SB_NL (3,"Version_number: ",p.version_number);
out_S2B_NL(3,"current_next_indicator: ",p.current_next_indicator, dvbstrCurrentNextIndicator(p.current_next_indicator));
out_SB_NL (3,"Section_number: ",p.section_number);
out_SB_NL (3,"Last_Section_number: ",p.last_section_number);
out_SB_NL (6,"reserved_3: ",p.reserved_3);
out_SW_NL (3,"PCR PID: ",p.pcr_pid);
// store_PidToMem (p.pcr_pid); $$$ TODO PCR is no section...
out_SB_NL (6,"reserved_4: ",p.reserved_4);
out_SW_NL (5,"Program_info_length: ",p.program_info_length);
len1 = p.section_length - 9;
b += 9 + 3;
len2 = p.program_info_length;
indent (+1);
while (len2 > 0) {
int x;
x = descriptor (b, DVB_SI);
len2 -= x;
b += x;
len1 -= x;
}
lenCheckErrOut(3,len2);
indent (-1);
out_NL (3);
out_nl (3,"Stream_type loop: ");
indent (+1);
while (len1 > 4) {
p2.stream_type = getBits (b, 0, 0, 8);
p2.reserved_1 = getBits (b, 0, 8, 3);
p2.elementary_PID = getBits (b, 0, 11, 13);
p2.reserved_2 = getBits (b, 0, 24, 4);
p2.ES_info_length = getBits (b, 0, 28, 12);
if (*dvbstrStream_TYPE_SHORT (p2.stream_type) == 'S') { // SECTION?
store_PidToMem (p2.elementary_PID); // $$$ TODO maybe PES-Spider too?
}
out_NL (3);
out_S2B_NL (3,"Stream_type: ",p2.stream_type,
dvbstrStream_TYPE (p2.stream_type));
out_SB_NL (6,"reserved_1: ",p2.reserved_1);
out_SW_NL (3,"Elementary_PID: ",p2.elementary_PID);
out_SB_NL (6,"reserved_2: ",p2.reserved_2);
out_SW_NL (5,"ES_info_length: ",p2.ES_info_length);
b += 5;
len1 -= 5;
len2 = p2.ES_info_length;
indent (+1);
while (len2 > 0) {
int x;
x = descriptor (b, DVB_SI);
len2 -= x;
len1 -= x;
b += x;
}
indent (-1);
// -- this is due to some braindead providers
lenCheckErrOut(3,len2);
out_NL (3);
} // while len1
indent (-1);
p.crc = getBits (b, 0, 0, 32);
out_SL_NL (5,"CRC: ",p.crc);
}
