/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is MPEG4IP.
 *
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
 *
 * Contributor(s):
 *      Dave Mackie     dmackie@cisco.com
 */

#include "src/impl.h"

namespace mp4v2 {
namespace impl {

///////////////////////////////////////////////////////////////////////////////

/* rtp hint track operations */

MP4RtpHintTrack::MP4RtpHintTrack(MP4File& file, MP4Atom& trakAtom)
        : MP4Track(file, trakAtom)
{
    m_pRefTrack = NULL;

    m_pRtpMapProperty = NULL;
    m_pPayloadNumberProperty = NULL;
    m_pMaxPacketSizeProperty = NULL;
    m_pSnroProperty = NULL;
    m_pTsroProperty = NULL;

    m_pReadHint = NULL;
    m_pReadHintSample = NULL;
    m_readHintSampleSize = 0;

    m_pWriteHint = NULL;
    m_writeHintId = MP4_INVALID_SAMPLE_ID;
    m_writePacketId = 0;

    m_pTrpy = NULL;
    m_pNump = NULL;
    m_pTpyl = NULL;
    m_pMaxr = NULL;
    m_pDmed = NULL;
    m_pDimm = NULL;
    m_pPmax = NULL;
    m_pDmax = NULL;

    m_pMaxPdu = NULL;
    m_pAvgPdu = NULL;
    m_pMaxBitRate = NULL;
    m_pAvgBitRate = NULL;

    m_thisSec = 0;
    m_bytesThisSec = 0;
    m_bytesThisHint = 0;
    m_bytesThisPacket = 0;
}

MP4RtpHintTrack::~MP4RtpHintTrack()
{
    delete m_pReadHint; m_pReadHint = NULL;
    MP4Free( m_pReadHintSample ); m_pReadHintSample = NULL;
    delete m_pWriteHint; m_pWriteHint = NULL;
}

void MP4RtpHintTrack::InitRefTrack()
{
    if (m_pRefTrack == NULL) {
        MP4Integer32Property* pRefTrackIdProperty = NULL;
        (void)m_trakAtom.FindProperty(
            "trak.tref.hint.entries[0].trackId",
            (MP4Property**)&pRefTrackIdProperty);
        ASSERT(pRefTrackIdProperty);

        m_pRefTrack = m_File.GetTrack(pRefTrackIdProperty->GetValue());
    }
}

void MP4RtpHintTrack::InitRtpStart()
{
    number::srandom( time::getLocalTimeMilliseconds() );

    (void)m_trakAtom.FindProperty(
        "trak.udta.hnti.rtp .snro.offset",
        (MP4Property**)&m_pSnroProperty);

    if (m_pSnroProperty) {
        m_rtpSequenceStart = m_pSnroProperty->GetValue();
    } else {
        m_rtpSequenceStart = number::random32();
    }

    (void)m_trakAtom.FindProperty(
        "trak.udta.hnti.rtp .tsro.offset",
        (MP4Property**)&m_pTsroProperty);

    if (m_pTsroProperty) {
        m_rtpTimestampStart = m_pTsroProperty->GetValue();
    } else {
        m_rtpTimestampStart = number::random32();
    }
}

void MP4RtpHintTrack::ReadHint(
    MP4SampleId hintSampleId,
    uint16_t* pNumPackets)
{
    if (m_pRefTrack == NULL) {
        InitRefTrack();
        InitRtpStart();
    }

    // dispose of any old hint
    delete m_pReadHint; m_pReadHint = NULL;
    MP4Free( m_pReadHintSample ); m_pReadHintSample = NULL;
    m_readHintSampleSize = 0;

    // read the desired hint sample into memory
    ReadSample(
        hintSampleId,
        &m_pReadHintSample,
        &m_readHintSampleSize,
        &m_readHintTimestamp);

    m_File.EnableMemoryBuffer(m_pReadHintSample, m_readHintSampleSize);

    m_pReadHint = new MP4RtpHint(*this);
    m_pReadHint->Read(m_File);

    m_File.DisableMemoryBuffer();

    if (pNumPackets) {
        *pNumPackets = GetHintNumberOfPackets();
    }
}

uint16_t MP4RtpHintTrack::GetHintNumberOfPackets()
{
    if (m_pReadHint == NULL) {
        throw new Exception("no hint has been read",
                            __FILE__, __LINE__, __FUNCTION__);
    }
    return m_pReadHint->GetNumberOfPackets();
}

bool MP4RtpHintTrack::GetPacketBFrame(uint16_t packetIndex)
{
    if (m_pReadHint == NULL) {
        throw new Exception("no hint has been read",
                            __FILE__, __LINE__, __FUNCTION__);
    }
    MP4RtpPacket* pPacket =
        m_pReadHint->GetPacket(packetIndex);

    return pPacket->IsBFrame();
}

uint16_t MP4RtpHintTrack::GetPacketTransmitOffset(uint16_t packetIndex)
{
    if (m_pReadHint == NULL) {
        throw new Exception("no hint has been read",
                            __FILE__, __LINE__, __FUNCTION__);
     }

    MP4RtpPacket* pPacket =
        m_pReadHint->GetPacket(packetIndex);

    return pPacket->GetTransmitOffset();
}

void MP4RtpHintTrack::ReadPacket(
    uint16_t packetIndex,
    uint8_t** ppBytes,
    uint32_t* pNumBytes,
    uint32_t ssrc,
    bool addHeader,
    bool addPayload)
{
    if (m_pReadHint == NULL) {
        throw new Exception("no hint has been read",
                            __FILE__, __LINE__, __FUNCTION__);
    }
    if (!addHeader && !addPayload) {
        throw new Exception("no data requested",
                             __FILE__, __LINE__, __FUNCTION__);
    }

    MP4RtpPacket* pPacket =
        m_pReadHint->GetPacket(packetIndex);

    *pNumBytes = 0;
    if (addHeader) {
        *pNumBytes += 12;
    }
    if (addPayload) {
        *pNumBytes += pPacket->GetDataSize();
    }

    // if needed, allocate the packet memory
    bool buffer_malloc = false;

    if (*ppBytes == NULL) {
        *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes);
        buffer_malloc = true;
    }

