/*
 * 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 - 2004.  All Rights Reserved.
 *
 * 3GPP features implementation is based on 3GPP's TS26.234-v5.60,
 * and was contributed by Ximpo Group Ltd.
 *
 * Portions created by Ximpo Group Ltd. are
 * Copyright (C) Ximpo Group Ltd. 2003, 2004.  All Rights Reserved.
 *
 * Contributor(s):
 *      Dave Mackie         dmackie@cisco.com
 *      Alix Marchandise-Franquet   alix@cisco.com
 *              Ximpo Group Ltd.                mp4v2@ximpo.com
 */

#include "src/impl.h"

namespace mp4v2 { namespace impl {

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

#define AMR_UNINITIALIZED -1
#define AMR_TRUE 0
#define AMR_FALSE 1

MP4Track::MP4Track(MP4File& file, MP4Atom& trakAtom)
    : m_File(file)
    , m_trakAtom(trakAtom)
{
    m_lastStsdIndex = 0;
    m_lastSampleFile = NULL;

    m_cachedReadSampleId = MP4_INVALID_SAMPLE_ID;
    m_pCachedReadSample = NULL;
    m_cachedReadSampleSize = 0;

    m_writeSampleId = 1;
    m_fixedSampleDuration = 0;
    m_pChunkBuffer = NULL;
    m_chunkBufferSize = 0;
    m_sizeOfDataInChunkBuffer = 0;
    m_chunkSamples = 0;
    m_chunkDuration = 0;

    // m_bytesPerSample should be set to 1, except for the
    // quicktime audio constant bit rate samples, which have non-1 values
    m_bytesPerSample = 1;
    m_samplesPerChunk = 0;
    m_durationPerChunk = 0;
    m_isAmr = AMR_UNINITIALIZED;
    m_curMode = 0;

    m_cachedSttsSid = MP4_INVALID_SAMPLE_ID;
    m_cachedCttsSid = MP4_INVALID_SAMPLE_ID;

    bool success = true;

    MP4Integer32Property* pTrackIdProperty;
    success &= m_trakAtom.FindProperty(
                   "trak.tkhd.trackId",
                   (MP4Property**)&pTrackIdProperty);
    if (success) {
        m_trackId = pTrackIdProperty->GetValue();
    }

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.mdhd.timeScale",
                   (MP4Property**)&m_pTimeScaleProperty);
    if (success) {
        // default chunking is 1 second of samples
        m_durationPerChunk = m_pTimeScaleProperty->GetValue();
    }

    success &= m_trakAtom.FindProperty(
                   "trak.tkhd.duration",
                   (MP4Property**)&m_pTrackDurationProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.mdhd.duration",
                   (MP4Property**)&m_pMediaDurationProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.tkhd.modificationTime",
                   (MP4Property**)&m_pTrackModificationProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.mdhd.modificationTime",
                   (MP4Property**)&m_pMediaModificationProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.hdlr.handlerType",
                   (MP4Property**)&m_pTypeProperty);

    // get handles on sample size information


    m_pStszFixedSampleSizeProperty = NULL;
    bool have_stsz =
        m_trakAtom.FindProperty("trak.mdia.minf.stbl.stsz.sampleSize",
                                  (MP4Property**)&m_pStszFixedSampleSizeProperty);

    if (have_stsz) {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stsz.sampleCount",
                       (MP4Property**)&m_pStszSampleCountProperty);

        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stsz.entries.entrySize",
                       (MP4Property**)&m_pStszSampleSizeProperty);
        m_stsz_sample_bits = 32;
    } else {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stz2.sampleCount",
                       (MP4Property**)&m_pStszSampleCountProperty);
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stz2.entries.entrySize",
                       (MP4Property**)&m_pStszSampleSizeProperty);
        MP4Integer8Property *stz2_field_size;
        if (m_trakAtom.FindProperty(
                    "trak.mdia.minf.stbl.stz2.fieldSize",
                    (MP4Property **)&stz2_field_size)) {
            m_stsz_sample_bits = stz2_field_size->GetValue();
            m_have_stz2_4bit_sample = false;
        } else success = false;
    }

    // get handles on information needed to map sample id's to file offsets

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stsc.entryCount",
                   (MP4Property**)&m_pStscCountProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stsc.entries.firstChunk",
                   (MP4Property**)&m_pStscFirstChunkProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stsc.entries.samplesPerChunk",
                   (MP4Property**)&m_pStscSamplesPerChunkProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stsc.entries.sampleDescriptionIndex",
                   (MP4Property**)&m_pStscSampleDescrIndexProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stsc.entries.firstSample",
                   (MP4Property**)&m_pStscFirstSampleProperty);

    bool haveStco = m_trakAtom.FindProperty(
                        "trak.mdia.minf.stbl.stco.entryCount",
                        (MP4Property**)&m_pChunkCountProperty);

    if (haveStco) {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stco.entries.chunkOffset",
                       (MP4Property**)&m_pChunkOffsetProperty);
    } else {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.co64.entryCount",
                       (MP4Property**)&m_pChunkCountProperty);

        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.co64.entries.chunkOffset",
                       (MP4Property**)&m_pChunkOffsetProperty);
    }

    // get handles on sample timing info

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stts.entryCount",
                   (MP4Property**)&m_pSttsCountProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stts.entries.sampleCount",
                   (MP4Property**)&m_pSttsSampleCountProperty);

    success &= m_trakAtom.FindProperty(
                   "trak.mdia.minf.stbl.stts.entries.sampleDelta",
                   (MP4Property**)&m_pSttsSampleDeltaProperty);

    // get handles on rendering offset info if it exists

    m_pCttsCountProperty = NULL;
    m_pCttsSampleCountProperty = NULL;
    m_pCttsSampleOffsetProperty = NULL;

    bool haveCtts = m_trakAtom.FindProperty(
                        "trak.mdia.minf.stbl.ctts.entryCount",
                        (MP4Property**)&m_pCttsCountProperty);

    if (haveCtts) {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.ctts.entries.sampleCount",
                       (MP4Property**)&m_pCttsSampleCountProperty);

        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.ctts.entries.sampleOffset",
                       (MP4Property**)&m_pCttsSampleOffsetProperty);
    }

    // get handles on sync sample info if it exists

    m_pStssCountProperty = NULL;
    m_pStssSampleProperty = NULL;

    bool haveStss = m_trakAtom.FindProperty(
                        "trak.mdia.minf.stbl.stss.entryCount",
                        (MP4Property**)&m_pStssCountProperty);

    if (haveStss) {
        success &= m_trakAtom.FindProperty(
                       "trak.mdia.minf.stbl.stss.entries.sampleNumber",
                       (MP4Property**)&m_pStssSampleProperty);
    }

    // edit list
    (void)InitEditListProperties();

    // was everything found?
    if (!success) {
        throw new Exception("invalid track", __FILE__, __LINE__, __FUNCTION__ );
    }
    CalculateBytesPerSample();

    // update sdtp log from sdtp atom
    MP4SdtpAtom* sdtp = (MP4SdtpAtom*)m_trakAtom.FindAtom( "trak.mdia.minf.stbl.sdtp" );
    if( sdtp ) {
        uint8_t* buffer;
        uint32_t bufsize;
        sdtp->data.GetValue( &buffer, &bufsize );
        m_sdtpLog.assign( (char*)buffer, bufsize );
        free( buffer );
    }
}

MP4Track::~MP4Track()
{
    MP4Free(m_pCachedReadSample);
    m_pCachedReadSample = NULL;
    MP4Free(m_pChunkBuffer);
    m_pChunkBuffer = NULL;
}

const char* MP4Track::GetType()
{
    return m_pTypeProperty->GetValue();
}

void MP4Track::SetType(const char* type)
{
    m_pTypeProperty->SetValue(MP4NormalizeTrackType(type));
}

