dvbctrl.c

linux下的dvb收看解析软件代码； 带参考程序

{
    uint16_t servicecount = 0;
    int i;

    MessageReset(&message);
    if (strcmp(servicesCmd, argv[0]) == 0)
    {
        MessageSetCode(&message, MSGCODE_SSLA);
    }
    if (strcmp(multiplexCmd, argv[0]) == 0)
    {
        MessageSetCode(&message, MSGCODE_SSLM);
    }

    MESSAGE_SENDRECV();

    CHECK_EXPECTED(MSGCODE_RLS);

    MessageReadUint16( &message, &servicecount);

    for (i = 0; i < servicecount; i ++)
    {
        char *name = NULL;
        MessageReadString( &message, &name);
        if (name)
        {
            printf("%s\n", name);
            free(name);
        }
    }
}

static void CommandSelect(char *argv[])
{
    if (!Authenticate())
    {
        printf("Failed to authenticate username/password!\n");
        return;
    }

    MessageInit(&message, MSGCODE_CSPS);
    MessageEncode(&message, "s", argv[1]);

    MESSAGE_SENDRECV();

    CHECK_RERR_OK();
}

static void CommandCurrent(char *argv[])
{
    MessageInit(&message, MSGCODE_SSPS);

    MESSAGE_SENDRECV();

    if (MessageGetCode(&message) == MSGCODE_RERR)
    {
        uint8_t code;
        char *text = NULL;
        MessageDecode(&message, "bs", &code, &text);
        if (code == 0)
        {
            printf("%s\n", text);
        }
        else
        {
            printf("ERROR (%d) %s\n", code, text);
        }
    }
    else
    {
        printlog(LOG_ERROR, "Unexpected response message! (type 0x%02x)",
                 MessageGetCode(&message) );
    }
}

static void CommandPids(char *argv[])
{
    uint16_t i;
    uint16_t pidCount = 0;
    uint16_t pid;

    if (strcmp(pidsCmd, argv[0]) == 0)
    {
        MessageInit(&message, MSGCODE_SSPL);
    }
    else
    {
        MessageInit(&message, MSGCODE_SOLP);
    }

    MessageEncode(&message, "s", argv[1]);

    MESSAGE_SENDRECV();

    CHECK_EXPECTED(MSGCODE_RLP);

    MessageReadUint16(&message, &pidCount);
    printlog(LOG_DEBUG, "pidCount=%u\n", (unsigned int)pidCount);
    for ( i = 0; i < pidCount; i ++)
    {
        MessageReadUint16(&message, &pid);
        printf("0x%04x\n", pid);
    }
}

static void CommandStats(char *argv[])
{
    uint32_t bitrate = 0;
    uint32_t totalPC = 0;
    uint32_t patPC = 0;
    uint32_t pmtPC = 0;
    uint32_t sdtPC = 0;
    int i;
    ServiceOutputList_t *serviceOutputs = NULL;
    ManualOutputList_t *manualOutputs = NULL;
    MessageInit(&message, MSGCODE_STSS);
    MESSAGE_SENDRECV();
    CHECK_EXPECTED(MSGCODE_RTSS);

    MessageDecode(&message, "lllll", &bitrate, &totalPC, &patPC, &pmtPC, &sdtPC);

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

    printf("\t%-15s : %u\n", "PAT", (unsigned int)patPC);
    printf("\t%-15s : %u\n", "PMT", (unsigned int)pmtPC);
    printf("\t%-15s : %u\n", "SDT", (unsigned int)sdtPC);

    printf("\n");

    printf("Service Filter Statistics\n"
           "-------------------------\n");

    serviceOutputs = GetServiceOutputs();
    if (serviceOutputs)
    {
        for (i = 0; i < serviceOutputs->nrofOutputs; i ++)
        {
            uint32_t pc = 0;
            MessageInit(&message, MSGCODE_SSPC);
            MessageEncode(&message, "s", serviceOutputs->outputs[i].name);

            MESSAGE_SENDRECV();

            if (MessageGetCode(&message) == MSGCODE_ROPC)
            {
                MessageDecode( &message, "l", &pc);
                printf("\t%-15s : %u\n", serviceOutputs->outputs[i].name, (unsigned int)pc);
            }
        }
        FreeServiceOutputs(serviceOutputs);
    }
    printf("\n");

    printf("Manual Output Statistics\n"
           "------------------------\n");
    manualOutputs = GetManualOutputs();
    if (manualOutputs)
    {
        for (i = 0; i < manualOutputs->nrofOutputs; i ++)
        {
            uint32_t pc = 0;
            MessageInit(&message, MSGCODE_SOPC);
            MessageEncode(&message, "s", manualOutputs->outputs[i].name);

            MESSAGE_SENDRECV();

            if (MessageGetCode(&message) == MSGCODE_ROPC)
            {
                MessageDecode( &message, "l", &pc);
                printf("\t%-15s : %u\n", manualOutputs->outputs[i].name, (unsigned int)pc);
            }
        }
        FreeManualOutputs(manualOutputs);
    }
    printf("\n");

    printf("Total packets processed: %u\n", (unsigned int)totalPC);
    printf("Approximate TS bitrate : %gMbs\n", ((double)bitrate / (1024.0 * 1024.0)));
}