    try {
        uint8_t* pDest = *ppBytes;

        if (addHeader) {
            *pDest++ =
                0x80 | (pPacket->GetPBit() << 5) | (pPacket->GetXBit() << 4);

            *pDest++ =
                (pPacket->GetMBit() << 7) | pPacket->GetPayload();

            *((uint16_t*)pDest) =
                MP4V2_HTONS(m_rtpSequenceStart + pPacket->GetSequenceNumber());
            pDest += 2;

            *((uint32_t*)pDest) =
                MP4V2_HTONL(m_rtpTimestampStart + (uint32_t)m_readHintTimestamp);
            pDest += 4;

            *((uint32_t*)pDest) =
                MP4V2_HTONL(ssrc);
            pDest += 4;
        }

        if (addPayload) {
            pPacket->GetData(pDest);
        }
    }
    catch (Exception* x) {
        if (buffer_malloc) {
            MP4Free(*ppBytes);
            *ppBytes = NULL;
        }
        throw x;
    }

    log.hexDump(0, MP4_LOG_VERBOSE1, *ppBytes, *pNumBytes,
                "\"%s\": %u ", GetFile().GetFilename().c_str(),
                packetIndex);
}

MP4Timestamp MP4RtpHintTrack::GetRtpTimestampStart()
{
    if (m_pRefTrack == NULL) {
        InitRefTrack();
        InitRtpStart();
    }

    return m_rtpTimestampStart;
}

void MP4RtpHintTrack::SetRtpTimestampStart(MP4Timestamp start)
{
    if (!m_pTsroProperty) {
        MP4Atom* pTsroAtom =
            m_File.AddDescendantAtoms(&m_trakAtom, "udta.hnti.rtp .tsro");

        ASSERT(pTsroAtom);

        (void)pTsroAtom->FindProperty("offset",
                                      (MP4Property**)&m_pTsroProperty);

        ASSERT(m_pTsroProperty);
    }

    m_pTsroProperty->SetValue(start);
    m_rtpTimestampStart = start;
}

void MP4RtpHintTrack::InitPayload()
{
    if (m_pRtpMapProperty == NULL) {
        (void)m_trakAtom.FindProperty(
            "trak.udta.hinf.payt.rtpMap",
            (MP4Property**)&m_pRtpMapProperty);
    }

    if (m_pPayloadNumberProperty == NULL) {
        (void)m_trakAtom.FindProperty(
            "trak.udta.hinf.payt.payloadNumber",
            (MP4Property**)&m_pPayloadNumberProperty);
    }

    if (m_pMaxPacketSizeProperty == NULL) {
        (void)m_trakAtom.FindProperty(
            "trak.mdia.minf.stbl.stsd.rtp .maxPacketSize",
            (MP4Property**)&m_pMaxPacketSizeProperty);
    }
}

void MP4RtpHintTrack::GetPayload(
    char** ppPayloadName,
    uint8_t* pPayloadNumber,
    uint16_t* pMaxPayloadSize,
    char **ppEncodingParams)
{
    const char* pRtpMap;
    const char* pSlash;
    uint32_t length;
    InitPayload();

    if (ppPayloadName || ppEncodingParams) {
        if (ppPayloadName)
            *ppPayloadName = NULL;
        if (ppEncodingParams)
            *ppEncodingParams = NULL;
        if (m_pRtpMapProperty) {
            pRtpMap = m_pRtpMapProperty->GetValue();
            pSlash = strchr(pRtpMap, '/');

            if (pSlash) {
                length = pSlash - pRtpMap;
            } else {
                length = (uint32_t)strlen(pRtpMap);
            }

            if (ppPayloadName) {
                *ppPayloadName = (char*)MP4Calloc(length + 1);
                strncpy(*ppPayloadName, pRtpMap, length);
            }
            if (pSlash && ppEncodingParams) {
                pSlash++;
                pSlash = strchr(pSlash, '/');
                if (pSlash != NULL) {
                    pSlash++;
                    if (*pSlash ) {
                        length = (uint32_t)strlen(pRtpMap) - (pSlash - pRtpMap);
                        *ppEncodingParams = (char *)MP4Calloc(length + 1);
                        strncpy(*ppEncodingParams, pSlash, length);
                    }
                }
            }
        }
    }

    if (pPayloadNumber) {
        if (m_pPayloadNumberProperty) {
            *pPayloadNumber = m_pPayloadNumberProperty->GetValue();
        } else {
            *pPayloadNumber = 0;
        }
    }

    if (pMaxPayloadSize) {
        if (m_pMaxPacketSizeProperty) {
            *pMaxPayloadSize = m_pMaxPacketSizeProperty->GetValue();
        } else {
            *pMaxPayloadSize = 0;
        }
    }
}

void MP4RtpHintTrack::SetPayload(
    const char* payloadName,
    uint8_t payloadNumber,
    uint16_t maxPayloadSize,
    const char *encoding_parms,
    bool include_rtp_map,
    bool include_mpeg4_esid)
{
    InitRefTrack();
    InitPayload();

    ASSERT(m_pRtpMapProperty);
    ASSERT(m_pPayloadNumberProperty);
    ASSERT(m_pMaxPacketSizeProperty);

    size_t len = strlen(payloadName) + 16;
    if (encoding_parms != NULL) {
        size_t temp = strlen(encoding_parms);
        if (temp == 0) {
            encoding_parms = NULL;
        } else {
            len += temp;
        }
    }

    char* rtpMapBuf = (char*)MP4Malloc(len);
    snprintf(rtpMapBuf, len, "%s/%u%c%s",
             payloadName,
             GetTimeScale(),
             encoding_parms != NULL ? '/' : '\0',
             encoding_parms == NULL ? "" : encoding_parms);
    m_pRtpMapProperty->SetValue(rtpMapBuf);

    m_pPayloadNumberProperty->SetValue(payloadNumber);

    if (maxPayloadSize == 0) {
        maxPayloadSize = 1460;
    }
    m_pMaxPacketSizeProperty->SetValue(maxPayloadSize);

    // set sdp media type
    const char* sdpMediaType;
    if (!strcmp(m_pRefTrack->GetType(), MP4_AUDIO_TRACK_TYPE)) {
        sdpMediaType = "audio";
    } else if (!strcmp(m_pRefTrack->GetType(), MP4_VIDEO_TRACK_TYPE)) {
        sdpMediaType = "video";
    } else if (!strcmp(m_pRefTrack->GetType(), MP4_CNTL_TRACK_TYPE)) {
        sdpMediaType = "control";
    } else {
        sdpMediaType = "application";
    }

    uint32_t maxlen =
        (uint32_t)strlen(sdpMediaType) + (uint32_t)strlen(rtpMapBuf) + 256;
    char* sdpBuf = (char*)MP4Malloc(maxlen);
    uint32_t buflen;
    buflen = snprintf(sdpBuf, maxlen,
                      "m=%s 0 RTP/AVP %u\015\012"
                      "a=control:trackID=%u\015\012",
                      sdpMediaType, payloadNumber,
                      m_trackId);
    if (include_rtp_map) {
        buflen += snprintf(sdpBuf + buflen, maxlen - buflen,
                           "a=rtpmap:%u %s\015\012",
                           payloadNumber, rtpMapBuf);
    }
    if (include_mpeg4_esid) {
        snprintf(sdpBuf + buflen, maxlen - buflen,
                 "a=mpeg4-esid:%u\015\012",
                 m_pRefTrack->GetId());
    }

    MP4StringProperty* pSdpProperty = NULL;
    (void)m_trakAtom.FindProperty("trak.udta.hnti.sdp .sdpText",
                                    (MP4Property**)&pSdpProperty);
    ASSERT(pSdpProperty);
    pSdpProperty->SetValue(sdpBuf);

    // cleanup
    MP4Free(rtpMapBuf);
    MP4Free(sdpBuf);
}

void MP4RtpHintTrack::AddHint(bool isBFrame, uint32_t timestampOffset)
{
    // on first hint, need to lookup the reference track
    if (m_writeHintId == MP4_INVALID_SAMPLE_ID) {
        InitRefTrack();
        InitStats();
    }

    if (m_pWriteHint) {
        throw new Exception("unwritten hint is still pending", __FILE__, __LINE__, __FUNCTION__);
    }

    m_pWriteHint = new MP4RtpHint(*this);
    m_pWriteHint->SetBFrame(isBFrame);
    m_pWriteHint->SetTimestampOffset(timestampOffset);

    m_bytesThisHint = 0;
    m_writeHintId++;
}

void MP4RtpHintTrack::AddPacket(bool setMbit, int32_t transmitOffset)
{
    if (m_pWriteHint == NULL) {
        throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__);
    }