void MP4Track::ReadSample(
    MP4SampleId   sampleId,
    uint8_t**     ppBytes,
    uint32_t*     pNumBytes,
    MP4Timestamp* pStartTime,
    MP4Duration*  pDuration,
    MP4Duration*  pRenderingOffset,
    bool*         pIsSyncSample,
    bool*         hasDependencyFlags, 
    uint32_t*     dependencyFlags )
{
    if( sampleId == MP4_INVALID_SAMPLE_ID )
        throw new Exception( "sample id can't be zero", __FILE__, __LINE__, __FUNCTION__ );

    if( hasDependencyFlags )
        *hasDependencyFlags = !m_sdtpLog.empty();

    if( dependencyFlags ) {
        if( m_sdtpLog.empty() ) {
            *dependencyFlags = 0;
        }
        else {
            if( sampleId > m_sdtpLog.size() )
                throw new Exception( "sample id > sdtp logsize", __FILE__, __LINE__, __FUNCTION__ );
            *dependencyFlags = m_sdtpLog[sampleId-1]; // sampleId is 1-based
        }
    }

    // handle unusual case of wanting to read a sample
    // that is still sitting in the write chunk buffer
    if (m_pChunkBuffer && sampleId >= m_writeSampleId - m_chunkSamples) {
        WriteChunkBuffer();
    }

    File* fin = GetSampleFile( sampleId );
    if( fin == (File*)-1 )
        throw new Exception( "sample is located in an inaccessible file", __FILE__, __LINE__, __FUNCTION__ );

    uint64_t fileOffset = GetSampleFileOffset(sampleId);

    uint32_t sampleSize = GetSampleSize(sampleId);
    if (*ppBytes != NULL && *pNumBytes < sampleSize) {
        throw new Exception("sample buffer is too small",
                            __FILE__, __LINE__, __FUNCTION__ );
    }
    *pNumBytes = sampleSize;

    log.verbose3f("\"%s\": ReadSample: track %u id %u offset 0x%" PRIx64 " size %u (0x%x)",
                  GetFile().GetFilename().c_str(), m_trackId, sampleId, fileOffset, *pNumBytes, *pNumBytes);

    bool bufferMalloc = false;
    if (*ppBytes == NULL) {
        *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes);
        bufferMalloc = true;
    }

    uint64_t oldPos = m_File.GetPosition( fin ); // only used in mode == 'w'
    try {
        m_File.SetPosition( fileOffset, fin );
        m_File.ReadBytes( *ppBytes, *pNumBytes, fin );

        if (pStartTime || pDuration) {
            GetSampleTimes(sampleId, pStartTime, pDuration);

            log.verbose3f("\"%s\": ReadSample:  start %" PRIu64 " duration %" PRId64,
                          GetFile().GetFilename().c_str(), (pStartTime ? *pStartTime : 0),
                          (pDuration ? *pDuration : 0));
        }
        if (pRenderingOffset) {
            *pRenderingOffset = GetSampleRenderingOffset(sampleId);

            log.verbose3f("\"%s\": ReadSample:  renderingOffset %" PRId64,
                          GetFile().GetFilename().c_str(), *pRenderingOffset);
        }
        if (pIsSyncSample) {
            *pIsSyncSample = IsSyncSample(sampleId);

            log.verbose3f("\"%s\": ReadSample:  isSyncSample %u",
                          GetFile().GetFilename().c_str(), *pIsSyncSample);
        }
    }

    catch (Exception* x) {
        if( bufferMalloc ) {
            MP4Free( *ppBytes );
            *ppBytes = NULL;
        }

        if( m_File.IsWriteMode() )
            m_File.SetPosition( oldPos, fin );

        throw x;
    }

    if( m_File.IsWriteMode() )
        m_File.SetPosition( oldPos, fin );
}

void MP4Track::ReadSampleFragment(
    MP4SampleId sampleId,
    uint32_t sampleOffset,
    uint16_t sampleLength,
    uint8_t* pDest)
{
    if (sampleId == MP4_INVALID_SAMPLE_ID) {
        throw new Exception("invalid sample id",
                            __FILE__, __LINE__, __FUNCTION__ );
    }

    if (sampleId != m_cachedReadSampleId) {
        MP4Free(m_pCachedReadSample);
        m_pCachedReadSample = NULL;
        m_cachedReadSampleSize = 0;
        m_cachedReadSampleId = MP4_INVALID_SAMPLE_ID;

        ReadSample(
            sampleId,
            &m_pCachedReadSample,
            &m_cachedReadSampleSize);

        m_cachedReadSampleId = sampleId;
    }

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

    memcpy(pDest, &m_pCachedReadSample[sampleOffset], sampleLength);
}

void MP4Track::WriteSample(
    const uint8_t* pBytes,
    uint32_t       numBytes,
    MP4Duration    duration,
    MP4Duration    renderingOffset,
    bool           isSyncSample )
{
    uint8_t curMode = 0;

    log.verbose3f("\"%s\": WriteSample: track %u id %u size %u (0x%x) ",
                  GetFile().GetFilename().c_str(),
                  m_trackId, m_writeSampleId, numBytes, numBytes);

    if (pBytes == NULL && numBytes > 0) {
        throw new Exception("no sample data", __FILE__, __LINE__, __FUNCTION__ );
    }

    if (m_isAmr == AMR_UNINITIALIZED ) {
        // figure out if this is an AMR audio track
        if (m_trakAtom.FindAtom("trak.mdia.minf.stbl.stsd.samr") ||
                m_trakAtom.FindAtom("trak.mdia.minf.stbl.stsd.sawb")) {
            m_isAmr = AMR_TRUE;
            m_curMode = (pBytes[0] >> 3) & 0x000F;
        } else {
            m_isAmr = AMR_FALSE;
        }
    }

    if (m_isAmr == AMR_TRUE) {
        curMode = (pBytes[0] >> 3) &0x000F; // The mode is in the first byte
    }

    if (duration == MP4_INVALID_DURATION) {
        duration = GetFixedSampleDuration();
    }

    log.verbose3f("\"%s\": duration %" PRIu64, GetFile().GetFilename().c_str(), 
                  duration);

    if ((m_isAmr == AMR_TRUE) &&
            (m_curMode != curMode)) {
        WriteChunkBuffer();
        m_curMode = curMode;
    }

    // append sample bytes to chunk buffer
    if( m_sizeOfDataInChunkBuffer + numBytes > m_chunkBufferSize ) {
        m_pChunkBuffer = (uint8_t*)MP4Realloc(m_pChunkBuffer, m_chunkBufferSize + numBytes);
        if (m_pChunkBuffer == NULL) 
            return;	
        
        m_chunkBufferSize += numBytes;
    }

    memcpy(&m_pChunkBuffer[m_sizeOfDataInChunkBuffer], pBytes, numBytes);
    m_sizeOfDataInChunkBuffer += numBytes;
    m_chunkSamples++;
    m_chunkDuration += duration;

    UpdateSampleSizes(m_writeSampleId, numBytes);

    UpdateSampleTimes(duration);

    UpdateRenderingOffsets(m_writeSampleId, renderingOffset);

    UpdateSyncSamples(m_writeSampleId, isSyncSample);

    if (IsChunkFull(m_writeSampleId)) {
        WriteChunkBuffer();
        m_curMode = curMode;
    }

    UpdateDurations(duration);

    UpdateModificationTimes();

    m_writeSampleId++;
}

void MP4Track::WriteSampleDependency(
    const uint8_t* pBytes,
    uint32_t       numBytes,
    MP4Duration    duration,
    MP4Duration    renderingOffset,
    bool           isSyncSample,
    uint32_t       dependencyFlags )
{
    m_sdtpLog.push_back( dependencyFlags ); // record dependency flags for processing at finish
    WriteSample( pBytes, numBytes, duration, renderingOffset, isSyncSample );
}

