core/MsBinaryFile/PptFile/Drawing/AudioOverlay.h

/*
 * Copyright (C) Ascensio System SIA, 2009-2026
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation, together with the
 * additional terms provided in the LICENSE file.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
 * details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA by email at info@onlyoffice.com
 * or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
 * LV-1050, Latvia, European Union.
 *
 * The interactive user interfaces in modified versions of the Program
 * are required to display Appropriate Legal Notices in accordance with
 * Section 5 of the GNU AGPL version 3.
 *
 * No trademark rights are granted under this License.
 *
 * All non-code elements of the Product, including illustrations,
 * icon sets, and technical writing content, are licensed under the
 * Creative Commons Attribution-ShareAlike 4.0 International License:
 * https://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 * This license applies only to such non-code elements and does not
 * modify or replace the licensing terms applicable to the Program's
 * source code, which remains licensed under the GNU Affero General
 * Public License v3.
 *
 * SPDX-License-Identifier: AGPL-3.0-only
 */
#pragma once
#include "Elements.h"

namespace PPT
{
    class CAudioPart
    {
    public:
        std::wstring            m_strFile;

        double			m_dStartTime;
        double			m_dEndTime;

        double			m_dClipStartTime;
        double			m_dClipEndTime;

        double			m_dAudioDuration;

        bool			m_bLoop;
        bool			m_bStop;

        bool			m_bIsTransition;

        double			m_dAmplify;

    public:
        CAudioPart()
        {
            m_dStartTime	= 0.0;
            m_dEndTime		= -1.0;

            m_dClipStartTime	= 0.0;
            m_dClipEndTime	= -1.0;

            m_dAudioDuration	= 0.0;

            m_bLoop		= false;
            m_bStop		= false;

            m_bIsTransition	= false;

            m_dAmplify		= 100.0;
        }

        ~CAudioPart()
        {
        }

        CAudioPart(const CAudioPart& oSrc)
        {
            *this = oSrc;
        }

        CAudioPart& operator=(const CAudioPart& oSrc)
        {
            m_strFile			= oSrc.m_strFile;

            m_dStartTime		= oSrc.m_dStartTime;
            m_dEndTime			= oSrc.m_dEndTime;

            m_dClipStartTime	= oSrc.m_dClipStartTime;
            m_dClipEndTime		= oSrc.m_dClipEndTime;

            m_dAudioDuration	= oSrc.m_dAudioDuration;

            m_bLoop				= oSrc.m_bLoop;
            m_bStop				= oSrc.m_bStop;

            m_bIsTransition		= oSrc.m_bIsTransition;

            m_dAmplify			= oSrc.m_dAmplify;

            return *this;
        }

        CAudioPart(CAudioElement* pAudioElem)
        {
            if (NULL == pAudioElem)
            {
                m_strFile			= L"";

                m_dStartTime		= 0.0;
                m_dEndTime			= -1.0;

                m_dClipStartTime	= 0.0;
                m_dClipEndTime		= -1.0;

                m_dAudioDuration	= 0.0;

                m_bLoop				= false;
                m_bStop				= false;

                m_bIsTransition		= false;

                m_dAmplify			= 100.0;
            }
            else
            {
                m_strFile			= pAudioElem->m_strAudioFileName;

                m_dStartTime		= pAudioElem->m_dStartTime;
                m_dEndTime			= pAudioElem->m_dEndTime;

                m_dClipStartTime	= pAudioElem->m_dClipStartTime;
                m_dClipEndTime		= pAudioElem->m_dClipEndTime;

                m_dAudioDuration	= pAudioElem->m_dAudioDuration;

                m_bLoop				= ( pAudioElem->m_bLoop == TRUE) ? true : false;;
                m_bStop				= false;

                m_bIsTransition		= false;

                m_dAmplify			= 100.0;
            }
        }

    public:
        void CalculateDuration()
        {
            if (0.0 < m_dAudioDuration || L"" == m_strFile)
                return;
        }
    };

    class CAudioOverlay
    {
    public:
        std::vector<CAudioPart> m_arParts;
        double m_dAllDuration;

