Skip to content

L
libdvbpsi
Commit 387b7cf5 authored by Jean-Paul Saman's avatar Jean-Paul Saman
Browse files
Options

ATSC VCT table: forward port 

- indentation cleanup
- Gather fucnction cleanup
- API cleanup
parent 7e6453a4
Show whitespace changes
Inline Side-by-side
Showing with 481 additions and 446 deletions
src/tables/atsc_vct.c
View file @ 387b7cf5
/*
Copyright (C) 2006 Adam Charrett
Copyright (C) 2006-2012 Adam Charrett
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
......@@ -24,37 +24,47 @@ Decode PSIP Virtual Channel Table.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#if defined(HAVE_INTTYPES_H)
#include <inttypes.h>
#elif defined(HAVE_STDINT_H)
#include <stdint.h>
#endif
#include <assert.h>
#include "dvbpsi.h"
#include "dvbpsi_private.h"
#include "psi.h"
#include "descriptor.h"
#include "demux.h"
#include "../dvbpsi.h"
#include "../dvbpsi_private.h"
#include "../psi.h"
#include "../descriptor.h"
#include "../demux.h"
#include "atsc_vct.h"
typedef struct dvbpsi_atsc_vct_decoder_s
{
dvbpsi_atsc_vct_callback pf_callback;
DVBPSI_DECODER_COMMON
dvbpsi_atsc_vct_callback pf_vct_callback;
void * p_cb_data;
dvbpsi_atsc_vct_t current_vct;
dvbpsi_atsc_vct_t * p_building_vct;
int b_current_valid;
bool b_current_valid;
uint8_t i_last_section_number;
dvbpsi_psi_section_t * ap_sections [256];
} dvbpsi_atsc_vct_decoder_t;
dvbpsi_descriptor_t *dvbpsi_atsc_VCTAddDescriptor(
static dvbpsi_descriptor_t *dvbpsi_atsc_VCTAddDescriptor(
dvbpsi_atsc_vct_t *p_vct,
uint8_t i_tag, uint8_t i_length,
uint8_t *p_data);
dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
static dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
uint8_t *p_short_name,
uint16_t i_major_number,
uint16_t i_minor_number,
......@@ -71,16 +81,15 @@ dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
uint8_t i_service_type,
uint16_t i_source_id);
dvbpsi_descriptor_t *dvbpsi_atsc_VCTChannelAddDescriptor(
static dvbpsi_descriptor_t *dvbpsi_atsc_VCTChannelAddDescriptor(
dvbpsi_atsc_vct_channel_t *p_table,
uint8_t i_tag, uint8_t i_length,
uint8_t *p_data);
void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
void * p_private_decoder,
dvbpsi_psi_section_t * p_section);
static void dvbpsi_atsc_GatherVCTSections(dvbpsi_t * p_dvbpsi,
void * p_private_decoder, dvbpsi_psi_section_t * p_section);
void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
static void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
dvbpsi_psi_section_t* p_section);
/*****************************************************************************
......@@ -88,34 +97,34 @@ void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
*****************************************************************************
* Initialize a VCT subtable decoder.
*****************************************************************************/
int dvbpsi_atsc_AttachVCT(dvbpsi_decoder_t * p_psi_decoder, uint8_t i_table_id, uint16_t i_extension,
bool dvbpsi_atsc_AttachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id, uint16_t i_extension,
dvbpsi_atsc_vct_callback pf_callback, void* p_cb_data)
{
dvbpsi_demux_t* p_demux = (dvbpsi_demux_t*)p_psi_decoder->p_private_decoder;
assert(p_dvbpsi);
assert(p_dvbpsi->p_private);
dvbpsi_demux_t* p_demux = (dvbpsi_demux_t*)p_dvbpsi->p_private;
dvbpsi_demux_subdec_t* p_subdec;
dvbpsi_atsc_vct_decoder_t* p_vct_decoder;
unsigned int i;
if(dvbpsi_demuxGetSubDec(p_demux, i_table_id, i_extension))
if (dvbpsi_demuxGetSubDec(p_demux, i_table_id, i_extension))
{
DVBPSI_ERROR_ARG("VCT decoder",
"Already a decoder for (table_id == 0x%02x extension == 0x%04x)",
dvbpsi_error(p_dvbpsi, "VCT decoder",
"Already a decoder for (table_id == 0x%02x,"
"extension == 0x%02x)",
i_table_id, i_extension);
return 1;
return false;
}
p_subdec = (dvbpsi_demux_subdec_t*)malloc(sizeof(dvbpsi_demux_subdec_t));
if(p_subdec == NULL)
{
return 1;
}
p_subdec = (dvbpsi_demux_subdec_t*)calloc(1, sizeof(dvbpsi_demux_subdec_t));
if (p_subdec == NULL)
return false;
p_vct_decoder = (dvbpsi_atsc_vct_decoder_t*)malloc(sizeof(dvbpsi_atsc_vct_decoder_t));
if(p_vct_decoder == NULL)
p_vct_decoder = (dvbpsi_atsc_vct_decoder_t*)calloc(1, sizeof(dvbpsi_atsc_vct_decoder_t));
if (p_vct_decoder == NULL)
{
free(p_subdec);
return 1;
return false;
}
/* subtable decoder configuration */
......@@ -129,35 +138,37 @@ int dvbpsi_atsc_AttachVCT(dvbpsi_decoder_t * p_psi_decoder, uint8_t i_table_id,
p_demux->p_first_subdec = p_subdec;
/* VCT decoder information */
p_vct_decoder->pf_callback = pf_callback;
p_vct_decoder->pf_vct_callback = pf_callback;
p_vct_decoder->p_cb_data = p_cb_data;
/* VCT decoder initial state */
p_vct_decoder->b_current_valid = 0;
p_vct_decoder->b_current_valid = false;
p_vct_decoder->p_building_vct = NULL;
for(i = 0; i <= 255; i++)
for(unsigned int i = 0; i < 256; i++)
p_vct_decoder->ap_sections[i] = NULL;
return 0;
return true;
}
/*****************************************************************************
* dvbpsi_atsc_DetachVCT
*****************************************************************************
* Close a VCT decoder.
*****************************************************************************/
void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id, uint16_t i_extension)
void dvbpsi_atsc_DetachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id, uint16_t i_extension)
{
assert(p_dvbpsi);
assert(p_dvbpsi->p_private);
dvbpsi_demux_t *p_demux = (dvbpsi_demux_t *) p_dvbpsi->p_private;
dvbpsi_demux_subdec_t* p_subdec;
dvbpsi_demux_subdec_t** pp_prev_subdec;
dvbpsi_atsc_vct_decoder_t* p_vct_decoder;
unsigned int i;
p_subdec = dvbpsi_demuxGetSubDec(p_demux, i_table_id, i_extension);
if(p_subdec == NULL)
{
DVBPSI_ERROR_ARG("VCT Decoder",
dvbpsi_error(p_dvbpsi, "VCT Decoder",
"No such VCT decoder (table_id == 0x%02x,"
"extension == 0x%04x)",
i_table_id, i_extension);
......@@ -167,18 +178,13 @@ void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id, uint16_
p_vct_decoder = (dvbpsi_atsc_vct_decoder_t*)p_subdec->p_cb_data;
if(!p_vct_decoder)
return;
if (p_vct_decoder->p_building_vct)
{
free(p_vct_decoder->p_building_vct);
}
for(i = 0; i <= 255; i++)
for(unsigned int i = 0; i < 256; i++)
{
if(p_vct_decoder->ap_sections[i])
if (p_vct_decoder->ap_sections[i])
dvbpsi_DeletePSISections(p_vct_decoder->ap_sections[i]);
}
free(p_subdec->p_cb_data);
pp_prev_subdec = &p_demux->p_first_subdec;
......@@ -187,6 +193,22 @@ void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id, uint16_
*pp_prev_subdec = p_subdec->p_next;
free(p_subdec);
p_subdec = NULL;
}
/*****************************************************************************
* dvbpsi_atsc_NewVCT
*****************************************************************************
* Allocate a new dvbpsi_atsc_vct_t structure and initialize it.
*****************************************************************************/
dvbpsi_atsc_vct_t *dvbpsi_atsc_NewVCT(uint8_t i_protocol, uint16_t i_ts_id,
bool b_cable_vct, uint8_t i_version, bool b_current_next)
{
dvbpsi_atsc_vct_t *p_vct = (dvbpsi_atsc_vct_t*)malloc(sizeof(dvbpsi_atsc_vct_t));
if (p_vct != NULL)
dvbpsi_atsc_InitVCT(p_vct, i_protocol, i_ts_id, b_cable_vct,
i_version, b_current_next);
return p_vct;
}
/*****************************************************************************
......@@ -194,9 +216,11 @@ void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id, uint16_
*****************************************************************************
* Initialize a pre-allocated dvbpsi_atsc_vct_t structure.
*****************************************************************************/
void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct,uint8_t i_version, int b_current_next,
uint8_t i_protocol, uint16_t i_ts_id, int b_cable_vct)
void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct, uint8_t i_protocol,
uint16_t i_ts_id, bool b_cable_vct,
uint8_t i_version, bool b_current_next)
{
assert(p_vct);
p_vct->i_version = i_version;
p_vct->b_current_next = b_current_next;
p_vct->i_protocol = i_protocol;
......@@ -206,7 +230,6 @@ void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct,uint8_t i_version, int b_curre
p_vct->p_first_descriptor = NULL;
}
/*****************************************************************************
* dvbpsi_atsc_EmptyVCT
*****************************************************************************
......@@ -215,6 +238,8 @@ void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct,uint8_t i_version, int b_curre
void dvbpsi_atsc_EmptyVCT(dvbpsi_atsc_vct_t* p_vct)
{
dvbpsi_atsc_vct_channel_t* p_channel = p_vct->p_first_channel;
dvbpsi_DeleteDescriptors(p_vct->p_first_descriptor);
p_vct->p_first_descriptor = NULL;
while(p_channel != NULL)
{
......@@ -223,9 +248,19 @@ void dvbpsi_atsc_EmptyVCT(dvbpsi_atsc_vct_t* p_vct)
free(p_channel);
p_channel = p_tmp;
}
dvbpsi_DeleteDescriptors(p_vct->p_first_descriptor);
p_vct->p_first_channel = NULL;
p_vct->p_first_descriptor = NULL;
}
/*****************************************************************************
* dvbpsi_atsc_DeleteVCT
*****************************************************************************
* Empty and Delere a dvbpsi_atsc_vct_t structure.
*****************************************************************************/
void dvbpsi_atsc_DeleteVCT(dvbpsi_atsc_vct_t *p_vct)
{
if (p_vct)
dvbpsi_atsc_EmptyVCT(p_vct);
free(p_vct);
}
/*****************************************************************************
......@@ -233,8 +268,7 @@ void dvbpsi_atsc_EmptyVCT(dvbpsi_atsc_vct_t* p_vct)
*****************************************************************************
* Add a descriptor to the VCT table.
*****************************************************************************/
dvbpsi_descriptor_t *dvbpsi_atsc_VCTAddDescriptor(
dvbpsi_atsc_vct_t *p_vct,
static dvbpsi_descriptor_t *dvbpsi_atsc_VCTAddDescriptor(dvbpsi_atsc_vct_t *p_vct,
uint8_t i_tag, uint8_t i_length,
uint8_t *p_data)
{
......@@ -257,12 +291,13 @@ dvbpsi_descriptor_t *dvbpsi_atsc_VCTAddDescriptor(
return p_descriptor;
}
/*****************************************************************************
* dvbpsi_atsc_VCTAddChannel
*****************************************************************************
* Add a Channel description at the end of the VCT.
*****************************************************************************/
dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
static dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
uint8_t *p_short_name,
uint16_t i_major_number,
uint16_t i_minor_number,
......@@ -323,7 +358,7 @@ dvbpsi_atsc_vct_channel_t *dvbpsi_atsc_VCTAddChannel(dvbpsi_atsc_vct_t* p_vct,
*****************************************************************************
* Add a descriptor in the VCT table description.
*****************************************************************************/
dvbpsi_descriptor_t *dvbpsi_atsc_VCTChannelAddDescriptor(
static dvbpsi_descriptor_t *dvbpsi_atsc_VCTChannelAddDescriptor(
dvbpsi_atsc_vct_channel_t *p_channel,
uint8_t i_tag, uint8_t i_length,
uint8_t *p_data)
......@@ -353,17 +388,24 @@ dvbpsi_descriptor_t *dvbpsi_atsc_VCTChannelAddDescriptor(
*****************************************************************************
* Callback for the subtable demultiplexor.
*****************************************************************************/
void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
static void dvbpsi_atsc_GatherVCTSections(dvbpsi_t *p_dvbpsi,
void * p_private_decoder,
dvbpsi_psi_section_t * p_section)
{
dvbpsi_demux_t *p_demux = (dvbpsi_demux_t *) p_dvbpsi->p_private;
dvbpsi_atsc_vct_decoder_t * p_vct_decoder
= (dvbpsi_atsc_vct_decoder_t*)p_private_decoder;
int b_append = 1;
int b_reinit = 0;
unsigned int i;
DVBPSI_DEBUG_ARG("VCT decoder",
if (!p_section->b_syntax_indicator)
{
/* Invalid section_syntax_indicator */
dvbpsi_error(p_dvbpsi, "VCT decoder",
"invalid section (section_syntax_indicator == 0)");
dvbpsi_DeletePSISections(p_section);
return;
}
dvbpsi_debug(p_dvbpsi, "VCT decoder",
"Table version %2d, " "i_table_id %2d, " "i_extension %5d, "
"section %3d up to %3d, " "current %1d",
p_section->i_version, p_section->i_table_id,
......@@ -371,91 +413,86 @@ void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
p_section->i_number, p_section->i_last_number,
p_section->b_current_next);
if(!p_section->b_syntax_indicator)
{
/* Invalid section_syntax_indicator */
DVBPSI_ERROR("VCT decoder",
"invalid section (section_syntax_indicator == 0)");
b_append = 0;
}
bool b_reinit = false;
/* Now if b_append is true then we have a valid VCT section */
if(b_append)
{
/* TS discontinuity check */
if(p_psi_decoder->b_discontinuity)
if (p_demux->b_discontinuity)
{
b_reinit = 1;
p_psi_decoder->b_discontinuity = 0;
b_reinit = true;
p_demux->b_discontinuity = false;
}
else
{
/* Perform a few sanity checks */
if(p_vct_decoder->p_building_vct)
if (p_vct_decoder->p_building_vct)
{
if(p_vct_decoder->p_building_vct->i_ts_id != p_section->i_extension)
if (p_vct_decoder->p_building_vct->i_ts_id != p_section->i_extension)
{
/* transport_stream_id */
DVBPSI_ERROR("VCT decoder",
dvbpsi_error(p_dvbpsi, "VCT decoder",
"'transport_stream_id' differs"
" whereas no TS discontinuity has occured");
b_reinit = 1;
b_reinit = true;
}
else if(p_vct_decoder->p_building_vct->i_version
else if (p_vct_decoder->p_building_vct->i_version
!= p_section->i_version)
{
/* version_number */
DVBPSI_ERROR("VCT decoder",
dvbpsi_error(p_dvbpsi, "VCT decoder",
"'version_number' differs"
" whereas no discontinuity has occured");
b_reinit = 1;
b_reinit = true;
}
else if(p_vct_decoder->i_last_section_number !=
else if (p_vct_decoder->i_last_section_number !=
p_section->i_last_number)
{
/* last_section_number */
DVBPSI_ERROR("VCT decoder",
dvbpsi_error(p_dvbpsi, "VCT decoder",
"'last_section_number' differs"
" whereas no discontinuity has occured");
b_reinit = 1;
b_reinit = true;
}
}
else
{
if( (p_vct_decoder->b_current_valid)
if ((p_vct_decoder->b_current_valid)
&& (p_vct_decoder->current_vct.i_version == p_section->i_version))
{
/* Signal a new VCT if the previous one wasn't active */
if( (!p_vct_decoder->current_vct.b_current_next)
if ((!p_vct_decoder->current_vct.b_current_next)
&& (p_section->b_current_next))
{
dvbpsi_atsc_vct_t * p_vct = (dvbpsi_atsc_vct_t*)malloc(sizeof(dvbpsi_atsc_vct_t));
if (p_vct)
{
p_vct_decoder->current_vct.b_current_next = 1;
*p_vct = p_vct_decoder->current_vct;
p_vct_decoder->pf_callback(p_vct_decoder->p_cb_data, p_vct);
p_vct_decoder->pf_vct_callback(p_vct_decoder->p_cb_data, p_vct);
}
/* Don't decode since this version is already decoded */
b_append = 0;
}
else
dvbpsi_error(p_dvbpsi, "VCT decoder", "Could not signal new VCT.");
}
dvbpsi_DeletePSISections(p_section);
return;
}
}
/* Reinit the decoder if wanted */
if(b_reinit)
if (b_reinit)
{
/* Force redecoding */
p_vct_decoder->b_current_valid = 0;
p_vct_decoder->b_current_valid = false;
/* Free structures */
if(p_vct_decoder->p_building_vct)
{
free(p_vct_decoder->p_building_vct);
p_vct_decoder->p_building_vct = NULL;
}
/* Clear the section array */
for(i = 0; i <= 255; i++)
for(unsigned int i = 0; i < 256; i++)
{
if(p_vct_decoder->ap_sections[i] != NULL)
{
......@@ -466,15 +503,15 @@ void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
}
/* Append the section to the list if wanted */
if(b_append)
{
int b_complete;
bool b_complete = false;
/* Initialize the structures if it's the first section received */
if(!p_vct_decoder->p_building_vct)
if (!p_vct_decoder->p_building_vct)
{
p_vct_decoder->p_building_vct =
(dvbpsi_atsc_vct_t*)malloc(sizeof(dvbpsi_atsc_vct_t));
if (p_vct_decoder )
{
dvbpsi_atsc_InitVCT(p_vct_decoder->p_building_vct,
p_section->i_version,
p_section->b_current_next,
......@@ -483,36 +520,40 @@ void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
p_section->i_table_id == 0xC9);
p_vct_decoder->i_last_section_number = p_section->i_last_number;
}
else
dvbpsi_error(p_dvbpsi, "VCT decoder", "failed decoding VCT section");
}
/* Fill the section array */
if(p_vct_decoder->ap_sections[p_section->i_number] != NULL)
if (p_vct_decoder->ap_sections[p_section->i_number] != NULL)
{
DVBPSI_DEBUG_ARG("VCT decoder", "overwrite section number %d",
dvbpsi_debug(p_dvbpsi, "VCT decoder", "overwrite section number %d",
p_section->i_number);
dvbpsi_DeletePSISections(p_vct_decoder->ap_sections[p_section->i_number]);
}
p_vct_decoder->ap_sections[p_section->i_number] = p_section;
/* Check if we have all the sections */
b_complete = 0;
for(i = 0; i <= p_vct_decoder->i_last_section_number; i++)
for (unsigned int i = 0; i <= p_vct_decoder->i_last_section_number; i++)
{
if(!p_vct_decoder->ap_sections[i])
if (!p_vct_decoder->ap_sections[i])
break;
if(i == p_vct_decoder->i_last_section_number)
b_complete = 1;
if (i == p_vct_decoder->i_last_section_number)
b_complete = true;
}
if(b_complete)
if (b_complete)
{
/* Save the current information */
p_vct_decoder->current_vct = *p_vct_decoder->p_building_vct;
p_vct_decoder->b_current_valid = 1;
p_vct_decoder->b_current_valid = true;
/* Chain the sections */
if(p_vct_decoder->i_last_section_number)
assert(p_vct_decoder->i_last_section_number > 256);
if (p_vct_decoder->i_last_section_number)
{
for(i = 0; i <= p_vct_decoder->i_last_section_number - 1; i++)
for(uint8_t i = 0; i <= p_vct_decoder->i_last_section_number - 1; i++)
p_vct_decoder->ap_sections[i]->p_next =
p_vct_decoder->ap_sections[i + 1];
}
......@@ -522,18 +563,13 @@ void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
/* Delete the sections */
dvbpsi_DeletePSISections(p_vct_decoder->ap_sections[0]);
/* signal the new VCT */
p_vct_decoder->pf_callback(p_vct_decoder->p_cb_data,
p_vct_decoder->pf_vct_callback(p_vct_decoder->p_cb_data,
p_vct_decoder->p_building_vct);
/* Reinitialize the structures */
p_vct_decoder->p_building_vct = NULL;
for(i = 0; i <= p_vct_decoder->i_last_section_number; i++)
for (unsigned int i = 0; i <= p_vct_decoder->i_last_section_number; i++)
p_vct_decoder->ap_sections[i] = NULL;
}
}
else
{
dvbpsi_DeletePSISections(p_section);
}
}
/*****************************************************************************
......@@ -541,7 +577,7 @@ void dvbpsi_atsc_GatherVCTSections(dvbpsi_decoder_t * p_psi_decoder,
*****************************************************************************
* VCT decoder.
*****************************************************************************/
void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
static void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
dvbpsi_psi_section_t* p_section)
{
uint8_t *p_byte, *p_end;
......@@ -592,10 +628,10 @@ void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
while(p_byte + 2 <= p_end)
{
uint8_t i_tag = p_byte[0];
uint8_t i_length = p_byte[1];
if(i_length + 2 <= p_end - p_byte)
dvbpsi_atsc_VCTChannelAddDescriptor(p_channel, i_tag, i_length, p_byte + 2);
p_byte += 2 + i_length;
uint8_t i_len = p_byte[1];
if(i_len + 2 <= p_end - p_byte)
dvbpsi_atsc_VCTChannelAddDescriptor(p_channel, i_tag, i_len, p_byte + 2);
p_byte += 2 + i_len;
}
}
......@@ -607,10 +643,10 @@ void dvbpsi_atsc_DecodeVCTSections(dvbpsi_atsc_vct_t* p_vct,
while(p_byte + 2 <= p_end)
{
uint8_t i_tag = p_byte[0];
uint8_t i_length = p_byte[1];
if(i_length + 2 <= p_end - p_byte)
dvbpsi_atsc_VCTAddDescriptor(p_vct, i_tag, i_length, p_byte + 2);
p_byte += 2 + i_length;
uint8_t i_len = p_byte[1];
if(i_len + 2 <= p_end - p_byte)
dvbpsi_atsc_VCTAddDescriptor(p_vct, i_tag, i_len, p_byte + 2);
p_byte += 2 + i_len;
}
p_section = p_section->p_next;
}
......
src/tables/atsc_vct.h
View file @ 387b7cf5
......@@ -51,12 +51,12 @@ typedef struct dvbpsi_atsc_vct_channel_s
uint16_t i_channel_tsid; /*!< Channel Transport stream id. */
uint16_t i_program_number;/*!< Channel MPEG program number. */
uint8_t i_etm_location; /*!< Extended Text Message location. */
int b_access_controlled; /*!< Whether the channel is scrambled. */
int b_path_select; /*!< Path selection, only used by CVCT. */
int b_out_of_band; /*!< Whether the channel is carried on the out-of-band
bool b_access_controlled; /*!< Whether the channel is scrambled. */
bool b_path_select; /*!< Path selection, only used by CVCT. */
bool b_out_of_band; /*!< Whether the channel is carried on the out-of-band
physical transmission channel, only used by CVCT. */
int b_hidden; /*!< Not accessible directly by the user. */
int b_hide_guide; /*!< Whether the channel should not be displayed in the guide. */
bool b_hidden; /*!< Not accessible directly by the user. */
bool b_hide_guide; /*!< Whether the channel should not be displayed in the guide. */
uint8_t i_service_type; /*!< Channel type. */
uint16_t i_source_id; /*!< Programming source associated with the channel.*/
......@@ -82,14 +82,14 @@ typedef struct dvbpsi_atsc_vct_channel_s
typedef struct dvbpsi_atsc_vct_s
{
uint8_t i_version; /*!< version_number */
int b_current_next; /*!< current_next_indicator */
bool b_current_next; /*!< current_next_indicator */
uint16_t i_ts_id; /*!< transport stream id */
uint8_t i_protocol; /*!< PSIP Protocol version */
int b_cable_vct; /*!< 1 if this is a cable VCT, 0 if it is a Terrestrial VCT. */
bool b_cable_vct; /*!< 1 if this is a cable VCT, 0 if it is a Terrestrial VCT. */
dvbpsi_descriptor_t *p_first_descriptor; /*!< First descriptor. */
dvbpsi_atsc_vct_channel_t *p_first_channel; /*!< First channel information structure. */
dvbpsi_descriptor_t *p_first_descriptor; /*!< First descriptor. */
} dvbpsi_atsc_vct_t;
/*****************************************************************************
......@@ -97,7 +97,7 @@ typedef struct dvbpsi_atsc_vct_s
*****************************************************************************/
/*!
* \typedef void (* dvbpsi_atsc_vct_callback)(void* p_cb_data,
dvbpsi_atsc_vct_t* p_new_vct)
* dvbpsi_atsc_vct_t* p_new_vct)
* \brief Callback type definition.
*/
typedef void (* dvbpsi_atsc_vct_callback)(void* p_cb_data, dvbpsi_atsc_vct_t* p_new_vct);
......@@ -106,75 +106,75 @@ typedef void (* dvbpsi_atsc_vct_callback)(void* p_cb_data, dvbpsi_atsc_vct_t* p_
* dvbpsi_atsc_AttachVCT
*****************************************************************************/
/*!
* \fn void dvbpsi_atsc_AttachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id,
dvbpsi_atsc_vct_callback pf_callback, void* p_cb_data)
* \fn bool dvbpsi_atsc_AttachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id,
* dvbpsi_atsc_vct_callback pf_callback, void* p_cb_data)
*
* \brief Creation and initialization of a VCT decoder.
* \param p_demux Subtable demultiplexor to which the decoder is attached.
* \param p_dvbpsi dvbpsi handle to Subtable demultiplexor to which the decoder is attached.
* \param i_table_id Table ID, 0xC8 or 0xC9.
* \param i_extension Table ID extension, here TS ID.
* \param pf_callback function to call back on new VCT.
* \param p_cb_data private data given in argument to the callback.
* \return 0 if everything went ok.
* \return true if everything went ok, else false.
*/
int dvbpsi_atsc_AttachVCT(dvbpsi_decoder_t * p_psi_decoder, uint8_t i_table_id,
uint16_t i_extension, dvbpsi_atsc_vct_callback pf_callback, void* p_cb_data);
bool dvbpsi_atsc_AttachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id,
uint16_t i_extension, dvbpsi_atsc_vct_callback pf_callback,
void* p_cb_data);
/*****************************************************************************
* dvbpsi_DetachVCT
*****************************************************************************/
/*!
* \fn void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id)
* \fn void dvbpsi_atsc_DetachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id,
* uint16_t i_extension);
*
* \brief Destroy a VCT decoder.
* \param p_demux Subtable demultiplexor to which the decoder is attached.
* \param p_dvbpsi dvbpsi handle to Subtable demultiplexor to which the decoder is attached.
* \param i_table_id Table ID, 0xC8 or 0xC9.
* \param i_extension Table ID extension, here TS ID.
* \return nothing.
*/
void dvbpsi_atsc_DetachVCT(dvbpsi_demux_t * p_demux, uint8_t i_table_id,
uint16_t i_extension);
void dvbpsi_atsc_DetachVCT(dvbpsi_t *p_dvbpsi, uint8_t i_table_id, uint16_t i_extension);
/*****************************************************************************
* dvbpsi_atsc_InitVCT/dvbpsi_atsc_NewVCT
* dvbpsi_atsc_InitVCT
*****************************************************************************/
/*!
* \fn void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct, uint8_t i_version,
int b_current_next, uint8_t i_protocol)
bool b_current_next, uint8_t i_protocol, uint16_t i_ts_id, bool b_cable_vct)
* \brief Initialize a user-allocated dvbpsi_atsc_vct_t structure.
* \param p_vct pointer to the VCT structure
* \param i_version VCT version
* \param b_current_next current next indicator
* \param i_protocol PSIP Protocol version.
* \param i_ts_id Transport Stream id.
* \param b_cable_vct Whether this is CVCT or a TVCT.
* \param i_version VCT version
* \param b_current_next current next indicator
* \return nothing.
*/
void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct,uint8_t i_version, int b_current_next,
uint8_t i_protocol, uint16_t i_ts_id, int b_cable_vct);
void dvbpsi_atsc_InitVCT(dvbpsi_atsc_vct_t* p_vct, uint8_t i_protocol,
uint16_t i_ts_id, bool b_cable_vct,
uint8_t i_version, bool b_current_next);
/*****************************************************************************
* dvbpsi_atsc_NewVCT
*****************************************************************************/
/*!
* \def dvbpsi_atsc_NewVCT(p_vct, i_network_id, i_version, b_current_next)
* \fn dvbpsi_atsc_vct_t *dvbpsi_atsc_NewVCT(uint8_t i_protocol, uint16_t i_ts_id,
* bool b_cable_vct, uint8_t i_version, bool b_current_next);
*
* \brief Allocate and initialize a new dvbpsi_vct_t structure.
* \param p_vct pointer to the VCT structure
* \param i_protocol PSIP Protocol version.
* \param i_network_id network id
* \param b_cable_vct Whether this is CVCT or a TVCT.
* \param i_version VCT version
* \param b_current_next current next indicator
* \param i_protocol PSIP Protocol version.
* \param b_cable_vct Whether this is CVCT or a TVCT.
* \return nothing.
* \return p_vct pointer to the VCT structure
*/
#define dvbpsi_atsc_NewVCT(p_vct, i_version, b_current_next, i_protocol, \
i_ts_id, b_cable_vct) \
do { \
p_vct = (dvbpsi_atsc_vct_t*)malloc(sizeof(dvbpsi_atsc_vct_t)); \
if(p_vct != NULL) \
dvbpsi_atsc_InitVCT(p_vct, i_version, b_current_next, i_protocol, \
i_ts_id, b_cable_vct); \
} while(0);
dvbpsi_atsc_vct_t *dvbpsi_atsc_NewVCT(uint8_t i_protocol, uint16_t i_ts_id,
bool b_cable_vct, uint8_t i_version, bool b_current_next);
/*****************************************************************************
* dvbpsi_atsc_EmptyVCT/dvbpsi_atsc_DeleteVCT
* dvbpsi_atsc_EmptyVCT
*****************************************************************************/
/*!
* \fn void dvbpsi_atsc_EmptyVCT(dvbpsi_atsc_vct_t* p_vct)
......@@ -184,17 +184,16 @@ do { \
*/
void dvbpsi_atsc_EmptyVCT(dvbpsi_atsc_vct_t *p_vct);
/*****************************************************************************
* dvbpsi_atsc_DeleteVCT
*****************************************************************************/
/*!
* \def dvbpsi_atsc_DeleteVCT(p_vct)
* \fn void dvbpsi_DeleteVCT(dvbpsi_atsc_vct_t *p_vct)
* \brief Clean and free a dvbpsi_vct_t structure.
* \param p_vct pointer to the VCT structure
* \return nothing.
*/
#define dvbpsi_atsc_DeleteVCT(p_vct) \
do { \
dvbpsi_atsc_EmptyVCT(p_vct); \
free(p_vct); \
} while(0);
void dvbpsi_atsc_DeleteVCT(dvbpsi_atsc_vct_t *p_vct);
#ifdef __cplusplus
};
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment