/* ------------------------------------------------------------------
 * 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.
 * -------------------------------------------------------------------
 */
#ifndef __SDP_INFO_H__
#define __SDP_INFO_H__

#include "oscl_mem.h"
#include "session_info.h"
#include "media_info.h"
#include "aac_media_info.h"
#include "amr_media_info.h"
#include "evrc_media_info.h"
#include "m4v_media_info.h"
#include "rfc3640_media_info.h"
#include "h263_media_info.h"
#include "still_image_media_info.h"
#include "bool_array.h"
#include "pcmu_media_info.h"
#include "pcma_media_info.h"

#ifndef OSCL_STRING_H_INCLUDED
#include "oscl_string.h"
#endif


//----------------------------------------------------------------------
// Global Constant Declarations
//----------------------------------------------------------------------
#define MAX_MEDIA_OBJECTS	50
#define MAX_SEGMENTS		10

struct segmentSpecific
{
    bool segmentActive;
    bool segmentPayloadOrderPref;
};

typedef BoolArray<MAX_MEDIA_OBJECTS> SDPSelectionType;
//----------------------------------------------------------------------
// Global Type Declarations
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Global Data Declarations
//----------------------------------------------------------------------

//======================================================================
//  CLASS DEFINITIONS and FUNCTION DECLARATIONS
//======================================================================
#include "mime_registry.h"

class SDPInfo
{
    public:
        SDPInfo()
        {
            registrar_locally_allocated = false;
            reg = NULL;
            numMediaObjects = 0;
            iMediaObjectIndex = 0;
            segmentCount = 0;
            for (int ii = 0; ii < MAX_SEGMENTS; ii++)
            {
                segmentInfo[ii].segmentActive = true;
                segmentInfo[ii].segmentPayloadOrderPref = false;
            }
        }

        SDPInfo(const SDPInfo &sourceSdpInfo)
        {
            registrar_locally_allocated = false;
            reg = NULL;
            numMediaObjects = 0;
            iMediaObjectIndex = 0;
            segmentCount = sourceSdpInfo.segmentCount;
            for (int jj = 0; jj < MAX_SEGMENTS; jj++)
            {
                segmentInfo[jj] = sourceSdpInfo.segmentInfo[jj];
            }

            session_info = sourceSdpInfo.session_info;
            bool alternateMedia;
            for (int ii = 0; ii < sourceSdpInfo.numMediaObjects; ii++)
            {
                for (int ss = 0; ss < (int)pMediaInfo[ii].size(); ss++)
                {
                    const char *MIMEType = (sourceSdpInfo.pMediaInfo[ii][ss])->getMIMEType();
                    if (!oscl_strncmp(MIMEType, "AAC", oscl_strlen("AAC")) || !oscl_strncmp(MIMEType, "MP4A-LATM", oscl_strlen("MP4A-LATM")))
                    {
                        aac_mediaInfo *pSourceAAC = (aac_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        //void *memory = alloc(sizeof(aac_mediaInfo) + pSourceAAC->getDecoderSpecificInfoSize());
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(aac_mediaInfo), alternateMedia);
                        aac_mediaInfo *pAAC = OSCL_PLACEMENT_NEW(memory, aac_mediaInfo());
                        //	unsigned char *decSpecificInfo = (unsigned char *)(memory) + sizeof(aac_mediaInfo);
                        //	pAAC->setDecoderSpecificInfo(decSpecificInfo, pSourceAAC->getDecoderSpecificInfoSize());
                        *pAAC = *pSourceAAC;
                    }
                    else if (!oscl_strncmp(MIMEType, "AMR", oscl_strlen("AMR")))
                    {
                        amr_mediaInfo *pSourceAMR = (amr_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(amr_mediaInfo), alternateMedia);
                        amr_mediaInfo *pAMR = OSCL_PLACEMENT_NEW(memory, amr_mediaInfo());
                        *pAMR = *pSourceAMR;
                    }
                    else if (!oscl_strncmp(MIMEType, "EVRC", oscl_strlen("EVRC")))
                    {
                        evrc_mediaInfo *pSourceEVRC = (evrc_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(evrc_mediaInfo), alternateMedia);
                        evrc_mediaInfo *pEVRC = OSCL_PLACEMENT_NEW(memory, evrc_mediaInfo());
                        *pEVRC = *pSourceEVRC;
                    }
                    else if (!oscl_strncmp(MIMEType, "MP4V-ES", oscl_strlen("MP4V-ES")))
                    {
                        m4v_mediaInfo *pSourceM4V = (m4v_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;
                        void *memory = alloc(sizeof(m4v_mediaInfo), alternateMedia);
                        m4v_mediaInfo *pM4V = OSCL_PLACEMENT_NEW(memory, m4v_mediaInfo());
                        *pM4V = *pSourceM4V;
                    }
                    else if (!oscl_strncmp(MIMEType, "H263-1998", oscl_strlen("H263-1998")))
                    {
                        h263_mediaInfo *pSourceH263 = (h263_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(h263_mediaInfo), alternateMedia);
                        h263_mediaInfo *pH263 = OSCL_PLACEMENT_NEW(memory, h263_mediaInfo());
                        *pH263 = *pSourceH263;
                    }
                    else if (!oscl_strncmp(MIMEType, "H263-2000", oscl_strlen("H263-2000")))
                    {
                        h263_mediaInfo *pSourceH263 = (h263_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(h263_mediaInfo), alternateMedia);
                        h263_mediaInfo *pH263 = OSCL_PLACEMENT_NEW(memory, h263_mediaInfo());
                        *pH263 = *pSourceH263;
                    }
                    else if (!oscl_strncmp(MIMEType, "PVMP4V-ES", oscl_strlen("PVMP4V-ES")))
                    {
                        m4v_mediaInfo *pSourceM4V = (m4v_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(m4v_mediaInfo), alternateMedia);
                        m4v_mediaInfo *pM4V = OSCL_PLACEMENT_NEW(memory, m4v_mediaInfo());
                        (mediaInfo)*pM4V = (mediaInfo) * pSourceM4V;
                        *pM4V = *pSourceM4V;
                    }
                    else if (!oscl_strncmp(MIMEType, "mpeg4-generic", oscl_strlen("mpeg4-generic")))
                    {
                        rfc3640_mediaInfo *pSourceRFC3640 = (rfc3640_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(rfc3640_mediaInfo), alternateMedia);
                        rfc3640_mediaInfo *pRFC3640 = OSCL_PLACEMENT_NEW(memory, rfc3640_mediaInfo());
                        (mediaInfo)*pRFC3640 = (mediaInfo) * pSourceRFC3640;
                        *pRFC3640 = *pSourceRFC3640;
                    }
                    else if (!oscl_strncmp(MIMEType, "X-MP4V-IMAGE", oscl_strlen("X-MP4V-IMAGE")))
                    {
                        still_image_mediaInfo *pSourceImage = (still_image_mediaInfo*)sourceSdpInfo.pMediaInfo[ii][ss];
                        if (ss == 0)
                            alternateMedia = false;
                        else
                            alternateMedia = true;

                        void *memory = alloc(sizeof(still_image_mediaInfo), alternateMedia);
                        still_image_mediaInfo *pImage = OSCL_PLACEMENT_NEW(memory, still_image_mediaInfo());
                        *pImage = *pSourceImage;
                    }

                }
            }
        }

        ~SDPInfo()
        {
            int ii = 0;
            int ss = 0;
            for (ii = 0; ii < numMediaObjects; ii++)
            {
                for (ss = 0; ss < (int)pMediaInfo[ii].size();ss++)
                {
                    pMediaInfo[ii][ss]->~mediaInfo();
                    dealloc(pMediaInfo[ii][ss]);
                }
            }
            numMediaObjects = 0;

        }

        sessionDescription *getSessionInfo()
        {
            return &session_info;
        };
        Oscl_Vector<mediaInfo *, SDPParserAlloc> getMediaInfo(int Object)
        {
            if ((Object >= 0) && (Object < MAX_MEDIA_OBJECTS))
            {
                return pMediaInfo[Object];
            }
            else
            {
                return 0;
            }
        };
        Oscl_Vector<mediaInfo *, SDPParserAlloc> *getMediaArray()
        {
            return pMediaInfo;
        };
        int getNumMediaObjects()
        {
            return numMediaObjects;
        };
        inline void dealloc(void *ptr)
        {
            oscl_free(ptr);
        };

        mediaInfo* getMediaInfoBasedOnID(uint32 trackID)
        {
            int numObjects = getNumMediaObjects();

            for (int i = 0; i < numObjects; i++)
            {
                Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec;
                mediaInfoVec = getMediaInfo(i);

                for (uint32 j = 0; j < mediaInfoVec.size(); j++)
                {
                    mediaInfo* minfo = mediaInfoVec[j];

                    if (minfo != NULL)
                    {
                        if (minfo->getMediaInfoID() == trackID)
                        {
                            return minfo;
                        }
                    }
                }
            }
            return NULL;
        }

        mediaInfo* getMediaInfoBasedOnDependsOnID(uint32 trackID)
        {
            if (trackID == 0)
            {
                return NULL;
            }

            int numObjects = getNumMediaObjects();

            for (int i = 0; i < numObjects; i++)
            {
                Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec;
                mediaInfoVec = getMediaInfo(i);

                for (uint32 j = 0; j < mediaInfoVec.size(); j++)
                {
                    mediaInfo* minfo = mediaInfoVec[j];

                    if (minfo != NULL)
                    {
                        if ((uint32)(minfo->getControlTrackID()) == trackID)
                        {
                            return minfo;
                        }
                    }
                }
            }
            return NULL;
        }


        void *alloc(const int size, bool alternateMedia)
        {
            OSCL_UNUSED_ARG(alternateMedia);

            if (numMediaObjects < MAX_MEDIA_OBJECTS)
            {
                void *mem = oscl_malloc(size * sizeof(char));
                if (mem != NULL)
                {
                    iMediaObjectIndex++;
                    pMediaInfo[numMediaObjects].push_back((mediaInfo *)mem);
                }
                return mem;
            }
            else
            {
                return NULL;
            }
        }

        void IncrementAlternateMediaInfoVectorIndex()
        {
            pMediaInfo[numMediaObjects][0]->setSegmentNumber(segmentCount);
            numMediaObjects++;
        }

        void copyFmDefMedia(mediaInfo *media)
        {
            *media = *pMediaInfo[numMediaObjects][0];
        }

        inline void reset()
        {
            session_info.resetSessionDescription();
            int ii = 0;
            int ss = 0;
            for (ii = 0; ii < numMediaObjects; ii++)
            {
                for (ss = 0; ss < (int)pMediaInfo[ii].size(); ss++)
                {
                    pMediaInfo[ii][ss]->~mediaInfo();
                    dealloc(pMediaInfo[ii][ss]);
                }
            }
            numMediaObjects = 0;
        }

        inline uint32 getMediaObjectIndex()
        {
            return iMediaObjectIndex;
        }

        bool getMediaInfoInSegment(int segment, Oscl_Vector< mediaInfo *, SDPParserAlloc>& segmentMediaInfo)
        {
            if (segmentCount == 0)
                return false;
            for (int ii = 0; ii < numMediaObjects; ii++)
            {
                if (pMediaInfo[ii][0]->getSegmentNumber() == (uint)segment)
                {
                    segmentMediaInfo.push_back(pMediaInfo[ii][0]);
                }
            }
            return true;
        }

        void setSegmentCount(int count)
        {
            segmentCount = count;
        }

        int getSegmentCount()
        {
            return segmentCount;
        }

        bool setSegmentActive(int segment, bool status)
        {
            if (segment <= segmentCount)
            {
                segmentInfo[segment].segmentActive = status;
                return true;
            }
            else
                return false;
        }

        bool isSegmentActive(int segment)
        {
            if (segment <= segmentCount)
                return segmentInfo[segment].segmentActive;
            else
                return false;
        }

        bool setSegmentPayloadOrderPref(int segment, int* payloadArray, int len)
        {
            segmentInfo[segment].segmentPayloadOrderPref = false;
            if (segment <= segmentCount)
            {
                Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo;
                if (getMediaInfoInSegment(segment, segmentMediaInfo) == true)
                {
                    for (int ii = 0; ii < len; ii++)
                    {
                        for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++)
                        {
                            if (segmentMediaInfo[jj]->getPayloadSpecificInfoVector()[0]->getPayloadNumber() == (uint32)payloadArray[ii])
                            {
                                segmentMediaInfo[jj]->setPayloadPreference(ii);
                                break;
                            }
                        }
                    }
                }
            }
            else
                return false;
            segmentInfo[segment].segmentPayloadOrderPref = true;
            return true;
        }

        bool isPayloadOrderPreferenceSet(int segment)
        {
            if (segment <= segmentCount)
                return segmentInfo[segment].segmentPayloadOrderPref;
            else
                return false;
        }

        mediaInfo* getPreferedMediaInfo(int segment)
        {
            mediaInfo* media = NULL;
            Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo;
            if (getMediaInfoInSegment(segment, segmentMediaInfo) == true)
            {
                for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++)
                {
                    if (segmentMediaInfo[jj]->isMatched() == true)
                    {
                        media = segmentMediaInfo[jj];
                        break;
                    }
                }
            }
            return media;
        }

        int getPreferedPayloadNumber(int segment)
        {
            int payload = -1;
            Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo;
            if (getMediaInfoInSegment(segment, segmentMediaInfo) == true)
            {
                for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++)
                {
                    if (segmentMediaInfo[jj]->isMatched() == true)
                    {
                        payload = segmentMediaInfo[jj]->getPayloadSpecificInfoVector()[0]->getPayloadNumber();
                        break;
                    }
                }
            }
            return payload;
        }

        const oscl_wchar *getSdpFilename(uint32 &retsize)
        {
            retsize = SdpFilename.get_size();
            return SdpFilename.get_cstr();
        }

        void setSDPFilename(OSCL_wString& aURL)
        {
            SdpFilename = aURL;
        }

    private:
        sessionDescription session_info;
        Oscl_Vector< mediaInfo *, SDPParserAlloc> pMediaInfo[MAX_MEDIA_OBJECTS];
        int numMediaObjects;
        registrar *reg;
        bool registrar_locally_allocated;
        uint32 iMediaObjectIndex;
        int segmentCount;
        segmentSpecific segmentInfo[MAX_SEGMENTS];
        OSCL_wHeapString<SDPParserAlloc> SdpFilename;
};
#endif // __SDP_INFO_H__