rtp/src/rtcp_decoder.cpp

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/*                                                                               */
/*********************************************************************************/

/*
**   File:   rtcp_decoder.cpp
**
**   Description:
**      This module implements the RTCP_Decoder class. This class is used to encode and
**      decode RTCP_Decoder packets. Please refer to the RTCP_Decoder design document for
**      details.
*/

/*
** Includes
*/


#define DEBUG_PRINT 0
#if DEBUG_PRINT
#include <stdio.h>
#endif

#ifdef PV_OS_ZREX
//you get a compile error on zrex for the arm target
//unless these includes come first.
#include <stdlib.h>
#include <math.h>
#endif

#include "rtcp_decoder.h"
#include "rtcp_constants.h"
#include "oscl_mem.h"

/*
** Constants
*/

/*
** Methods
*/
OSCL_EXPORT_REF  RTCP_Decoder::RTCP_Decoder(const uint8 version)
        : RTCP_Base(version)
{

}

OSCL_EXPORT_REF RTCP_Decoder::~RTCP_Decoder()
{
}

OSCL_EXPORT_REF RTCP_Decoder::Error_t
RTCP_Decoder::scan_compound_packet(OsclMemoryFragment& input_packet,
                                   int32 max_array_size, int32& filled_size,
                                   RTCPPacketType *array_of_packet_types,
                                   OsclMemoryFragment *array_of_packets)
{

    uint8 *ptr = (uint8 *) input_packet.ptr;
    int32 remaining_len = input_packet.len;

    filled_size = 0;

    if (! ptr || remaining_len <= 0)
    {
        return FAIL;
    }

    OsclBinIStreamBigEndian inStream;
    inStream.Attach(ptr, remaining_len);
    uint8 tempChar;

    while (remaining_len > 0 && filled_size < max_array_size)
    {

        inStream >> tempChar;
        if (inStream.fail())
        {
            return EOS_ON_READ;
        }

        // read the type
        uint8 payloadType;
        uint16 rtcpLength;
        inStream >> payloadType;
        inStream >> rtcpLength;
        if (inStream.fail())
        {
            return EOS_ON_READ;
        }

        // store the length and type
        switch (payloadType)
        {

            case SR_PACKET_TYPE:
                array_of_packet_types[filled_size] = SR_RTCP_PACKET;
                break;

            case RR_PACKET_TYPE:
                array_of_packet_types[filled_size] = RR_RTCP_PACKET;
                break;

            case SDES_PACKET_TYPE:
                array_of_packet_types[filled_size] = SDES_RTCP_PACKET;
                break;

            case BYE_PACKET_TYPE:
                array_of_packet_types[filled_size] = BYE_RTCP_PACKET;
                break;

            case APP_PACKET_TYPE:
            {
                // figure out whether this is a PVSS type
                // ptr is at the beginning of APP packet
                uint8* test_ptr = ptr + 8;
                if (oscl_memcmp(test_ptr, PVSS_APP_RTCP_NAME, 4))
                {
                    array_of_packet_types[filled_size] = APP_RTCP_PACKET;
                }
                else
                {
                    array_of_packet_types[filled_size] = PVSS_APP_RTCP_PACKET;
                }
                break;
            }


            default:
                array_of_packet_types[filled_size] = UNKNOWN_RTCP_PACKET;
                break;
        }

        // record the ptr and length
        array_of_packets[filled_size].ptr = ptr;
        array_of_packets[filled_size++].len = (rtcpLength + 1) * 4;

        remaining_len -= (rtcpLength + 1) * 4;

        ptr += (rtcpLength + 1) * 4;
        if (rtcpLength)
        {
            inStream.seekFromCurrentPosition((rtcpLength*4));
            if (inStream.fail())
            {
                return EOS_ON_READ;
            }
        }

    } // end while loop


    return RTCP_SUCCESS;

}


// Start of new code

