source: svn/newcon3bcm2_21bu/BSEAV/lib/scte_18/ts_scte_18.c

/***************************************************************************
 *     Copyright (c) 2008, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: ts_scte_18.c $
 * $brcm_Revision: $
 * $brcm_Date: $
 *
 * [File Description:]
 *
 * Revision History:
 *
 ***************************************************************************/
#include "ts_scte_18.h"

/* use my own one instead ctype.h */
#define isprint(c)      (((c) >= 32) && ((c) < 127))

BDBG_MODULE(ts_scte_18);

#define TS_SCTE_18_EAS_EVENT_LENGTH(buf)        (buf[TS_SCTE_18_EAS_EVENT_CODE_LENGTH]);
//#define SCTE_DBG
#ifdef SCTE_DBG
void TS_SCTE_18_PrintText(const uint8_t *buf, size_t size)
{
        CHECK(buf);
        CHECK(size);

        printf("'");        
        do
        {
                if (isprint(*buf))
                        printf("%c", *buf);
                else
                        printf(" ");
                buf++;
        } while (--size > 0);
        printf("'");        
}

void TS_SCTE_18_DumpHeader(TS_SCTE_18_header *pHdr)
{
        int i;
        uint8_t *p;

        CHECK(pHdr);

        printf("\n", pHdr->table_id);
        printf("table_id        = 0x%2x\n", pHdr->table_id);
        printf("section_length  = %d\n", pHdr->section_length);
        printf("sequence_number = %d\n", pHdr->sequence_number);
        printf("EAS_event_ID    = 0x%02x\n", pHdr->EAS_event_ID);
        printf("originator_code = %c%c%c\n", (char)(pHdr->EAS_originator_code >> 16),
                   (char)(pHdr->EAS_originator_code >> 8), (char)pHdr->EAS_originator_code);
        printf("event_code_len  = %d\n", pHdr->EAS_event_code_length);
        printf("nature_of_activa= %d\n", pHdr->nature_of_activation_text_length);
        printf("alert_msg_time  = %d\n", pHdr->alert_message_time_remaining);   /* range 1 - 120 */
        printf("event_start_time= %d\n", pHdr->event_start_time);
        printf("event_duration  = %d\n", pHdr->event_duration);                                 /* minutes range 15 - 6000 */
        printf("alert_priority  = %d\n", pHdr->alert_priority);
        printf("details_OOB_s_ID= 0x%04x\n", pHdr->details_OOB_source_ID);
        printf("details_major_ch= %d\n", pHdr->details_major_channel_number);   /* 10 bits */
        printf("details_minor_ch= %d\n", pHdr->details_minor_channel_number);   /* 10 bits */
        printf("audio_OOB_src_ID= 0x%04x\n", pHdr->audio_OOB_source_ID);
        printf("alert_text_len  = %d\n", pHdr->alert_text_length);
        printf("location_code_ct= %d\n", pHdr->location_code_count);                    /* for TS_SCTE_18_location_code structure */
        printf("exception_count = %d\n", pHdr->exception_count);                                /* for TS_SCTE_18_exception */
        printf("descriptors_len = %d\n", pHdr->descriptors_length);
}

