source: svn/newcon3bcm2_21bu/nexus/utils/message.c

/******************************************************************************

 *    (c)2008-2012 Broadcom Corporation

 *

 * This program is the proprietary software of Broadcom Corporation and/or its licensors,

 * and may only be used, duplicated, modified or distributed pursuant to the terms and

 * conditions of a separate, written license agreement executed between you and Broadcom

 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants

 * no license (express or implied), right to use, or waiver of any kind with respect to the

 * Software, and Broadcom expressly reserves all rights in and to the Software and all

 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU

 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY

 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.

 *

 * Except as expressly set forth in the Authorized License,

 *

 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade

 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,

 * and to use this information only in connection with your use of Broadcom integrated circuit products.

 *

 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"

 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR

 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO

 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES

 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,

 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION

 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF

 * USE OR PERFORMANCE OF THE SOFTWARE.

 *

 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS

 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR

 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR

 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT

 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE

 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF

 * ANY LIMITED REMEDY.

 *

 * $brcm_Workfile: message.c $

 * $brcm_Revision: 9 $

 * $brcm_Date: 2/13/12 5:23p $

 *

 * Module Description:

 *

 * Revision History:

 *

 * $brcm_Log: /nexus/utils/message.c $

 * 

 * 9   2/13/12 5:23p erickson

 * SW7335-1216: add overflow callback, fix playback pid channel close

 * 

 * 8   2/8/12 9:51a erickson

 * SW7335-1216: do actual PMT filtering

 * 

 * 7   1/24/12 1:10p erickson

 * SW7425-2199: fix shutdown

 * 

 * 6   7/11/11 1:13p erickson

 * SW7335-1216: remove #if 0 around WaitForEvent

 * 

 * 5   7/1/11 12:50p erickson

 * SW7335-1216: use default maxContiguousMessageSize so example works with

 *  SW filtering

 * 

 * 4   12/8/09 3:00p gmohile

 * SW7408-1 : Add support for platforms with no frontend

 * 

 * 3   9/18/09 4:30p erickson

 * SWDEPRECATED-3717: use NEXUS_MessageSettings.bufferSize

 *

 * 2   5/4/09 4:25p erickson

 * PR54807: add basic psip support

 *

 * 1   5/4/09 2:38p erickson

 * PR54807: added message util

 *

 * 7   4/13/09 3:31p erickson

 * PR54058: remove NEXUS_PidChannelSettings.requireMessageBuffer

 *

 * 6   3/16/09 3:01p erickson

 * PR35457: use app-allocated buffer as recommended in Nexus_Usage.pdf

 *

 * 5   7/18/08 11:31a jgarrett

 * PR 44953: Removing -Wstrict-prototypes warnings

 *

 * 4   4/23/08 12:18p erickson

 * PR35457: parse the PAT to make it a more complete example

 *

 * 3   2/25/08 9:34a jgarrett

 * PR 39435: Fixing includes

 *

 * 2   1/24/08 12:52p vsilyaev

 * PR 38682: fixed return type of NEXUS_Platform_GetStreamerInputBand

 *

 *****************************************************************************/

#include "nexus_platform.h"

#include "nexus_pid_channel.h"

#include "nexus_parser_band.h"

#include "nexus_message.h"

#include "nexus_playback.h"

#include "nexus_file.h"



#include "bstd.h"

#include "bkni.h"



#include <stdio.h>

#include <stdlib.h>

#include <string.h>



BDBG_MODULE(message);



static struct {

    NEXUS_PlaybackHandle playback;

    NEXUS_PlaypumpHandle playpump;

    NEXUS_FilePlayHandle file;

    NEXUS_ParserBand parserBand;

    BKNI_EventHandle event;

} app;



#define MAX_MESSAGE_FILTERS 100

struct message_t {

    unsigned short pid;

    NEXUS_MessageHandle message;

    NEXUS_PidChannelHandle pidChannel;

} g_message[MAX_MESSAGE_FILTERS];



static void message_callback(void *context, int param)

{

    BSTD_UNUSED(param);

    BKNI_SetEvent((BKNI_EventHandle)context);

}



static void overflow_callback(void *context, int param)

{

    BSTD_UNUSED(context);

    BDBG_WRN(("overflow on pid %#x", g_message[param].pid));

}



struct message_opts_t {

    unsigned short pid;

    unsigned buffer_size;

    const char *filename;

    bool hex;

    bool ascii;

    bool psi;

    bool psip;

    NEXUS_TransportType transportType;