/*
** Description:
**      Decode a sender or receiver report block
**
** Returns: SUCCESS if successful, FAIL if not.
** Side effects: None.
*/
RTCP_Decoder::Error_t RTCP_Decoder::DecodeReportBlock(
    OsclBinIStreamBigEndian & inStream,       /* Input stream reference */
    RTCP_ReportBlock* report
)
{
    if (! report)
    {
        return FAIL;
    }

    inStream >> report->sourceSSRC;
    const uint32 SIGN_BIT_MASK = 0x800000;
    const uint32 SIGN_EXTENSION = 0xFF000000;

    uint32 tempint32;
    inStream >> tempint32;
    report->fractionLost = (uint8)(tempint32 >> FRACTION_LOST_POSITION);
    report->cumulativeNumberOfPacketsLost =  tempint32 & FRACTION_LOST_MASK;
    if (report->cumulativeNumberOfPacketsLost & SIGN_BIT_MASK)
    {
        report->cumulativeNumberOfPacketsLost |= SIGN_EXTENSION;
    }

    inStream >> report->highestSequenceNumberReceived;
    inStream >> report->interarrivalJitter;

    inStream >> report->lastSR;
    inStream >> report->delaySinceLastSR;

    if (inStream.fail())
    {
        return FAIL;
    }
    else
    {
        return RTCP_SUCCESS;
    }
}


OSCL_EXPORT_REF RTCP_Decoder::Error_t
RTCP_Decoder::DecodeRR(OsclMemoryFragment& input_packet,
                       RTCP_RR& rr_packet)
{

#if DEBUG_PRINT
    printf("Within RTCP_Decoder::DecodeRR\n");
#endif

    // attach the bin stream
    OsclBinIStreamBigEndian inStream;

    if (input_packet.ptr == NULL ||
            input_packet.len == 0)
    {
        return FAIL;
    }

    inStream.Attach(input_packet.ptr, input_packet.len);
    uint8 tempChar;

    // decode the version, report count, packet type, and length
    inStream >> tempChar;
    if (inStream.eof() || inStream.fail())
    {
        return FAIL;
    }

    uint8 rcvdVersion = tempChar >> RTPRTCP_VERSION_BIT_POSITION;
    uint8 report_count = tempChar & RECORD_COUNT_MASK;
    if (rcvdVersion != rtcpVersion)
    {
#if DEBUG_PRINT
        printf("Wrong RR RTP version\n");
#endif
        return UNSUPPORTED_RTCP_VERSION;
    }

    uint8 payloadType;
    uint16 rtcpLength;
    inStream >> payloadType;
    inStream >> rtcpLength;
    if (inStream.fail())
    {
        return FAIL;
    }

    if (payloadType != RR_PACKET_TYPE)
    {
        return RTCP_PACKET_TYPE_MISMATCH;
    }

    if (rtcpLength < (report_count*6 + 1))
    {
        return RTCP_LENGTH_MISMATCH;
    }

    // set the number of report blocks
    rr_packet.set_max_report_blocks(report_count);

    // decode the sender SSRC
    inStream >> rr_packet.senderSSRC;

    Error_t status;
    // decode each of the report blocks
    for (uint ii = 0; ii < report_count; ++ii)
    {
        if ((status = DecodeReportBlock(inStream, rr_packet.get_report_block(ii))) != RTCP_SUCCESS)
        {
            return status;
        }
    }

    return RTCP_SUCCESS;
}

