cmd_info.c

Dvbstreamer 用在解析MPTS的部分内容

        }
        if ((filterByType & FILTER_TYPE_UNKNOWN)&& (service->type == ServiceType_Unknown))
        {
            filterByTypeResult = TRUE;
        }
    }
    else
    {
        filterByTypeResult = TRUE;
    }

    if (filterByAccess)
    {
        if ((filterByAccess & FILTER_ACCESS_FTA) && !service->conditionalAccess)
        {
            filterByAccessResult = TRUE;
        }        
        if ((filterByAccess & FILTER_ACCESS_CA) && service->conditionalAccess)
        {
            filterByAccessResult = TRUE;
        }
    }
    else
    {
        filterByAccessResult = TRUE;
    }

    if (provider)
    {
        filterByProviderResult = service->provider && (strcmp(provider, service->provider) == 0);
    }    
    else
    {
        filterByProviderResult = TRUE;
    }
    return filterByTypeResult && filterByAccessResult && filterByProviderResult;
}

static void CommandListMuxes(int argc, char **argv)
{
    MultiplexEnumerator_t enumerator = MultiplexEnumeratorGet();
    Multiplex_t *multiplex;
    bool ids = FALSE;
    if ((argc == 1) && (strcmp(argv[0], "-id") == 0))
    {
        ids = TRUE;
    }
    do
    {
        multiplex = MultiplexGetNext(enumerator);
        if (multiplex)
        {
            if (ids)
            {
                CommandPrintf("%04x.%04x : %d \n", 
                    multiplex->networkId & 0xffff, multiplex->tsId & 0xffff, multiplex->uid);
            }
            else
            {
                CommandPrintf("%d\n", multiplex->uid);
            }
            MultiplexRefDec(multiplex);
        }
    }while(multiplex && ! ExitProgram);
    MultiplexEnumeratorDestroy(enumerator);
}

static void CommandCurrent(int argc, char **argv)
{
    Service_t *service = TuningCurrentServiceGet();
    if ( service)
    {
        Multiplex_t *multiplex = TuningCurrentMultiplexGet();
        
        CommandPrintf("%04x.%04x.%04x : \"%s\"\n",
            multiplex->networkId & 0xffff, multiplex->tsId & 0xffff, service->id & 0xffff,
            service->name);
        ServiceRefDec(service);
        MultiplexRefDec(multiplex);
    }
    else
    {
        CommandPrintf("No current service\n");
    }
}
static void CommandServiceInfo(int argc, char **argv)
{
    Service_t *service;
    Multiplex_t *multiplex;

    UpdateDatabase();
    
    service = ServiceFindName(argv[0]);

    if (service)
    {
        static const char *serviceType[]= {"Digital TV", "Digital Radio", "Data", "Unknown"};
        multiplex = MultiplexFindUID(service->multiplexUID);            
        CommandPrintf("Name                : %s\n", service->name);
        CommandPrintf("Provider            : %s\n", service->provider);
        CommandPrintf("Type                : %s\n", serviceType[service->type]);
        CommandPrintf("Conditional Access? : %s\n", service->conditionalAccess ? "CA":"Free to Air");
        CommandPrintf("ID                  : %04x.%04x.%04x\n", multiplex->networkId, multiplex->tsId, service->id);
        CommandPrintf("Multiplex UID       : %d\n", service->multiplexUID);
        CommandPrintf("Source              : 0x%04x\n", service->source);
        CommandPrintf("Default Authority   : %s\n", service->defaultAuthority);
        CommandPrintf("PMT PID             : 0x%04x\n", service->pmtPid);
        CommandPrintf("    Version         : %d\n", service->pmtVersion);
        ServiceRefDec(service);
        MultiplexRefDec(multiplex);
    }
    else
    {
        CommandError(COMMAND_ERROR_GENERIC, "Service not found!");
    }
}

static void CommandMuxInfo(int argc, char **argv)
{
    Multiplex_t *multiplex = NULL;
    if (argc == 1)
    {
        multiplex = MultiplexFind(argv[0]);
    }
    if (argc == 2)
    {
        int netId = 0;
        int tsId = 0;
        sscanf(argv[0], "%x", &netId);
        sscanf(argv[1], "%x", &tsId);        
        multiplex = MultiplexFindId(netId, tsId);
    }
    if (multiplex)
    {
        CommandPrintf("UID                 : %d\n", multiplex->uid);
        CommandPrintf("ID                  : %04x.%04x\n", multiplex->networkId, multiplex->tsId);
        CommandPrintf("PAT Version         : %d\n", multiplex->patVersion);
        CommandPrintf("Tuning Parameters\n");
        CommandPrintf("    Frequency       : %d\n", multiplex->freq);
        CommandPrintf("    Type            : %s\n", FETypesStr[multiplex->type]);
        
        MultiplexRefDec(multiplex);
    }
    else
    {
        CommandError(COMMAND_ERROR_GENERIC, "Multiplex not found!");
    }
}