    MP4RtpPacket* pPacket = m_pWriteHint->AddPacket();

    ASSERT(m_pPayloadNumberProperty);

    pPacket->Set(
        m_pPayloadNumberProperty->GetValue(),
        m_writePacketId++,
        setMbit);
    pPacket->SetTransmitOffset(transmitOffset);

    m_bytesThisHint += 12;
    if (m_bytesThisPacket > m_pPmax->GetValue()) {
        m_pPmax->SetValue(m_bytesThisPacket);
    }
    m_bytesThisPacket = 12;
    m_pNump->IncrementValue();
    m_pTrpy->IncrementValue(12); // RTP packet header size
}

void MP4RtpHintTrack::AddImmediateData(
    const uint8_t* pBytes,
    uint32_t numBytes)
{
    if (m_pWriteHint == NULL) {
        throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
    }

    MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
    if (pPacket == NULL) {
        throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__);
    }

    if (pBytes == NULL || numBytes == 0) {
        throw new Exception("no data",
                            __FILE__, __LINE__, __FUNCTION__ );
    }
    if (numBytes > 14) {
        throw new Exception("data size is larger than 14 bytes",
                            __FILE__, __LINE__, __FUNCTION__ );
    }

    MP4RtpImmediateData* pData = new MP4RtpImmediateData(*pPacket);
    pData->Set(pBytes, numBytes);

    pPacket->AddData(pData);

    m_bytesThisHint += numBytes;
    m_bytesThisPacket += numBytes;
    m_pDimm->IncrementValue(numBytes);
    m_pTpyl->IncrementValue(numBytes);
    m_pTrpy->IncrementValue(numBytes);
}

