siparser.cpp

数字电视中间件小型库

#include "mythcontext.h"
#include "mythdbcon.h"
#include "util.h"

#include "siparser.h"
#include <qdatetime.h>
#include <qtextcodec.h>
#include <qregexp.h>
#include "dvbtypes.h"
#include "atsc_huffman.h"

#include "dsmcc.h"
#include <zlib.h>

/* needed for kenneths verification functions that need to be re-written*/
#define WORD(i,j)   ((i << 8) | j)

// Set EIT_DEBUG_SID to a valid serviceid to enable EIT debugging
// #define EIT_DEBUG_SID 1602

SIParser::description_table_rec SIParser::description_table[] = 
{ 
    { 0x10, "Movies" },
    { 0x11, "Movie - detective/thriller" },
    { 0x12, "Movie - adventure/western/war" },
    { 0x13, "Movie - science fiction/fantasy/horror" },
    { 0x14, "Movie - comedy" },
    { 0x15, "Movie - soap/melodrama/folkloric" },
    { 0x16, "Movie - romance" },
    { 0x17, "Movie - serious/classical/religious/historical movie/drama" },
    { 0x18, "Movie - adult movie/drama" },
    
    { 0x20, "News" },
    { 0x21, "news/weather report" },
    { 0x22, "news magazine" },
    { 0x23, "documentary" },
    { 0x24, "discussion/interview/debate" },
    
    { 0x30, "show/game Show" },
    { 0x31, "game show/quiz/contest" },
    { 0x32, "variety show" },
    { 0x33, "talk show" },
    
    { 0x40, "Sports" },
    { 0x41, "special events (Olympic Games, World Cup etc.)" },
    { 0x42, "sports magazines" },
    { 0x43, "football/soccer" },
    { 0x44, "tennis/squash" },
    { 0x45, "team sports (excluding football)" },
    { 0x46, "athletics" },
    { 0x47, "motor sport" },
    { 0x48, "water sport" },
    { 0x49, "winter sports" },
    { 0x4A, "equestrian" },
    { 0x4B, "martial sports" },
    
    { 0x50, "Kids" },
    { 0x51, "pre-school children's programmes" },
    { 0x52, "entertainment programmes for 6 to14" },
    { 0x53, "entertainment programmes for 10 to 16" },
    { 0x54, "informational/educational/school programmes" },
    { 0x55, "cartoons/puppets" },
    
    { 0x60, "music/ballet/dance" },
    { 0x61, "rock/pop" },
    { 0x62, "serious music/classical music" },
    { 0x63, "folk/traditional music" },
    { 0x64, "jazz" },
    { 0x65, "musical/opera" },
    { 0x66, "ballet" },

    { 0x70, "arts/culture" },
    { 0x71, "performing arts" },
    { 0x72, "fine arts" },
    { 0x73, "religion" },
    { 0x74, "popular culture/traditional arts" },
    { 0x75, "literature" },
    { 0x76, "film/cinema" },
    { 0x77, "experimental film/video" },
    { 0x78, "broadcasting/press" },
    { 0x79, "new media" },
    { 0x7A, "arts/culture magazines" },
    { 0x7B, "fashion" },
    
    { 0x80, "social/policical/economics" },
    { 0x81, "magazines/reports/documentary" },
    { 0x82, "economics/social advisory" },
    { 0x83, "remarkable people" },
    
    { 0x90, "Education/Science/Factual" },
    { 0x91, "nature/animals/environment" },
    { 0x92, "technology/natural sciences" },
    { 0x93, "medicine/physiology/psychology" },
    { 0x94, "foreign countries/expeditions" },
    { 0x95, "social/spiritual sciences" },
    { 0x96, "further education" },
    { 0x97, "languages" },
    
    { 0xA0, "leisure/hobbies" },
    { 0xA1, "tourism/travel" },
    { 0xA2, "handicraft" },
    { 0xA3, "motoring" },
    { 0xA4, "fitness & health" },
    { 0xA5, "cooking" },
    { 0xA6, "advertizement/shopping" },
    { 0xA7, "gardening" },
    // Special
    { 0xB0, "Original Language" },
    { 0xB1, "black & white" },
    { 0xB2, "unpublished" },
    { 0xB3, "live broadcast" },
    // UK Freeview custom id
    { 0xF0, "Drama" },
    { 0, NULL }    
};