void MP4Track::WriteChunkBuffer()
{
    if (m_sizeOfDataInChunkBuffer == 0) {
        return;
    }

    uint64_t chunkOffset = m_File.GetPosition();

    // write chunk buffer
    m_File.WriteBytes(m_pChunkBuffer, m_sizeOfDataInChunkBuffer);

    log.verbose3f("\"%s\": WriteChunk: track %u offset 0x%" PRIx64 " size %u (0x%x) numSamples %u",
                  GetFile().GetFilename().c_str(), 
                  m_trackId, chunkOffset, m_sizeOfDataInChunkBuffer,
                  m_sizeOfDataInChunkBuffer, m_chunkSamples);

    UpdateSampleToChunk(m_writeSampleId,
                        m_pChunkCountProperty->GetValue() + 1,
                        m_chunkSamples);

    UpdateChunkOffsets(chunkOffset);

    // note: we do not free our chunk buffer; we reuse it, expanding as needed.
    // It gets zapped when this class goes out of scope
    m_sizeOfDataInChunkBuffer = 0;
    m_chunkSamples = 0;
    m_chunkDuration = 0;
}

void MP4Track::FinishWrite(uint32_t options)
{
    FinishSdtp();

    // write out any remaining samples in chunk buffer
    WriteChunkBuffer();

    if (m_pStszFixedSampleSizeProperty == NULL &&
            m_stsz_sample_bits == 4) {
        if (m_have_stz2_4bit_sample) {
            ((MP4Integer8Property *)m_pStszSampleSizeProperty)->AddValue(m_stz2_4bit_sample_value);
            m_pStszSampleSizeProperty->IncrementValue();
        }
    }

    // record buffer size and bitrates
    MP4BitfieldProperty* pBufferSizeProperty;

    if (m_trakAtom.FindProperty(
                "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.bufferSizeDB",
                (MP4Property**)&pBufferSizeProperty)) {
        pBufferSizeProperty->SetValue(GetMaxSampleSize());
    }

	// don't overwrite bitrate if it was requested in the Close call
    if( !(options & MP4_CLOSE_DO_NOT_COMPUTE_BITRATE)) {
        MP4Integer32Property* pBitrateProperty;

        if (m_trakAtom.FindProperty(
                    "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.maxBitrate",
                    (MP4Property**)&pBitrateProperty)) {
            pBitrateProperty->SetValue(GetMaxBitrate());
        }

        if (m_trakAtom.FindProperty(
                    "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.avgBitrate",
                    (MP4Property**)&pBitrateProperty)) {
            pBitrateProperty->SetValue(GetAvgBitrate());
        }
    }

    // cleaup trak.udta
    MP4BytesProperty* nameProperty = NULL;
    m_trakAtom.FindProperty("trak.udta.name.value", (MP4Property**) &nameProperty);
    if( nameProperty != NULL && nameProperty->GetValueSize() == 0 ){
        // Zero length name value--delete name, and then udta if no child atoms
        MP4Atom* name = m_trakAtom.FindChildAtom("udta.name");
        if( name ) {
            MP4Atom* udta = name->GetParentAtom();
            udta->DeleteChildAtom( name );
            delete name;

            if( udta->GetNumberOfChildAtoms() == 0 ) {
                udta->GetParentAtom()->DeleteChildAtom( udta );
                delete udta;
            }
        }
    }
}

// Process sdtp log and add sdtp atom.
//
// Testing (subjective) showed a marked improvement with QuickTime
// player on Mac OS X when scrubbing. Best results were obtained
// from encodings using low number of bframes. It's expected sdtp may help
// other QT-based players.
//
void MP4Track::FinishSdtp()
{
    // bail if log is empty -- indicates dependency information was not written
    if( m_sdtpLog.empty() )
        return;

    MP4SdtpAtom* sdtp = (MP4SdtpAtom*)m_trakAtom.FindAtom( "trak.mdia.minf.stbl.sdtp" );
    if( !sdtp )
        sdtp = (MP4SdtpAtom*)AddAtom( "trak.mdia.minf.stbl", "sdtp" );
    sdtp->data.SetValue( (const uint8_t*)m_sdtpLog.data(), (uint32_t)m_sdtpLog.size() );

    // add avc1 compatibility indicator if not present
    MP4FtypAtom* ftyp = (MP4FtypAtom*)m_File.FindAtom( "ftyp" );
    if( ftyp ) {
        bool found = false;
        const uint32_t max = ftyp->compatibleBrands.GetCount();
        for( uint32_t i = 0; i < max; i++ ) {
            if( !strcmp( ftyp->compatibleBrands.GetValue( i ), "avc1" )) {
                found = true;
                break;
            }
        }

        if( !found )
            ftyp->compatibleBrands.AddValue( "avc1" );
    }
}

bool MP4Track::IsChunkFull(MP4SampleId sampleId)
{
    if (m_samplesPerChunk) {
        return m_chunkSamples >= m_samplesPerChunk;
    }

    ASSERT(m_durationPerChunk);
    return m_chunkDuration >= m_durationPerChunk;
}

uint32_t MP4Track::GetNumberOfSamples()
{
    return m_pStszSampleCountProperty->GetValue();
}

uint32_t MP4Track::GetSampleSize(MP4SampleId sampleId)
{
    if (m_pStszFixedSampleSizeProperty != NULL) {
        uint32_t fixedSampleSize =
            m_pStszFixedSampleSizeProperty->GetValue();

        if (fixedSampleSize != 0) {
            return fixedSampleSize * m_bytesPerSample;
        }
    }
    // will have to check for 4 bit sample size here
    if (m_stsz_sample_bits == 4) {
        uint8_t value = m_pStszSampleSizeProperty->GetValue((sampleId - 1) / 2);
        if ((sampleId - 1) / 2 == 0) {
            value >>= 4;
        } else value &= 0xf;
        return m_bytesPerSample * value;
    }
    return m_bytesPerSample *
           m_pStszSampleSizeProperty->GetValue(sampleId - 1);
}

uint32_t MP4Track::GetMaxSampleSize()
{
    if (m_pStszFixedSampleSizeProperty != NULL) {
        uint32_t fixedSampleSize =
            m_pStszFixedSampleSizeProperty->GetValue();

        if (fixedSampleSize != 0) {
            return fixedSampleSize * m_bytesPerSample;
        }
    }

    uint32_t maxSampleSize = 0;
    uint32_t numSamples = m_pStszSampleSizeProperty->GetCount();
    for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
        uint32_t sampleSize =
            m_pStszSampleSizeProperty->GetValue(sid - 1);
        if (sampleSize > maxSampleSize) {
            maxSampleSize = sampleSize;
        }
    }
    return maxSampleSize * m_bytesPerSample;
}

uint64_t MP4Track::GetTotalOfSampleSizes()
{
    uint64_t retval;
    if (m_pStszFixedSampleSizeProperty != NULL) {
        uint32_t fixedSampleSize =
            m_pStszFixedSampleSizeProperty->GetValue();

        // if fixed sample size, just need to multiply by number of samples
        if (fixedSampleSize != 0) {
            retval = m_bytesPerSample;
            retval *= fixedSampleSize;
            retval *= GetNumberOfSamples();
            return retval;
        }
    }

    // else non-fixed sample size, sum them
    uint64_t totalSampleSizes = 0;
    uint32_t numSamples = m_pStszSampleSizeProperty->GetCount();
    for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
        uint32_t sampleSize =
            m_pStszSampleSizeProperty->GetValue(sid - 1);
        totalSampleSizes += sampleSize;
    }
    return totalSampleSizes * m_bytesPerSample;
}

void MP4Track::SampleSizePropertyAddValue (uint32_t size)
{
    // this has to deal with different sample size values
    switch (m_pStszSampleSizeProperty->GetType()) {
    case Integer32Property:
        ((MP4Integer32Property *)m_pStszSampleSizeProperty)->AddValue(size);
        break;
    case Integer16Property:
        ((MP4Integer16Property *)m_pStszSampleSizeProperty)->AddValue(size);
        break;
    case Integer8Property:
        if (m_stsz_sample_bits == 4) {
            if (m_have_stz2_4bit_sample == false) {
                m_have_stz2_4bit_sample = true;
                m_stz2_4bit_sample_value = size << 4;
                return;
            } else {
                m_have_stz2_4bit_sample = false;
                size &= 0xf;
                size |= m_stz2_4bit_sample_value;
            }
        }
        ((MP4Integer8Property *)m_pStszSampleSizeProperty)->AddValue(size);
        break;
    default:
        break;
    }


    //  m_pStszSampleSizeProperty->IncrementValue();
}