void MP4RtpHintTrack::AddSampleData(
    MP4SampleId sampleId,
    uint32_t dataOffset,
    uint32_t dataLength)
{
    if (m_pWriteHint == NULL) {
        throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
    }

    MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
    if (pPacket == NULL) {
        throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__ );
    }

    MP4RtpSampleData* pData = new MP4RtpSampleData(*pPacket);

    pData->SetReferenceSample(sampleId, dataOffset, dataLength);

    pPacket->AddData(pData);

    m_bytesThisHint += dataLength;
    m_bytesThisPacket += dataLength;
    m_pDmed->IncrementValue(dataLength);
    m_pTpyl->IncrementValue(dataLength);
    m_pTrpy->IncrementValue(dataLength);
}

void MP4RtpHintTrack::AddESConfigurationPacket()
{
    if (m_pWriteHint == NULL) {
        throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
    }

    uint8_t* pConfig = NULL;
    uint32_t configSize = 0;

    m_File.GetTrackESConfiguration(m_pRefTrack->GetId(),
                                   &pConfig, &configSize);

    if (pConfig == NULL) {
        return;
    }

    ASSERT(m_pMaxPacketSizeProperty);

    if (configSize > m_pMaxPacketSizeProperty->GetValue()) {
        throw new Exception("ES configuration is too large for RTP payload", __FILE__, __LINE__, __FUNCTION__ );
    }

    AddPacket(false);

    MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
    ASSERT(pPacket);

    // This is ugly!
    // To get the ES configuration data somewhere known
    // we create a sample data reference that points to
    // this hint track (not the media track)
    // and this sample of the hint track
    // the offset into this sample is filled in during the write process
    MP4RtpSampleData* pData = new MP4RtpSampleData(*pPacket);

    pData->SetEmbeddedImmediate(m_writeSampleId, pConfig, configSize);

    pPacket->AddData(pData);

    m_bytesThisHint += configSize;
    m_bytesThisPacket += configSize;
    m_pTpyl->IncrementValue(configSize);
    m_pTrpy->IncrementValue(configSize);
}

void MP4RtpHintTrack::WriteHint(MP4Duration duration, bool isSyncSample)
{
    if (m_pWriteHint == NULL) {
        throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
    }

    uint8_t* pBytes;
    uint64_t numBytes;

    m_File.EnableMemoryBuffer();

    m_pWriteHint->Write(m_File);

    m_File.DisableMemoryBuffer(&pBytes, &numBytes);

    WriteSample(pBytes, numBytes, duration, 0, isSyncSample);

    MP4Free(pBytes);

    // update statistics
    if (m_bytesThisPacket > m_pPmax->GetValue()) {
        m_pPmax->SetValue(m_bytesThisPacket);
    }

    if (duration > m_pDmax->GetValue()) {
        m_pDmax->SetValue(duration);
    }

    MP4Timestamp startTime;

    GetSampleTimes(m_writeHintId, &startTime, NULL);

    if (startTime < m_thisSec + GetTimeScale()) {
        m_bytesThisSec += m_bytesThisHint;
    } else {
        if (m_bytesThisSec > m_pMaxr->GetValue()) {
            m_pMaxr->SetValue(m_bytesThisSec);
        }
        m_thisSec = startTime - (startTime % GetTimeScale());
        m_bytesThisSec = m_bytesThisHint;
    }

    // cleanup
    delete m_pWriteHint;
    m_pWriteHint = NULL;
}

void MP4RtpHintTrack::FinishWrite(uint32_t option)
{
    if (m_writeHintId != MP4_INVALID_SAMPLE_ID) {
        m_pMaxPdu->SetValue(m_pPmax->GetValue());
        if (m_pNump->GetValue()) {
            m_pAvgPdu->SetValue(m_pTrpy->GetValue() / m_pNump->GetValue());
        }

        m_pMaxBitRate->SetValue(m_pMaxr->GetValue() * 8);
        if (GetDuration()) {
            m_pAvgBitRate->SetValue(
                m_pTrpy->GetValue() * 8 * GetTimeScale() / GetDuration());
        }
    }

    MP4Track::FinishWrite();
}

void MP4RtpHintTrack::InitStats()
{
    MP4Atom* pHinfAtom = m_trakAtom.FindAtom("trak.udta.hinf");

    ASSERT(pHinfAtom);

    (void)pHinfAtom->FindProperty("hinf.trpy.bytes", (MP4Property**)&m_pTrpy);
    (void)pHinfAtom->FindProperty("hinf.nump.packets", (MP4Property**)&m_pNump);
    (void)pHinfAtom->FindProperty("hinf.tpyl.bytes", (MP4Property**)&m_pTpyl);
    (void)pHinfAtom->FindProperty("hinf.maxr.bytes", (MP4Property**)&m_pMaxr);
    (void)pHinfAtom->FindProperty("hinf.dmed.bytes", (MP4Property**)&m_pDmed);
    (void)pHinfAtom->FindProperty("hinf.dimm.bytes", (MP4Property**)&m_pDimm);
    (void)pHinfAtom->FindProperty("hinf.pmax.bytes", (MP4Property**)&m_pPmax);
    (void)pHinfAtom->FindProperty("hinf.dmax.milliSecs", (MP4Property**)&m_pDmax);

    MP4Atom* pHmhdAtom = m_trakAtom.FindAtom("trak.mdia.minf.hmhd");

    ASSERT(pHmhdAtom);

    (void)pHmhdAtom->FindProperty("hmhd.maxPduSize", (MP4Property**)&m_pMaxPdu);
    (void)pHmhdAtom->FindProperty("hmhd.avgPduSize", (MP4Property**)&m_pAvgPdu);
    (void)pHmhdAtom->FindProperty("hmhd.maxBitRate", (MP4Property**)&m_pMaxBitRate);
    (void)pHmhdAtom->FindProperty("hmhd.avgBitRate", (MP4Property**)&m_pAvgBitRate);

    MP4Integer32Property* pMaxrPeriod = NULL;
    (void)pHinfAtom->FindProperty("hinf.maxr.granularity",
                                  (MP4Property**)&pMaxrPeriod);
    if (pMaxrPeriod) {
        pMaxrPeriod->SetValue(1000);    // 1 second
    }
}


