Container.h

/*******************************************************************************
 * Copyright (c) 2024, 2026, Olivier Ayache.  All rights reserved.
 *
 * This file is part of AVPKit.
 *
 * AVPKit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * AVPKit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with AVPKit.  If not, see <http://www.gnu.org/licenses/>.
 *******************************************************************************/
 
#ifndef CONTAINER_H_
#define CONTAINER_H_
 
#include <com/avpkit/ferry/RefCounted.h>
#include <com/avpkit/ferry/RefPointer.h>
#include <com/avpkit/core/IContainer.h>
#include <com/avpkit/core/FfmpegIncludes.h>
#include <com/avpkit/core/Stream.h>
#include <com/avpkit/core/StreamCoder.h>
#include <com/avpkit/core/ContainerFormat.h>
#include <com/avpkit/core/MetaData.h>
 
#include <com/avpkit/core/io/URLProtocolHandler.h>
#include <vector>
#include <list>
 
#include <com/avpkit/core/io/URLProtocolHandlerFactory.h>
 
namespace com { namespace avpkit { namespace core
{
  class Container : public IContainer
  {
    VS_JNIUTILS_REFCOUNTED_OBJECT(Container)
  public:
    virtual int32_t setInputBufferLength(int32_t size);
    virtual int32_t getInputBufferLength();
    virtual bool isOpened();
    virtual bool isHeaderWritten();
 
    virtual int32_t open(const char *url, Type type,
        IContainerFormat* pContainerFormat);
    virtual int32_t open(const char *url, Type type,
        IContainerFormat* pContainerFormat, bool, bool);
    virtual IStreamCoder::CodecStandardsCompliance getStandardsCompliance();
    virtual int32_t setStandardsCompliance(IStreamCoder::CodecStandardsCompliance compliance);
    virtual IContainerFormat *getContainerFormat();
 
    virtual Type getType();
    virtual int32_t close();
    virtual int32_t close(bool);
    virtual int32_t getNumStreams();
 
    virtual Stream* getStream(int32_t position);
 
    virtual Stream* addNewStream(int32_t id);
 
    virtual int32_t readNextPacket(IPacket *packet);
    virtual int32_t writePacket(IPacket *packet, bool forceInterleave);
    virtual int32_t writePacket(IPacket *packet);
 
    virtual int32_t writeHeader();
    virtual int32_t writeTrailer();
    AVFormatContext *getFormatContext();
 
    /*
     * Added as of 1.17
     */
    virtual int32_t queryStreamMetaData();
    virtual int32_t seekKeyFrame(int streamIndex, int64_t timestamp, int32_t flags);
    virtual int64_t getDuration();
    virtual int64_t getStartTime();
    virtual int64_t getFileSize();
    virtual int32_t getBitRate();
    virtual int32_t setPreload(int32_t preload);
    virtual int32_t getPreload();
    virtual int32_t setMaxDelay(int32_t maxdelay);
    virtual int32_t getMaxDelay();
 
    /*
     * Added for 1.19
     */
    virtual int32_t getNumProperties();
    virtual IProperty* getPropertyMetaData(int32_t propertyNo);
    virtual IProperty* getPropertyMetaData(const char *name);
 
    virtual int32_t setProperty(const char* name, const char* value);
    virtual int32_t setProperty(const char* name, double value);
    virtual int32_t setProperty(const char* name, int64_t value);
    virtual int32_t setProperty(const char* name, bool value);
    virtual int32_t setProperty(const char* name, IRational *value);
    
    virtual char * getPropertyAsString(const char* name);
    virtual double getPropertyAsDouble(const char* name);
    virtual int64_t getPropertyAsLong(const char* name);
    virtual  IRational *getPropertyAsRational(const char* name);
    virtual bool getPropertyAsBoolean(const char* name);
    
    virtual int32_t getFlags();
    virtual void setFlags(int32_t newFlags);
    virtual bool getFlag(Flags flag);
    virtual void setFlag(Flags flag, bool value);
    
    virtual const char * getURL();
    virtual int32_t flushPackets();
    
    virtual int32_t getReadRetryCount();
    virtual void setReadRetryCount(int32_t count);
 
    virtual bool canStreamsBeAddedDynamically();
 
    virtual IMetaData* getMetaData();
    virtual void setMetaData(IMetaData* metaData);
    virtual int32_t createSDPData(com::avpkit::ferry::IBuffer* buffer);
 
    virtual int32_t setForcedAudioCodec(ICodec::ID id);
    virtual int32_t setForcedVideoCodec(ICodec::ID id);
    virtual int32_t setForcedSubtitleCodec(ICodec::ID id);
    
    /*
     * Added for 3.4
     */
    virtual int32_t seekKeyFrame(int32_t streamIndex, int64_t minTimeStamp,
        int64_t targetTimeStamp, int64_t maxTimeStamp, int32_t flags);
 
    /*
     * Added for 5.0
     */
    virtual Stream* addNewStream(ICodec::ID id);
    virtual Stream* addNewStream(ICodec* codec);
    virtual Stream* addNewStream(IStreamCoder* coder);
 
    virtual ContainerFormat *getFormat() { return mFormat.get(); };
    virtual int32_t setFormat(IContainerFormat* format);
    static Container* make(IContainerFormat* format);
 
    virtual int32_t setProperty(IMetaData* valuesToSet, IMetaData* valuesNotFound);
    virtual int32_t open(const char *url, Type type,
        IContainerFormat* pContainerFormat, bool, bool,
        IMetaData*, IMetaData*);
    
    int32_t setCustomIOProtocol(io::URLProtocolHandlerFactory* factory);
    
  protected:
    virtual ~Container();
    Container();
 
  private:
    // This is the object we wrap
    int32_t openInputURL(const char*url, bool, bool, AVDictionary** options);
    int32_t openOutputURL(const char*url, bool, AVDictionary **options);
    int32_t setupAllInputStreams();
    AVFormatContext *mFormatContext;
    AVPacket *mPacket;
    AVPacket *mBsfPacket;
    void reset();
    void resetContext();
    // We do pointer to RefPointers to avoid too many
    // acquire() / release() cycles as the vector manages
    // itself.
    std::vector<
      com::avpkit::ferry::RefPointer<Stream>*
      > mStreams;
    uint32_t mNumStreams;
    bool mIsOpened;
    bool mNeedTrailerWrite;
    std::list<
      com::avpkit::ferry::RefPointer<IStreamCoder>
      > mOpenCoders;
 
    bool mIsMetaDataQueried;
    size_t mInputBufferLength;
    
    int32_t mReadRetryCount;
    com::avpkit::ferry::RefPointer<MetaData> mMetaData;
    com::avpkit::ferry::RefPointer<ContainerFormat> mFormat;
 
    io::URLProtocolHandler *mCustomIOHandler;
  };
}}}
 
#endif /*CONTAINER_H_*/