siparser.cpp

数字电视中间件小型库

        if (CurrentTransport)
            ((ServiceHandler*) Table[SERVICES])->Services[0][s.ServiceID] = s;
        else
            ((ServiceHandler*) Table[SERVICES])->Services[s.TransportID][s.ServiceID] = s;
        s.Reset();  
        pos += (descriptors_loop_length + 5);
    }

    if (CurrentTransport)
        emit FindServicesComplete();

    // TODO: This is temp
    Table[EVENTS]->DependencyMet(SERVICES);
    Table[EVENTS]->AddPid(0x12,0x00,0x00,true);
}

void SIParser::ParseDVBEIT(tablehead_t* head, uint8_t* buffer ,int size)
{

    uint8_t last_segment_number  = buffer[4];
    uint8_t last_table_id        = buffer[5];

    if (!((EventHandler*) Table[EVENTS])->TrackerSetup[head->table_id_ext])
    {
        if (PrivateTypes.CustomGuideRanges)
        {
            if ((head->table_id >= PrivateTypes.CurrentTransportTableMin)
                && (head->table_id <= PrivateTypes.CurrentTransportTableMax))
            {
                for (int x = PrivateTypes.CurrentTransportTableMin; x <= PrivateTypes.CurrentTransportTableMax; x++)
                    ((EventHandler*) Table[EVENTS])->Tracker[head->table_id_ext][x].Reset();
            }
            else if ((head->table_id >= PrivateTypes.OtherTransportTableMin)
                && (head->table_id <= PrivateTypes.OtherTransportTableMax))
            {
                for (int x = PrivateTypes.OtherTransportTableMin; x <= PrivateTypes.OtherTransportTableMax; x++)
                    ((EventHandler*) Table[EVENTS])->Tracker[head->table_id_ext][x].Reset();
            }
            
        }
        else
        {
            if ((head->table_id & 0xF0) == 0x50)
            {
                for (int x = 0x50 ; x < (last_table_id & 0x0F) + 0x50 ; x++)
                   ((EventHandler*) Table[EVENTS])->Tracker[head->table_id_ext][x].Reset();
            }

            if ((head->table_id & 0xF0) == 0x60)
            {
                for (int x = 0x60 ; x < (last_table_id & 0x0F) + 0x60 ; x++)
                    ((EventHandler*) Table[EVENTS])->Tracker[head->table_id_ext][x].Reset();
            }
        }
        ((EventHandler*) Table[EVENTS])->TrackerSetup[head->table_id_ext] = true;
    }

    if (Table[EVENTS]->AddSection(head,head->table_id_ext,head->table_id))
        return;

    if (last_segment_number != head->section_last)
    {
        for (int x=(last_segment_number+1);x<((head->section_number&0xF8)+8);x++)
            ((EventHandler*) Table[EVENTS])->Tracker[head->table_id_ext][head->table_id].MarkUnused(x);

    }

    uint16_t pos = 6;
    uint16_t des_pos = 0;
    uint16_t descriptor_length = 0;

    // Event to use temporarily to fill in data
    Event e;

    // Set ServiceID/NetworkID/TransportID since they remain the same per table
    e.ServiceID                  = head->table_id_ext;
    e.TransportID                = buffer[0] << 8 | buffer[1];
    e.NetworkID                  = buffer[2]  << 8 | buffer[3];

#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
    fprintf(stdout,"EIT_DEBUG: sid:%d nid:%04X tid:%04X lseg:%02X ltab:%02X tab:%02X sec:%02X lsec: %02X size:%d\n",
           e.ServiceID,
           e.NetworkID,
           e.TransportID,
           last_segment_number,
           last_table_id,
           head->table_id,
           head->section_number,
           head->section_last,
           size);
}
#endif

   // Loop through table (last 4 bytes are CRC)
   while (pos < (size-4))
   {

       e.EventID = buffer[pos] << 8 | buffer[pos+1];
       e.StartTime = ConvertDVBDate(&buffer[pos+2]);
       e.EndTime = e.StartTime.addSecs(
                       (bcdtoint(buffer[pos+7] & 0xFF) * 3600) +
                       (bcdtoint(buffer[pos+8] & 0xFF) * 60) +
                       (bcdtoint(buffer[pos+9] & 0xFF)) ) ;

#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
       fprintf(stdout,"EIT_EVENT: %d EventID: %d   Time: %s - %s\n",e.ServiceID,e.EventID,e.StartTime.toString(QString("yyyyMMddhhmm")).ascii(),e.EndTime.toString(QString("yyyyMMddhhmm")).ascii());
}
#endif

        // variables to store info about "best descriptor" 4D & 4E
        // (used to pick out the one with the preferred language 
        // in case there are more than one)
        int bd4D_prio = -1;
        uint8_t *bd4D_data = NULL;
        QString bd4D_lang;
        int bd4E_prio = -1;
        uint8_t *bd4E_data = NULL;
        QString bd4E_lang;

        // Parse descriptors
        descriptor_length = ((buffer[pos+10] & 0x0F) << 8) | buffer[pos+11];
        pos+=12;
        des_pos = pos;
        while (des_pos < (pos + descriptor_length)) 
        { 
            switch (buffer[des_pos]) 
            {
                case 0x4D:
                    {
                        QString lang = QString::fromLatin1((const char*) &buffer[des_pos + 2], 3);
                        int prio = LanguagePriority[lang];

#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
       fprintf(stdout,"EIT_EVENT: 4D descriptor, lang %s, prio %i\n", lang.ascii(), prio);
}
#endif

                        if ((prio > 0 && prio < bd4D_prio) || bd4D_prio == -1)
                        {
                            // this descriptor is better than what we have
                            // => store a reference to this one
                            bd4D_lang = lang;
                            bd4D_prio = prio;
                            bd4D_data = &buffer[des_pos];
                        }
                    }
                    break;

                case 0x4E:
                    {
                        QString lang = QString::fromLatin1((const char*) &buffer[des_pos + 3], 3);
                        int prio = LanguagePriority[lang];

#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
       fprintf(stdout,"EIT_EVENT: 4E descriptor, lang %s, prio %i\n", lang.ascii(), prio);
}
#endif

                        if ((prio > 0 && prio < bd4E_prio) || bd4E_prio == -1)
                        {
                            // this descriptor is better than what we have
                            // => store a reference to this one
                            bd4E_lang = lang;
                            bd4E_prio = prio;
                            bd4E_data = &buffer[des_pos];
                        }
                    }
                    break;

                case 0x50:
                    ProcessComponentDescriptor(&buffer[des_pos], buffer[des_pos+1]+2,e);
                    break;

                case 0x54:
                    e.ContentDescription =
                            ProcessContentDescriptor(&buffer[des_pos],buffer[des_pos+1]+2);
                    break;

                default:            
                    ProcessUnknownDescriptor(&buffer[des_pos],buffer[des_pos+1]+2);
                    break;
            }
            des_pos += (buffer[des_pos+1]+2);

            if (des_pos > size)
                return;
        }


        // Resolve data for "best" 4D & 4E descriptors
        if (bd4D_data != NULL)
        {
#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
        fprintf(stdout, "EIT_EVENT: using 4D data for language='%s'\n", bd4D_lang.ascii());
}
#endif
            e.LanguageCode = bd4D_lang;
            ProcessShortEventDescriptor(bd4D_data, bd4D_data[1] + 2, e);
        }
        if (bd4E_data != NULL)
        {
#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
        fprintf(stdout, "EIT_EVENT: using 4E data for language='%s'\n", bd4E_lang.ascii());
}
#endif
            e.LanguageCode = bd4E_lang;
            ProcessExtendedEventDescriptor(bd4E_data, bd4E_data[1] + 2, e);
        }


        EITFixUp(e);