MP4RtpHint::MP4RtpHint(MP4RtpHintTrack& track)
    : m_track(track)
{
    AddProperty( /* 0 */
        new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "packetCount"));
    AddProperty( /* 1 */
        new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "reserved"));
}

MP4RtpHint::~MP4RtpHint()
{
    for (uint32_t i = 0; i < m_rtpPackets.Size(); i++) {
        delete m_rtpPackets[i];
    }
}

MP4RtpPacket* MP4RtpHint::AddPacket()
{
    MP4RtpPacket* pPacket = new MP4RtpPacket(*this);
    m_rtpPackets.Add(pPacket);

    // packetCount property
    ((MP4Integer16Property*)m_pProperties[0])->IncrementValue();

    pPacket->SetBFrame(m_isBFrame);
    pPacket->SetTimestampOffset(m_timestampOffset);

    return pPacket;
}

void MP4RtpHint::Read(MP4File& file)
{
    // call base class Read for required properties
    MP4Container::Read(file);

    uint16_t numPackets =
        ((MP4Integer16Property*)m_pProperties[0])->GetValue();

    for (uint16_t i = 0; i < numPackets; i++) {
        MP4RtpPacket* pPacket = new MP4RtpPacket(*this);

        m_rtpPackets.Add(pPacket);

        pPacket->Read(file);
    }

    if (log.verbosity >= MP4_LOG_VERBOSE1) {
        log.verbose1f("\"%s\": ReadHint:", GetTrack().GetFile().GetFilename().c_str());
        Dump(10, false);
    }
}

void MP4RtpHint::Write(MP4File& file)
{
    uint64_t hintStartPos = file.GetPosition();

    MP4Container::Write(file);

    uint64_t packetStartPos = file.GetPosition();

    uint32_t i;

    // first write out packet (and data) entries
    for (i = 0; i < m_rtpPackets.Size(); i++) {
        m_rtpPackets[i]->Write(file);
    }

    // now let packets write their extra data into the hint sample
    for (i = 0; i < m_rtpPackets.Size(); i++) {
        m_rtpPackets[i]->WriteEmbeddedData(file, hintStartPos);
    }

    uint64_t endPos = file.GetPosition();

    file.SetPosition(packetStartPos);

    // finally rewrite the packet and data entries
    // which now contain the correct offsets for the embedded data
    for (i = 0; i < m_rtpPackets.Size(); i++) {
        m_rtpPackets[i]->Write(file);
    }

    file.SetPosition(endPos);

    if (log.verbosity >= MP4_LOG_VERBOSE1) {
        log.verbose1f("\"%s\": WriteRtpHint:", GetTrack().GetFile().GetFilename().c_str());
        Dump(14, false);
    }
}

void MP4RtpHint::Dump(uint8_t indent, bool dumpImplicits)
{
    MP4Container::Dump(indent, dumpImplicits);

    for (uint32_t i = 0; i < m_rtpPackets.Size(); i++) {
        log.dump(indent, MP4_LOG_VERBOSE1,"\"%s\": RtpPacket: %u",
                 GetTrack().GetFile().GetFilename().c_str(), i);
        m_rtpPackets[i]->Dump(indent + 1, dumpImplicits);
    }
}

MP4RtpPacket::MP4RtpPacket(MP4RtpHint& hint)
    : m_hint(hint)
{
    AddProperty( /* 0 */
        new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "relativeXmitTime"));
    AddProperty( /* 1 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved1", 2));
    AddProperty( /* 2 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Pbit", 1));
    AddProperty( /* 3 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Xbit", 1));
    AddProperty( /* 4 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved2", 4));
    AddProperty( /* 5 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Mbit", 1));
    AddProperty( /* 6 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "payloadType", 7));
    AddProperty( /* 7  */
        new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "sequenceNumber"));
    AddProperty( /* 8 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved3", 13));
    AddProperty( /* 9 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "extraFlag", 1));
    AddProperty( /* 10 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "bFrameFlag", 1));
    AddProperty( /* 11 */
        new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "repeatFlag", 1));
    AddProperty( /* 12 */
        new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "entryCount"));
}

MP4RtpPacket::~MP4RtpPacket()
{
    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        delete m_rtpData[i];
    }
}

void MP4RtpPacket::AddExtraProperties()
{
    AddProperty( /* 13 */
        new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "extraInformationLength"));

    // This is a bit of a hack, since the tlv entries are really defined
    // as atoms but there is only one type defined now, rtpo, and getting
    // our atom code hooked up here would be a major pain with little gain

    AddProperty( /* 14 */
        new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "tlvLength"));
    AddProperty( /* 15 */
        new MP4StringProperty(this->GetHint().GetTrack().GetTrakAtom(), "tlvType"));
    AddProperty( /* 16 */
        new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "timestampOffset"));

    ((MP4Integer32Property*)m_pProperties[13])->SetValue(16);
    ((MP4Integer32Property*)m_pProperties[14])->SetValue(12);
    ((MP4StringProperty*)m_pProperties[15])->SetFixedLength(4);
    ((MP4StringProperty*)m_pProperties[15])->SetValue("rtpo");
}