void MP4Track::UpdateSampleSizes(MP4SampleId sampleId, uint32_t numBytes)
{
    if (m_bytesPerSample > 1) {
        if ((numBytes % m_bytesPerSample) != 0) {
            // error
            log.errorf("%s: \"%s\": numBytes %u not divisible by bytesPerSample %u sampleId %u",
                       __FUNCTION__, GetFile().GetFilename().c_str(),
                       numBytes, m_bytesPerSample, sampleId);
        }
        numBytes /= m_bytesPerSample;
    }
    // for first sample
    // wmay - if we are adding, we want to make sure that
    // we don't inadvertently set up the fixed size again.
    // so, we check the number of samples
    if (sampleId == 1 && GetNumberOfSamples() == 0) {
        if (m_pStszFixedSampleSizeProperty == NULL ||
                numBytes == 0) {
            // special case of first sample is zero bytes in length
            // leave m_pStszFixedSampleSizeProperty at 0
            // start recording variable sample sizes
            if (m_pStszFixedSampleSizeProperty != NULL)
                m_pStszFixedSampleSizeProperty->SetValue(0);
            SampleSizePropertyAddValue(0);
        } else {
            // presume sample size is fixed
            m_pStszFixedSampleSizeProperty->SetValue(numBytes);
        }
    } else { // sampleId > 1

        uint32_t fixedSampleSize = 0;
        if (m_pStszFixedSampleSizeProperty != NULL) {
            fixedSampleSize = m_pStszFixedSampleSizeProperty->GetValue();
        }

        // if we don't have a fixed size, or the current sample size
        // doesn't match our sample size, we need to write the current
        // sample size into the table
        if (fixedSampleSize == 0 || numBytes != fixedSampleSize) {
            if (fixedSampleSize != 0) {
                // fixed size was set; we need to clear fixed sample size
                m_pStszFixedSampleSizeProperty->SetValue(0);

                // and create sizes for all previous samples
                // use GetNumberOfSamples due to needing the total number
                // not just the appended part of the file
                uint32_t samples = GetNumberOfSamples();
                for (MP4SampleId sid = 1; sid <= samples; sid++) {
                    SampleSizePropertyAddValue(fixedSampleSize);
                }
            }
            // add size value for this sample
            SampleSizePropertyAddValue(numBytes);
        }
    }
    // either way, we increment the number of samples.
    m_pStszSampleCountProperty->IncrementValue();
}

uint32_t MP4Track::GetAvgBitrate()
{
    if (GetDuration() == 0) {
        return 0;
    }

    double calc = double(GetTotalOfSampleSizes());
    // this is a bit better - we use the whole duration
    calc *= 8.0;
    calc *= GetTimeScale();
    calc /= double(GetDuration());
    // we might want to think about rounding to the next 100 or 1000
    return (uint32_t) ceil(calc);
}

uint32_t MP4Track::GetMaxBitrate()
{
    uint32_t timeScale = GetTimeScale();
    MP4SampleId numSamples = GetNumberOfSamples();
    uint32_t maxBytesPerSec = 0;
    uint32_t bytesThisSec = 0;
    MP4Timestamp thisSecStart = 0;
    MP4Timestamp lastSampleTime = 0;
    uint32_t lastSampleSize = 0;

    MP4SampleId thisSecStartSid = 1;
    for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
        uint32_t sampleSize;
        MP4Timestamp sampleTime;

        sampleSize = GetSampleSize(sid);
        GetSampleTimes(sid, &sampleTime, NULL);

        if (sampleTime < thisSecStart + timeScale) {
            bytesThisSec += sampleSize;
            lastSampleSize = sampleSize;
            lastSampleTime = sampleTime;
        } else {
            // we've already written the last sample and sampleSize.
            // this means that we've probably overflowed the last second
            // calculate the time we've overflowed
            MP4Duration overflow_dur =
                (thisSecStart + timeScale) - lastSampleTime;
            // calculate the duration of the last sample
            MP4Duration lastSampleDur = sampleTime - lastSampleTime;
            // now, calculate the number of bytes we overflowed.  Round up.
            if( lastSampleDur > 0 ) {
                uint32_t overflow_bytes = 0;
                overflow_bytes = ((lastSampleSize * overflow_dur) + (lastSampleDur - 1)) / lastSampleDur;

                if (bytesThisSec - overflow_bytes > maxBytesPerSec) {
                    maxBytesPerSec = bytesThisSec - overflow_bytes;
                }
            }

            // now adjust the values for this sample.  Remove the bytes
            // from the first sample in this time frame
            lastSampleTime = sampleTime;
            lastSampleSize = sampleSize;
            bytesThisSec += sampleSize;
            bytesThisSec -= GetSampleSize(thisSecStartSid);
            thisSecStartSid++;
            GetSampleTimes(thisSecStartSid, &thisSecStart, NULL);
        }
    }

    return maxBytesPerSec * 8;
}

uint32_t MP4Track::GetSampleStscIndex(MP4SampleId sampleId)
{
    uint32_t stscIndex;
    uint32_t numStscs = m_pStscCountProperty->GetValue();

    if (numStscs == 0) {
        throw new Exception("No data chunks exist", __FILE__, __LINE__, __FUNCTION__ );
    }

    for (stscIndex = 0; stscIndex < numStscs; stscIndex++) {
        if (sampleId < m_pStscFirstSampleProperty->GetValue(stscIndex)) {
            ASSERT(stscIndex != 0);
            stscIndex -= 1;
            break;
        }
    }
    if (stscIndex == numStscs) {
        ASSERT(stscIndex != 0);
        stscIndex -= 1;
    }

    return stscIndex;
}

File* MP4Track::GetSampleFile( MP4SampleId sampleId )
{
    uint32_t stscIndex = GetSampleStscIndex( sampleId );
    uint32_t stsdIndex = m_pStscSampleDescrIndexProperty->GetValue( stscIndex );

    // check if the answer will be the same as last time
    if( m_lastStsdIndex && stsdIndex == m_lastStsdIndex )
        return m_lastSampleFile;

    MP4Atom* pStsdAtom = m_trakAtom.FindAtom( "trak.mdia.minf.stbl.stsd" );
    ASSERT( pStsdAtom );

    MP4Atom* pStsdEntryAtom = pStsdAtom->GetChildAtom( stsdIndex - 1 );
    ASSERT( pStsdEntryAtom );

    MP4Integer16Property* pDrefIndexProperty = NULL;
    if( !pStsdEntryAtom->FindProperty( "*.dataReferenceIndex", (MP4Property**)&pDrefIndexProperty ) ||
        pDrefIndexProperty == NULL )
    {
        return nullptr; // Fallback to filename.
        throw new Exception( "invalid stsd entry", __FILE__, __LINE__, __FUNCTION__ );
    }

    uint32_t drefIndex = pDrefIndexProperty->GetValue();

    MP4Atom* pDrefAtom = m_trakAtom.FindAtom( "trak.mdia.minf.dinf.dref" );
    ASSERT(pDrefAtom);

    MP4Atom* pUrlAtom = pDrefAtom->GetChildAtom( drefIndex - 1 );
    ASSERT( pUrlAtom );

    File* file;

    // make sure this is actually a url atom (somtimes it's "cios", like in iTunes videos)
    if( strcmp(pUrlAtom->GetType(), "url ") ||
        pUrlAtom->GetFlags() & 1 ) {
        file = NULL; // self-contained
    }
    else {
        MP4StringProperty* pLocationProperty = NULL;
        ASSERT( pUrlAtom->FindProperty( "*.location", (MP4Property**)&pLocationProperty) );
        ASSERT( pLocationProperty );

        const char* url = pLocationProperty->GetValue();

        log.verbose3f("\"%s\": dref url = %s", GetFile().GetFilename().c_str(), 
                      url);

        file = (File*)-1;

        // attempt to open url if it's a file url
        // currently this is the only thing we understand
        if( !strncmp( url, "file:", 5 )) {
            const char* fileName = url + 5;

            if( !strncmp(fileName, "//", 2 ))
                fileName = strchr( fileName + 2, '/' );

            if( fileName ) {
                file = new File( fileName, File::MODE_READ );
                if( !file->open() ) {
                    delete file;
                    file = (File*)-1;
                }
            }
        }
    }

    if( m_lastSampleFile )
        m_lastSampleFile->close();

    // cache the answer
    m_lastStsdIndex = stsdIndex;
    m_lastSampleFile = file;

    return file;
}