void TS_SCTE_18_DumpPacket(uint8_t *pkt, TS_SCTE_18_header *pHdr)
{
        size_t ex_size;
        CHECK(pkt);
        CHECK(pHdr);

        if (TS_SCTE_18_EAS_TABLE_ID == pHdr->table_id)
        {
                size_t size, j;
                uint8_t *pOffset;

                TS_SCTE_18_DumpHeader(pHdr);
                if (pHdr->EAS_event_code_length)
                {
                        pOffset = TS_SCTE_18_getEASEventCodeOffset((const char *)pkt, &size);
                        if (pOffset)
                        {
                                printf("%18s", "Event = ");
                                TS_SCTE_18_PrintText(pOffset, size);
                                printf("\n");
                        }
                }
                if (pHdr->nature_of_activation_text_length)
                {
                        pOffset = TS_SCTE_18_getActivationTextOffset((const char *)pkt, &size);
                        if (pOffset)
                        {
                                printf("%18s", "ActivationText = ");
                                TS_SCTE_18_PrintText(pOffset, size);
                                printf("\n");
                        }
                }
                if (pHdr->alert_text_length)
                {
                        pOffset = TS_SCTE_18_getAlrtTextOffset((const char *)pkt, &size);
                        if (pOffset)
                        {
                                printf("%18s", "AlertText = ");
                                TS_SCTE_18_PrintText(pOffset, size);
                                printf("\n");
                        }
                }
                if (pHdr->location_code_count)
                {
                        pOffset = TS_SCTE_18_getLocationOffset((const char *)pkt, &size);
                        if (pOffset)
                        {
                                TS_SCTE_18_location_code s;
                                for (j = 0; j < pHdr->location_code_count; j++)
                                {
                                        if (TS_SCTE_18_getLocationCode(pOffset, j, &s))
                                        {
                                                printf("Loaction[%d]\n", j);
                                                printf("\tstate=%d\n", s.state_code);
                                                printf("\tcounty_subdivision=%d\n", s.county_subdivision);
                                                printf("\tcounty_code=%d\n", s.county_code);
                                                printf("\n");
                                        }
                                }
                        }
                }
                if (pHdr->exception_count)
                {
                        pOffset = TS_SCTE_18_getExpectionOffset((const char *)pkt, &ex_size);
                        if (pOffset)
                        {
                                TS_SCTE_18_exception s;
                                for (j = 0; j < pHdr->exception_count; j++)
                                {
                                        if (TS_SCTE_18_getException(pOffset, j, &s))
                                        {
                                                printf("Exception[%d]\n", j);
                                                printf("\tin_band_ref=%d\n", s.in_band_reference);
                                                if (s.in_band_reference)
                                                {
                                                        printf("\tmajor channel num=%d\n", s.major_channel_number);
                                                        printf("\tminor channel num=%d\n", s.minor_channel_number);
                                                }
                                                else
                                                {
                                                        pOffset += 3;
                                                        printf("\tOOB Source ID=%04x\n", s.OOB_source_ID);
                                                }
                                                printf("\n");
                                        }
                                }
                        }
                }
                if (pHdr->descriptors_length)
                {
                        printf("Descriptor length = %d\n", pHdr->descriptors_length);
                        pOffset = TS_SCTE_18_getDescriptorOffset((const char *)pkt, &ex_size);
                        if (pOffset)
                        {

                                TS_SCTE_18_in_band_channel_descriptor s;
                                if (TS_SCTE_18_getInBandChannelDescriptor(pOffset, &s,ex_size))
                                {
                                        printf("In_Band_Channel_Descriptor\n");
                                        printf("\texception_RF_channel=%d\n", s.exception_RF_channel);
                                        printf("\texception_program_number=%d\n", s.exception_program_number);
                                }
                        }       
                }
        }
        else
                printf("%s: invalid table ID=%02x\n", __func__, pHdr->table_id);
}
#endif /* #ifdef BCM_DEBUG */