    NEXUS_TransportTimestampType tsTimestampType;

    NEXUS_PlaybackLoopMode endOfStreamAction;

};



void cmdline_default_message_opts(struct message_opts_t *opts)

{

    BKNI_Memset(opts, 0, sizeof(*opts));

    opts->buffer_size = 4096;

    opts->transportType = NEXUS_TransportType_eTs;

    opts->tsTimestampType = NEXUS_TransportTimestampType_eNone;

    opts->endOfStreamAction = NEXUS_PlaybackLoopMode_eLoop;

}



static int add_message_filter(const struct message_opts_t *opts, unsigned short pid, const NEXUS_MessageFilter *pFilter)

{

    unsigned i;

    NEXUS_MessageSettings settings;

    NEXUS_MessageStartSettings startSettings;

    NEXUS_Error rc;

    struct message_t *msg = NULL;



    for (i=0;i<MAX_MESSAGE_FILTERS;i++) {

        if (!g_message[i].message) {

            msg = &g_message[i];

            break;

        }

    }

    if (!msg) {

        return -1;

    }

    msg->pid = pid;

    if (app.playback) {

        msg->pidChannel = NEXUS_Playback_OpenPidChannel(app.playback, pid, NULL);

    }

    else {

        msg->pidChannel = NEXUS_PidChannel_Open(app.parserBand, pid, NULL);

    }

    BDBG_ASSERT(msg->pidChannel);



    NEXUS_Message_GetDefaultSettings(&settings);

    settings.dataReady.callback = message_callback;

    settings.dataReady.context = app.event;

    settings.overflow.callback = overflow_callback;

    settings.overflow.param = i;

    /* use default settings.maxContiguousMessageSize */

    settings.bufferSize = opts->buffer_size;

    msg->message = NEXUS_Message_Open(&settings);



    NEXUS_Message_GetDefaultStartSettings(msg->message, &startSettings);

    startSettings.pidChannel = msg->pidChannel;

    if (pFilter) {

        startSettings.filter = *pFilter;

    }

    rc = NEXUS_Message_Start(msg->message, &startSettings);

    BDBG_ASSERT(!rc);

    

    return 0;

}



static void remove_message_filter(unsigned i)

{

    NEXUS_MessageHandle msg = g_message[i].message;

    if (!msg) return;

    g_message[i].message = NULL;

    NEXUS_Message_Close(msg);

}



void print_usage(void)

{

    printf(

    "Usage: nexus message [options] [pvrfile]\n"

    "-buffer_size X   message capture buffer size in bytes\n"

    "-pid X           PID to filter (default is 0)\n"

    "-hex             print contents of all messages in hex\n"

    "-ascii           print contents of all messages in ascii (useful for PSIP)\n"

    "-psi             parse PSI tables\n"

    "-psip            parse PSIP tables\n"

    "\n"

    "If pvrfile not given, streamer input will be parsed\n"

    );

}



int cmdline_parse_message_opts(int argc, char **argv, struct message_opts_t *opts)

{

    int curarg = 1;



    while (curarg < argc) {

        if (!strcmp("--help", argv[curarg]) ||

            !strcmp("-h", argv[curarg]) ||

            !strcmp("-?", argv[curarg])) {

            print_usage();

            return 1;

        }

        else if (!strcmp("-buffer_size", argv[curarg]) && curarg+1 < argc) {

            opts->buffer_size = atoi(argv[++curarg]);

        }

        else if (!strcmp("-pid", argv[curarg]) && curarg+1 < argc) {

            opts->pid = strtoul(argv[++curarg], NULL, 0);

        }

        else if (!strcmp("-hex", argv[curarg])) {

            opts->hex = true;

        }

        else if (!strcmp("-ascii", argv[curarg])) {

            opts->ascii = true;

        }

        else if (!strcmp("-psi", argv[curarg])) {

            opts->psi = true;

            opts->pid = 0; /* PID for PAT */

        }

        else if (!strcmp("-psip", argv[curarg])) {

            opts->psip = true;

            opts->pid = 0x1ffb; /* PID for MGT */

        }

        else if (!opts->filename) {

            opts->filename = argv[curarg];

        }

        else {

            printf("Unknown param: %s\n", argv[curarg]);

            return -1;

        }

        curarg++;

    }

    return 0;

}