static void CommandAddOutput(char *argv[])
{
    AUTHENTICATE();

    if (strcmp(addoutputCmd, argv[0]) == 0)
    {
        MessageInit(&message, MSGCODE_COAO);
    }
    else
    {
        MessageInit(&message, MSGCODE_CSSA);
    }
    MessageEncode(&message, "ss", argv[1], argv[2]);

    MESSAGE_SENDRECV();

    CHECK_RERR_OK();
}

static void CommandRmOutput(char *argv[])
{
    AUTHENTICATE();

    if (strcmp(rmoutputCmd, argv[0]) == 0)
    {
        MessageInit(&message, MSGCODE_CORO);
    }
    else
    {
        MessageInit(&message, MSGCODE_CSSR);
    }
    MessageEncode(&message, "s", argv[1]);

    MESSAGE_SENDRECV();

    CHECK_RERR_OK();
}

static void CommandOutputs(char *argv[])
{
    int i;
    ManualOutputList_t *outputs = NULL;

    outputs = GetManualOutputs();
    if (outputs)
    {
        for (i = 0 ; i < outputs->nrofOutputs; i ++)
        {
            printf("%-15s : %s\n", outputs->outputs[i].name, outputs->outputs[i].destination);
        }
        FreeManualOutputs(outputs);
    }
}

static void CommandAddRmPID(char *argv[])
{
    int pid = ParsePID(argv[2]);
    if (pid == -1)
    {
        printf("Failed to parse \"%s\" as a PID!\n", argv[2]);
        return;
    }
    AUTHENTICATE();
    if (strcmp(addpidCmd, argv[0]) == 0)
    {
        MessageInit(&message, MSGCODE_COAP);
    }
    else
    {
        MessageInit(&message, MSGCODE_CORP);
    }
    MessageEncode(&message, "sdd", argv[1], 1, pid);

    MESSAGE_SENDRECV();

    CHECK_RERR_OK();
}

static void CommandListSFS(char *argv[])
{
    int i;
    ServiceOutputList_t *outputs = NULL;

    outputs = GetServiceOutputs();
    if (outputs)
    {
        for (i = 0; i < outputs->nrofOutputs; i ++)
        {
            printf("%-15s : %s (%s)\n",
                outputs->outputs[i].name,
                outputs->outputs[i].destination,
                outputs->outputs[i].service[0] ? outputs->outputs[i].service:"<None>");
        }
        FreeServiceOutputs(outputs);
    }
}

static void CommandSetSF(char *argv[])
{
    AUTHENTICATE();

    MessageInit(&message, MSGCODE_CSSS);
    MessageEncode(&message, "ss", argv[1], argv[2]);

    MESSAGE_SENDRECV();

    CHECK_RERR_OK();
}

static void CommandFEStatus(char *argv[])
{
    uint8_t status = 0;
    uint32_t ber = 0;
    uint16_t snr = 0;
    uint16_t strength = 0;
    MessageInit(&message, MSGCODE_SFES);

    MESSAGE_SENDRECV();

    CHECK_EXPECTED(MSGCODE_RFES);

    MessageDecode(&message, "bldd", &status,&ber,&snr,&strength);

    printf("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, ":"");
    printf("BER = %u Signal Strength = %u SNR = %u\n", (unsigned int)ber, (unsigned int)strength, (unsigned int)snr);
}

