rtphint.c

#include "funcprotos.h"

#include "quicktime.h"


quicktime_rtp_sample_t* quicktime_get_hint_sample(u_char* hintBuf)
{
    return (quicktime_rtp_sample_t*)hintBuf;
}

quicktime_rtp_packet_entry_t* quicktime_get_hint_last_packet_entry(
    u_char* hintBuf)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);
    u_int16_t numPacketEntries = ntohs(sample->entryCount);
    u_char* bufPtr = hintBuf + sizeof(quicktime_rtp_sample_t);	
    int i;

    if (numPacketEntries == 0) {
        return NULL;
    }

    for (i = 0; i < numPacketEntries - 1; i++) {
        bufPtr += quicktime_get_packet_size(bufPtr);
    }

    return (quicktime_rtp_packet_entry_t*)bufPtr;
}

void quicktime_init_hint_sample(u_char* hintBuf, u_int* pHintBufSize)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);

    sample->entryCount = htons(0);
    sample->reserved = htons(0);

    (*pHintBufSize) = sizeof(quicktime_rtp_sample_t);
}

void quicktime_add_hint_packet(u_char* hintBuf, u_int* pHintBufSize, 
                               u_int payloadNumber, u_int rtpSeqNum)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);
    quicktime_rtp_packet_entry_t* packetEntry = 
        (quicktime_rtp_packet_entry_t*)(hintBuf + (*pHintBufSize));

    sample->entryCount = htons(ntohs(sample->entryCount) + 1);

    packetEntry->relativeXmitTime = htonl(0);
    packetEntry->headerInfo = htons(payloadNumber);
    packetEntry->seqNum = htons(rtpSeqNum);
    packetEntry->flags = htons(0);
    packetEntry->numDataEntries = htons(0);

    (*pHintBufSize) += sizeof(quicktime_rtp_packet_entry_t);
}

void quicktime_set_rtp_hint_timestamp_offset(u_char* hintBuf, 
                                             u_int* pHintBufSize, int offset)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    u_int32_t* pTlvTableSize = (u_int32_t*)
        ((u_char*)packetEntry + sizeof(quicktime_rtp_packet_entry_t));
    quicktime_rtp_tlv_entry_t* tlvEntry = (quicktime_rtp_tlv_entry_t*)
        ((u_char*)pTlvTableSize + sizeof(u_int32_t));

    /* nothing to do */
    if (offset == 0) {
        return ;
    }

    if (ntohs(packetEntry->numDataEntries)) {
#ifdef DEBUG
        printf("OOPS, have already added data to this hint packet\n");
#endif
        return ;
    }

    packetEntry->flags |= htons(1 << 2); 	/* signal presence of TLV */

    *pTlvTableSize = htonl(16);

    /* the TLV entry */
    tlvEntry->size = htonl(12);
    memcpy(tlvEntry->id, "rtpo", sizeof(tlvEntry->id));
    *((int32_t*)&tlvEntry->data) = htonl(offset);

    (*pHintBufSize) += 16;
}

void quicktime_add_hint_immed_data(u_char* hintBuf, u_int* pHintBufSize, 
                                   u_char* data, u_int length)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    quicktime_rtp_immed_data_entry_t* dataEntry = 
        (quicktime_rtp_immed_data_entry_t*)(hintBuf + (*pHintBufSize));

    dataEntry->source = 1;
    dataEntry->length = MIN(length, sizeof(dataEntry->data));
    memcpy(dataEntry->data, data, dataEntry->length);

    packetEntry->numDataEntries = htons(ntohs(packetEntry->numDataEntries) + 1);
    (*pHintBufSize) += sizeof(quicktime_rtp_immed_data_entry_t);
}

void quicktime_add_hint_sample_data(u_char* hintBuf, u_int* pHintBufSize, 
                                    u_int fromSampleNum, u_int offset, u_int length)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    quicktime_rtp_sample_data_entry_t* dataEntry = 
        (quicktime_rtp_sample_data_entry_t*)(hintBuf + (*pHintBufSize));

    dataEntry->source = 2;
    dataEntry->trackId = 0;
    dataEntry->length = htons(length);
    dataEntry->fromSampleNum = htonl(fromSampleNum);
    dataEntry->offset = htonl(offset);
    dataEntry->bytesPerCompressionBlock = htons(0);
    dataEntry->samplesPerCompressionBlock = htons(0);

    packetEntry->numDataEntries = htons(ntohs(packetEntry->numDataEntries) + 1);
    (*pHintBufSize) += sizeof(quicktime_rtp_sample_data_entry_t);
}

