IStreamCoder.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 ISTREAMCODER_H_
#define ISTREAMCODER_H_
 
#include <com/avpkit/ferry/RefCounted.h>
#include <com/avpkit/core/AVPKit.h>
#include <com/avpkit/core/ICodec.h>
#include <com/avpkit/core/IRational.h>
#include <com/avpkit/core/IPixelFormat.h>
#include <com/avpkit/core/IAudioSamples.h>
#include <com/avpkit/core/IVideoPicture.h>
#include <com/avpkit/core/IPacket.h>
#include <com/avpkit/core/IProperty.h>
#include <com/avpkit/core/IMetaData.h>
 
namespace com { namespace avpkit { namespace core
{
 
  class IStream;
  
  class VS_API_AVPKIT IStreamCoder : public com::avpkit::ferry::RefCounted
  {
  public:
 
    typedef enum Direction
    {
      ENCODING,
      DECODING
    } Direction;
 
    typedef enum Flags {
      FLAG_QSCALE=0x0002,  
      FLAG_4MV   =0x0004,  
      FLAG_QPEL  =0x0010,  
      FLAG_GMC   =0x0020,  
      FLAG_MV0   =0x0040,
      FLAG_INPUT_PRESERVED=0x0100,
      FLAG_PASS1          =0x0200,   
      FLAG_PASS2          =0x0400,   
      FLAG_GRAY           =0x2000,   
      FLAG_EMU_EDGE       =0x4000,   
      FLAG_PSNR           =0x8000,   
      FLAG_TRUNCATED      =0x00010000, 
      FLAG_NORMALIZE_AQP =0x00020000, 
      FLAG_INTERLACED_DCT=0x00040000, 
      FLAG_LOW_DELAY     =0x00080000, 
      FLAG_GLOBAL_HEADER =0x00400000, 
      FLAG_BITEXACT      =0x00800000, 
      /* Fx : Flag for h263+ extra options */
      FLAG_AC_PRED       =0x01000000, 
      FLAG_CBP_RD        =0x04000000, 
      FLAG_QP_RD         =0x08000000, 
      FLAG_LOOP_FILTER   =0x00000800, 
      FLAG_INTERLACED_ME =0x20000000, 
      FLAG_CLOSED_GOP    =0x80000000,
      FLAG2_FAST         =0x00000001, 
      FLAG2_STRICT_GOP   =0x00000002, 
      FLAG2_NO_OUTPUT    =0x00000004, 
      FLAG2_LOCAL_HEADER =0x00000008, 
      FLAG2_SKIP_RD      =0x00004000, 
      FLAG2_CHUNKS       =0x00008000, 
      FLAG2_SHOW_ALL     =0x00400000, 
    } Flags;
 
    virtual Direction getDirection()=0;
 
    virtual IStream* getStream()=0;
 
    virtual ICodec* getCodec()=0;
 
    virtual ICodec::Type getCodecType()=0;
 
    virtual ICodec::ID getCodecID()=0;
 
    virtual void setCodec(ICodec *codec)=0;
 
    virtual void setCodec(ICodec::ID id)=0;
 
    virtual int32_t getBitRate()=0;
 
    virtual void setBitRate(int32_t rate)=0;
 
    virtual int32_t getBitRateTolerance()=0;
 
    virtual void setBitRateTolerance(int32_t tolerance)=0;
 
    virtual int32_t getHeight()=0;
 
    virtual void setHeight(int32_t height)=0;
 
    virtual int32_t getWidth()=0;
 
    virtual void setWidth(int32_t width)=0;
 
    virtual IRational* getTimeBase()=0;
 
    virtual void setTimeBase(IRational* newTimeBase)=0;
 
    virtual IRational* getFrameRate()=0;
 
    virtual void setFrameRate(IRational* newFrameRate)=0;
 
    virtual int32_t getNumPicturesInGroupOfPictures()=0;
 
    virtual void setNumPicturesInGroupOfPictures(int32_t gops)=0;
 
    virtual IPixelFormat::Type getPixelType()=0;
 
    virtual void setPixelType(IPixelFormat::Type pixelFmt)=0;
 
    virtual int32_t getSampleRate()=0;
 
    virtual void setSampleRate(int32_t sampleRate)=0;
 
    virtual IAudioSamples::Format getSampleFormat()=0;
 
    virtual void setSampleFormat(IAudioSamples::Format aFormat)=0;
 
    virtual int32_t getChannels()=0;
 
    virtual void setChannels(int32_t channels)=0;
    
 
    virtual int32_t getAudioFrameSize()=0;
 
    virtual int32_t getGlobalQuality()=0;
 
    virtual void setGlobalQuality(int32_t newQuality)=0;
 
