mediafile.h

Go to the documentation of this file.

/*
 * mediafile.h
 *
 * Media file declaration
 *
 * Portable Windows Library
 *
 * Copyright (C) 2017 Vox Lucida Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Tools Library.
 *
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 */

#ifndef PTLIB_PMEDIAFILE_H
#define PTLIB_PMEDIAFILE_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib.h>

#if P_MEDIAFILE

#include <ptlib/pfactory.h>
#include <ptlib/smartptr.h>
#include <ptlib/sound.h>
#include <ptlib/videoio.h>
#include <ptclib/delaychan.h>


class PMediaFile : public PSmartObject
{
    PCLASSINFO(PMediaFile, PSmartObject);
  protected:
    PMediaFile();

    bool      m_reading;
    PFilePath m_filePath;
    PString   m_lastErrorText;

    bool CheckOpenAndTrack(unsigned track) const;
    bool CheckMode(bool reading) const;
    bool CheckOpenTrackAndMode(unsigned track, bool reading) const;
    bool CheckModeAndTrackType(bool reading, const PString & expectedTrackType, const PString & actualTrackType) const;

    bool SetErrorText(const PString & error);

  public:
    ~PMediaFile();

    typedef PFactory<PMediaFile, PFilePathString> Factory;

    typedef PSmartPtr<PMediaFile> Ptr;

    static PMediaFile * Create(
      const PFilePath & file      
    ) { return Factory::CreateInstance(file.GetType()); }

    static PStringSet GetAllFileTypes();

    static const PString & Audio();

    static const PString & Video();

    virtual bool IsSupported(
      const PString & format    
    ) const = 0;

    virtual bool OpenForReading(
      const PFilePath & filePath    
    ) = 0;

    virtual bool OpenForWriting(
      const PFilePath & filePath    
    ) = 0;

    virtual bool IsOpen() const = 0;

    virtual bool Close() = 0;

    bool IsReading() const { return m_reading; }

    const PFilePath & GetFilePath() const { return m_filePath; }

    const PString & GetErrorText() const { return m_lastErrorText; }

    struct TrackInfo
    {
      TrackInfo(const PString & type = PString::Empty(), const PString & format = PString::Empty());
      TrackInfo(unsigned rate, unsigned channels); // Audio track
#if P_VIDEO
      TrackInfo(unsigned width, unsigned height, double rate); // Video track
#endif

      bool operator==(const TrackInfo & other) const;
      bool operator!=(const TrackInfo & other) const { return !operator==(other); }

      PCaselessString m_type;            
      PString         m_format;          
      unsigned        m_size;            
      int64_t         m_frames;          
      double          m_rate;            
      unsigned        m_channels;        
      unsigned        m_width, m_height; 
      PStringOptions  m_options;         
    };
    typedef std::vector<TrackInfo> TracksInfo;

    virtual bool GetDefaultTrackInfo(
      const PCaselessString & type,   
      TrackInfo & info                
    ) const = 0;

    virtual unsigned GetTrackCount() const = 0;

    virtual bool GetTracks(
      TracksInfo & tracks   
    ) = 0;

    virtual bool SetTracks(
      const TracksInfo & tracks   
    ) = 0;

    virtual bool ReadNative(
      unsigned track,   
      void * data,      
      PINDEX & size,    
      unsigned & frames 
    ) = 0;

    virtual bool WriteNative(
      unsigned track,     
      const void * data,  
      PINDEX & size,      
      unsigned & frames 
    ) = 0;

    virtual bool ConfigureAudio(
      unsigned track,     
      unsigned channels,  
      unsigned sampleRate 
    ) = 0;

    virtual bool ReadAudio(
      unsigned track,   
      void * pcm,      
      PINDEX size,      
      PINDEX & length   
    ) = 0;

    virtual bool WriteAudio(
      unsigned track,     
      const void * pcm,   
      PINDEX length,      
      PINDEX & written    
    ) = 0;

#if P_VIDEO

    virtual bool ConfigureVideo(
      unsigned track,                   
      const PVideoFrameInfo & frameInfo 
    ) = 0;

    virtual bool ReadVideo(
      unsigned track,   
      void * data,      
      PTimeInterval * sampleTime = NULL  
    ) = 0;

    virtual bool WriteVideo(
      unsigned track,     
      const void * data,  
      const PTimeInterval & sampleTime = -1  
    ) = 0;
#endif


    class SoundChannel : public PSoundChannelEmulation
    {
      PCLASSINFO(SoundChannel, PSoundChannelEmulation);
      public:
        explicit SoundChannel(const Ptr & mediaFile = Ptr(), unsigned track = 0);
        ~SoundChannel();

        virtual bool Open(const Params & params);
        virtual PString GetName() const;
        virtual PBoolean Close();
        virtual PBoolean IsOpen() const;

      protected:
        virtual bool RawWrite(const void * buf, PINDEX len);
        virtual bool RawRead(void * buf, PINDEX len);
        virtual bool Rewind();

        Ptr      m_mediaFile;
        unsigned m_track;
    };

#if P_VIDEO
    class VideoInputDevice : public PVideoInputEmulatedDevice
    {
      PCLASSINFO(VideoInputDevice, PVideoInputEmulatedDevice);
      public:
        explicit VideoInputDevice(const Ptr & mediaFile = Ptr(), unsigned track = 0);
        ~VideoInputDevice();

        virtual PStringArray GetDeviceNames() const;
        virtual PBoolean Open(const PString & deviceName, PBoolean startImmediate = true);
        virtual PBoolean IsOpen();
        virtual PBoolean Close();

      protected:
        virtual bool InternalReadFrameData(BYTE * frame);

        Ptr            m_mediaFile;
        unsigned       m_track;
    };
#endif // P_VIDEO
};


PFACTORY_LOAD(PMediaFile_WAV);


#if P_VIDEO

//
// This class defines a video display (output) device that writes video to a raw YUV file
//

class PVideoOutputDevice_MediaFile : public PVideoOutputDevice
{
  PCLASSINFO(PVideoOutputDevice_MediaFile, PVideoOutputDevice);

  public:
    PVideoOutputDevice_MediaFile();

    virtual ~PVideoOutputDevice_MediaFile();

    static PStringArray GetOutputDeviceNames();

    virtual PStringArray GetDeviceNames() const
      { return GetOutputDeviceNames(); }

    virtual PBoolean Open(
      const PString & deviceName,   
      PBoolean startImmediate = true    
    );

    PBoolean Start();

    PBoolean Stop();

    virtual PBoolean Close();

    virtual PBoolean IsOpen();

    virtual PBoolean SetColourFormat(
      const PString & colourFormat   // New colour format for device.
    );
    
    virtual PBoolean SetFrameData(const FrameData & frameData);

  protected:  
   PMediaFile * m_file;
};

#endif // P_VIDEO

#endif // P_MEDIAFILE

#endif // PTLIB_PMEDIAFILE_H


// End Of File ///////////////////////////////////////////////////////////////