/*
** Description:
**      Decode a SR (sender report) RTCP_Decoder object.
**
** Returns: SUCCESS if successful, FAIL if not.
** Side effects: None.
*/
OSCL_EXPORT_REF RTCP_Decoder::Error_t RTCP_Decoder::DecodeSR(
    const OsclMemoryFragment& input_packet,
    RTCP_SR& sr_packet)
{

#if DEBUG_PRINT
    printf("Within RTCP_Decoder::DecodeSR\n");
#endif

    // attach the bin stream
    OsclBinIStreamBigEndian inStream;

    if (input_packet.ptr == NULL ||
            input_packet.len == 0)
    {
        return FAIL;
    }

    inStream.Attach(input_packet.ptr, input_packet.len);
    uint8 tempChar;

    // decode the version, report count, packet type, and length
    inStream >> tempChar;
    if (inStream.eof() || inStream.fail())
    {
        return FAIL;
    }

    uint8 rcvdVersion = tempChar >> RTPRTCP_VERSION_BIT_POSITION;
    uint8 report_count = tempChar & RECORD_COUNT_MASK;
    if (rcvdVersion != rtcpVersion)
    {
#if DEBUG_PRINT
        printf("Wrong SR RTCP version\n");
#endif
        return UNSUPPORTED_RTCP_VERSION;
    }

    // set the max report


    uint8 payloadType;
    uint16 rtcpLength;
    inStream >> payloadType;
    inStream >> rtcpLength;
    if (inStream.fail())
    {
        return FAIL;
    }

    if (payloadType != SR_PACKET_TYPE)
    {
        return RTCP_PACKET_TYPE_MISMATCH;
    }

    if (rtcpLength < (report_count*6 + 6))
    {
        return RTCP_LENGTH_MISMATCH;
    }

    // read the sender information
    // decode the sender SSRC
    inStream >> sr_packet.senderSSRC;
    inStream >> sr_packet.NTP_timestamp_high;
    inStream >> sr_packet.NTP_timestamp_low;
    inStream >> sr_packet.RTP_timestamp;
    inStream >> sr_packet.packet_count;
    inStream >> sr_packet.octet_count;

    if (inStream.fail())
    {
        return FAIL;
    }

    // set the number of report blocks
    sr_packet.set_max_report_blocks(report_count);


    Error_t status;
    // decode each of the report blocks
    for (uint ii = 0; ii < report_count; ++ii)
    {
        if ((status = DecodeReportBlock(inStream, sr_packet.get_report_block(ii))) != RTCP_SUCCESS)
        {
            return status;
        }
    }

    return RTCP_SUCCESS;
}


/*
** Description:
**      Decode a SDES RTCP_Decoder object. The only field supported and encoded is CNAME.
**
** Returns: SUCCESS if successful, FAIL if not.
** Side effects: None.
*/
OSCL_EXPORT_REF RTCP_Decoder::Error_t
RTCP_Decoder::DecodeSDES(
    const OsclMemoryFragment& input_packet,
    RTCP_SDES& sdes_packet)
{

    // attach the bin stream
    OsclBinIStreamBigEndian inStream;

    if (input_packet.ptr == NULL ||
            input_packet.len == 0)
    {
        return FAIL;
    }

    inStream.Attach(input_packet.ptr, input_packet.len);
    uint8 tempChar;

    // decode the version, report count, packet type, and length
    inStream >> tempChar;
    if (inStream.eof() || inStream.fail())
    {
        return FAIL;
    }

    uint8 rcvdVersion = tempChar >> RTPRTCP_VERSION_BIT_POSITION;
    uint8 chunk_count = tempChar & RECORD_COUNT_MASK;
    if (rcvdVersion != rtcpVersion)
    {
#if DEBUG_PRINT
        printf("Wrong RR RTP version\n");
#endif
        return UNSUPPORTED_RTCP_VERSION;
    }

    uint8 payloadType;
    uint16 rtcpLength;
    inStream >> payloadType;
    inStream >> rtcpLength;
    if (inStream.fail())
    {
        return FAIL;
    }

    if (payloadType != SDES_PACKET_TYPE)
    {
        return RTCP_PACKET_TYPE_MISMATCH;
    }


    sdes_packet.set_max_chunks(chunk_count);

    // now decode each chunk
    SDES_chunk* chunk_ptr;
    Error_t status;
    OsclMemoryFragment chunk_frag;
    for (uint ii = 0; ii < chunk_count; ++ii)
    {
        if (!(chunk_ptr = sdes_packet.get_chunk(ii)))
        {
            return FAIL;
        }
        chunk_frag.ptr = inStream.tellg() + ((int8*)input_packet.ptr);
        chunk_frag.len = input_packet.len - inStream.tellg();
        if ((status = DecodeSDESChunk(inStream, chunk_ptr, chunk_frag)) != RTCP_SUCCESS)
        {
            return status;
        }
    }

    return RTCP_SUCCESS;

}