    public:
        CAudioOverlay() : m_arParts(), m_dAllDuration(0.0)
        {
        }
        ~CAudioOverlay()
        {
        }
        CAudioOverlay(const CAudioOverlay& oSrc)
        {
            *this = oSrc;
        }
        CAudioOverlay& operator=(const CAudioOverlay& oSrc)
        {
            m_arParts.insert(m_arParts.end(), oSrc.m_arParts.begin(), oSrc.m_arParts.end());
            m_dAllDuration = oSrc.m_dAllDuration;
            return *this;
        }

    public:

        void Calculate()
        {
            size_t nCount = m_arParts.size();

            // normalize first
            for (size_t i = 0; i < nCount; ++i)
            {
                CAudioPart* pPart = &m_arParts[i];

                pPart->CalculateDuration();

                if (pPart->m_dStartTime < 0.0)
                    pPart->m_dStartTime = 0.0;

                pPart->m_dEndTime = pPart->m_dStartTime + pPart->m_dAudioDuration;
                if (pPart->m_dEndTime > m_dAllDuration)
                {
                    pPart->m_dEndTime = m_dAllDuration;
                }
                if (pPart->m_bLoop)
                {
                    pPart->m_dEndTime = m_dAllDuration;
                }
            }

            // recalculation
            for (size_t i = 0; i < nCount; ++i)
            {
                CAudioPart* pPart = &m_arParts[i];

                if (pPart->m_bIsTransition)
                {
                    if (pPart->m_bStop)
                    {
                        // need to stop all music before this
                        for (size_t j = 0; j < nCount; ++j)
                        {
                            if (j == i)
                                continue;

                            CAudioPart* pMem = &m_arParts[j];
                            if (pMem->m_dStartTime <= pPart->m_dStartTime && pMem->m_dEndTime > pPart->m_dStartTime)
                            {
                                pMem->m_dEndTime = pPart->m_dStartTime;
                            }
                        }
                    }
                    if (pPart->m_bLoop)
                    {
                        // loop until the first audio encounter

                        double dMin = m_dAllDuration;
                        for (size_t j = 0; j < nCount; ++j)
                        {
                            if (j == i)
                                continue;

                            CAudioPart* pMem = &m_arParts[j];
                            if (pMem->m_dStartTime > pPart->m_dEndTime)
                            {
                                if (dMin > pMem->m_dStartTime)
                                    dMin = pMem->m_dStartTime;
                            }
                        }

                        pPart->m_dEndTime = dMin;
                    }
                }
                else
                {
                    if (pPart->m_bLoop)
                    {
                        pPart->m_dEndTime = m_dAllDuration;
                    }
                }
            }
        }

        std::wstring GetAudioOverlay()
        {
            std::wstring strRes;

            size_t nCount = m_arParts.size();

            for (size_t i = 0; i < nCount; ++i)
            {
                CAudioPart* pPart = &m_arParts[i];

                std::wstring strOverlay1 = L"<AudioSource StartTime='" + std::to_wstring(pPart->m_dStartTime)
                        + L"' Duration='" + std::to_wstring(pPart->m_dEndTime - pPart->m_dStartTime)
                        + L"' Amplify='" + std::to_wstring(pPart->m_dAmplify) + L"'>";

                int lIndex = pPart->m_strFile.find(L"file:///");
                if (0 == lIndex)
                {
                    pPart->m_strFile = pPart->m_strFile.substr(8);
                    //pPart->m_strFile.Replace('/', '\\');
                    //pPart->m_strFile.Replace(L"%20", L" ");
                }

                std::wstring strFile_ = pPart->m_strFile;
                CorrectXmlString(strFile_);

                std::wstring strOverlay2 = L"<Source StartTime='" + std::to_wstring(pPart->m_dClipStartTime)
                        + L"' EndTime='" + std::to_wstring(pPart->m_dClipEndTime)
                        + L"' FilePath='" + strFile_+ L"'/></AudioSource>";

                strRes += strOverlay1 + strOverlay2;
            }

            return strRes;
        }
    };
}