#ifdef EIT_DEBUG_SID
if (e.ServiceID == EIT_DEBUG_SID) {
        fprintf(stdout, "EIT_EVENT: LanguageCode='%s' Event_Name='%s' Description='%s'\n", e.LanguageCode.ascii(), e.Event_Name.ascii(), e.Description.ascii());
}
#endif

        ((EventHandler*) Table[EVENTS])->Events[head->table_id_ext][e.EventID] = e;
        e.clearEventValues();
        pos += descriptor_length;
    }
}


/*------------------------------------------------------------------------
 *   COMMON DESCRIPTOR PARSERS
 *------------------------------------------------------------------------*/
// Descriptor 0x09 - Conditional Access Descriptor
CAPMTObject SIParser::ParseDescriptorCA(uint8_t* buffer, int size)
{
    (void) size;
    CAPMTObject retval;

    retval.CASystemID = buffer[2] << 8 | buffer[3];
    retval.PID = (buffer[4] & 0x1F) << 8 | buffer[5];
    retval.Data_Length = buffer[1] - 4;
    if (retval.Data_Length > 0)
    {
        memcpy(retval.Data, &buffer[6], retval.Data_Length);
    }

    return retval;
}

/*------------------------------------------------------------------------
 *   DVB DESCRIPTOR PARSERS
 *------------------------------------------------------------------------*/
// Descriptor 0x40 - NetworkName
void SIParser::ParseDescriptorNetworkName(uint8_t* buffer, int size, NetworkObject &n)
{
    (void) size;

    n.NetworkName = DecodeText(buffer + 2, buffer[1]);
}