RTCP_Decoder::Error_t
RTCP_Decoder::DecodeSDESChunk(OsclBinIStreamBigEndian & inStream,
                              SDES_chunk* sdes_chunk,
                              OsclMemoryFragment& chunk_data)
{
    // create a temporary for up to TMP_SDES_STORAGE sdes items.
    const uint TMP_SDES_STORAGE = 10;

    if (! sdes_chunk)
    {
        return FAIL;
    }

    uint8* ptr = (uint8 *)chunk_data.ptr;
    int32 len = chunk_data.len;
    uint8* end_ptr = ptr + len;

    SDES_item tmp_sdes_items[TMP_SDES_STORAGE];


    // get the ssrc
    inStream >> sdes_chunk->ssrc;
    len -= sizeof(sdes_chunk->ssrc);
    ptr += sizeof(sdes_chunk->ssrc);

    uint num_items = 0;
    // figure out the number of sdes items
    while ((ptr <= end_ptr - 2) && (*ptr != 0))
    {
        if (num_items < TMP_SDES_STORAGE)
        {
            // store the information
            tmp_sdes_items[num_items].type = *ptr++;
            uint8 item_len = *ptr++;
            len -= 2;
            if (item_len > len)
            {
                return EOS_ON_READ;
            }
            tmp_sdes_items[num_items].content.ptr = ptr;
            tmp_sdes_items[num_items].content.len = item_len;
            ptr += item_len;
            len -= item_len;
        }
        else
        {
            // simply skip over this one and count it.
            ++ptr;
            uint8 item_len = *ptr++;
            len -= 2;
            if (item_len > len)
            {
                return EOS_ON_READ;
            }
            ptr += item_len;
            len -= item_len;
        }

        ++num_items;
    }

    if (*ptr != 0)
    {
        return EOS_ON_READ;
    }


    // set the max number of sdes items
    sdes_chunk->set_max_items(num_items);

    // record the tmp SDES items
    uint loop_limit = (num_items <= TMP_SDES_STORAGE) ? num_items : TMP_SDES_STORAGE;

    SDES_item* sdes_item_ptr;
    uint ii;
    for (ii = 0; ii < loop_limit; ++ii)
    {
        if (!(sdes_item_ptr = sdes_chunk->get_item(ii)))
        {
            return FAIL;
        }
        *sdes_item_ptr = tmp_sdes_items[ii];
    }

    // record any remaining items beyond the temp storage size
    if ((loop_limit < num_items) && (ii < TMP_SDES_STORAGE))
    {
        uint8* cp_ptr = (uint8*) tmp_sdes_items[ii].content.ptr;
        uint8 cp_len = (uint8)(tmp_sdes_items[ii].content.len & 0xFF);

        cp_ptr += cp_len;
        len = end_ptr - cp_ptr;
        ii = loop_limit;
        while ((ii < num_items) && (cp_ptr <= end_ptr - 2) && (*cp_ptr != 0))
        {
            if (!(sdes_item_ptr = sdes_chunk->get_item(ii)))
            {
                return FAIL;
            }

            sdes_item_ptr->type = *cp_ptr++;
            uint8 item_len = *cp_ptr++;
            len -= 2;
            if (item_len > len)
            {
                return EOS_ON_READ;
            }
            sdes_item_ptr->content.ptr = cp_ptr;
            sdes_item_ptr->content.len = item_len;
            cp_ptr += item_len;
            len -= item_len;
            ++ii;
        }

    }

    // now skip over the padding
    // subtract off the SSRC length (even though it is
    len = ptr  - sizeof(sdes_chunk->ssrc) - (uint8 *)chunk_data.ptr;

    int32 pad_bytes = 4 - (len & 0x3);

    // move the inStream pos ahead
    inStream.seekFromCurrentPosition(len + pad_bytes);

    if (inStream.fail())
    {
        return FAIL;
    }

    return RTCP_SUCCESS;

}