int TS_SCTE_18_getSectionHeader( const uint8_t *pkt, size_t size, TS_SCTE_18_header *p_header )
{
        uint16_t tmp;
        uint8_t *p;

        /* assume that the length of the packet is checked */
        p_header->table_id = pkt[TS_PSI_TABLE_ID_OFFSET];
        CHECK(TS_SCTE_18_EAS_TABLE_ID == pkt[0]);

        p_header->section_length = TS_PSI_GET_SECTION_LENGTH(pkt);
        if ((p_header->section_length + 3) > size)
        {
                /* short packet */
                return -1;
        }
        /* table extension ID */
        tmp = (uint16_t)(TS_READ_16(&(pkt)[TS_PSI_TABLE_ID_EXT_OFFSET]));
        CHECK(tmp == 0);

        p_header->sequence_number = (uint8_t)((pkt[TS_PSI_CNI_OFFSET]>>1) & 0x1F);
        //p_header->section_number = pkt[TS_PSI_SECTION_NUMBER_OFFSET];
        //p_header->last_section_number = pkt[TS_PSI_LAST_SECTION_NUMBER_OFFSET];
        //p_header->protocol_version = pkt[TS_SCTE_18_PROTOCOL_VERSION];

        p_header->EAS_event_ID = (uint16_t)(TS_READ_16(&(pkt)[TS_SCTE_18_EAS_EVENT_ID]));       /* any field after it other than time_remaining changes */
        p_header->EAS_originator_code = (uint32_t)(TS_READ_32(&(pkt)[TS_SCTE_18_EAS_ORIGINATOR_CODE])) & 0xffffff;      /* 3 bytes ASCII, like EAS, CIV, WXR and PEP */
        p_header->EAS_event_code_length = TS_SCTE_18_EAS_EVENT_LENGTH(pkt);

        /* skip EAS_event_code */
        p = (uint8_t *)pkt;
        p += (TS_SCTE_18_EAS_EVENT_CODE_LENGTH + p_header->EAS_event_code_length + 1);
        p_header->nature_of_activation_text_length = *p; p += 1;

        /* skip nature of activation text length */
        p += p_header->nature_of_activation_text_length;

        p_header->alert_message_time_remaining = *p; p += 1;
        CHECK( p_header->alert_message_time_remaining <= 120);

        p_header->event_start_time = (uint32_t)(TS_READ_32(p)); p += 4;
        p_header->event_duration = (uint16_t)(TS_READ_16(p)); p += 2;
        /*RLQ, note that 0 is allowed as infinity as well */
        CHECK((0 == p_header->event_duration) || (p_header->event_duration >= 15 && p_header->event_duration <= 6000));
        p_header->alert_priority = (uint16_t)(TS_READ_16(p)) & 0x0f; p += 2;

        p_header->details_OOB_source_ID = (uint16_t)(TS_READ_16(p)); p += 2;
        p_header->details_major_channel_number = (uint16_t)(TS_READ_16(p)) & 0x3ff; p += 2;
        p_header->details_minor_channel_number = (uint16_t)(TS_READ_16(p)) & 0x3ff; p += 2;

        p_header->audio_OOB_source_ID = (uint16_t)(TS_READ_16(p)); p += 2;
        p_header->alert_text_length = (uint16_t)(TS_READ_16(p)); p += 2;
        /* skip alert_text */
        p += p_header->alert_text_length;

        p_header->location_code_count = *p; p += 1; 

        /* skip location_code */
        p += (p_header->location_code_count * TS_SCTE_18_LOCATION_CODE_BYTES);

        p_header->exception_count = *p; p += 1;

        /* skip exception */
        p += (p_header->exception_count * TS_SCTE_18_EXCEPTION_BYTES);

        p_header->descriptors_length = (uint16_t)(TS_READ_16(p)) & 0x3ff; p += 2;

        return 0;
}

uint8_t *TS_SCTE_18_getEASEventCodeOffset(const uint8_t *pkt, size_t *size)
{
        uint8_t *p;

        /* assume that the length of the packet is checked */
        CHECK(TS_SCTE_18_EAS_TABLE_ID == pkt[0]);
        CHECK(size);

        p = (uint8_t *)pkt;
        /* get size */
        *size = TS_SCTE_18_EAS_EVENT_LENGTH(p);
        /* to code offset */
        p += (TS_SCTE_18_EAS_EVENT_CODE_LENGTH + 1);
        return p;
}

/* nature of activation test code offset */
uint8_t *TS_SCTE_18_getActivationTextOffset(const uint8_t *pkt, size_t *size)
{
        uint16_t len;
        uint8_t *p;

        /* assume that the length of the packet is checked */
        CHECK(TS_SCTE_18_EAS_TABLE_ID == pkt[0]);

        /* skip EAS_event_code */
        p = (uint8_t *)pkt;
        len = TS_SCTE_18_EAS_EVENT_LENGTH(p);
        p += (TS_SCTE_18_EAS_EVENT_CODE_LENGTH + len + 1);
        *size = *p; 
        p += 1; /* nature_of_activation_text_length */  
        return p;
}

uint8_t *TS_SCTE_18_getAlrtTextOffset(const uint8_t *pkt, size_t *size)
{
        uint16_t len;
        uint8_t *p;

        /* assume that the length of the packet is checked */
        CHECK(TS_SCTE_18_EAS_TABLE_ID == pkt[0]);

        /* skip EAS_event_code */
        p = (uint8_t *)pkt;
        len = TS_SCTE_18_EAS_EVENT_LENGTH(p);
        p += (TS_SCTE_18_EAS_EVENT_CODE_LENGTH + len + 1);
        len = *p; //p += 1;
        /* skip nature of activation text length */
        p += len + 18 ;

        //p += (1 + 4 + 2 + 2 + 2 + 2 + 2 + 2);
        //p += 17;

        *size = (uint16_t)(TS_READ_16(p));
        p += 2;

        return p;
}

