ATSC VCT table: forward port

- indentation cleanup
- Gather fucnction cleanup
- API cleanup

src/tables/atsc_vct.c

 /*
-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

@@ -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
 };