uint64_t MP4Track::GetSampleFileOffset(MP4SampleId sampleId)
{
    uint32_t stscIndex =
        GetSampleStscIndex(sampleId);

    // firstChunk is the chunk index of the first chunk with
    // samplesPerChunk samples in the chunk.  There may be multiples -
    // ie: several chunks with the same number of samples per chunk.
    uint32_t firstChunk =
        m_pStscFirstChunkProperty->GetValue(stscIndex);

    MP4SampleId firstSample =
        m_pStscFirstSampleProperty->GetValue(stscIndex);

    uint32_t samplesPerChunk =
        m_pStscSamplesPerChunkProperty->GetValue(stscIndex);

    // chunkId tells which is the absolute chunk number that this sample
    // is stored in.
    MP4ChunkId chunkId = firstChunk +
                         ((sampleId - firstSample) / samplesPerChunk);

    // chunkOffset is the file offset (absolute) for the start of the chunk
    uint64_t chunkOffset = m_pChunkOffsetProperty->GetValue(chunkId - 1);

    MP4SampleId firstSampleInChunk =
        sampleId - ((sampleId - firstSample) % samplesPerChunk);

    // need cumulative samples sizes from firstSample to sampleId - 1
    uint32_t sampleOffset = 0;
    for (MP4SampleId i = firstSampleInChunk; i < sampleId; i++) {
        sampleOffset += GetSampleSize(i);
    }

    return chunkOffset + sampleOffset;
}

void MP4Track::UpdateSampleToChunk(MP4SampleId sampleId,
                                   MP4ChunkId chunkId, uint32_t samplesPerChunk)
{
    uint32_t numStsc = m_pStscCountProperty->GetValue();

    // if samplesPerChunk == samplesPerChunk of last entry
    if (numStsc && samplesPerChunk ==
            m_pStscSamplesPerChunkProperty->GetValue(numStsc-1)) {

        // nothing to do

    } else {
        // add stsc entry
        m_pStscFirstChunkProperty->AddValue(chunkId);
        m_pStscSamplesPerChunkProperty->AddValue(samplesPerChunk);
        m_pStscSampleDescrIndexProperty->AddValue(1);
        m_pStscFirstSampleProperty->AddValue(sampleId - samplesPerChunk + 1);

        m_pStscCountProperty->IncrementValue();
    }
}

void MP4Track::UpdateChunkOffsets(uint64_t chunkOffset)
{
    if (m_pChunkOffsetProperty->GetType() == Integer32Property) {
        ((MP4Integer32Property*)m_pChunkOffsetProperty)->AddValue(chunkOffset);
    } else {
        ((MP4Integer64Property*)m_pChunkOffsetProperty)->AddValue(chunkOffset);
    }
    m_pChunkCountProperty->IncrementValue();
}

MP4Duration MP4Track::GetFixedSampleDuration()
{
    uint32_t numStts = m_pSttsCountProperty->GetValue();

    if (numStts == 0) {
        return m_fixedSampleDuration;
    }
    if (numStts != 1) {
        return MP4_INVALID_DURATION;    // sample duration is not fixed
    }
    return m_pSttsSampleDeltaProperty->GetValue(0);
}

void MP4Track::SetFixedSampleDuration(MP4Duration duration)
{
    uint32_t numStts = m_pSttsCountProperty->GetValue();

    // setting this is only allowed before samples have been written
    if (numStts != 0) {
        return;
    }
    m_fixedSampleDuration = duration;
    return;
}

void MP4Track::GetSampleTimes(MP4SampleId sampleId,
                              MP4Timestamp* pStartTime, MP4Duration* pDuration)
{
    uint32_t numStts = m_pSttsCountProperty->GetValue();
    MP4SampleId sid;
    MP4Duration elapsed;


    if (m_cachedSttsSid != MP4_INVALID_SAMPLE_ID && sampleId >= m_cachedSttsSid) {
        sid   = m_cachedSttsSid;
        elapsed   = m_cachedSttsElapsed;
    } else {
        m_cachedSttsIndex = 0;
        sid   = 1;
        elapsed   = 0;
    }

    for (uint32_t sttsIndex = m_cachedSttsIndex; sttsIndex < numStts; sttsIndex++) {
        uint32_t sampleCount =
            m_pSttsSampleCountProperty->GetValue(sttsIndex);
        uint32_t sampleDelta =
            m_pSttsSampleDeltaProperty->GetValue(sttsIndex);

        if (sampleId <= sid + sampleCount - 1) {
            if (pStartTime) {
                *pStartTime = (sampleId - sid);
                *pStartTime *= sampleDelta;
                *pStartTime += elapsed;
            }
            if (pDuration) {
                *pDuration = sampleDelta;
            }

            m_cachedSttsIndex = sttsIndex;
            m_cachedSttsSid = sid;
            m_cachedSttsElapsed = elapsed;

            return;
        }
        sid += sampleCount;
        elapsed += sampleCount * sampleDelta;
    }

    throw new Exception("sample id out of range",
                        __FILE__, __LINE__, __FUNCTION__ );
}

MP4SampleId MP4Track::GetSampleIdFromTime(
    MP4Timestamp when,
    bool wantSyncSample)
{
    uint32_t numStts = m_pSttsCountProperty->GetValue();
    MP4SampleId sid = 1;
    MP4Duration elapsed = 0;

    for (uint32_t sttsIndex = 0; sttsIndex < numStts; sttsIndex++) {
        uint32_t sampleCount =
            m_pSttsSampleCountProperty->GetValue(sttsIndex);
        uint32_t sampleDelta =
            m_pSttsSampleDeltaProperty->GetValue(sttsIndex);

        if (sampleDelta == 0 && sttsIndex < numStts - 1) {
            log.warningf("%s: \"%s\": Zero sample duration, stts entry %u",
                         __FUNCTION__, GetFile().GetFilename().c_str(), sttsIndex);
        }

        MP4Duration d = when - elapsed;

        if (d <= sampleCount * sampleDelta) {
            MP4SampleId sampleId = sid;
            if (sampleDelta) {
                sampleId += (d / sampleDelta);
            }

            if (wantSyncSample) {
                return GetNextSyncSample(sampleId);
            }
            return sampleId;
        }

        sid += sampleCount;
        elapsed += sampleCount * sampleDelta;
    }

    throw new Exception("time out of range",
                        __FILE__, __LINE__, __FUNCTION__);

    return 0; // satisfy MS compiler
}

void MP4Track::UpdateSampleTimes(MP4Duration duration)
{
    uint32_t numStts = m_pSttsCountProperty->GetValue();

    // if duration == duration of last entry
    if (numStts
            && duration == m_pSttsSampleDeltaProperty->GetValue(numStts-1)) {
        // increment last entry sampleCount
        m_pSttsSampleCountProperty->IncrementValue(1, numStts-1);

    } else {
        // add stts entry, sampleCount = 1, sampleDuration = duration
        m_pSttsSampleCountProperty->AddValue(1);
        m_pSttsSampleDeltaProperty->AddValue(duration);
        m_pSttsCountProperty->IncrementValue();;
    }
}

