edlstream.h

Go to the documentation of this file.

/*
 * edlstream.h
 *
 * Copyright (C) 2007-2026 Hybrid Software Helix Ltd. All rights reserved.
 */

 
#ifndef EDLSTREAM_H
#define EDLSTREAM_H
 
#include <fstream>
#include <edl/edltypes.h>
#include <edl/iedlobject.h>
#include <edl/idomhashable.h>
#include <edl/edlvector.h>
#include <edl/edlerrors.h>
#include <edl/edlfwd.h>
 
#ifdef _WIN32
#include <cstdarg>
#endif
 
_BEGIN_EDL_NAMESPACE

 
class IEDLStream : virtual public IEDLObject
{
  public:
    virtual bool isValid() const = 0;

    virtual bool open()
    {
        try
        {
            openE();
            return true;
        }
        catch (IEDLError &e)
        {
            if (e.getErrorCode() == EDL_ERR_PANIC)
            {
                throw;
            }
            return false;
        }
    }

    virtual void openE() = 0;

    virtual void close() = 0;

    virtual int64 getPos() = 0;
};
DECL_SMART_PTR(IEDLStream);
#define edlobj2IEDLStream(src) edl_cast((IEDLStream *)nullptr, src)
 
class IInputStream;
DECL_SMART_PTR(IInputStream);
typedef CEDLVector<IInputStreamPtr> CIInputStreamVect;
class IRAInputStream;
DECL_SMART_PTR(IRAInputStream);
typedef CEDLVector<IRAInputStreamPtr> CIRAInputStreamVect;
class IRAOutputStream;
DECL_SMART_PTR(IRAOutputStream);
class IInputPushbackStream;
DECL_SMART_PTR(IInputPushbackStream);

typedef int (*UserStreamWriteFunc) (void *pPriv, void *pBuff, unsigned int len);

typedef int (*UserStreamReadFunc) (void *pPriv, void *pBuff, unsigned int len,
                                   unsigned int *pLenRead, int *pEof);

typedef int (*UserRAReadFunc) (void *pPriv, void *pBuff, int64 offset, int32 length);

 
class IInputStream : virtual public IEDLStream, virtual public IDOMHashable
{
  public:
    static EDL_API IRAInputStreamPtr createFromFile(IEDLClassFactory *pFactory, const EDLSysString &path);

    static EDL_API IRAInputStreamPtr createFromFile(IEDLClassFactory *pFactory, const EDLString &path);

    static EDL_API IRAInputStreamPtr createFromFileShared(IEDLClassFactory *pFactory, const EDLSysString &path);

    static EDL_API IRAInputStreamPtr createFromFileShared(IEDLClassFactory *pFactory, const EDLString &path);

    static EDL_API IRAInputStreamPtr createSharedFromStream(IEDLClassFactory *pFactory, const IRAInputStreamPtr &stream, bool clone = true);

    static EDL_API IRAInputStreamPtr createFromMemory(IEDLClassFactory *pFactory, const void *mem, uint32 length, bool copy = false, bool free = true);

    static EDL_API IInputStreamPtr createFromUserReadFunc(IEDLClassFactory *pFactory, UserStreamReadFunc readFunc, void *priv);

    static EDL_API IRAInputStreamPtr createFromRAUserFunc(IEDLClassFactory *pFactory, int64 length, UserRAReadFunc readFunc, void *priv);

    static EDL_API IRAInputStreamPtr createRandomAccessFromNonRandomAccess(IEDLClassFactory *pFactory, const IInputStreamPtr &stream);

    static EDL_API IRAInputStreamPtr createFromNewFileWithContents(IEDLClassFactory *pFactory, const EDLSysString &path, const IInputStreamPtr &stream);

    static EDL_API IRAInputStreamPtr createFromNewFileWithContents(IEDLClassFactory *pFactory, const EDLString &path, const IInputStreamPtr &stream);

    static EDL_API IInputStreamPtr createSubFile(IEDLClassFactory *pFactory, const IInputStreamPtr &stream, int64 offset, int64 length);

    static EDL_API IInputStreamPtr createFromFlateCompressed(IEDLClassFactory *pFactory, const IInputStreamPtr &stream, bool raw = true, bool ignoreChecksums = false);

    static EDL_API IInputStreamPtr createFromLz4Compressed(IEDLClassFactory *pFactory, const IInputStreamPtr &stream);