static void CommandStats(int argc, char **argv)
{
    ListIterator_t iterator;
    TSFilter_t *tsFilter = MainTSFilterGet();

    CommandPrintf("PSI/SI Processor Statistics\n"
                  "---------------------------\n");

    for ( ListIterator_Init(iterator, tsFilter->pidFilters); 
          ListIterator_MoreEntries(iterator); 
          ListIterator_Next(iterator))
    {
        PIDFilter_t *filter = (PIDFilter_t *)ListIterator_Current(iterator);
        if (strcmp(filter->type, PSISIPIDFilterType) == 0)
        {
            CommandPrintf("\t%-15s : %lld\n", filter->name, filter->packetsProcessed);
        }
    }
    CommandPrintf("\n");

    CommandPrintf("Service Filter Statistics\n"
                  "-------------------------\n");
    for ( ListIterator_Init(iterator, tsFilter->pidFilters); 
          ListIterator_MoreEntries(iterator); 
          ListIterator_Next(iterator))
    {
        PIDFilter_t *filter = (PIDFilter_t *)ListIterator_Current(iterator);
        if (strcmp(filter->type, ServicePIDFilterType) == 0)
        {
            CommandPrintf("\t%-15s : %lld\n", filter->name, filter->packetsProcessed);
        }
    }
    CommandPrintf("\n");

    CommandPrintf("Other Filter Statistics\n"
                  "------------------------\n");
     for ( ListIterator_Init(iterator, tsFilter->pidFilters); 
           ListIterator_MoreEntries(iterator); 
           ListIterator_Next(iterator))
    {
        PIDFilter_t *filter = (PIDFilter_t *)ListIterator_Current(iterator);
        if ((strcmp(filter->type, PSISIPIDFilterType) != 0) &&
            (strcmp(filter->type, ServicePIDFilterType) != 0))
        {
            CommandPrintf("\t%-15s : %lld (%s)\n", filter->name, filter->packetsFiltered, filter->type);
        }
    }
    CommandPrintf("\n");



    CommandPrintf("Total packets processed: %lld\n", tsFilter->totalPackets);
    CommandPrintf("Approximate TS bitrate : %gMbs\n", ((double)tsFilter->bitrate / (1024.0 * 1024.0)));
}


static void CommandFEStatus(int argc, char **argv)
{
    fe_status_t status;
    unsigned int ber, strength, snr, ucblocks;

    if (DVBFrontEndStatus(MainDVBAdapterGet(), &status, &ber, &strength, &snr, &ucblocks))
    {
        CommandPrintf("Failed to get frontend status!\n");
        return;
    }

    CommandPrintf("Tuner status:  %s%s%s%s%s%s\n",
             (status & FE_HAS_SIGNAL)?"Signal ":"",
             (status & FE_TIMEDOUT)?"Timed out ":"",
             (status & FE_HAS_LOCK)?"Lock ":"",
             (status & FE_HAS_CARRIER)?"Carrier ":"",
             (status & FE_HAS_VITERBI)?"VITERBI ":"",
             (status & FE_HAS_SYNC)?"Sync ":"");
    CommandPrintf("Signal Strength = %d%% SNR = %d%% BER = %x Uncorrected Blocks = %x\n",
        (strength * 100) / 0xffff, (snr * 100) / 0xffff, ber, ucblocks);
}