void MP4RtpPacket::Read(MP4File& file)
{
    // call base class Read for required properties
    MP4Container::Read(file);

    // read extra info if present
    // we only support the rtpo field!
    if (((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 1) {
        ReadExtra(file);
    }

    uint16_t numDataEntries =
        ((MP4Integer16Property*)m_pProperties[12])->GetValue();

    // read data entries
    for (uint16_t i = 0; i < numDataEntries; i++) {
        uint8_t dataType;
        file.PeekBytes(&dataType, 1);

        MP4RtpData* pData;

        switch (dataType) {
        case 0:
            pData = new MP4RtpNullData(*this);
            break;
        case 1:
            pData = new MP4RtpImmediateData(*this);
            break;
        case 2:
            pData = new MP4RtpSampleData(*this);
            break;
        case 3:
            pData = new MP4RtpSampleDescriptionData(*this);
            break;
        default:
            throw new Exception("unknown packet data entry type", __FILE__, __LINE__, __FUNCTION__ );
        }

        m_rtpData.Add(pData);

        // read data entry's properties
        pData->Read(file);
    }
}

void MP4RtpPacket::ReadExtra(MP4File& file)
{
    AddExtraProperties();

    int32_t extraLength = (int32_t)file.ReadUInt32();

    if (extraLength < 4) {
        throw new Exception("bad packet extra info length", __FILE__, __LINE__, __FUNCTION__ );
    }
    extraLength -= 4;

    while (extraLength > 0) {
        uint32_t entryLength = file.ReadUInt32();
        uint32_t entryTag = file.ReadUInt32();

        if (entryLength < 8) {
            throw new Exception("bad packet extra info entry length", __FILE__, __LINE__, __FUNCTION__ );
        }

        if (entryTag == STRTOINT32("rtpo") && entryLength == 12) {
            // read the rtp timestamp offset
            m_pProperties[16]->Read(file);
        } else {
            // ignore it, LATER carry it along
            file.SetPosition(file.GetPosition() + entryLength - 8);
        }

        extraLength -= entryLength;
    }

    if (extraLength < 0) {
        throw new Exception("invalid packet extra info length", __FILE__, __LINE__, __FUNCTION__ );
    }
}

void MP4RtpPacket::Set(uint8_t payloadNumber,
                       uint32_t packetId, bool setMbit)
{
    ((MP4BitfieldProperty*)m_pProperties[5])->SetValue(setMbit);
    ((MP4BitfieldProperty*)m_pProperties[6])->SetValue(payloadNumber);
    ((MP4Integer16Property*)m_pProperties[7])->SetValue(packetId);
}

int32_t MP4RtpPacket::GetTransmitOffset()
{
    return ((MP4Integer32Property*)m_pProperties[0])->GetValue();
}

void MP4RtpPacket::SetTransmitOffset(int32_t transmitOffset)
{
    ((MP4Integer32Property*)m_pProperties[0])->SetValue(transmitOffset);
}

bool MP4RtpPacket::GetPBit()
{
    return ((MP4BitfieldProperty*)m_pProperties[2])->GetValue();
}

bool MP4RtpPacket::GetXBit()
{
    return ((MP4BitfieldProperty*)m_pProperties[3])->GetValue();
}

bool MP4RtpPacket::GetMBit()
{
    return ((MP4BitfieldProperty*)m_pProperties[5])->GetValue();
}

uint8_t MP4RtpPacket::GetPayload()
{
    return ((MP4BitfieldProperty*)m_pProperties[6])->GetValue();
}

uint16_t MP4RtpPacket::GetSequenceNumber()
{
    return ((MP4Integer16Property*)m_pProperties[7])->GetValue();
}

bool MP4RtpPacket::IsBFrame()
{
    return ((MP4BitfieldProperty*)m_pProperties[10])->GetValue();
}

void MP4RtpPacket::SetBFrame(bool isBFrame)
{
    ((MP4BitfieldProperty*)m_pProperties[10])->SetValue(isBFrame);
}

void MP4RtpPacket::SetTimestampOffset(uint32_t timestampOffset)
{
    if (timestampOffset == 0) {
        return;
    }

    ASSERT(((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 0);

    // set X bit
    ((MP4BitfieldProperty*)m_pProperties[9])->SetValue(1);

    AddExtraProperties();

    ((MP4Integer32Property*)m_pProperties[16])->SetValue(timestampOffset);
}

void MP4RtpPacket::AddData(MP4RtpData* pData)
{
    m_rtpData.Add(pData);

    // increment entry count property
    ((MP4Integer16Property*)m_pProperties[12])->IncrementValue();
}

uint32_t MP4RtpPacket::GetDataSize()
{
    uint32_t totalDataSize = 0;

    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        totalDataSize += m_rtpData[i]->GetDataSize();
    }

    return totalDataSize;
}

void MP4RtpPacket::GetData(uint8_t* pDest)
{
    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        m_rtpData[i]->GetData(pDest);
        pDest += m_rtpData[i]->GetDataSize();
    }
}

void MP4RtpPacket::Write(MP4File& file)
{
    MP4Container::Write(file);

    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        m_rtpData[i]->Write(file);
    }
}

void MP4RtpPacket::WriteEmbeddedData(MP4File& file, uint64_t startPos)
{
    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        m_rtpData[i]->WriteEmbeddedData(file, startPos);
    }
}