// Descriptor 0x4A - Linkage - NIT
void SIParser::ParseDescriptorLinkage(uint8_t* buffer,int size,NetworkObject &n)
{
    (void) size;

    n.LinkageTransportID = buffer[2] << 8 | buffer[3];
    n.LinkageNetworkID = buffer[4] << 8 | buffer[5];
    n.LinkageServiceID = buffer[6] << 8 | buffer[7];
    n.LinkageType = buffer[8];
    n.LinkagePresent = 1;

    //The following was found to break EIT guide for 
    // Kristian Kalweit <[e-mail]>
    if (n.LinkageType == 4)
    {
        PrivateTypes.GuideOnSingleTransport = true;
        PrivateTypes.GuideTransportID = n.LinkageTransportID;
    }
}

// Descriptor 0x62 - Frequency List - NIT
void SIParser::ParseDescriptorFrequencyList(uint8_t* buffer,int size, TransportObject& t)
{
    int i = 2;
    uint8_t coding = buffer[i++] & 0x3;
    unsigned frequency;
    QString FrequencyTemp;
    for (; i < size ; i+=4)
    {
         switch (coding)
         {
         case 0x3:  //DVB-T
             frequency*=10;
             frequency = (((buffer[i] << 24) | (buffer[i+1] << 16) | (buffer[i+2] << 8 ) | buffer[i+3]))*10;
             break;
         default:
              FrequencyTemp = QString("%1%2%3%4%5%6%7%800")
             .arg((buffer[i] & 0xF0) >> 4)
             .arg( buffer[i] & 0x0F)
             .arg((buffer[i+1] & 0xF0) >> 4)
             .arg( buffer[i+1] & 0x0F)
             .arg((buffer[i+2] & 0xF0) >> 4)
             .arg( buffer[i+2] & 0x0F)
             .arg((buffer[i+3] & 0xF0) >> 4)
             .arg( buffer[i+3] & 0x0F);
             frequency=FrequencyTemp.toInt();
         }
         t.frequencies+=frequency;
    }
}

//Descriptor 0x83 UK specific channel list
void SIParser::ParseDescriptorUKChannelList(uint8_t* buffer,int size, QMap_uint16_t& numbers)
{
    int i = 2;

    for (; i < size ; i+=4)
    {

        uint16_t service_id = (buffer[i]<<8)|(buffer[i+1]&0xff);
        uint16_t channel_num = (buffer[i+2]&0x03<<8)|(buffer[i+3]&0xff);

        numbers[service_id] = channel_num;
    }
}

// Desctiptor 0x48 - Service - SDT
void SIParser::ParseDescriptorService(uint8_t* buffer, int size, SDTObject& s)
{
    (void) size;
    uint8_t tempType = buffer[2];

    if (PrivateTypes.TVServiceTypes.contains(tempType))
        s.ServiceType = PrivateTypes.TVServiceTypes[tempType];
    else
        s.ServiceType = tempType;

    buffer += 3;
    s.ProviderName = DecodeText(buffer + 1, buffer[0]);
    buffer += buffer[0] + 1;
    s.ServiceName = DecodeText(buffer + 1, buffer[0]);
}

// Descriptor 0x5A - DVB-T Transport - NIT
TransportObject SIParser::ParseDescriptorTerrestrialDeliverySystem(uint8_t* buffer, int size)
{
    (void) size;

    TransportObject retval;

    retval.Type = QString("DVB-T");

    retval.Frequency = ((buffer[2] << 24) | (buffer[3] << 16) | (buffer[4] << 8 ) | buffer[5]) * 10;

    // Bandwidth
    switch ((buffer[6] & 0xE0) >> 5) {
       case 0:
               retval.Bandwidth = "8";
               break;
       case 1:
               retval.Bandwidth = "7";
               break;
       case 2:
               retval.Bandwidth = "6";
               break;
       default:
               retval.Bandwidth = "auto";
               break;
    }

    // Consetellation
    switch ((buffer[7] & 0xC0) >> 6) {
       case 0:
               retval.Constellation = "qpsk";
               break;
       case 1:
               retval.Constellation = "qam_16";
               break;
       case 2:
               retval.Constellation = "qam_64";
               break;
       default:
               retval.Constellation = "auto";
               break;
    }

    // Heiarchy
    switch ((buffer[7] & 0x38) >> 3) {
       case 0:
               retval.Hiearchy = "n";
               break;
       case 1:
               retval.Hiearchy = "1";
               break;
       case 2:
               retval.Hiearchy = "2";
               break;
       case 3:
               retval.Hiearchy = "4";
               break;
       default:
               retval.Hiearchy = "a";
               break;
    }

    // CoderateHP
    switch (buffer[7] & 0x03) 
    {
    case 0:
        retval.CodeRateHP = "1/2";
        break;
    case 1:
        retval.CodeRateHP = "2/3";
        break;
    case 2:
        retval.CodeRateHP = "3/4";
        break;
    case 3:
        retval.CodeRateHP = "5/6";
        break;
    case 4:
        retval.CodeRateHP = "7/8";
        break;