    virtual int32_t getFlags()=0;
 
    virtual void setFlags(int32_t newFlags) = 0;
 
    virtual bool getFlag(Flags flag) = 0;
 
    virtual void setFlag(Flags flag, bool value) = 0;
 
 
    virtual int64_t getNextPredictedPts()=0;
 
    virtual int32_t open()=0;
    virtual int32_t close()=0;
 
    virtual int32_t decodeAudio(IAudioSamples * pOutSamples,
        IPacket *packet, int32_t byteOffset)=0;
 
    virtual int32_t decodeVideo(IVideoPicture * pOutFrame,
        IPacket *packet, int32_t byteOffset)=0;
 
    virtual int32_t encodeVideo(IPacket * pOutPacket,
        IVideoPicture * pFrame, int32_t suggestedBufferSize)=0;
 
    virtual int32_t encodeAudio(IPacket * pOutPacket,
        IAudioSamples* pSamples, int32_t sampleToStartFrom)=0;
 
    static IStreamCoder* make(Direction direction);
 
  protected:
    IStreamCoder();
    virtual ~IStreamCoder();
  public:
    /*
     * Added for 1.17
     */
 
    virtual int32_t getCodecTag()=0;
    virtual void setCodecTag(int32_t fourcc)=0;
    
    /*
     * Added for 1.19
     */
 
    virtual int32_t getNumProperties()=0;
    
    virtual IProperty *getPropertyMetaData(int32_t propertyNo)=0;
 
    virtual IProperty *getPropertyMetaData(const char *name)=0;
    
    virtual int32_t setProperty(const char *name, const char* value)=0;
 
 
    virtual int32_t setProperty(const char* name, double value)=0;
    
    virtual int32_t setProperty(const char* name, int64_t value)=0;
    
    virtual int32_t setProperty(const char* name, bool value)=0;
    
    virtual int32_t setProperty(const char* name, IRational *value)=0;
 
#ifdef SWIG
    %newobject getPropertyAsString(const char*);
    %typemap(newfree) char * "free($1);";
#endif
    virtual char * getPropertyAsString(const char* name)=0;
 
    virtual double getPropertyAsDouble(const char* name)=0;
 
    virtual int64_t getPropertyAsLong(const char* name)=0;
 
    virtual  IRational *getPropertyAsRational(const char* name)=0;
 
    virtual bool getPropertyAsBoolean(const char* name)=0;
 
    virtual bool isOpen()=0;
    
    
    // Added for 1.21
    
    virtual int32_t getDefaultAudioFrameSize()=0;
    
    virtual void setDefaultAudioFrameSize(int32_t aNewSize)=0;
    
    /*
     * Added for 1.22
     */
    
    static IStreamCoder* make(Direction direction, IStreamCoder* copyCoder);
    
    /*
     * Added for 3.1
     */
    
    virtual int64_t getNumDroppedFrames()=0;
    
    /*
     * Added for 3.2
     */
    
    virtual void setAutomaticallyStampPacketsForStream(bool value)=0;
    
    virtual bool getAutomaticallyStampPacketsForStream()=0;
    
    virtual void setCodecID(ICodec::ID id)=0;
 
    /*
     * Added for 3.3
     */
 
    virtual int32_t setExtraData(com::avpkit::ferry::IBuffer* src,
        int32_t offset,
        int32_t length, bool allocNew)=0;
 
    virtual int32_t getExtraData(com::avpkit::ferry::IBuffer *dest,
        int32_t offset,
        int32_t maxBytesToCopy)=0;
 
    virtual int32_t getExtraDataSize()=0;
 
    typedef enum {
      COMPLIANCE_VERY_STRICT=2,
      COMPLIANCE_STRICT=1,
      COMPLIANCE_NORMAL=0,
      COMPLIANCE_UNOFFICIAL=-1,
      COMPLIANCE_EXPERIMENTAL=-2,
    } CodecStandardsCompliance;
 
    virtual CodecStandardsCompliance getStandardsCompliance()=0;
 
    virtual int32_t setStandardsCompliance(CodecStandardsCompliance compliance)=0;
 
#ifndef SWIG
    virtual int32_t setHardwareDecoding(IPixelFormat::Type type, void* surface=NULL)=0;
    
    virtual void* getHardwareSurface()=0;
 
#endif
    
    virtual int32_t open(IMetaData *options, IMetaData* unsetOptions)=0;
 
    static IStreamCoder* make(Direction direction, ICodec* codec);
 
 
    static IStreamCoder* make(Direction direction, ICodec::ID id);
 
    virtual int32_t setProperty(IMetaData* valuesToSet, IMetaData* valuesNotFound)=0;
  };
 
}}}
 
#endif /*ISTREAMCODER_H_*/