void MP4RtpPacket::Dump(uint8_t indent, bool dumpImplicits)
{
    MP4Container::Dump(indent, dumpImplicits);

    for (uint32_t i = 0; i < m_rtpData.Size(); i++) {
        log.dump(indent, MP4_LOG_VERBOSE1, "\"%s\": RtpData: %u",
                 GetHint().GetTrack().GetFile().GetFilename().c_str(), i);
        m_rtpData[i]->Dump(indent + 1, dumpImplicits);
    }
}

MP4RtpData::MP4RtpData(MP4RtpPacket& packet)
    : m_packet(packet)
{
    AddProperty( /* 0 */
        new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "type"));
}

MP4Track* MP4RtpData::FindTrackFromRefIndex(uint8_t refIndex)
{
    MP4Track* pTrack;

    if (refIndex == (uint8_t)-1) {
        // ourselves
        pTrack = &GetPacket().GetHint().GetTrack();
    } else if (refIndex == 0) {
        // our reference track
        pTrack = GetPacket().GetHint().GetTrack().GetRefTrack();
    } else {
        // some other track
        MP4RtpHintTrack* pHintTrack =
            &GetPacket().GetHint().GetTrack();

        MP4Atom& trakAtom = pHintTrack->GetTrakAtom();

        MP4Integer32Property* pTrackIdProperty = NULL;
        (void)trakAtom.FindProperty(
            "trak.tref.hint.entries",
            (MP4Property**)&pTrackIdProperty);
        ASSERT(pTrackIdProperty);

        uint32_t refTrackId =
            pTrackIdProperty->GetValue(refIndex - 1);

        pTrack = pHintTrack->GetFile().GetTrack(refTrackId);
    }

    return pTrack;
}

MP4RtpNullData::MP4RtpNullData(MP4RtpPacket& packet)
        : MP4RtpData(packet)
{
    ((MP4Integer8Property*)m_pProperties[0])->SetValue(0);

    AddProperty( /* 1 */
        new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "pad", 15));

    ((MP4BytesProperty*)m_pProperties[1])->SetFixedSize(15);
}

MP4RtpImmediateData::MP4RtpImmediateData(MP4RtpPacket& packet)
        : MP4RtpData(packet)
{
    ((MP4Integer8Property*)m_pProperties[0])->SetValue(1);

    AddProperty( /* 1 */
        new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "count"));
    AddProperty( /* 2 */
        new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "data", 14));

    ((MP4BytesProperty*)m_pProperties[2])->SetFixedSize(14);
}

void MP4RtpImmediateData::Set(const uint8_t* pBytes, uint8_t numBytes)
{
    ((MP4Integer8Property*)m_pProperties[1])->SetValue(numBytes);
    ((MP4BytesProperty*)m_pProperties[2])->SetValue(pBytes, numBytes);
}

uint16_t MP4RtpImmediateData::GetDataSize()
{
    return ((MP4Integer8Property*)m_pProperties[1])->GetValue();
}

void MP4RtpImmediateData::GetData(uint8_t* pDest)
{
    uint8_t* pValue;
    uint32_t valueSize;
    ((MP4BytesProperty*)m_pProperties[2])->GetValue(&pValue, &valueSize);

    memcpy(pDest, pValue, GetDataSize());
    MP4Free(pValue);
}

MP4RtpSampleData::MP4RtpSampleData(MP4RtpPacket& packet)
        : MP4RtpData(packet)
{
    ((MP4Integer8Property*)m_pProperties[0])->SetValue(2);

    AddProperty( /* 1 */
        new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex"));
    AddProperty( /* 2 */
        new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length"));
    AddProperty( /* 3 */
        new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleNumber"));
    AddProperty( /* 4 */
        new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleOffset"));
    AddProperty( /* 5 */
        new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "bytesPerBlock"));
    AddProperty( /* 6 */
        new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "samplesPerBlock"));

    ((MP4Integer16Property*)m_pProperties[5])->SetValue(1);
    ((MP4Integer16Property*)m_pProperties[6])->SetValue(1);

    m_pRefData = NULL;
    m_pRefTrack = NULL;
    m_refSampleId = MP4_INVALID_SAMPLE_ID;
    m_refSampleOffset = 0;
}

void MP4RtpSampleData::SetEmbeddedImmediate(MP4SampleId sampleId,
        uint8_t* pData, uint16_t dataLength)
{
    ((MP4Integer8Property*)m_pProperties[1])->SetValue((uint8_t)-1);
    ((MP4Integer16Property*)m_pProperties[2])->SetValue(dataLength);
    ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId);
    ((MP4Integer32Property*)m_pProperties[4])->SetValue(0);
    CHECK_AND_FREE(m_pRefData);
    m_pRefData = pData;
}

void MP4RtpSampleData::SetReferenceSample(
    MP4SampleId refSampleId, uint32_t refSampleOffset,
    uint16_t sampleLength)
{
    ((MP4Integer8Property*)m_pProperties[1])->SetValue(0);
    ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength);
    ((MP4Integer32Property*)m_pProperties[3])->SetValue(refSampleId);
    ((MP4Integer32Property*)m_pProperties[4])->SetValue(refSampleOffset);
}