    static EDL_API IInputStreamPtr createFromPredictorCompressed(IEDLClassFactory *pFactory, const IInputStreamPtr &stream,
                                                                 uint8 predictor, uint8 colors, uint8 bitsPerComponent, uint32 columns);

    static EDL_API IInputStreamPtr createCompositeStream(IEDLClassFactory *pFactory, const CIInputStreamVect &streams);

    static EDL_API IInputPushbackStreamPtr createPushbackStream(IEDLClassFactory *pFactory, const IInputStreamPtr &sourceStream, bool clone = true);

    static EDL_API IInputStreamPtr createUelStream(IEDLClassFactory *pFactory, const IInputStreamPtr &sourceStream);

    static EDL_API IInputStreamPtr createTbcpStream(IEDLClassFactory *pFactory, const IInputStreamPtr &sourceStream, bool openSource = false);

    static EDL_API IRAInputStreamPtr createBackgroundCopyStream(const EDL::ISessionPtr &session,
                                                                const IRAInputStreamPtr &sourceStream,
                                                                bool clonable = true);

    static EDL_API IInputStreamPtr createBufferedStream(IEDLClassFactory *pFactory,
                                                        const IInputStreamPtr &sourceStream,
                                                        uint32 bufferSize = 4096);
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char OUTPUT[] {void *buffer}
#endif
#if SWIGPYTHON
    %apply char INOUT[] {void *buffer};
#endif
#endif

    virtual int32 read(void * buffer, int32 count) = 0;
#ifdef SWIG
    %clear void *buffer;
#endif

    virtual int8 read() = 0;

    virtual bool eof() const = 0;

    virtual int64 skip(int64 count)
    {
        static const int32 kBufSize = 1024;
        char buf[kBufSize];
        int64 rc = 0;
        int32 n_read;
        while (count > 0)
        {
            if ((n_read = read((void *)buf, (int32)((count > kBufSize)? kBufSize : count))) <= 0)
            {
                break;
            }
            else
            {
                rc += n_read;
            }
            count -= n_read;
        }
        return rc;
    }

    virtual bool getSourceFilePath(EDLSysString &sourcePath) = 0;

    virtual bool getCanonicalSourceFilePath(EDLSysString &sourceCanonicalPath) = 0;
 
    #ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char OUTPUT[] {void *buffer}
#endif
#if SWIGPYTHON
    %apply char INOUT[] {void *buffer}
#endif
#endif
    virtual bool completeRead(void * buffer, int32 count);
#ifdef SWIG
    %clear void *buffer;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char OUTPUT[] {void *buffer}
#endif
#if SWIGPYTHON
    %apply char INOUT[] {void *buffer}
#endif
#endif
    virtual void completeReadE(void *buffer, int32 count);
#ifdef SWIG
    %clear void *buffer;
#endif
 
#ifdef SWIG
    %apply unsigned long long &OUTPUT { uint64 &hash };
#endif
    virtual bool hash(uint64 &hash);
#ifdef SWIG
    %clear uint64 &hash;
#endif
};
#define edlobj2IInputStream(src) edl_cast((IInputStream *)nullptr, src)

 
class IRAStream
{
public:
    virtual ~IRAStream ()
    {}

    virtual int64 length() = 0;

    virtual bool setPos(int64 newPos) = 0;

    virtual void setPosE(int64 newPos)
    {
        if (!setPos(newPos))
        {
            throwEDLError(EDL_ERR_IOERROR);
        }
    }
};

class IPushbackStream
{
  public:
    virtual ~IPushbackStream ()
    {}

    virtual bool pushBack(uint8 byte) = 0;
    
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {const void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {const void *buffer}
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const void *buffer}
#endif
#endif
 
    virtual bool pushBack(const void *buffer, int32 count) = 0;
#ifdef SWIG
    %clear const void *buffer;
#endif
};

class IRAInputStream : virtual public IInputStream, virtual public IRAStream
{
};
 
DECL_SMART_PTR(IRAInputStream);
#define edlobj2IRAInputStream(src) edl_cast((IRAInputStream *)nullptr, src)

 
class IInputPushbackStream : virtual public IInputStream, virtual public IPushbackStream
{
};
 
#define edlobj2IInputPushbackStream(src) edl_cast((IInputPushbackStream *)nullptr, src)

 
class IRAInputPushbackStream : virtual public IRAInputStream, virtual public IPushbackStream
{
};
 
