source: svn/newcon3bcm2_21bu/magnum/commonutils/udp/budp_dccparse_divicom.c @ 22

/***************************************************************************
 *     Copyright (c) 2003-2010, 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: budp_dccparse_divicom.c $
 * $brcm_Revision: Hydra_Software_Devel/2 $
 * $brcm_Date: 10/28/10 3:58p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/commonutils/udp/budp_dccparse_divicom.c $
 * 
 * Hydra_Software_Devel/2   10/28/10 3:58p darnstein
 * SW3548-2364: trivial implementation of _isr functions for parsing.
 * 
 * Hydra_Software_Devel/1   7/27/10 5:06p darnstein
 * SW3548-3022: userdata parsing software.
 * 
 ***************************************************************************/

/* For debugging */
/* #define BUDP_P_GETUD_DUMP 1 */
#ifdef BUDP_P_GETUD_DUMP
static const char* BUDP_P_Getud_Filename = "userdata.getud";
#include <stdio.h>
#endif

#include "bstd.h"
#include "bavc.h"
#include "bdbg.h"
#include "budp.h"
#include "budp_bitread.h"
#include "budp_dccparse.h"

BDBG_MODULE(BUDP);


/***************************************************************************
* Forward declarations of static (private) functions
***************************************************************************/

static BERR_Code ParseDivicomData (
        const BAVC_USERDATA_info*      pUserdata_info,
        BUDP_Bitread_Context* pReader,
        size_t                                   length,
        size_t*                  pBytesParsed,
        uint8_t*                 pcc_count,
        BUDP_DCCparse_ccdata* pCCdata 
);
static size_t FindMpegUserdataStart (
        BUDP_Bitread_Context* pREader, size_t length);

#ifdef BUDP_P_GETUD_DUMP
static void dump_getud (
        const BAVC_USERDATA_info* pUserdata_info, size_t offset);
#endif

/***************************************************************************
* Static data (tables, etc.)
***************************************************************************/

static const bool bByteswap = (BSTD_CPU_ENDIAN == BSTD_ENDIAN_LITTLE);

/***************************************************************************
* Implementation of "BUDP_DCCparse_" API functions
***************************************************************************/


/***************************************************************************
 *
 */
BERR_Code BUDP_DCCparse_Divicom_isr ( 
        const BAVC_USERDATA_info*      pUserdata_info, 
        size_t                   offset, 
        size_t*                  pBytesParsed,
        uint8_t*                 pcc_count,
        BUDP_DCCparse_ccdata* pCCdata 
)
{
        size_t bytesParsedSub;
        size_t length;
        uint8_t* userdata;
        BERR_Code eErr;
        BUDP_Bitread_Context reader; 

        BDBG_ENTER(BUDP_DCCparse_Divicom);

        /* Check for obvious errors from user */
        if ((pUserdata_info == 0x0) ||
            (pBytesParsed   == 0x0) ||
            (pcc_count      == 0x0) ||
            (pCCdata        == 0x0)   )
        {
                return BERR_INVALID_PARAMETER;
        }

        /* Programming note:  all function parameters are now validated */

#ifdef BUDP_P_GETUD_DUMP
        dump_getud (pUserdata_info, offset);
#endif

        /* Take care of a special case */
        userdata = (uint8_t*)(pUserdata_info->pUserDataBuffer) + offset;
        length   = pUserdata_info->ui32UserDataBufSize - offset;
        if (length < 4)
        {
                *pBytesParsed = length;
                return BERR_BUDP_NO_DATA;
        }

        /* Prepare to play with bits */
        BUDP_Bitread_Init (&reader, bByteswap, userdata);

        /* jump past the first MPEG userdata start code */
        bytesParsedSub = FindMpegUserdataStart (&reader, length);
        *pBytesParsed = bytesParsedSub;
        length -= bytesParsedSub;

        /* If we did not find a start code, bail out now */
        if (length == 0)
        {
                return BERR_BUDP_NO_DATA;
        }

        eErr = ParseDivicomData (
                pUserdata_info, &reader, length, 
                &bytesParsedSub, pcc_count, pCCdata);
        switch (eErr)
        {
        case BERR_SUCCESS:
                /* fall into the next case */
        case BERR_BUDP_PARSE_ERROR:
                *pBytesParsed += bytesParsedSub;
                BDBG_LEAVE(BUDP_DCCparse_Divicom);
                return eErr;
                break;
        case BERR_BUDP_NO_DATA:
                break;
        default:
                /* Programming error */
                BDBG_ASSERT (false);
                break;
        }

        /* If we did not find a start code, bail out now */
        if (length == 0)
        {
                return BERR_BUDP_NO_DATA;
        }

        /* No userdata was found */
        BDBG_LEAVE(BUDP_DCCparse_Divicom);
        return BERR_BUDP_NO_DATA;
}

/***************************************************************************
* Private functions
***************************************************************************/

/***************************************************************************
 * This function finds the next userdata startcode 0x000001B2.  It 
 * indicates the byte following this startcode by its return value.
 * If no startcode was found, it simply returns the length of the
 * input data.
 */