uint32_t MP4Track::GetSampleCttsIndex(MP4SampleId sampleId,
                                      MP4SampleId* pFirstSampleId)
{
    uint32_t numCtts = m_pCttsCountProperty->GetValue();
    MP4SampleId sid;

    if (m_cachedCttsSid != MP4_INVALID_SAMPLE_ID && sampleId >= m_cachedCttsSid) {
        sid   = m_cachedCttsSid;
    } else {
        m_cachedCttsIndex = 0;
        sid = 1;
    }

    for (uint32_t cttsIndex = m_cachedCttsIndex; cttsIndex < numCtts; cttsIndex++) {
        uint32_t sampleCount =
            m_pCttsSampleCountProperty->GetValue(cttsIndex);
        
        if (sampleId <= sid + sampleCount - 1) {
            if (pFirstSampleId) {
                *pFirstSampleId = sid;
            }

            m_cachedCttsIndex = cttsIndex;
            m_cachedCttsSid = sid;

            return cttsIndex;
        }
        sid += sampleCount;
    }

    throw new Exception("sample id out of range",
                        __FILE__, __LINE__, __FUNCTION__ );
    return 0; // satisfy MS compiler
}

MP4Duration MP4Track::GetSampleRenderingOffset(MP4SampleId sampleId)
{
    if (m_pCttsCountProperty == NULL) {
        return 0;
    }
    if (m_pCttsCountProperty->GetValue() == 0) {
        return 0;
    }

    uint32_t cttsIndex = GetSampleCttsIndex(sampleId);

    return m_pCttsSampleOffsetProperty->GetValue(cttsIndex);
}

void MP4Track::UpdateRenderingOffsets(MP4SampleId sampleId,
                                      MP4Duration renderingOffset)
{
    // if ctts atom doesn't exist
    if (m_pCttsCountProperty == NULL) {

        // no rendering offset, so nothing to do
        if (renderingOffset == 0) {
            return;
        }

        // else create a ctts atom
        MP4Atom* pCttsAtom = AddAtom("trak.mdia.minf.stbl", "ctts");

        // and get handles on the properties
        ASSERT(pCttsAtom->FindProperty(
                   "ctts.entryCount",
                   (MP4Property**)&m_pCttsCountProperty));

        ASSERT(pCttsAtom->FindProperty(
                   "ctts.entries.sampleCount",
                   (MP4Property**)&m_pCttsSampleCountProperty));

        ASSERT(pCttsAtom->FindProperty(
                   "ctts.entries.sampleOffset",
                   (MP4Property**)&m_pCttsSampleOffsetProperty));

        // if this is not the first sample
        if (sampleId > 1) {
            // add a ctts entry for all previous samples
            // with rendering offset equal to zero
            m_pCttsSampleCountProperty->AddValue(sampleId - 1);
            m_pCttsSampleOffsetProperty->AddValue(0);
            m_pCttsCountProperty->IncrementValue();;
        }
    }

    // ctts atom exists (now)

    uint32_t numCtts = m_pCttsCountProperty->GetValue();

    // if renderingOffset == renderingOffset of last entry
    if (numCtts && renderingOffset
            == m_pCttsSampleOffsetProperty->GetValue(numCtts-1)) {

        // increment last entry sampleCount
        m_pCttsSampleCountProperty->IncrementValue(1, numCtts-1);

    } else {
        // add ctts entry, sampleCount = 1, sampleOffset = renderingOffset
        m_pCttsSampleCountProperty->AddValue(1);
        m_pCttsSampleOffsetProperty->AddValue(renderingOffset);
        m_pCttsCountProperty->IncrementValue();
    }
}

void MP4Track::SetSampleRenderingOffset(MP4SampleId sampleId,
                                        MP4Duration renderingOffset)
{
    // check if any ctts entries exist
    if (m_pCttsCountProperty == NULL
            || m_pCttsCountProperty->GetValue() == 0) {
        // if not then Update routine can be used
        // to create a ctts entry for samples before this one
        // and a ctts entry for this sample
        UpdateRenderingOffsets(sampleId, renderingOffset);

        // but we also need a ctts entry
        // for all samples after this one
        uint32_t afterSamples = GetNumberOfSamples() - sampleId;

        if (afterSamples) {
            m_pCttsSampleCountProperty->AddValue(afterSamples);
            m_pCttsSampleOffsetProperty->AddValue(0);
            m_pCttsCountProperty->IncrementValue();;
        }

        return;
    }

    MP4SampleId firstSampleId;
    uint32_t cttsIndex = GetSampleCttsIndex(sampleId, &firstSampleId);

    // do nothing in the degenerate case
    if (renderingOffset ==
            m_pCttsSampleOffsetProperty->GetValue(cttsIndex)) {
        return;
    }

    uint32_t sampleCount =
        m_pCttsSampleCountProperty->GetValue(cttsIndex);

    // if this sample has it's own ctts entry
    if (sampleCount == 1) {
        // then just set the value,
        // note we don't attempt to collapse entries
        m_pCttsSampleOffsetProperty->SetValue(renderingOffset, cttsIndex);
        return;
    }

    MP4SampleId lastSampleId = firstSampleId + sampleCount - 1;

    // else we share this entry with other samples
    // we need to insert our own entry
    if (sampleId == firstSampleId) {
        // our sample is the first one
        m_pCttsSampleCountProperty->
        InsertValue(1, cttsIndex);
        m_pCttsSampleOffsetProperty->
        InsertValue(renderingOffset, cttsIndex);

        m_pCttsSampleCountProperty->
        SetValue(sampleCount - 1, cttsIndex + 1);

        m_pCttsCountProperty->IncrementValue();

    } else if (sampleId == lastSampleId) {
        // our sample is the last one
        m_pCttsSampleCountProperty->
        InsertValue(1, cttsIndex + 1);
        m_pCttsSampleOffsetProperty->
        InsertValue(renderingOffset, cttsIndex + 1);

        m_pCttsSampleCountProperty->
        SetValue(sampleCount - 1, cttsIndex);

        m_pCttsCountProperty->IncrementValue();

    } else {
        // our sample is in the middle, UGH!

        // insert our new entry
        m_pCttsSampleCountProperty->
        InsertValue(1, cttsIndex + 1);
        m_pCttsSampleOffsetProperty->
        InsertValue(renderingOffset, cttsIndex + 1);

        // adjust count of previous entry
        m_pCttsSampleCountProperty->
        SetValue(sampleId - firstSampleId, cttsIndex);

        // insert new entry for those samples beyond our sample
        m_pCttsSampleCountProperty->
        InsertValue(lastSampleId - sampleId, cttsIndex + 2);
        uint32_t oldRenderingOffset =
            m_pCttsSampleOffsetProperty->GetValue(cttsIndex);
        m_pCttsSampleOffsetProperty->
        InsertValue(oldRenderingOffset, cttsIndex + 2);

        m_pCttsCountProperty->IncrementValue(2);
    }
}

bool MP4Track::IsSyncSample(MP4SampleId sampleId)
{
    if (m_pStssCountProperty == NULL) {
        return true;
    }

    uint32_t numStss = m_pStssCountProperty->GetValue();
    uint32_t stssLIndex = 0;
    uint32_t stssRIndex = numStss - 1;

    while (stssRIndex >= stssLIndex) {
        uint32_t stssIndex = (stssRIndex + stssLIndex) >> 1;
        MP4SampleId syncSampleId =
            m_pStssSampleProperty->GetValue(stssIndex);

        if (sampleId == syncSampleId) {
            return true;
        }

        if (sampleId > syncSampleId) {
            stssLIndex = stssIndex + 1;
        } else {
            stssRIndex = stssIndex - 1;
        }
    }

    return false;
}

// N.B. "next" is inclusive of this sample id
MP4SampleId MP4Track::GetNextSyncSample(MP4SampleId sampleId)
{
    if (m_pStssCountProperty == NULL) {
        return sampleId;
    }

    uint32_t numStss = m_pStssCountProperty->GetValue();

    for (uint32_t stssIndex = 0; stssIndex < numStss; stssIndex++) {
        MP4SampleId syncSampleId =
            m_pStssSampleProperty->GetValue(stssIndex);

        if (sampleId > syncSampleId) {
            continue;
        }
        return syncSampleId;
    }

    // LATER check stsh for alternate sample

    return MP4_INVALID_SAMPLE_ID;
}