DECL_SMART_PTR(IRAInputPushbackStream);
#define edlobj2IRAInputPushbackStream(src) edl_cast((IRAInputPushbackStream *)nullptr, src)
 
#define FILE_STREAM_GUID         0x89ad895, 0x48f1685b, 0x8dab9c1a, 0xe8e3b18b
#define SHARED_STREAM_GUID       0xe88a727d, 0xe53140da, 0x9bbff26d, 0x79a42d81
#define OUTPUTFILE_STREAM_GUID   0x50a914fc, 0xe81446b9, 0x8e420d48, 0x09454eff
#define OUTPUTUSER_STREAM_GUID   0x789AEE52, 0xD0384136, 0x8B4584B0, 0x942E55CA
#define INPUTUSER_STREAM_GUID    0xd55cc022, 0xa6844749, 0x9414d265, 0xeeab7cea
#define INPUTRAUSER_STREAM_GUID  0x9895EBEB, 0xe2654b86, 0xa527a102, 0x3c3d36cd
#define INPUT_MEMORY_STREAM_GUID 0x26CAC8F2, 0x726A432c, 0xB8399237, 0xEA12D95F
#define FILE_STREAM_WITH_CALLBACK_GUID 0X7FB63540, 0XC0684D87, 0XB513F53A, 0X4925CF1C
 
#define USERINPUT_RASTREAM_GUID  0x776b2562, 0x87e141b0, 0xa3d4c121, 0xdf3588ba
#define USEROUTPUT_STREAM_GUID   0x1d0a1b45, 0xb2694fd2, 0xa1b28077, 0xee815f6a

typedef void (*FileStreamReadFunc) (void *pPriv, int64 pos, int32 len);
 
class CFileStreamParams : public CClassParams
{
  public:
    CFileStreamParams(const EDLSysString & sName, bool append = false) : m_sName(sName), m_bAppend(append) {}
 
    EDLSysString      m_sName;
    bool              m_bAppend;
};
 
class CFileStreamWithCallbackParams : public CFileStreamParams
{
  public:
    CFileStreamWithCallbackParams(const EDLSysString & sName, FileStreamReadFunc pReadFunc, void *pPriv) :
    CFileStreamParams(sName),
    m_pReadFunc(pReadFunc),
    m_pPriv(pPriv)
    {
    }
 
    FileStreamReadFunc m_pReadFunc;
    void *m_pPriv;
};
 
// Forward declaration
class ISession;
 
 
class CUserStreamWriteParams : public CClassParams
{
  public:
    CUserStreamWriteParams(UserStreamWriteFunc pWriteFunc, void *pPriv) :
    m_pWriteFunc(pWriteFunc), m_pPriv(pPriv)
    {}
 
    UserStreamWriteFunc m_pWriteFunc;
    void *m_pPriv;
};
 
class CUserStreamReadParams : public CClassParams
{
  public:
    CUserStreamReadParams(UserStreamReadFunc pReadFunc, void *pPriv) :
    m_pReadFunc(pReadFunc), m_pPriv(pPriv)
    {}
 
    UserStreamReadFunc m_pReadFunc;
    void *m_pPriv;
};
 
class CRAUserStreamReadParams : public CClassParams
{
  public:
    CRAUserStreamReadParams(UserRAReadFunc pReadFunc, int64 length, void *pPriv) :
    m_pReadFunc(pReadFunc), m_pPriv(pPriv), m_length(length)
    {}
 
    UserRAReadFunc m_pReadFunc;
    void          *m_pPriv;
    int64          m_length;
};
 
class CInputMemoryParams : public CClassParams
{
  public:
    // If makeCopy is false and free is true, the memory input stream will take ownership of the memory
    // (which must be able to be freed by free()).
    // If makeCopy is true, then a copy is made and will be managed by the stream. In this case,
    // free is ignored.
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {const uint8 *mem}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {const uint8 *mem}
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const uint8 *mem}
#endif
#endif
    CInputMemoryParams(const uint8 *mem, int32 length, bool makeCopy, bool free = true) : m_memory(mem), m_length(length), m_makeCopy(makeCopy), m_free(free) {}
#ifdef SWIG
    %clear const uint8 *mem;