SIParser::SIParser()
{
    ThreadRunning = false;
    pthread_mutex_init(&pmap_lock, NULL);
    standardChange = false;
    SIStandard = SI_STANDARD_AUTO;

    /* Set the PrivateTypes to default values */
    PrivateTypesLoaded = false;
    PrivateTypes.reset();

    /* Initialize the Table Handlers */
    Table[PAT] = new PATHandler();
    Table[PMT] = new PMTHandler();
    Table[MGT] = new MGTHandler();
    Table[STT] = new STTHandler();
    Table[EVENTS] = new EventHandler();
    Table[SERVICES] = new ServiceHandler();
    Table[NETWORK] = new NetworkHandler();
    
    // --- BEGIN: changes by PJ ---
    Table[DSMCC] = new DSMCCHandler();
    //CarouselTracker.SetStorageRoot("/root/dsmcc");
    // --- END: changes by PJ ---

    initialiseCategories();

    Reset();

    // Get a list of wanted languages and set up their priorities
    // (Lowest number wins)
    QStringList PreferredLanguages = QStringList::split(",", gContext->GetSetting("PreferredLanguages", ""));
    QStringList::Iterator plit;
    int prio = 1;
    for (plit = PreferredLanguages.begin(); plit != PreferredLanguages.end(); ++plit)
    {
        SIPARSER(QString("Added preferred language %1 with priority %2").arg(*plit).arg(prio));
        LanguagePriority[*plit] = prio++;
    }
}

SIParser::~SIParser()
{
    pthread_mutex_destroy(&pmap_lock);
}

void SIParser::initialiseCategories()
{
    description_table_rec *p=description_table;
    while (p->id!= 0)
    { 
        m_mapCategories[p->id] = QObject::tr(p->desc);
        p++;
    }
}

/* Resets all trackers, and closes all section filters */
void SIParser::Reset()
{

    ParserInReset = true;

    // Close all pids that are open

    SIPARSER("About to do a reset");

    Table[MGT]->Reset();

    SIPARSER("Closing all PIDs");
    DelAllPids();

    PrivateTypesLoaded = false;
    PrivateTypes.reset();

    SIPARSER("Resetting all Table Handlers");
    pthread_mutex_lock(&pmap_lock);

    for (int x = 0; x < NumHandlers ; x++)
        Table[x]->Reset();

    pthread_mutex_unlock(&pmap_lock);

    // --- BEGIN: changes by PJ ---
    CarouselTracker.Clear();
    // --- END: changes by PJ ---

    SIPARSER("SIParser Reset due to channel change");

}

void SIParser::CheckTrackers()
{

    uint16_t pid;
    uint8_t filter,mask;

    pthread_mutex_lock(&pmap_lock);

    /* Check Dependencys and update if necessary */
    for (int x = 0 ; x < NumHandlers ; x++)
    {
        if (Table[x]->Complete())
        {
            SIPARSER(QString("Table[%1]->Complete() == true").arg((tabletypes) x));
            for (int y = 0 ; y < NumHandlers ; y++)
                Table[y]->DependencyMet((tabletypes) x);
// TODO: Emit completion here for tables to siscan
        }
    }

    /* Handle opening any PIDs in this loop only */
    for (int x = 0 ; x < NumHandlers ; x++)
    {
        if (Table[x]->RequirePIDs())
        {
            SIPARSER(QString("Table[%1]->RequirePIDs() == true").arg((tabletypes) x));
            while (Table[x]->GetPIDs(pid,filter,mask))
            {
                AddPid(pid, mask, filter, true, 
                        ((SIStandard == SI_STANDARD_DVB) && (x == EVENTS)) ? 1000 : 10);
            }
        }
    }

    uint16_t key0 = 0,key1 = 0;

    /* See if any new objects require an emit */
    for (int x = 0 ; x < NumHandlers ; x++)
    {
        if (Table[x]->EmitRequired())
        {
            SIPARSER(QString("Table[%1]->EmitRequired() == true").arg((tabletypes) x));
            switch (x)
            {
                case PMT:
                             while (Table[PMT]->GetEmitID(key0,key1))
                                 emit NewPMT( ((PMTHandler *) Table[PMT])->pmt[key0] );
                             break;
                case EVENTS:
                             while (Table[EVENTS]->GetEmitID(key0,key1))
                                 emit EventsReady( &((EventHandler *) Table[EVENTS])->Events[key0] );
                             break;
                case NETWORK:
                             while(Table[NETWORK]->GetEmitID(key0,key1))
                                 emit FindTransportsComplete();

                default:
                             break;
            }
        }
    }

    pthread_mutex_unlock(&pmap_lock);


}

