rtcptransmitter.cpp

symbian平台S60_2nd_FP2_SC rtp实现

    if (strlen(getSdesEmail()) > 0) list[i++] = rtcpSdesEmail;
    if (strlen(getSdesPhone()) > 0) list[i++] = rtcpSdesPhone;
    if (strlen(getSdesLoc ()) > 0) list[i++] = rtcpSdesLoc ;
    if (strlen(getSdesTool ()) > 0) list[i++] = rtcpSdesTool ;
    if (strlen(getSdesNote ()) > 0) list[i++] = rtcpSdesNote ;

    list[i] = rtcpSdesEnd;
    return addSDES (p, list, npadSize);
}


int RtcpTransmitter::addSDES (RtcpPacket* p, RtcpSDESType* SDESlist,
                              int npadSize)
{
    if (!tran) return -1;

    // header
    //cpLog (LOG_DEBUG_STACK, "RTCP: Making SDES packet");
    RtcpHeader* header = reinterpret_cast < RtcpHeader* > (p->freeData());
    int usage = p->allocData (sizeof(RtcpHeader));

    header->version = RTP_VERSION;
    header->padding = (npadSize > 0) ? 1 : 0;
    header->count = 1;
    header->type = rtcpTypeSDES;

    // only sends the sender's SDE

    // SDES chunk
    RtcpChunk* chunk = reinterpret_cast < RtcpChunk* > (p->freeData());
    usage += p->allocData (sizeof(RtpSrc));
    /*
    cout << "sizeof(RtcpChunk) =" << sizeof(RtcpChunk) << endl; // ?? should be 7
    */
    chunk->ssrc = htonl(tran->ssrc);

    // SDES items
    RtcpSDESItem* item = NULL;
    for (int i = 0; SDESlist[i] != rtcpSdesEnd; i++)
    {
        //cpLog (LOG_DEBUG_STACK, "RTCP:  Adding SDES %d", SDESlist[i]);
        item = reinterpret_cast < RtcpSDESItem* > (p->freeData());
        usage += p->allocData (sizeof(RtcpSDESItem) - 1);

        int len = 0;

        switch (SDESlist[i])
        {
            case rtcpSdesCname:
            strcpy(&(item->startOfText), getSdesCname());
            len = strlen(getSdesCname());
            //cpLog (LOG_DEBUG_STACK, "RTCP:  SDES Item Length: %d", len);
            //cpLog (LOG_DEBUG_STACK, "RTCP:  SDES Item Value: %s", getSdesCname());
            break;
            case rtcpSdesName:
            strcpy(&(item->startOfText), getSdesName());
            len = strlen(getSdesName());
            break;
            case rtcpSdesEmail:
            strcpy(&(item->startOfText), getSdesEmail());
            len = strlen(getSdesEmail());
            break;
            case rtcpSdesPhone:
            strcpy(&(item->startOfText), getSdesPhone());
            len = strlen(getSdesPhone());
            break;
            case rtcpSdesLoc:
            strcpy(&(item->startOfText), getSdesLoc());
            len = strlen(getSdesLoc());
            break;
            case rtcpSdesTool:
            strcpy(&(item->startOfText), getSdesTool());
            len = strlen(getSdesTool());
            break;
            case rtcpSdesNote:
            strcpy(&(item->startOfText), getSdesNote());
            len = strlen(getSdesNote());
            break;
            case rtcpSdesPriv:
            // future: not implemented
            assert (0);
            break;
            default:
            cpLog (LOG_ERR, "RtcpTransmitter:  SDES type unknown");
            assert (0);
            break;
        }
        item->type = SDESlist[i];

        // strlen removes the null that was copied
        item->length = len;
        usage += p->allocData (item->length);
    }

    // ending SDES item
    item = reinterpret_cast < RtcpSDESItem* > (p->freeData());
    usage += p->allocData (sizeof(RtcpSDESItem) - 1);
    item->type = rtcpSdesEnd;
    item->length = 0;

    // padding
    if (npadSize > 0)
    {
        // future: not implemented
        assert (0);
    }

    // end packet on 32-bit count
    if (usage % 4 != 0)
    {
        //cpLog (LOG_DEBUG_STACK, "RTCP:  SDES padded by: %d", 4-usage%4);
        usage += p->allocData (4 - usage % 4);
    }

    header->length = htons((usage / 4) - 1);
    //cpLog (LOG_DEBUG_STACK, "RTCP:  SDES packet used %d bytes/ %d words", usage, usage/4);
    return usage;
}



/* --- BYE RTCP packet --------------------------------------------- */

int RtcpTransmitter::addBYE (RtcpPacket* p, char* reason, int npadSize)
{
    if (!tran) return -1;

    RtpSrc list[1];
    list[0] = tran->getSSRC();
    return addBYE (p, list, 1, reason, npadSize);
}