void quicktime_set_hint_Mbit(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    packetEntry->headerInfo |= htons(1 << 7);
}

void quicktime_set_hint_Bframe(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    packetEntry->flags |= htons(1 << 1); 
}

void quicktime_set_hint_repeat(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    packetEntry->flags |= htons(1 << 0);
}

void quicktime_set_hint_repeat_offset(u_char* hintBuf, u_int32_t offset)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        quicktime_get_hint_last_packet_entry(hintBuf);
    packetEntry->relativeXmitTime = offset;
}

int quicktime_dump_hint_sample(u_char* hintBuf)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);
    int i, numPacketEntries;
    u_char* bufPtr;

    fprintf(stdout, " entryCount %u\n", ntohs(sample->entryCount));
    fprintf(stdout, " reserved %u\n", ntohs(sample->reserved));

    /* entryCount of quicktime_rtp_packet_entry_t follow */

    numPacketEntries = ntohs(sample->entryCount);
    bufPtr = hintBuf + sizeof(quicktime_rtp_sample_t);	

    for (i = 0; i < numPacketEntries; i++) {
        fprintf(stdout, " packet %u\n", i + 1);
        bufPtr += quicktime_dump_hint_packet(bufPtr);
    }

    /* return number of bytes dumped */
    return (bufPtr - hintBuf);
}

int quicktime_dump_hint_packet(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        (quicktime_rtp_packet_entry_t*)hintBuf;
    u_char* bufPtr;
    int i;

    fprintf(stdout, "  relativeXmitTime %lu\n", ntohl(packetEntry->relativeXmitTime));
    fprintf(stdout, "  headerInfo %x\n", packetEntry->headerInfo);
    fprintf(stdout, "  seqNum %u\n", ntohs(packetEntry->seqNum));
    fprintf(stdout, "  flags %x\n", ntohs(packetEntry->flags));
    fprintf(stdout, "  numDataEntries %u\n", ntohs(packetEntry->numDataEntries));

    bufPtr = hintBuf + sizeof(quicktime_rtp_packet_entry_t);

    /* if X bit is set in flags, TLV entries exist */
    if (packetEntry->flags & htons(1 << 2)) {
        u_char* tlvTableStart = bufPtr;

        u_int32_t tlvTableSize = ntohl(*(u_int32_t*)bufPtr);
        bufPtr += sizeof(u_int32_t);

        fprintf(stdout, "  tlvTableSize %u\n", tlvTableSize);

        i = 1;
        do {
            fprintf(stdout, "  tlvEntry %u\n", i);
            bufPtr += quicktime_dump_hint_tlv(bufPtr);
            i++;
        } while (bufPtr < tlvTableStart + tlvTableSize);
    }

    /* numDataEntries of qt_rtp_data_entry follow */
    for (i = 0; i < ntohs(packetEntry->numDataEntries); i++) {
        fprintf(stdout, "  dataEntry %u\n", i + 1);
        bufPtr += quicktime_dump_hint_data(bufPtr);
    }

    /* return number of bytes dumped */
    return (bufPtr - hintBuf);
}

int quicktime_dump_hint_tlv(u_char* hintBuf)
{
    quicktime_rtp_tlv_entry_t* tlvEntry = 
        (quicktime_rtp_tlv_entry_t*)hintBuf;

    fprintf(stdout, "   id %.4s\n", tlvEntry->id);
    if (!memcmp(tlvEntry->id, "rtpo", 4)) {
        fprintf(stdout, "   offset %d\n", ntohl(*(u_int32_t*)&tlvEntry->data));
    }

    return ntohl(tlvEntry->size);
}