void SIParser::LoadPrivateTypes(uint16_t NetworkID)
{
    QString STD;

    switch (SIStandard)
    {
        case SI_STANDARD_DVB:    STD = "dvb";
                                 break;
        case SI_STANDARD_ATSC:   STD = "atsc";
                                 break;
        /* If you don't know the SI Standard yet you need to bail out */
        default:
                                 return;
    }

    MSqlQuery query(MSqlQuery::InitCon());

    QString theQuery = QString("select private_type,private_value from dtv_privatetypes where "
                       "networkid = %1 and sitype = \"%2\"")
                       .arg(NetworkID)
                       .arg(STD);

    query.prepare(theQuery);

    if(!query.exec())
        MythContext::DBError("Loading Private Types for SIParser", query);

    if (!query.isActive())
        MythContext::DBError("Loading Private Types for SIParser", query);

    if (query.size() > 0)
    {
        query.next();
        for (int x = 0 ; x < query.size() ; x++)
        {
            SIPARSER( QString("Private Type %1 = %2 defined for NetworkID %3")
                     .arg(query.value(0).toString())
                     .arg(query.value(1).toString())
                     .arg(NetworkID) );

            if (QString(query.value(0).toString()) == "sdt_mapping")
            {
                PrivateTypes.SDTMapping = true;
                SIPARSER("SDT Mapping Incorrect for this Service Fixup Loaded");
            }
            if (QString(query.value(0).toString()) == "channel_numbers")
            {
                PrivateTypes.ChannelNumbers = query.value(1).toInt();
                SIPARSER(QString("ChannelNumbers Present using Descriptor %1")
                         .arg(PrivateTypes.ChannelNumbers));
            }
            if (QString(query.value(0).toString()) == "force_guide_present")
            {
                if (query.value(1).toString() == "yes")
                {
                    PrivateTypes.ForceGuidePresent = true;
                    SIPARSER(QString("Forcing Guide Present"));
                }
            }
            if (QString(query.value(0).toString()) == "guide_fixup")
            {
                PrivateTypes.EITFixUp = query.value(1).toInt();
                SIPARSER(QString("Using Guide Fixup Scheme #%1").arg(PrivateTypes.EITFixUp));
            }
            if (QString(query.value(0).toString()) == "guide_ranges")
            {
                PrivateTypes.CustomGuideRanges = true;
                QStringList temp  = QStringList::split(",",query.value(1).toString());
                PrivateTypes.CurrentTransportTableMin = temp[0].toInt();
                PrivateTypes.CurrentTransportTableMax = temp[1].toInt();
                PrivateTypes.OtherTransportTableMin = temp[2].toInt();
                PrivateTypes.OtherTransportTableMax = temp[3].toInt();
                
                SIPARSER(QString("Using Guide Custom Range; CurrentTransport: %1-%2, OtherTransport: %3-%4")
                         .arg(PrivateTypes.CurrentTransportTableMin,2,16)
                         .arg(PrivateTypes.CurrentTransportTableMax,2,16)
                         .arg(PrivateTypes.OtherTransportTableMin,2,16)
                         .arg(PrivateTypes.OtherTransportTableMax,2,16));
            }
            if (QString(query.value(0).toString()) == "tv_types")
            {
                PrivateTypes.TVServiceTypes.clear();
                QStringList temp  = QStringList::split(",",query.value(1).toString());
                QStringList::Iterator i;
                for (i = temp.begin() ; i != temp.end() ; i++)
                {
                    PrivateTypes.TVServiceTypes[(*i).toInt()] = 1;
                    SIPARSER(QString("Added TV Type %1").arg((*i).toInt()));
                }
            }
            if (QString(query.value(0).toString()) == "parse_subtitle_list")
            {
                PrivateTypes.ParseSubtitleServiceIDs.clear();
                QStringList temp  = QStringList::split(",",query.value(1).toString());
                for (QStringList::Iterator i = temp.begin();i!=temp.end();i++)
                {
                    PrivateTypes.ParseSubtitleServiceIDs[(*i).toInt()]=1;
                    SIPARSER(QString("Added ServiceID %1 to list of channels to parse subtitle from").arg((*i).toInt()));
                }
            }
            query.next();
        }
    }
    else
        SIPARSER(QString("No Private Types defined for NetworkID %1").arg(NetworkID));

    PrivateTypesLoaded = true;
}

bool SIParser::GetTransportObject(NITObject& NIT)
{
    pthread_mutex_lock(&pmap_lock);
    NIT = ((NetworkHandler*) Table[NETWORK])->NITList;
    pthread_mutex_unlock(&pmap_lock);
    return true;
}

bool SIParser::GetServiceObject(QMap_SDTObject& SDT)
{

    pthread_mutex_lock(&pmap_lock);
    SDT = ((ServiceHandler*) Table[SERVICES])->Services[0];
    pthread_mutex_unlock(&pmap_lock);
    return true;
}

void SIParser::AddPid(uint16_t pid,uint8_t mask,uint8_t filter, bool CheckCRC, int bufferFactor)
{
    (void) pid;
    (void) mask;
    (void) filter;
    (void) CheckCRC;
    (void) bufferFactor;
    SIPARSER("Using AddPid from SIParser which does nothing");
}

void SIParser::DelPid(int pid)
{
    (void) pid;
    SIPARSER("Using DelPid from SIParser which does nothing");
}

void SIParser::DelAllPids()
{
    SIPARSER("Using DelAllPids from SIParser which does nothing");
}

bool SIParser::FillPMap(SISTANDARD _SIStandard)
{

    pthread_mutex_lock(&pmap_lock);
    SIPARSER("Requesting PAT");