static void CommandListPids(int argc, char **argv)
{
    Service_t *service;

    service = ServiceFindName(argv[0]);
    if (service)
    {
        bool cached = TRUE;
        int i;
        PIDList_t *pids;
        bool numericOutput = FALSE;
            
        if ((argc == 2) && (strcmp(argv[1], "-n") == 0))
        {
            numericOutput =TRUE;
        }
        
        pids = CachePIDsGet(service);
        if (pids == NULL)
        {
            pids = PIDListGet(service);
            cached = FALSE;
        }

        if (pids)
        {
            CommandPrintf("%d PIDs for \"%s\"%s\n", pids->count, argv[0], cached ? " (Cached)":"");
            for (i = 0; i < pids->count; i ++)
            {
                if (numericOutput)
                {
                    CommandPrintf("%d %d %d\n",pids->pids[i].pid, pids->pids[i].type, pids->pids[i].subType);
                }
                else
                {
                    CommandPrintf("%d %s\n", pids->pids[i].pid, GetStreamTypeString(pids->pids[i].type));
                }

            }

            if (cached)
            {
                CachePIDsRelease();
            }
            else
            {
                PIDListFree(pids);
            }
        }
        else
        {
            CommandPrintf("0 PIDs for \"%s\"\n",argv[0]);
        }
        ServiceRefDec(service);
    }
    else
    {
        CommandError(COMMAND_ERROR_GENERIC, "Service not found!");
    }
}

static char *GetStreamTypeString(int type)
{
    char *result= "Unknown";
    switch(type)
    {
        case 0x00 : result ="ITU-T | ISO/IEC Reserved"; break;
        case 0x01 : result ="ISO/IEC 11172 Video"; break;
        case 0x02 : result ="ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream"; break;
        case 0x03 : result ="ISO/IEC 11172 Audio"; break;
        case 0x04 : result ="ISO/IEC 13818-3 Audio"; break;
        case 0x05 : result ="ITU-T Rec. H.222.0 | ISO/IEC 13818-1 private_sections"; break;
        case 0x06 : result ="ITU-T Rec. H.222.0 | ISO/IEC 13818-1 PES packets containing private data"; break;
        case 0x07 : result ="ISO/IEC 13522 MHEG"; break;
        case 0x08 : result ="ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Annex A DSM-CC"; break;
        case 0x09 : result ="ITU-T Rec. H.222.1"; break;
        case 0x0A : result ="ISO/IEC 13818-6 type A"; break;
        case 0x0B : result ="ISO/IEC 13818-6 type B"; break;
        case 0x0C : result ="ISO/IEC 13818-6 type C"; break;
        case 0x0D : result ="ISO/IEC 13818-6 type D"; break;
        case 0x0E : result ="ITU-T Rec. H.222.0 | ISO/IEC 13818-1 auxiliary"; break;
        case 0x0F : result ="ISO/IEC 13818-7 Audio with ADTS transport syntax"; break;
        case 0x10 : result ="ISO/IEC 14496-2 Visual"; break;
        case 0x11 : result ="ISO/IEC 14496-3 Audio with the LATM transport syntax as defined in ISO/IEC 14496-3 / AMD 1"; break;
        case 0x12 : result ="ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in PES packets"; break;
        case 0x13 : result ="ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in ISO/IEC14496_sections."; break;
        case 0x14 : result ="ISO/IEC 13818-6 Synchronized Download Protocol"; break;
        case 0x15 ... 0x7F : result ="ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Reserved"; break;
        case 0x80 ... 0xFF : result ="User Private"; break;
        default:
            break;
    }
    return result;
}
/*******************************************************************************
* Variable Functions                                                           *
*******************************************************************************/
static void CommandVariableUptimeGet(char *name)
{
    if (strcmp(name, "uptime") == 0)
    {
        time_t now;
        int seconds;
        int d, h, m, s;
        time(&now);
        seconds = (int)difftime(now, StartTime);
        d = seconds / (24 * 60 * 60);
        h = (seconds - (d * 24 * 60 * 60)) / (60 * 60);
        m = (seconds - ((d * 24 * 60 * 60) + (h * 60 * 60))) / 60;
        s = (seconds - ((d * 24 * 60 * 60) + (h * 60 * 60) + (m * 60)));
        CommandPrintf("%d Days %d Hours %d Minutes %d seconds\n", d, h, m, s);
    }else if (strcmp(name, "upsecs") == 0)
    {
        time_t now;
        time(&now);

        CommandPrintf("%d\n", (int)difftime(now, StartTime));
    }
}

static void CommandVariableFETypeGet(char *name)
{

    DVBAdapter_t *adapter = MainDVBAdapterGet();

    CommandPrintf("%s\n", FETypesStr[adapter->info.type]);
}

static void CommandVariableFENameGet(char *name)
{

    DVBAdapter_t *adapter = MainDVBAdapterGet();

    CommandPrintf("%s\n", adapter->info.name);
}

static void CommandVariableTSModeGet(char *name)
{

    DVBAdapter_t *adapter = MainDVBAdapterGet();

    CommandPrintf("%s\n", adapter->hardwareRestricted ? "H/W Restricted":"Full TS");
}