/*
** Description:
**      Decode a RTCP BYE report.
**
** Returns: SUCCESS if successful, FAIL if not.
** Side effects: None.
*/
OSCL_EXPORT_REF RTCP_Decoder::Error_t
RTCP_Decoder::DecodeBYE(const OsclMemoryFragment& input_packet,
                        RTCP_BYE& bye_packet)
{

#if DEBUG_PRINT
    printf("Within RTCP_Decoder::DecodeBYE\n");
#endif

    // attach the bin stream
    OsclBinIStreamBigEndian inStream;

    if (input_packet.ptr == NULL ||
            input_packet.len == 0)
    {
        return FAIL;
    }

    inStream.Attach(input_packet.ptr, input_packet.len);
    uint8 tempChar;

    // decode the version, report count, packet type, and length
    inStream >> tempChar;
    if (inStream.eof() || inStream.fail())
    {
        return FAIL;
    }

    uint8 rcvdVersion = tempChar >> RTPRTCP_VERSION_BIT_POSITION;
    uint8 sourceCount = tempChar & RECORD_COUNT_MASK;
    if (rcvdVersion != rtcpVersion)
    {
#if DEBUG_PRINT
        printf("Wrong SR RTCP version\n");
#endif
        return UNSUPPORTED_RTCP_VERSION;
    }

    uint8 payloadType;
    uint16 rtcpLength;
    inStream >> payloadType;
    inStream >> rtcpLength;
    if (inStream.fail())
    {
        return FAIL;
    }


    if (payloadType != BYE_PACKET_TYPE)
    {
        return RTCP_PACKET_TYPE_MISMATCH;
    }

    bye_packet.src_count = sourceCount;
    for (uint ii = 0; ii < sourceCount; ++ii)
    {
        inStream >> bye_packet.ssrc_array[ii];
        if (inStream.fail())
        {
            return FAIL;
        }
    }

    // now check the reason string
    int32 len = inStream.PositionInBlock();

    bye_packet.reason_string.ptr = 0;
    bye_packet.reason_string.len = 0;

    if (len < (rtcpLength + 1)*4)
    {
        uint8 tmplen;
        inStream >> tmplen;
        if (inStream.fail())
        {
            return FAIL;
        }

        if (tmplen + len + 1 > (rtcpLength + 1)*4)
        {
            return EOS_ON_READ;
        }

        bye_packet.reason_string.ptr = ((uint8*) input_packet.ptr) + len + 1;
        bye_packet.reason_string.len = tmplen;

    }

    return RTCP_SUCCESS;
}

