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


#define IMPLEMENT_SampleSizeAtom_H__

#include "samplesizeatom.h"
#include "atomutils.h"
#include "atomdefs.h"


// Stream-in constructor
SampleSizeAtom::SampleSizeAtom(MP4_FF_FILE *fp,
                               uint32 mediaType,
                               uint32 size,
                               uint32 type,
                               OSCL_wString& filename,
                               uint32 parsingMode)
        : FullAtom(fp, size, type),
        _mediaType(mediaType)
{
    _psampleSizeVec = NULL;

    _maxSampleSize = 0;
    _parsed_entry_cnt = 0;
    _fileptr = NULL;

    if (0 != AtomUtils::getFileBufferingCapacity(fp))
    {
        _stbl_buff_size = MAX_CACHED_TABLE_ENTRIES_MBDS;
    }
    else
    {
        _stbl_buff_size = MAX_CACHED_TABLE_ENTRIES_FILE;
    }

    _next_buff_number = 0;
    _curr_buff_number = 0;
    _curr_entry_point = 0;
    _stbl_fptr_vec = NULL;
    _parsing_mode = parsingMode;
    _firstSampleOnBkwdRepos = false;
    if (_success)
    {
        if (_size < (DEFAULT_FULL_ATOM_SIZE + 4 + 4))
        {
            _success = false;
            _mp4ErrorCode = READ_SAMPLE_SIZE_ATOM_FAILED;
            return;
        }

        if (!AtomUtils::read32read32(fp, ((uint32 &)_sampleSize), _sampleCount))
        {
            _success = false;
        }

        uint32 dataSize = _size - (DEFAULT_FULL_ATOM_SIZE + 4 + 4);

        uint32 entrySize = (4);

        if (_sampleSize == 0)
        {	//samples have different size
            if ((_sampleCount*entrySize) > dataSize)
            {
                _success = false;
            }
            else
            {	//the entry is valid

                if (_parsing_mode == 1)
                {
                    if ((_sampleCount > _stbl_buff_size)) // cahce size is 4K so that optimization should work if entry_count is greater than 4K
                    {
                        uint32 fptrBuffSize = (_sampleCount / _stbl_buff_size) + 1;

                        PV_MP4_FF_ARRAY_NEW(NULL, uint32, (fptrBuffSize), _stbl_fptr_vec);
                        if (_stbl_fptr_vec == NULL)
                        {
                            _success = false;
                            _mp4ErrorCode = MEMORY_ALLOCATION_FAILED;
                            return;
                        }

                        PV_MP4_FF_ARRAY_NEW(NULL, int32, (_stbl_buff_size), _psampleSizeVec);
                        if (_psampleSizeVec == NULL)
                        {
                            _success = false;
                            _mp4ErrorCode = MEMORY_ALLOCATION_FAILED;
                            return;
                        }

                        {
                            OsclAny* ptr = (MP4_FF_FILE *)(oscl_malloc(sizeof(MP4_FF_FILE)));
                            if (ptr == NULL)
                            {
                                _success = false;
                                _mp4ErrorCode = MEMORY_ALLOCATION_FAILED;
                                return;
                            }
                            _fileptr = OSCL_PLACEMENT_NEW(ptr, MP4_FF_FILE());
                            _fileptr->_fileServSession = fp->_fileServSession;
                            _fileptr->_pvfile.SetCPM(fp->_pvfile.GetCPM());
                            if (AtomUtils::OpenMP4File(filename,
                                                       Oscl_File::MODE_READ | Oscl_File::MODE_BINARY,
                                                       _fileptr) != 0)
                            {
                                _success = false;
                                _mp4ErrorCode = FILE_OPEN_FAILED;
                            }

                            _fileptr->_fileSize = fp->_fileSize;
                        }
                        int32 _head_offset = AtomUtils::getCurrentFilePosition(fp);
                        AtomUtils::seekFromCurrPos(fp, dataSize);
                        AtomUtils::seekFromStart(_fileptr, _head_offset);

                        return;
                    }
                    else
                    {
                        _parsing_mode = 0;
                        _stbl_buff_size = _sampleCount;

                    }
                }
                else
                {
                    _stbl_buff_size = _sampleCount;
                }

                PV_MP4_FF_ARRAY_NEW(NULL, int32, (_sampleCount), _psampleSizeVec);

                if (_psampleSizeVec == NULL)
                {
                    _success = false;
                    _mp4ErrorCode = MEMORY_ALLOCATION_FAILED;
                    return;
                }

                uint32 sample;
                for (uint32 i = 0; i < _sampleCount; i++)
                {
                    if (!AtomUtils::read32(fp, sample))
                    {
                        _success = false;
                        break;
                    }
                    _psampleSizeVec[i] = sample;

                    if (_psampleSizeVec[i] > _maxSampleSize)
                    {
                        _maxSampleSize = _psampleSizeVec[i];
                    }
                    _parsed_entry_cnt++;
                }
            }
        }
        else
            _maxSampleSize = (uint32)_sampleSize;

        if (!_success)
            _mp4ErrorCode = READ_SAMPLE_SIZE_ATOM_FAILED;

    }
    else
    {
        if (_mp4ErrorCode != ATOM_VERSION_NOT_SUPPORTED)
            _mp4ErrorCode = READ_SAMPLE_SIZE_ATOM_FAILED;
    }
}