void MP4RtpSampleData::SetEmbeddedSample(
    MP4SampleId sampleId, MP4Track* pRefTrack,
    MP4SampleId refSampleId, uint32_t refSampleOffset,
    uint16_t sampleLength)
{
    ((MP4Integer8Property*)m_pProperties[1])->SetValue((uint8_t)-1);
    ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength);
    ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId);
    ((MP4Integer32Property*)m_pProperties[4])->SetValue(0);
    m_pRefTrack = pRefTrack;
    m_refSampleId = refSampleId;
    m_refSampleOffset = refSampleOffset;
}

uint16_t MP4RtpSampleData::GetDataSize()
{
    return ((MP4Integer16Property*)m_pProperties[2])->GetValue();
}

void MP4RtpSampleData::GetData(uint8_t* pDest)
{
    uint8_t trackRefIndex =
        ((MP4Integer8Property*)m_pProperties[1])->GetValue();

    MP4Track* pSampleTrack =
        FindTrackFromRefIndex(trackRefIndex);

    pSampleTrack->ReadSampleFragment(
        ((MP4Integer32Property*)m_pProperties[3])->GetValue(),  // sampleId
        ((MP4Integer32Property*)m_pProperties[4])->GetValue(),  // sampleOffset
        ((MP4Integer16Property*)m_pProperties[2])->GetValue(),  // sampleLength
        pDest);
}

void MP4RtpSampleData::WriteEmbeddedData(MP4File& file, uint64_t startPos)
{
    // if not using embedded data, nothing to do
    if (((MP4Integer8Property*)m_pProperties[1])->GetValue() != (uint8_t)-1) {
        return;
    }

    // figure out the offset within this hint sample for this embedded data
    uint64_t offset = file.GetPosition() - startPos;
    ASSERT(offset <= 0xFFFFFFFF);
    ((MP4Integer32Property*)m_pProperties[4])->SetValue((uint32_t)offset);

    uint16_t length = ((MP4Integer16Property*)m_pProperties[2])->GetValue();

    if (m_pRefData) {
        file.WriteBytes(m_pRefData, length);
        return;
    }

    if (m_refSampleId != MP4_INVALID_SAMPLE_ID) {
        uint8_t* pSample = NULL;
        uint32_t sampleSize = 0;

        ASSERT(m_pRefTrack);
        m_pRefTrack->ReadSample(m_refSampleId, &pSample, &sampleSize);

        ASSERT(m_refSampleOffset + length <= sampleSize);

        file.WriteBytes(&pSample[m_refSampleOffset], length);

        MP4Free(pSample);
        return;
    }
}

MP4RtpSampleDescriptionData::MP4RtpSampleDescriptionData(MP4RtpPacket& packet)
        : MP4RtpData(packet)
{
    ((MP4Integer8Property*)m_pProperties[0])->SetValue(3);

    AddProperty( /* 1 */
        new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex"));
    AddProperty( /* 2 */
        new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length"));
    AddProperty( /* 3 */
        new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionIndex"));
    AddProperty( /* 4 */
        new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionOffset"));
    AddProperty( /* 5 */
        new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "reserved"));
}

void MP4RtpSampleDescriptionData::Set(uint32_t sampleDescrIndex,
                                      uint32_t offset, uint16_t length)
{
    ((MP4Integer16Property*)m_pProperties[2])->SetValue(length);
    ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleDescrIndex);
    ((MP4Integer32Property*)m_pProperties[4])->SetValue(offset);
}

uint16_t MP4RtpSampleDescriptionData::GetDataSize()
{
    return ((MP4Integer16Property*)m_pProperties[2])->GetValue();
}

void MP4RtpSampleDescriptionData::GetData(uint8_t* pDest)
{
    // we start with the index into our track references
    uint8_t trackRefIndex =
        ((MP4Integer8Property*)m_pProperties[1])->GetValue();

    // from which we can find the track structure
    MP4Track* pSampleTrack =
        FindTrackFromRefIndex(trackRefIndex);

    // next find the desired atom in the track's sample description table
    uint32_t sampleDescrIndex =
        ((MP4Integer32Property*)m_pProperties[3])->GetValue();

    MP4Atom& trakAtom =
        pSampleTrack->GetTrakAtom();

    char sdName[64];
    snprintf(sdName, 64, "trak.mdia.minf.stbl.stsd.*[%u]", sampleDescrIndex);

    MP4Atom* pSdAtom =
        trakAtom.FindAtom(sdName);

    // bad reference
    if (pSdAtom == NULL) {
        throw new Exception("invalid sample description index", __FILE__, __LINE__, __FUNCTION__ );
    }

    // check validity of the upcoming copy
    uint16_t length =
        ((MP4Integer16Property*)m_pProperties[2])->GetValue();
    uint32_t offset =
        ((MP4Integer32Property*)m_pProperties[4])->GetValue();

    if (offset + length > pSdAtom->GetSize()) {
        throw new Exception("offset and/or length are too large",
                            __FILE__, __LINE__, __FUNCTION__);
    }

    // now we use the raw file to get the desired bytes

    MP4File& file = GetPacket().GetHint().GetTrack().GetFile();

    uint64_t orgPos = file.GetPosition();

    // It's not entirely clear from the spec whether the offset is from
    // the start of the sample descirption atom, or the start of the atom's
    // data. I believe it is the former, but the commented out code will
    // realize the latter interpretation if I turn out to be wrong.
    uint64_t dataPos = pSdAtom->GetStart();
    //uint64_t dataPos = pSdAtom->GetEnd() - pSdAtom->GetSize();

    file.SetPosition(dataPos + offset);

    file.ReadBytes(pDest, length);

    file.SetPosition(orgPos);
}

///////////////////////////////////////////////////////////////////////////////

}
} // namespace mp4v2::impl