int RtcpTransmitter::addBYE (RtcpPacket* p, RtpSrc* lst, int count,
                             char* reason, int npadSize)
{
    assert (count > 0);

    // header
    //cpLog (LOG_DEBUG_STACK, "RTCP: Making BYE packet");
    RtcpHeader* header = reinterpret_cast < RtcpHeader* > (p->freeData());
    int usage = p->allocData (sizeof(RtcpHeader));

    header->version = RTP_VERSION;
    header->padding = (npadSize > 0) ? 1 : 0;
    header->count = count;
    header->type = rtcpTypeBYE;

    // transmitter leaving
    RtpSrc* s = NULL;
    for (int i = 0; i < count; i++)
    {
        s = reinterpret_cast < RtpSrc* > (p->freeData());
        usage += p->allocData (sizeof(RtpSrc));
        *s = htonl(lst[i]);
        //cpLog (LOG_DEBUG_STACK, "RTCP:  SRC: %d", list[i]);
    }

    // reason - optional

    if (reason)
    {
        RtcpBye* byeReason = reinterpret_cast < RtcpBye* > (p->freeData());
        usage += p->allocData (sizeof(RtcpBye) - 1);

        byeReason->length = strlen(reason);
        strncpy (&(byeReason->startOfText), reason, byeReason->length);
        usage += p->allocData (byeReason->length);
        //cpLog (LOG_DEBUG_STACK, "RTCP:  Reason: %s", reason);
    }

    // padding

    if (npadSize > 0)
    {
        // future: not implemented
        assert (0);
    }

    // end packet on 32-bit count
    if (usage % 4 != 0)
    {
        //cpLog (LOG_DEBUG_STACK, "RTCP:  BYE padded by: %d", 4-usage%4);
        usage += p->allocData (4 - usage % 4);
    }

    header->length = htons((usage / 4) - 1);
    //cpLog (LOG_DEBUG_STACK, "RTCP:  BYE packet used %d bytes/ %d words",
    //       usage, usage/4);
    return usage;
}



/* --- APP RTCP packet --------------------------------------------- */

int RtcpTransmitter::addAPP (RtcpPacket* /*packet*/, int /*npadSize*/)
{
    // future: not implemented
    assert (0);
    return -1;
}



/* --- SDES Information -------------------------------------------- */

void RtcpTransmitter::setSdesCname ()
{
    char user[64] = "unknown_user";
    char hn[64] = "uknown_host";
    char cnameres [64 + 20 + 64];

#if 0
    uid_t uid = getuid();
    struct passwd *pw = getpwuid(uid);
    if (pw != NULL)
    {
        strncpy(user, pw->pw_name, sizeof(user));
        user[63] = (char)0;
    }
#endif  // 0
    gethostname (hn, sizeof(hn));
//???    sprintf (cnameres, "%s.%d@%s", user, getpid(), hn);

 //   assert (strlen(cnameres) < 255);
    strcpy (SDESInfo->cname, cnameres);
}


void RtcpTransmitter::setSdesName (char* text)
{
    assert (strlen(text) < 255);
    strcpy (SDESInfo->name, text);
}

void RtcpTransmitter::setSdesEmail (char* text)
{
    assert (strlen(text) < 255);
    strcpy (SDESInfo->email, text);
}

void RtcpTransmitter::setSdesPhone (char* text)
{
    assert (strlen(text) < 256);
    strcpy (SDESInfo->phone, text);
}

void RtcpTransmitter::setSdesLoc (char* text)
{
    assert (strlen(text) < 255);
    strcpy (SDESInfo->loc, text);
}

void RtcpTransmitter::setSdesTool (char* text)
{
    assert (strlen(text) < 255);
    strcpy (SDESInfo->tool, text);
}

void RtcpTransmitter::setSdesNote (char* text)
{
    assert (strlen(text) < 255);
    strcpy (SDESInfo->note, text);
}


char* RtcpTransmitter::getSdesCname ()
{
    return SDESInfo->cname;
}

char* RtcpTransmitter::getSdesName ()
{
    return SDESInfo->name;
}

char* RtcpTransmitter::getSdesEmail ()
{
    return SDESInfo->email;
}

char* RtcpTransmitter::getSdesPhone ()
{
    return SDESInfo->phone;
}

char* RtcpTransmitter::getSdesLoc ()
{
    return SDESInfo->loc;
}

char* RtcpTransmitter::getSdesTool ()
{
    return SDESInfo->tool;
}

char* RtcpTransmitter::getSdesNote ()
{
    return SDESInfo->note;
}




/* --- misc functions ---------------------------------------------- */

void RtcpTransmitter::setRTPtran (RtpTransmitter* s)
{
    if (SDESInfo == NULL)
        SDESInfo = new SDESdata;

    tran = s;
}

void RtcpTransmitter::setRTPrecv (RtpReceiver* s)
{
    recv = s;
}

void RtcpTransmitter::setRTCPrecv (RtcpReceiver* s)
{
    rtcpRecv = s;
}