uint8_t *TS_SCTE_18_getLocationOffset(const uint8_t *pkt, size_t *size)
{
        uint16_t len;
        uint8_t *p;

        /* assume that the length of the packet is checked */
        CHECK(TS_SCTE_18_EAS_TABLE_ID == pkt[0]);

        /* skip EAS_event_code */
        p = (uint8_t *)pkt;
        len = TS_SCTE_18_EAS_EVENT_LENGTH(p);
        p += (TS_SCTE_18_EAS_EVENT_CODE_LENGTH + len + 1);
        len = *p;
        p += len + 18;

        len = (uint16_t)(TS_READ_16(p));
        p += len + 2;

        *size = *p;
        p += 1;

        return p;
}

uint8_t *TS_SCTE_18_getExpectionOffset(const uint8_t *pkt, size_t *size)
{
        uint8_t *p;

        p = TS_SCTE_18_getLocationOffset(pkt, size);
        p += (*size * TS_SCTE_18_LOCATION_CODE_BYTES);

        *size = *p;
        p += 1;

        return p;
}

uint8_t *TS_SCTE_18_getDescriptorOffset(const uint8_t *pkt, size_t *size)
{
        uint8_t *p;

        p = TS_SCTE_18_getExpectionOffset(pkt, size);
        p += (*size * TS_SCTE_18_EXCEPTION_BYTES);

        *size = (uint16_t)(TS_READ_16(p)) & 0x3ff; 
        p += 2;

        return p;
}

bool TS_SCTE_18_getLocationCode( const uint8_t *buf, int index, TS_SCTE_18_location_code *p_location )
{
        uint8_t *p = (uint8_t *)buf;

        if (!p_location)
                return 0;

        p += index * TS_SCTE_18_LOCATION_CODE_BYTES;
        p_location->state_code = *p++;
        p_location->county_subdivision = (*p >> 4) & 0x0f;
        p_location->county_code = (uint16_t)(TS_READ_16(p)) & 0x3ff;

        return 1;
}

bool TS_SCTE_18_getException( const uint8_t *buf, int index, TS_SCTE_18_exception *p_exception )
{
        uint8_t *p = (uint8_t *)buf;

        if (!p_exception)
                return 0;

        p += index * TS_SCTE_18_EXCEPTION_BYTES;
        p_exception->in_band_reference = (*p >> 7) & 0x01; p++;
        if (p_exception->in_band_reference)
        {
                p_exception->major_channel_number = (uint16_t)(TS_READ_16(p)) & 0x3ff; p += 2;
                p_exception->minor_channel_number = (uint16_t)(TS_READ_16(p)) & 0x3ff;
        }
        else
        {
                p += 2;
                p_exception->OOB_source_ID = (uint16_t)(TS_READ_16(p));
        }
        return 1;
}

bool TS_SCTE_18_getInBandChannelDescriptor(const uint8_t *buf, TS_SCTE_18_in_band_channel_descriptor *p_descriptor,size_t size)
{
        uint8_t *p = (uint8_t *)buf;
        int length;
        uint8_t *p_start = (uint8_t *)buf;
        bool found = false;

        if (!buf || !p_descriptor)
                return 0;

        /* if not in_band_exception_channel_descriptor */
        while (((p - p_start) < size) && !found)
        {
                found = (IN_BAND_DETAILS_CHANNEL_DESCRIPTOR_TAG == *(p++));
                length = *(p++);
                if (!found)
                        p += length;
        }

        if (!found)
        {
                return 0;
        }       
        p_descriptor->exception_RF_channel = *p++;
        p_descriptor->exception_program_number = (uint16_t)(TS_READ_16(p)); 

        return 1;
}

bool TS_SCTE_18_getInBandExceptionDescriptorCount(const uint8_t *buf, int *count)
{
        uint8_t *p = (uint8_t *)buf;

        if (!buf)
                return 0;

        /* if not in_band_exception_channel_descriptor */
        if (IN_BAND_EXCEPTION_CHANNEL_DESCRIPTOR_TAG != *p) {
                return 0;
        }

        p += 2;
        *count = (int)*p;

        return 1;
}