/*
** Description:
**      Decode a RTCP BYE report.
**
** Returns: SUCCESS if successful, FAIL if not.
** Side effects: None.
*/
OSCL_EXPORT_REF RTCP_Decoder::Error_t RTCP_Decoder::DecodeAPP(const OsclMemoryFragment& input_packet,
        RTCP_APP& app_packet)
{

    // attach the bin stream
    OsclBinIStreamBigEndian inStream;

    if (input_packet.ptr == NULL ||
            input_packet.len == 0)
    {
        return FAIL;
    }

    inStream.Attach(input_packet.ptr, input_packet.len);
    uint8 tempChar;

    // decode the version, report count, packet type, and length
    inStream >> tempChar;
    if (inStream.eof() || inStream.fail())
    {
        return FAIL;
    }

    uint8 rcvdVersion = tempChar >> RTPRTCP_VERSION_BIT_POSITION;
    uint8 padBit = ((tempChar & (1 << RTPRTCP_PAD_FLAG_BIT_POSITION)) != 0);
    uint8 subType = tempChar & RECORD_COUNT_MASK;
    if (rcvdVersion != rtcpVersion)
    {
#if DEBUG_PRINT
        printf("Wrong SR RTCP version\n");
#endif
        return UNSUPPORTED_RTCP_VERSION;
    }

    uint8 payloadType;
    uint16 rtcpLength;
    inStream >> payloadType;
    inStream >> rtcpLength;
    if (inStream.fail())
    {
        return FAIL;
    }


    if (payloadType != APP_PACKET_TYPE)
    {
        return RTCP_PACKET_TYPE_MISMATCH;
    }

    uint8* endPtr = (uint8*)input_packet.ptr + (rtcpLength + 1) * 4;
    if (padBit)
    {
        uint8 pad_size = *(endPtr - 1);
        endPtr -= pad_size;
        // must at least be 12 characters
        if (endPtr < (uint8*)input_packet.ptr + 12)
        {
            return FAIL;
        }
    }


    inStream >> app_packet.ssrc;
    inStream.get((int8 *) app_packet.type, 4);
    if (inStream.fail())
    {
        return FAIL;
    }


    app_packet.subtype = subType;
    if (oscl_memcmp(app_packet.type, PVSS_APP_RTCP_NAME, 4))
    {
        // some other app packet -- just record the memory ptr and length
        app_packet.app_data.ptr = ((uint8*)input_packet.ptr) + inStream.tellg();
        app_packet.app_data.len = endPtr - ((uint8*)app_packet.app_data.ptr);
        return RTCP_SUCCESS;
    }


    // store the subtype in the PVSS APP data structure also.
    app_packet.pvss_app_data.subtype = subType;

    // Check SubType
    if (subType > RTCP_PVSS_APP_MAX_SUPPORTED_SUBTYPE)
    {
#if DEBUG_PRINT
        printf("Unsupported APP SubType\n");
#endif
        inStream.seekFromCurrentPosition((rtcpLength - 2)*4);
        return UNSUPPORTED_RTCP_PVSS_APP;
    }

    int32 curpos = inStream.tellg();
    inStream >> app_packet.pvss_app_data.common.sendTime;
    inStream >> app_packet.pvss_app_data.common.recvRate;
    inStream >> app_packet.pvss_app_data.common.recvRateInterval;
    inStream >> app_packet.pvss_app_data.common.playbackBufDepth;
    inStream >> app_packet.pvss_app_data.common.highestCtrlMediaSeqNum;
    inStream >> app_packet.pvss_app_data.common.cumulativeBytes;
    if (inStream.fail())
    {
        return FAIL;
    }


    switch (subType)
    {
        case 0: // DRC
            inStream >> app_packet.pvss_app_data.extraDRC.rebufCount;
            inStream >> app_packet.pvss_app_data.extraDRC.missingPackets;
            inStream >> app_packet.pvss_app_data.extraDRC.cumulativePacketsReceived;
            inStream >> app_packet.pvss_app_data.extraDRC.totalProcessedFrames;
            inStream >> app_packet.pvss_app_data.extraDRC.totalSkippedFrames;
            inStream >> app_packet.pvss_app_data.extraDRC.cumulativePacketsLost;

            break;
        case 1: // BufLow
            inStream >> app_packet.pvss_app_data.extraBufLow.depletionRateInteger;
            inStream >> app_packet.pvss_app_data.extraBufLow.depletionRateFraction;

            break;
        case 2:  // BufHigh
            inStream >> app_packet.pvss_app_data.extraBufHigh.fillRateInteger;
            inStream >> app_packet.pvss_app_data.extraBufHigh.fillRateFraction;

            break;
        default:
            break;
    }

    if (inStream.fail())
    {
        return FAIL;
    }


    int32 diff = inStream.tellg() - curpos;

    diff = (rtcpLength - 2) * 4 - diff;
    if (diff < 0)
    {
        return FAIL;
    }
    else if (diff > 0)
    {
        inStream.seekFromCurrentPosition(diff);
    }

    return RTCP_SUCCESS;
}