bool SampleSizeAtom::ParseEntryUnit(uint32 sample_cnt)
{
    uint32 threshold = 0;
    if (0 != AtomUtils::getFileBufferingCapacity(_fileptr))
    {
        threshold = TABLE_ENTRIES_THRESHOLD_MBDS;
    }
    else
    {
        threshold = TABLE_ENTRIES_THRESHOLD_FILE;
    }

    sample_cnt += threshold;

    if (sample_cnt > _sampleCount)
        sample_cnt = _sampleCount;


    uint32 sample;
    while (_parsed_entry_cnt < sample_cnt)
    {
        _curr_entry_point = _parsed_entry_cnt % _stbl_buff_size;
        _curr_buff_number = _parsed_entry_cnt / _stbl_buff_size;
        if (_curr_buff_number  == _next_buff_number)
        {
            uint32 currFilePointer = AtomUtils::getCurrentFilePosition(_fileptr);
            _stbl_fptr_vec[_curr_buff_number] = currFilePointer;
            _next_buff_number++;
        }

        if (!_curr_entry_point)
        {
            uint32 currFilePointer = _stbl_fptr_vec[_curr_buff_number];
            AtomUtils::seekFromStart(_fileptr, currFilePointer);
        }

        if (!AtomUtils::read32(_fileptr, sample))
        {
            return false;
        }
        _psampleSizeVec[_curr_entry_point] = sample;

        if (_psampleSizeVec[_curr_entry_point] > _maxSampleSize)
        {
            _maxSampleSize = _psampleSizeVec[_curr_entry_point];
        }
        _parsed_entry_cnt++;
    }
    return true;
}

// Destructor
SampleSizeAtom::~SampleSizeAtom()
{
    if (_psampleSizeVec != NULL)
    {
        // CLEAN UP VECTOR
        PV_MP4_ARRAY_DELETE(NULL, _psampleSizeVec);
    }
    if (_fileptr != NULL)
    {
        if (_fileptr->IsOpen())
        {
            AtomUtils::CloseMP4File(_fileptr);
        }

        oscl_free(_fileptr);
    }
    if (_stbl_fptr_vec != NULL)
        PV_MP4_ARRAY_DELETE(NULL, _stbl_fptr_vec);

}

int32
SampleSizeAtom::getSampleSizeAt(uint32 index)
{
    if (_psampleSizeVec == NULL)
    {
        return _sampleSize;
    }

    if (_parsing_mode == 1)
    {
        if (index < _sampleCount)
        {
            if (index >= _parsed_entry_cnt)
            {
                ParseEntryUnit(index);
            }
            else
            {
                uint32 entryLoc = index / _stbl_buff_size;
                if (!_firstSampleOnBkwdRepos) //Not to use old entries in case of backward Repos.
                {
                    uint32 actualEntryIndex = _parsed_entry_cnt % _stbl_buff_size;
                    uint32 prevEntriesInBuffer = _stbl_buff_size - actualEntryIndex;
                    if ((index > actualEntryIndex) && prevEntriesInBuffer)
                    {
                        uint32 entryFallsInPreviousBuffer = _curr_buff_number - entryLoc;

                        if (entryFallsInPreviousBuffer == 1)
                            return (_psampleSizeVec[index%_stbl_buff_size]);
                    }
                }
                _firstSampleOnBkwdRepos = false;
                if (_curr_buff_number != entryLoc)
                {
                    _parsed_entry_cnt = entryLoc * _stbl_buff_size;
                    while (_parsed_entry_cnt <= index)
                        ParseEntryUnit(_parsed_entry_cnt);
                }
            }
            return (_psampleSizeVec[index%_stbl_buff_size]);
        }
        else
        {
            return PV_ERROR;
        }
    }
    return _psampleSizeVec[index];
}