void MP4Track::UpdateSyncSamples(MP4SampleId sampleId, bool isSyncSample)
{
    if (isSyncSample) {
        // if stss atom exists, add entry
        if (m_pStssCountProperty) {
            m_pStssSampleProperty->AddValue(sampleId);
            m_pStssCountProperty->IncrementValue();
        } // else nothing to do (yet)

    } else { // !isSyncSample
        // if stss atom doesn't exist, create one
        if (m_pStssCountProperty == NULL) {

            MP4Atom* pStssAtom = AddAtom("trak.mdia.minf.stbl", "stss");

            ASSERT(pStssAtom->FindProperty(
                       "stss.entryCount",
                       (MP4Property**)&m_pStssCountProperty));

            ASSERT(pStssAtom->FindProperty(
                       "stss.entries.sampleNumber",
                       (MP4Property**)&m_pStssSampleProperty));

            // set values for all samples that came before this one
            uint32_t samples = GetNumberOfSamples();
            for (MP4SampleId sid = 1; sid < samples; sid++) {
                m_pStssSampleProperty->AddValue(sid);
                m_pStssCountProperty->IncrementValue();
            }
        } // else nothing to do
    }
}

MP4Atom* MP4Track::AddAtom(const char* parentName, const char* childName)
{
    MP4Atom* pParentAtom = m_trakAtom.FindAtom(parentName);
    ASSERT(pParentAtom);

    MP4Atom* pChildAtom = MP4Atom::CreateAtom(m_File, pParentAtom, childName);

    pParentAtom->AddChildAtom(pChildAtom);

    pChildAtom->Generate();

    return pChildAtom;
}

uint64_t MP4Track::GetDuration()
{
    return m_pMediaDurationProperty->GetValue();
}

uint32_t MP4Track::GetTimeScale()
{
    return m_pTimeScaleProperty->GetValue();
}

void MP4Track::UpdateDurations(MP4Duration duration)
{
    // update media, track, and movie durations
    m_pMediaDurationProperty->SetValue(
        m_pMediaDurationProperty->GetValue() + duration);

    MP4Duration movieDuration = ToMovieDuration(
        m_pMediaDurationProperty->GetValue());
    m_pTrackDurationProperty->SetValue(movieDuration);

    m_File.UpdateDuration(m_pTrackDurationProperty->GetValue());
}

MP4Duration MP4Track::ToMovieDuration(MP4Duration trackDuration)
{
    return (trackDuration * m_File.GetTimeScale())
           / m_pTimeScaleProperty->GetValue();
}

void MP4Track::UpdateModificationTimes()
{
    // update media and track modification times
    MP4Timestamp now = MP4GetAbsTimestamp();
    m_pMediaModificationProperty->SetValue(now);
    m_pTrackModificationProperty->SetValue(now);
}

uint32_t MP4Track::GetNumberOfChunks()
{
    return m_pChunkOffsetProperty->GetCount();
}

uint32_t MP4Track::GetChunkStscIndex(MP4ChunkId chunkId)
{
    uint32_t stscIndex;
    uint32_t numStscs = m_pStscCountProperty->GetValue();

    ASSERT(chunkId);
    ASSERT(numStscs > 0);

    for (stscIndex = 0; stscIndex < numStscs; stscIndex++) {
        if (chunkId < m_pStscFirstChunkProperty->GetValue(stscIndex)) {
            ASSERT(stscIndex != 0);
            break;
        }
    }
    return stscIndex - 1;
}

MP4Timestamp MP4Track::GetChunkTime(MP4ChunkId chunkId)
{
    uint32_t stscIndex = GetChunkStscIndex(chunkId);

    MP4ChunkId firstChunkId =
        m_pStscFirstChunkProperty->GetValue(stscIndex);

    MP4SampleId firstSample =
        m_pStscFirstSampleProperty->GetValue(stscIndex);

    uint32_t samplesPerChunk =
        m_pStscSamplesPerChunkProperty->GetValue(stscIndex);

    MP4SampleId firstSampleInChunk =
        firstSample + ((chunkId - firstChunkId) * samplesPerChunk);

    MP4Timestamp chunkTime;

    GetSampleTimes(firstSampleInChunk, &chunkTime, NULL);

    return chunkTime;
}

uint32_t MP4Track::GetChunkSize(MP4ChunkId chunkId)
{
    uint32_t stscIndex = GetChunkStscIndex(chunkId);

    MP4ChunkId firstChunkId =
        m_pStscFirstChunkProperty->GetValue(stscIndex);

    MP4SampleId firstSample =
        m_pStscFirstSampleProperty->GetValue(stscIndex);

    uint32_t samplesPerChunk =
        m_pStscSamplesPerChunkProperty->GetValue(stscIndex);

    MP4SampleId firstSampleInChunk =
        firstSample + ((chunkId - firstChunkId) * samplesPerChunk);

    // need cumulative sizes of samples in chunk
    uint32_t chunkSize = 0;
    for (uint32_t i = 0; i < samplesPerChunk; i++) {
        chunkSize += GetSampleSize(firstSampleInChunk + i);
    }

    return chunkSize;
}

void MP4Track::ReadChunk(MP4ChunkId chunkId,
                         uint8_t** ppChunk, uint32_t* pChunkSize)
{
    ASSERT(chunkId);
    ASSERT(ppChunk);
    ASSERT(pChunkSize);

    uint64_t chunkOffset =
        m_pChunkOffsetProperty->GetValue(chunkId - 1);

    *pChunkSize = GetChunkSize(chunkId);
    *ppChunk = (uint8_t*)MP4Malloc(*pChunkSize);

    log.verbose3f("\"%s\": ReadChunk: track %u id %u offset 0x%" PRIx64 " size %u (0x%x)",
                  GetFile().GetFilename().c_str(),
                  m_trackId, chunkId, chunkOffset, *pChunkSize, *pChunkSize);

    uint64_t oldPos = m_File.GetPosition(); // only used in mode == 'w'
    try {
        m_File.SetPosition( chunkOffset );
        m_File.ReadBytes( *ppChunk, *pChunkSize );
    }
    catch( Exception* x ) {
        MP4Free( *ppChunk );
        *ppChunk = NULL;

        if( m_File.IsWriteMode() )
            m_File.SetPosition( oldPos );

        throw x;
    }

    if( m_File.IsWriteMode() )
        m_File.SetPosition( oldPos );
}

void MP4Track::RewriteChunk(MP4ChunkId chunkId,
                            uint8_t* pChunk, uint32_t chunkSize)
{
    uint64_t chunkOffset = m_File.GetPosition();

    m_File.WriteBytes(pChunk, chunkSize);

    m_pChunkOffsetProperty->SetValue(chunkOffset, chunkId - 1);

    log.verbose3f("\"%s\": RewriteChunk: track %u id %u offset 0x%" PRIx64 " size %u (0x%x)",
                  GetFile().GetFilename().c_str(),
                  m_trackId, chunkId, chunkOffset, chunkSize, chunkSize);
}

// map track type name aliases to official names


bool MP4Track::InitEditListProperties()
{
    m_pElstCountProperty = NULL;
    m_pElstMediaTimeProperty = NULL;
    m_pElstDurationProperty = NULL;
    m_pElstRateProperty = NULL;
    m_pElstReservedProperty = NULL;

    MP4Atom* pElstAtom =
        m_trakAtom.FindAtom("trak.edts.elst");

    if (!pElstAtom) {
        return false;
    }

    (void)pElstAtom->FindProperty(
        "elst.entryCount",
        (MP4Property**)&m_pElstCountProperty);
    (void)pElstAtom->FindProperty(
        "elst.entries.mediaTime",
        (MP4Property**)&m_pElstMediaTimeProperty);
    (void)pElstAtom->FindProperty(
        "elst.entries.segmentDuration",
        (MP4Property**)&m_pElstDurationProperty);
    (void)pElstAtom->FindProperty(
        "elst.entries.mediaRate",
        (MP4Property**)&m_pElstRateProperty);

    (void)pElstAtom->FindProperty(
        "elst.entries.reserved",
        (MP4Property**)&m_pElstReservedProperty);

    return m_pElstCountProperty
           && m_pElstMediaTimeProperty
           && m_pElstDurationProperty
           && m_pElstRateProperty
           && m_pElstReservedProperty;
}