#endif
 
    const uint8 * m_memory;
    int32         m_length;
    bool          m_makeCopy;
    bool          m_free; // Ignored if m_makeCopy is true
};
 
class IOutputStream;
DECL_SMART_PTR(IOutputStream);

 
class IOutputStream : virtual public IEDLStream
{
  public:
    static EDL_API IRAOutputStreamPtr createToFile(IEDLClassFactory *pFactory, const EDLSysString &path, bool append = false);

    static EDL_API IRAOutputStreamPtr createToFile(IEDLClassFactory *pFactory, const EDLString &path, bool append = false);

    static EDL_API IOutputStreamPtr createFromUserWriteFunc(IEDLClassFactory *pFactory, UserStreamWriteFunc writeFunc, void *priv);

    static EDL_API IOutputStreamPtr createToFlateCompressed(IEDLClassFactory *pFactory, const IOutputStreamPtr &stream, uint32 compressionLevel, bool raw = true);

    static EDL_API IOutputStreamPtr createToLz4Compressed(IEDLClassFactory *pFactory, const IOutputStreamPtr &stream, bool openSourceStream = true);

    static EDL_API int64 copy(const IInputStreamPtr &inStream, const IOutputStreamPtr &outStream);
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {const void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {const void *buffer}
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const void *buffer}
#endif
#endif

    virtual int32 write(const void *buffer, int32 count) = 0;
#ifdef SWIG
    %clear const void *buffer;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE { const void *buffer }
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] { const void *buffer }
#endif
#if SWIGPYTHON
    %apply char INPUT[] { const void *buffer }
#endif
#endif

    virtual int32 writeE(const void *buffer, int32 count);
#ifdef SWIG
    %clear const void *buffer;
#endif

    static EDL_API int64 writeStream(const IInputStreamPtr &inStream, const IOutputStreamPtr &outStream);

    virtual int32 write(const char *str);

    virtual int32 writeE(const char *str);

    virtual bool flush() = 0;

    virtual int32 writeFormatted(const char *fmt, ...);

    virtual int32 writeFormattedE(const char *fmt, ...);
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {const void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {const void *buffer}
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const void *buffer}
#endif
#endif

    virtual bool completeWrite(const void * buffer, int32 count);
#ifdef SWIG
    %clear const void *buffer;
#endif

    virtual bool completeWrite(const char *str);
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE {const void *buffer}
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] {const void *buffer}
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const void *buffer}
#endif
#endif
    virtual void completeWriteE(const void *buffer, int32 count);
#ifdef SWIG
    %clear const void *buffer;
#endif

    virtual void completeWriteE(const char *str);

    virtual void flushE();
};
#define edlobj2IOutputStream(src) edl_cast((IOutputStream *)nullptr, src)

 
class IRAOutputStream : public IOutputStream, virtual public IRAStream
{
};
 
#define edlobj2IRAOutputStream(src) edl_cast((IRAOutputStream *)nullptr, src)
 
class IRAInputOutputStream : public IRAInputStream, public IRAOutputStream
{
};
 
DECL_SMART_PTR(IRAInputOutputStream);
#define edlobj2IRAInputOutputStream(src) edl_cast((IRAInputOutputStream *)nullptr, src)

class EDLIFStream : public std::ifstream
{
  public:
    EDLIFStream() : std::ifstream() {}
    explicit EDLIFStream(const char* filename, std::ios_base::openmode mode = std::ios_base::in) : std::ifstream()
    {
        open(filename, mode);
    }
#ifdef _WIN32
    void open(const char* filename, std::ios_base::openmode mode = std::ios_base::in)
    {
        EDLString wFilename = EDLSysStringToEDLString(EDLSysString(filename));
        std::ifstream::open(wFilename.c_str(), mode);
    }
#endif
};

class EDLOFStream : public std::ofstream
{
  public:
    EDLOFStream() : std::ofstream() {}
    explicit EDLOFStream(const char* filename, std::ios_base::openmode mode = std::ios_base::out) : std::ofstream()
    {
        open(filename, mode);
    }
#ifdef _WIN32
    void open(const char* filename, std::ios_base::openmode mode = std::ios_base::out)
    {
        EDLString wFilename = EDLSysStringToEDLString(EDLSysString(filename));
        std::ofstream::open(wFilename.c_str(), mode);
    }
#endif
};
 
_END_EDL_NAMESPACE
 
#endif /* EDLSTREAM_H */