int quicktime_dump_hint_data(u_char* hintBuf)
{
    quicktime_rtp_data_entry_t* dataEntry = 
        (quicktime_rtp_data_entry_t*)hintBuf;

    fprintf(stdout, "   source %u\n", dataEntry->null.source);

    if (dataEntry->null.source == 1) {
        u_int i;

        fprintf(stdout, "   length %u\n", dataEntry->immed.length);
        fprintf(stdout, "   data ");
        for (i = 0; i < MIN(dataEntry->immed.length, sizeof(dataEntry->immed.data)); i++) {
            fprintf(stdout, "%x ", dataEntry->immed.data[i]);
        }
        fprintf(stdout, "\n");
    } else if (dataEntry->null.source == 2) {
        fprintf(stdout, "   trackId %u\n", dataEntry->sample.trackId);
        fprintf(stdout, "   length %u\n", ntohs(dataEntry->sample.length));
        fprintf(stdout, "   fromSampleNum %u\n", ntohl(dataEntry->sample.fromSampleNum));
        fprintf(stdout, "   offset %u\n", ntohl(dataEntry->sample.offset));
        fprintf(stdout, "   bytesPerCompressionBlock %u\n", ntohs(dataEntry->sample.bytesPerCompressionBlock));
        fprintf(stdout, "   samplesPerCompressionBlock %u\n", ntohs(dataEntry->sample.samplesPerCompressionBlock));
    } 

    /* return number of bytes dumped */
    return sizeof(quicktime_rtp_data_entry_t); 
}

int quicktime_get_hint_size(u_char* hintBuf)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);
    u_int16_t numPacketEntries = ntohs(sample->entryCount);
    u_char* bufPtr = hintBuf + sizeof(quicktime_rtp_sample_t);	
    int i;

    for (i = 0; i < numPacketEntries; i++) {
        bufPtr += quicktime_get_packet_size(bufPtr);
    }

    return (bufPtr - hintBuf);
}

int quicktime_get_packet_entry_size(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        (quicktime_rtp_packet_entry_t*)hintBuf;
    u_char* bufPtr = hintBuf + sizeof(quicktime_rtp_packet_entry_t);

    if (packetEntry->flags & htons(1 << 2)) {
        u_int32_t tlvTableSize = ntohl(*(u_int32_t*)bufPtr);
        bufPtr += tlvTableSize;
    }

    return (bufPtr - hintBuf);
}

int quicktime_get_packet_size(u_char* hintBuf)
{
    quicktime_rtp_packet_entry_t* packetEntry = 
        (quicktime_rtp_packet_entry_t*)hintBuf;
    u_int numDataEntries = ntohs(packetEntry->numDataEntries);

    return quicktime_get_packet_entry_size(hintBuf) 
        + (numDataEntries * sizeof(quicktime_rtp_data_entry_t));
}

int quicktime_get_hint_info(u_char* hintBuf, u_int hintBufSize, quicktime_hint_info_t* pHintInfo)
{
    quicktime_rtp_sample_t* sample = quicktime_get_hint_sample(hintBuf);
    u_int16_t numPacketEntries = ntohs(sample->entryCount);
    u_char* bufPtr = hintBuf + sizeof(quicktime_rtp_sample_t);	
    int i, j;

    memset(pHintInfo, 0, sizeof(quicktime_hint_info_t));

    pHintInfo->nump = numPacketEntries;

    for (i = 0; i < numPacketEntries; i++) {
        quicktime_rtp_packet_entry_t* packetEntry = 
            (quicktime_rtp_packet_entry_t*)bufPtr;
        u_int numDataEntries = ntohs(packetEntry->numDataEntries);
        u_int32_t rtpPacketLength = 0;

        pHintInfo->tmin = MIN(pHintInfo->tmin,
            (int32_t)ntohl(packetEntry->relativeXmitTime));
        pHintInfo->tmax = MAX(pHintInfo->tmax,
            (int32_t)ntohl(packetEntry->relativeXmitTime));

        bufPtr += quicktime_get_packet_entry_size(bufPtr);

        for (j = 0; j < numDataEntries; j++) {
            quicktime_rtp_data_entry_t* dataEntry =
                (quicktime_rtp_data_entry_t*)bufPtr; 
            u_int16_t dataLength = 0;

            if (dataEntry->null.source == 1) {
                /* immediate data */
                dataLength = dataEntry->immed.length;
                pHintInfo->dimm += dataLength;
            } else if (dataEntry->null.source == 2) {
                /* sample data */
                dataLength = ntohs(dataEntry->sample.length);
                pHintInfo->dmed += dataLength;
            }
            rtpPacketLength += dataLength;

            bufPtr += sizeof(quicktime_rtp_data_entry_t);
        }

        pHintInfo->trpy += RTP_HEADER_STD_SIZE + rtpPacketLength;
        pHintInfo->tpyl += rtpPacketLength;
        if (ntohs(packetEntry->flags) & 0x80) {
            /* repeated data */
            pHintInfo->drep += rtpPacketLength;
        }
        pHintInfo->pmax = MAX(pHintInfo->pmax, 
            RTP_HEADER_STD_SIZE + rtpPacketLength);
    }

    return 0;
}