static size_t FindMpegUserdataStart (
        BUDP_Bitread_Context* pReader, size_t length)
{
    size_t count = 0;
        uint8_t saved[4];

        /* Special case (failure) */
        if (length < 4)
                return length;

        /* Initialize */
        saved[1] = BUDP_Bitread_Byte (pReader);
        saved[2] = BUDP_Bitread_Byte (pReader);
        saved[3] = BUDP_Bitread_Byte (pReader);

        while (length >= 4)
        { 
                /* Read in another byte */
                saved[0] = saved[1];
                saved[1] = saved[2];
                saved[2] = saved[3];
                saved[3] = BUDP_Bitread_Byte (pReader);

                if ((saved[0] == 0x00) &&
                    (saved[1] == 0x00) &&
                        (saved[2] == 0x01) &&
                        (saved[3] == 0xB2)    ) 
                {
                        /* Found it! */
                        break;
                }

                /* proceed to the next byte */
                --length;
                ++count;
        }

        if (length >= 4)
        {
                /* found the pattern before the end of stream */   
                return count + 4;
        }
        else
        {
                /* Didn't find any start code */
                return count + 3;
        }
}

/***************************************************************************
 * This function parses Divicom data.  It assumes that the userdata
 * startcode 0x000001B2 has just been read.
 */
static BERR_Code ParseDivicomData (
        const BAVC_USERDATA_info*      pUserdata_info,
        BUDP_Bitread_Context* pReader,
        size_t                                   length,
        size_t*                  pBytesParsed,
        uint8_t*                 pcc_count,
        BUDP_DCCparse_ccdata* pCCdata 
)
{
        unsigned int cc_count;
        unsigned int vbi_field_type;
        unsigned int icount;
        int data_found;

        BSTD_UNUSED (pUserdata_info);

        /* Start counting */
        *pcc_count = 0;
        *pBytesParsed = 0;
        data_found = 0;

        /* Start travelling pointer into data */
        if (length < 2)
        {   
                return BERR_BUDP_PARSE_ERROR;
        }

        /* Dig out first count of cc data pairs,  and field type */
        cc_count       = BUDP_Bitread_Byte (pReader);
        vbi_field_type = BUDP_Bitread_Byte (pReader);

        /* It seems that a zero cc_count marks the end of data. This is not
         * documented */
        while (cc_count != 0)
        {
                /* Only a few legal values for cc_count and vbi_field_type */
                if ((cc_count != 2) && (cc_count != 4))
                {
                        return BERR_BUDP_PARSE_ERROR;
                }
                if ((vbi_field_type != 0x09) && (vbi_field_type != 0x0a))
                {
                        return BERR_BUDP_PARSE_ERROR;
                }

                /* Account for cc_count and vbi_field_type bytes */
                length -= 2;
                *pBytesParsed += 2;

                /* Account for closed caption bytes about to be parsed */
                if (length < cc_count)
                {   
                        /* Packet too short */
                        return BERR_BUDP_PARSE_ERROR;
                }
                length -= cc_count;
                *pBytesParsed += cc_count;

                /* Dig out the closed caption data pairs */
                for (icount = 0 ; icount < cc_count/2 ; icount+=2)
                {
                        /* Kludge */
                        pCCdata[data_found].line_offset = 11;
                        pCCdata[data_found].cc_valid    =  1;
                        pCCdata[data_found].cc_priority =  0;

                        /* Here is the closed caption data, finally. */
                        pCCdata[data_found].cc_data_1 = 
                                BUDP_Bitread_Byte (pReader);
                        pCCdata[data_found].cc_data_2 = 
                                BUDP_Bitread_Byte (pReader);
                        pCCdata[data_found].format = BUDP_DCCparse_Format_Divicom;
                        pCCdata[data_found].bIsAnalog = true;

                        /* Parity of extracted data is determined by vbi_field_type */
                        if (vbi_field_type == 0x09) 
                        {
                                pCCdata[data_found].polarity = BAVC_Polarity_eTopField;
                                pCCdata[data_found].seq.cc_type = 0;
                        }
                        else
                        {
                                pCCdata[data_found].polarity = BAVC_Polarity_eBotField;
                                pCCdata[data_found].seq.cc_type = 1;
                        }

                        /* Update count of items written to output data */
                        ++data_found;
                }

                /* Dig out next cc_count */
                cc_count       = BUDP_Bitread_Byte (pReader);
                vbi_field_type = BUDP_Bitread_Byte (pReader);
        }

        *pcc_count = data_found;
        return BERR_SUCCESS;
}

#ifdef BUDP_P_GETUD_DUMP
static void dump_getud (
        const BAVC_USERDATA_info* pUserdata_info, size_t offset)
{
        unsigned int iByte;
        static FILE* fd = NULL;
        static unsigned int nPicture;
        uint8_t* userdata = (uint8_t*)(pUserdata_info->pUserDataBuffer) + offset;
        size_t   length   = pUserdata_info->ui32UserDataBufSize - offset;

        /* Initialization */
        if (fd == NULL)
        {
                if ((fd = fopen (BUDP_P_Getud_Filename, "w")) == 0)
                {
                        fprintf (stderr, "ERROR: could not open %s for debug output\n",
                                BUDP_P_Getud_Filename);
                        return;
                }
                fprintf (fd, "getud output format version 1\n");
                nPicture = 0;
        }

        fprintf (fd, "\nPic %u LOC %06lx TR %u\n", ++nPicture, 0UL, 0U);
        fprintf (fd, "PS %d TFF %d RFF %d\n",
                pUserdata_info->eSourcePolarity,
                pUserdata_info->bTopFieldFirst,
                pUserdata_info->bRepeatFirstField);
        fprintf (fd, "UDBYTES %u\n", length);
    for (iByte = 0 ; iByte < length ; ++iByte)
    {
        fprintf (fd, "%02x", userdata[iByte]);
        if ((iByte % 16) == 15)
            putc ('\n', fd);
        else
            putc (' ', fd);
    }
    if ((iByte % 16) != 15)
        putc ('\n', fd);
}
#endif