int main(int argc, char **argv) {

    struct message_opts_t opts;

    NEXUS_Error rc;

    unsigned count;

    unsigned i;

    NEXUS_PlatformSettings platformSettings;



    cmdline_default_message_opts(&opts);

    if (cmdline_parse_message_opts(argc, argv, &opts)) {

        return 0;

    }



    NEXUS_Platform_GetDefaultSettings(&platformSettings);

    platformSettings.openFrontend = false;

    rc = NEXUS_Platform_Init(NULL);

    if (rc) return -1;



    if (opts.filename) {

        NEXUS_PlaybackSettings playbackSettings;



        app.playpump = NEXUS_Playpump_Open(0, NULL);

        BDBG_ASSERT(app.playpump);

        app.playback = NEXUS_Playback_Create();

        BDBG_ASSERT(app.playback);



        app.file = NEXUS_FilePlay_OpenPosix(opts.filename, NULL);

        if (!app.file) {

            fprintf(stderr, "can't open file:%s\n", opts.filename);

            return -1;

        }



        NEXUS_Playback_GetSettings(app.playback, &playbackSettings);

        playbackSettings.playpump = app.playpump;

        playbackSettings.playpumpSettings.transportType = opts.transportType;

        playbackSettings.playpumpSettings.timestamp.type = opts.tsTimestampType;

        playbackSettings.endOfStreamAction = opts.endOfStreamAction;

        rc = NEXUS_Playback_SetSettings(app.playback, &playbackSettings);

        BDBG_ASSERT(!rc);



        rc = NEXUS_Playback_Start(app.playback, app.file, NULL);

        BDBG_ASSERT(!rc);

    }

#if NEXUS_NUM_PARSER_BANDS

    else {

        NEXUS_InputBand inputBand;

        NEXUS_ParserBandSettings parserBandSettings;



        app.parserBand = NEXUS_ParserBand_e0;

        NEXUS_Platform_GetStreamerInputBand(0, &inputBand);



        NEXUS_ParserBand_GetSettings(app.parserBand, &parserBandSettings);

        parserBandSettings.sourceType = NEXUS_ParserBandSourceType_eInputBand;

        parserBandSettings.sourceTypeSettings.inputBand = inputBand;

        rc = NEXUS_ParserBand_SetSettings(app.parserBand, &parserBandSettings);

        BDBG_ASSERT(!rc);

    }

#endif



    BKNI_CreateEvent(&app.event);

    

    BDBG_WRN(("starting message filter"));



    add_message_filter(&opts, opts.pid, NULL);



    /* Read the PAT a few times */

    for (count=0;;count++) {

        const uint8_t *buffer;

        size_t size;

        unsigned programNum, message_length;



        if (count == MAX_MESSAGE_FILTERS) {

            count = 0;

        }



        if (!g_message[count].message) {

            continue;

        }



        rc = NEXUS_Message_GetBuffer(g_message[count].message, (const void **)&buffer, &size);

        BDBG_ASSERT(!rc);



        if (!size) {

            BERR_Code rc = BKNI_WaitForEvent(app.event, 5 * 1000); /* wait 5 seconds */

            if (rc == NEXUS_TIMEOUT) {

                BDBG_WRN(("timeout")); 

                rc = -1; 

                break;

            }

            BDBG_ASSERT(!rc);

            continue;

        }



#define TS_READ_16( BUF ) ((uint16_t)((BUF)[0]<<8|(BUF)[1]))

#define TS_PSI_GET_SECTION_LENGTH( BUF )    (uint16_t)(TS_READ_16( &(BUF)[1] ) & 0x0FFF)



        /* We should always get whole PAT's because maxContiguousMessageSize is 4K */

        message_length = TS_PSI_GET_SECTION_LENGTH(buffer) + 3;

        BDBG_ASSERT(size >= (size_t)message_length);



        if (opts.psi) {

            if (buffer[0] == 0) {



                /* Program Association Table */

                printf("PAT: size=%d\n", message_length);

                for (programNum=0;programNum<(unsigned)(TS_PSI_GET_SECTION_LENGTH(buffer)-7)/4;programNum++) {

                    unsigned byteOffset = 8 + programNum*4;

                    unsigned program = TS_READ_16( &buffer[byteOffset] );

                    unsigned short pid = (uint16_t)(TS_READ_16( &buffer[byteOffset+2] ) & 0x1FFF);

                    NEXUS_MessageFilter filter;

                    

                    printf("  program %#x: pid %#x\n", program, pid);

                    NEXUS_Message_GetDefaultFilter(&filter);

                    /* these fields must match */

                    filter.mask[0] = 0x00;

                    filter.mask[2] = 0x00;

                    filter.mask[3] = 0x00;

                    /* they must match these values */

                    filter.coefficient[0] = 0x02;

                    filter.coefficient[2] = (program & 0xFF00) >> 8;

                    filter.coefficient[3] = program & 0xFF;

                    add_message_filter(&opts, pid, &filter);

                }

                remove_message_filter(count);

            }

            else if (buffer[0] == 1) {

                /* Conditional Access Table */

                printf("CAT: size=%d\n", message_length);

            }

            else if (buffer[0] == 2) {

                unsigned i, byteOffset;



                /* Program Table */

                printf("PMT: pid=%#x size=%d\n", g_message[count].pid, message_length);

#if 0

                for (i=0;i<message_length;i++) {

                    printf("%02x ", buffer[i]);

                }

                printf("\n");

#endif



#define TS_PSI_LAST_SECTION_NUMBER_OFFSET   7

#define TS_PSI_MAX_BYTE_OFFSET( buf )               (TS_PSI_GET_SECTION_LENGTH(buf) - 1)

#define PROGRAM_INFO_LENGTH_OFFSET (TS_PSI_LAST_SECTION_NUMBER_OFFSET+3)

#define PROGRAM_INFO_LENGTH(buf) (TS_READ_16(&buf[PROGRAM_INFO_LENGTH_OFFSET])&0xFFF)

#define DESCRIPTOR_BASE(buf) (&buf[TS_PSI_LAST_SECTION_NUMBER_OFFSET+5])

#define STREAM_BASE(buf) (TS_PSI_LAST_SECTION_NUMBER_OFFSET + 5 + PROGRAM_INFO_LENGTH(buf))



                byteOffset = STREAM_BASE(buffer);



                while (byteOffset < (unsigned)TS_PSI_MAX_BYTE_OFFSET(buffer) && byteOffset < message_length)

                {

                    printf("  stream_type 0x%02x, pid 0x%x\n",

                        buffer[byteOffset], (uint16_t)(TS_READ_16( &buffer[byteOffset+1] ) & 0x1FFF));



                    byteOffset += 5 + (TS_READ_16( &buffer[byteOffset+3] ) & 0xFFF);

                    i++;

                }

                remove_message_filter(count);

            }

        }

        else if (opts.psip) {

            if (buffer[0] == 0xC7) {

                printf("Master Guide Table (MGT)\n");



                /* TODO: parse and filter PID's for EIT and ETT */

            }

            else if (buffer[0] == 0xC8) {

                printf("Terrestrial Virtual Channel Table (VCT)\n");

            }

            else if (buffer[0] == 0xC9) {

                printf("Cable Virtual Channel Table (CVCT)\n");

            }

            else if (buffer[0] == 0xCA) {

                printf("Rating Region Table (RRT)\n");

            }

            else if (buffer[0] == 0xCB) {

                printf("Event Information Table (EIT)\n");

            }

            else if (buffer[0] == 0xCC) {

                printf("Extended Text Table (ETT)\n");

            }

            else if (buffer[0] == 0xCD) {

                printf("System Time Table (STT)\n");

            }

        }

        else {

            printf("Found message: id=%d size=%d\n", buffer[0], message_length);

        }



        if (opts.hex) {

            unsigned i;

            for (i=0;i<message_length;i++) {

                printf("%02x", buffer[i]);

            }

            printf("\n");

        }

        if (opts.ascii) {

            unsigned i;

            for (i=0;i<message_length;i++) {

                printf("%c", buffer[i] < 32 ? '.':buffer[i]);

            }

            printf("\n");

        }



        if (g_message[count].message) {

            /* only complete one message */

            if (message_length % 4) {

                message_length += 4 - (message_length % 4);

            }

            NEXUS_Message_ReadComplete(g_message[count].message, message_length);

        }

    }



    for (i=0;i<MAX_MESSAGE_FILTERS;i++) {

        remove_message_filter(i);

        if (g_message[i].pidChannel) {

            if (app.playback) {

                NEXUS_Playback_ClosePidChannel(app.playback, g_message[i].pidChannel);

            }

            else {

                NEXUS_PidChannel_Close(g_message[i].pidChannel);

            }

        }

    }

    if (app.playback) {

        NEXUS_Playback_Stop(app.playback);

        NEXUS_FilePlay_Close(app.file);

        NEXUS_Playback_Destroy(app.playback);

        NEXUS_Playpump_Close(app.playpump);

    }

    BKNI_DestroyEvent(app.event);

    NEXUS_Platform_Uninit();

    return 0;

}