static bool Authenticate()
{
    bool authenticated = FALSE;
    if (!username)
    {
        printlog(LOG_ERROR, "No username supplied!\n");
        return authenticated;
    }
    if (!password)
    {
        printlog(LOG_ERROR, "No password supplied!\n");
        return authenticated;
    }
    MessageInit(&message, MSGCODE_AUTH);
    MessageEncode(&message, "ss", username, password );

    MESSAGE_SENDRECV();

    if (MessageGetCode(&message) == MSGCODE_RERR)
    {
        uint8_t code = 0;
        MessageReadUint8(&message, &code);
        authenticated = (code == 0);
    }
    else
    {
        printlog(LOG_ERROR, "Unexpected response message! (type 0x%02x)\n",
                 MessageGetCode(&message) );
    }

    return authenticated;
}

static int ParsePID(char *argument)
{
    char *formatstr;
    int pid;

    if ((argument[0] == '0') && (tolower(argument[1])=='x'))
    {
        argument[1] = 'x';
        formatstr = "0x%hx";
    }
    else
    {
        formatstr = "%hd";
    }

    if (sscanf(argument, formatstr, &pid) == 0)
    {
        return -1;
    }

    return pid;
}

static ServiceOutputList_t* GetServiceOutputs()
{
    ServiceOutputList_t *result = NULL;
    uint8_t nrofOutputs = 0;
    int i;
    MessageInit(&message, MSGCODE_SSFL);

    MESSAGE_SENDRECV();

    if (MessageGetCode(&message) == MSGCODE_RERR)
    {
        uint8_t code = 0;
        char *text = NULL;
        MessageReadUint8(&message, &code);
        MessageReadString(&message, &text);
        printf("ERROR (%d) %s\n", code, text);
        free(text);
        return NULL;
    }
    else if (MessageGetCode(&message) != MSGCODE_RSSL)
    {
        printlog(LOG_ERROR, "Unexpected response message! (type 0x%02x)",
                 MessageGetCode(&message) );
        return NULL;
    }

    MessageDecode(&message, "b", &nrofOutputs);
    result = calloc(1, sizeof(ServiceOutputList_t));
    if (!result)
    {
        return result;
    }
    result->nrofOutputs = nrofOutputs & 0xff;
    result->outputs = calloc(result->nrofOutputs, sizeof(ServiceOutput_t));
    if (!result->outputs)
    {
        free(result);
        return NULL;
    }
    for (i = 0; i < result->nrofOutputs; i ++)
    {
        MessageDecode(&message, "sss",
            &result->outputs[i].name,
            &result->outputs[i].destination,
            &result->outputs[i].service);
    }
    return result;
}

static void FreeServiceOutputs(ServiceOutputList_t *list)
{
    int i;
    for (i = 0 ; i < list->nrofOutputs; i ++)
    {
        if (list->outputs[i].name)
        {
            free(list->outputs[i].name);
        }
        if (list->outputs[i].destination)
        {
            free(list->outputs[i].destination);
        }
        if (list->outputs[i].service)
        {
            free(list->outputs[i].service);
        }
    }
    free(list->outputs);
    free(list);
}

static ManualOutputList_t* GetManualOutputs()
{
    ManualOutputList_t *result = NULL;
    uint8_t nrofOutputs = 0;
    int i;
    MessageInit(&message, MSGCODE_SOLO);

    MESSAGE_SENDRECV();

    if (MessageGetCode(&message) == MSGCODE_RERR)
    {
        uint8_t code = 0;
        char *text = NULL;
        MessageReadUint8(&message, &code);
        MessageReadString(&message, &text);
        printf("ERROR (%d) %s\n", code, text);
        free(text);
        return NULL;
    }
    else if (MessageGetCode(&message) != MSGCODE_ROLO)
    {
        printlog(LOG_ERROR, "Unexpected response message! (type 0x%02x)",
                 MessageGetCode(&message) );
        return NULL;
    }

    MessageDecode(&message, "b", &nrofOutputs);

    result = calloc(1, sizeof(ManualOutputList_t));
    if (!result)
    {
        return result;
    }
    result->nrofOutputs = nrofOutputs & 0xff;
    result->outputs = calloc(result->nrofOutputs, sizeof(ManualOutput_t));
    if (!result->outputs)
    {
        free(result);
        return NULL;
    }
    for (i = 0; i < result->nrofOutputs; i ++)
    {
        MessageDecode(&message, "ss",
            &result->outputs[i].name,
            &result->outputs[i].destination);
    }
    return result;
}

static void FreeManualOutputs(ManualOutputList_t *list)
{
    int i;
    for (i = 0 ; i < list->nrofOutputs; i ++)
    {
        if (list->outputs[i].name)
        {
            free(list->outputs[i].name);
        }
        if (list->outputs[i].destination)
        {
            free(list->outputs[i].destination);
        }
    }
    free(list->outputs);
    free(list);
}