MP4EditId MP4Track::AddEdit(MP4EditId editId)
{
    if (!m_pElstCountProperty) {
        (void)m_File.AddDescendantAtoms(&m_trakAtom, "edts.elst");
        if (InitEditListProperties() == false) return MP4_INVALID_EDIT_ID;
    }

    if (editId == MP4_INVALID_EDIT_ID) {
        editId = m_pElstCountProperty->GetValue() + 1;
    }

    m_pElstMediaTimeProperty->InsertValue(0, editId - 1);
    m_pElstDurationProperty->InsertValue(0, editId - 1);
    m_pElstRateProperty->InsertValue(1, editId - 1);
    m_pElstReservedProperty->InsertValue(0, editId - 1);

    m_pElstCountProperty->IncrementValue();

    return editId;
}

void MP4Track::DeleteEdit(MP4EditId editId)
{
    if (editId == MP4_INVALID_EDIT_ID) {
        throw new Exception("edit id can't be zero",
                            __FILE__, __LINE__, __FUNCTION__ );
    }

    if (!m_pElstCountProperty
            || m_pElstCountProperty->GetValue() == 0) {
        throw new Exception("no edits exist",
                            __FILE__, __LINE__, __FUNCTION__ );
    }

    m_pElstMediaTimeProperty->DeleteValue(editId - 1);
    m_pElstDurationProperty->DeleteValue(editId - 1);
    m_pElstRateProperty->DeleteValue(editId - 1);
    m_pElstReservedProperty->DeleteValue(editId - 1);

    m_pElstCountProperty->IncrementValue(-1);

    // clean up if last edit is deleted
    if (m_pElstCountProperty->GetValue() == 0) {
        m_pElstCountProperty = NULL;
        m_pElstMediaTimeProperty = NULL;
        m_pElstDurationProperty = NULL;
        m_pElstRateProperty = NULL;
        m_pElstReservedProperty = NULL;

        m_trakAtom.DeleteChildAtom(
            m_trakAtom.FindAtom("trak.edts"));
    }
}

MP4Timestamp MP4Track::GetEditStart(
    MP4EditId editId)
{
    if (editId == MP4_INVALID_EDIT_ID) {
        return MP4_INVALID_TIMESTAMP;
    } else if (editId == 1) {
        return 0;
    }
    return (MP4Timestamp)GetEditTotalDuration(editId - 1);
}

MP4Duration MP4Track::GetEditTotalDuration(
    MP4EditId editId)
{
    uint32_t numEdits = 0;

    if (m_pElstCountProperty) {
        numEdits = m_pElstCountProperty->GetValue();
    }

    if (editId == MP4_INVALID_EDIT_ID) {
        editId = numEdits;
    }

    if (numEdits == 0 || editId > numEdits) {
        return MP4_INVALID_DURATION;
    }

    MP4Duration totalDuration = 0;

    for (MP4EditId eid = 1; eid <= editId; eid++) {
        totalDuration +=
            m_pElstDurationProperty->GetValue(eid - 1);
    }

    return totalDuration;
}

MP4SampleId MP4Track::GetSampleIdFromEditTime(
    MP4Timestamp editWhen,
    MP4Timestamp* pStartTime,
    MP4Duration* pDuration)
{
    MP4SampleId sampleId = MP4_INVALID_SAMPLE_ID;
    uint32_t numEdits = 0;

    if (m_pElstCountProperty) {
        numEdits = m_pElstCountProperty->GetValue();
    }

    if (numEdits) {
        MP4Duration editElapsedDuration = 0;

        for (MP4EditId editId = 1; editId <= numEdits; editId++) {
            // remember edit segment's start time (in edit timeline)
            MP4Timestamp editStartTime =
                (MP4Timestamp)editElapsedDuration;

            // accumulate edit segment's duration
            editElapsedDuration +=
                m_pElstDurationProperty->GetValue(editId - 1);

            // calculate difference between the specified edit time
            // and the end of this edit segment
            if (editElapsedDuration - editWhen <= 0) {
                // the specified time has not yet been reached
                continue;
            }

            // 'editWhen' is within this edit segment

            // calculate the specified edit time
            // relative to just this edit segment
            MP4Duration editOffset =
                editWhen - editStartTime;

            // calculate the media (track) time that corresponds
            // to the specified edit time based on the edit list
            MP4Timestamp mediaWhen =
                m_pElstMediaTimeProperty->GetValue(editId - 1)
                + editOffset;

            // lookup the sample id for the media time
            sampleId = GetSampleIdFromTime(mediaWhen, false);

            // lookup the sample's media start time and duration
            MP4Timestamp sampleStartTime;
            MP4Duration sampleDuration;

            GetSampleTimes(sampleId, &sampleStartTime, &sampleDuration);

            // calculate the difference if any between when the sample
            // would naturally start and when it starts in the edit timeline
            MP4Duration sampleStartOffset =
                mediaWhen - sampleStartTime;

            // calculate the start time for the sample in the edit time line
            MP4Timestamp editSampleStartTime =
                editWhen - min(editOffset, sampleStartOffset);

            MP4Duration editSampleDuration = 0;

            // calculate how long this sample lasts in the edit list timeline
            if (m_pElstRateProperty->GetValue(editId - 1) == 0) {
                // edit segment is a "dwell"
                // so sample duration is that of the edit segment
                editSampleDuration =
                    m_pElstDurationProperty->GetValue(editId - 1);

            } else {
                // begin with the natural sample duration
                editSampleDuration = sampleDuration;

                // now shorten that if the edit segment starts
                // after the sample would naturally start
                if (editOffset < sampleStartOffset) {
                    editSampleDuration -= sampleStartOffset - editOffset;
                }

                // now shorten that if the edit segment ends
                // before the sample would naturally end
                if (editElapsedDuration
                        < editSampleStartTime + sampleDuration) {
                    editSampleDuration -= (editSampleStartTime + sampleDuration)
                                          - editElapsedDuration;
                }
            }

            if (pStartTime) {
                *pStartTime = editSampleStartTime;
            }

            if (pDuration) {
                *pDuration = editSampleDuration;
            }

            log.verbose2f("\"%s\": GetSampleIdFromEditTime: when %" PRIu64 " "
                          "sampleId %u start %" PRIu64 " duration %" PRId64,
                          GetFile().GetFilename().c_str(),
                          editWhen, sampleId,
                          editSampleStartTime, editSampleDuration);

            return sampleId;
        }

        throw new Exception("time out of range",
                            __FILE__, __LINE__, __FUNCTION__ );

    } else { // no edit list
        sampleId = GetSampleIdFromTime(editWhen, false);

        if (pStartTime || pDuration) {
            GetSampleTimes(sampleId, pStartTime, pDuration);
        }
    }

    return sampleId;
}

void MP4Track::CalculateBytesPerSample ()
{
    MP4Atom *pMedia = m_trakAtom.FindAtom("trak.mdia.minf.stbl.stsd");
    MP4Atom *pMediaData;
    const char *media_data_name;
    if (pMedia == NULL) return;

    if (pMedia->GetNumberOfChildAtoms() != 1) return;

    pMediaData = pMedia->GetChildAtom(0);
    media_data_name = pMediaData->GetType();
    if ((ATOMID(media_data_name) == ATOMID("twos")) ||
            (ATOMID(media_data_name) == ATOMID("sowt"))) {
        MP4IntegerProperty *chan, *sampleSize;
        chan = (MP4IntegerProperty *)pMediaData->GetProperty(4);
        sampleSize = (MP4IntegerProperty *)pMediaData->GetProperty(5);
        m_bytesPerSample = chan->GetValue() * (sampleSize->GetValue() / 8);
    }
}

MP4Duration MP4Track::GetDurationPerChunk()
{
    return m_durationPerChunk;
}

void MP4Track::SetDurationPerChunk( MP4Duration duration )
{
    m_durationPerChunk = duration;
}

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

}} // namespace mp4v2::impl