liblives.hpp

Go to the documentation of this file.

// liblives.hpp
// LiVES (lives-exe)
// (c) G. Finch <salsaman@gmail.com> 2015
// Released under the GPL 3 or later
// see file ../COPYING for licensing details

#ifndef HAS_LIBLIVES_H
#define HAS_LIBLIVES_H

#define LIVES_VERSION_MAJOR 2

#define LIVES_VERSION_MINOR 4

#define LIVES_VERSION_MICRO 1

#define LIVES_CHECK_VERSION(major, minor, micro) (major > LIVES_VERSION_MAJOR || (major == LIVES_VERSION_MAJOR && (minor > LIVES_VERSION_MINOR || (minor == LIVES_VERSION_MINOR && micro >= LIVES_VERSION_MICRO)))) 


// defs shared with lbindings.c

typedef enum {
  LIVES_FILE_CHOOSER_VIDEO_AUDIO,  
  LIVES_FILE_CHOOSER_AUDIO_ONLY, 
  //  LIVES_FILE_CHOOSER_VIDEO_AUDIO_MULTI, ///< file chooser options for multiple video or audio files
  //LIVES_FILE_CHOOSER_VIDEO_RANGE ///< file chooser options for video range (start time/number of frames)
} lives_filechooser_t;

typedef enum {
  LIVES_INTERFACE_MODE_INVALID=-1, 
  LIVES_INTERFACE_MODE_CLIPEDIT, 
  LIVES_INTERFACE_MODE_MULTITRACK 
} lives_interface_mode_t;


typedef enum {
  LIVES_STATUS_INVALID=-1, 
  LIVES_STATUS_NOTREADY, 
  LIVES_STATUS_READY, 
  LIVES_STATUS_PLAYING, 
  LIVES_STATUS_PROCESSING, 
  LIVES_STATUS_PREVIEW 
} lives_status_t;


typedef enum {
  LIVES_LITTLEENDIAN,
  LIVES_BIGENDIAN
} lives_endian_t;


typedef enum {
  LIVES_CALLBACK_FRAME_SYNCH = 1, 
  LIVES_CALLBACK_PLAYBACK_STARTED = 2,  
  LIVES_CALLBACK_PLAYBACK_STOPPED = 3, 
  LIVES_CALLBACK_PLAYBACK_STOPPED_RD = 4,

  LIVES_CALLBACK_RECORD_STARTED = 32, 
  LIVES_CALLBACK_RECORD_STOPPED = 33, 

  LIVES_CALLBACK_APP_QUIT = 64, 

  LIVES_CALLBACK_CLIP_OPENED = 128, 
  LIVES_CALLBACK_CLIP_CLOSED = 129, 


  LIVES_CALLBACK_CLIPSET_OPENED = 256, 
  LIVES_CALLBACK_CLIPSET_SAVED = 257, 

  LIVES_CALLBACK_MODE_CHANGED = 4096, 

  LIVES_CALLBACK_OBJECT_DESTROYED = 16384, 

#ifndef DOXYGEN_SKIP
  LIVES_CALLBACK_PRIVATE = 32768 
#endif
} lives_callback_t;



typedef enum {
  LIVES_CHAR_ENCODING_UTF8, 
  LIVES_CHAR_ENCODING_LOCAL8BIT, 
  LIVES_CHAR_ENCODING_FILESYSTEM, 
  //LIVES_CHAR_ENCODING_UTF16, ///< UTF-16 char encoding
} lives_char_encoding_t;

#define LIVES_CHAR_ENCODING_DEFAULT LIVES_CHAR_ENCODING_UTF8

typedef enum {
// positive values for custom responses
  LIVES_DIALOG_RESPONSE_INVALID=-1, 
  LIVES_DIALOG_RESPONSE_NONE=0, 
  LIVES_DIALOG_RESPONSE_OK, 
  LIVES_DIALOG_RESPONSE_RETRY, 
  LIVES_DIALOG_RESPONSE_ABORT, 
  LIVES_DIALOG_RESPONSE_RESET, 
  LIVES_DIALOG_RESPONSE_SHOW_DETAILS, 
  LIVES_DIALOG_RESPONSE_CANCEL, 
  LIVES_DIALOG_RESPONSE_ACCEPT, 
  LIVES_DIALOG_RESPONSE_YES, 
  LIVES_DIALOG_RESPONSE_NO 
} lives_dialog_response_t;


typedef enum {
  LIVES_AUDIO_SOURCE_UNKNOWN, 
  LIVES_AUDIO_SOURCE_INTERNAL, 
  LIVES_AUDIO_SOURCE_EXTERNAL 
} lives_audio_source_t;


typedef enum {
  LIVES_AUDIO_PLAYER_UNKNOWN, 
  LIVES_AUDIO_PLAYER_PULSE, 
  LIVES_AUDIO_PLAYER_JACK, 
  LIVES_AUDIO_PLAYER_SOX, 
  LIVES_AUDIO_PLAYER_MPLAYER, 
  LIVES_AUDIO_PLAYER_MPLAYER2 
} lives_audio_player_t;



typedef enum {
  LIVES_INSERT_MODE_NORMAL
} lives_insert_mode_t;



typedef enum {
  LIVES_GRAVITY_NORMAL, 
  LIVES_GRAVITY_LEFT, 
  LIVES_GRAVITY_RIGHT 
} lives_gravity_t;



typedef enum {
  LIVES_LOOP_MODE_NONE=0, 
  LIVES_LOOP_MODE_CONTINUOUS=1, 
  LIVES_LOOP_MODE_FIT_AUDIO=2 
} lives_loop_mode_t;



#ifdef __cplusplus

#include <vector>
#include <list>
#include <map>

#include <inttypes.h>

#include <string>

typedef unsigned long ulong;


#ifndef DOXYGEN_SKIP
extern "C" {
  void binding_cb (lives_callback_t cb_type, const char *msgstring, uint64_t id);
}
#endif

using namespace std;






namespace lives {


  typedef class livesApp livesApp;

  typedef class set set;

  typedef class clip clip;

  typedef class effectKey effectKey;

  typedef class effectKeyMap effectKeyMap;

  typedef class effect effect;


  typedef class player player;


  typedef class multitrack multitrack;


  typedef class block block;


  typedef class livesString livesString;


  typedef list<livesString> livesStringList;




  class livesString : public std::string {
  public:
    livesString(const string& str="", lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e), std::string(str) {}
    livesString(const string& str, size_t pos, size_t len = npos, lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e),
      std::string(str, pos, len) {}
    livesString(const char* s, lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e), std::string(s) {}
    livesString(const char* s, size_t n, lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e), std::string(s, n) {}
    livesString(size_t n, char c, lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e), std::string(n, c) {}
    template <class InputIterator>
    livesString  (InputIterator first, InputIterator last, 
                  lives_char_encoding_t e=LIVES_CHAR_ENCODING_DEFAULT) : m_encoding(e), std::string(first, last) {}

    livesString toEncoding(lives_char_encoding_t enc);

    void setEncoding(lives_char_encoding_t enc);

    lives_char_encoding_t encoding();

  private:
    lives_char_encoding_t m_encoding;
  };

#ifndef DOXYGEN_SKIP
  typedef void *(*callback_f)(void *);

  typedef struct {
    ulong id;
    livesApp *object;
    lives_callback_t cb_type;
    callback_f func;
    void *data;
  } closure;

  typedef list<closure *> closureList;
  typedef list<closure *>::iterator closureListIterator;
#endif

  typedef struct {
    lives_interface_mode_t mode; 
  } modeChangedInfo;


  typedef struct {
    int signum; 
  } appQuitInfo;


#ifndef DOXYGEN_SKIP
  typedef struct {
    ulong id;
    char *response;
  } _privateInfo;


  typedef bool (*private_callback_f)(_privateInfo *, void *);
#endif

  typedef bool (*modeChanged_callback_f)(livesApp *, modeChangedInfo *, void *);

  typedef bool (*appQuit_callback_f)(livesApp *, appQuitInfo *, void *);


  typedef bool (*objectDestroyed_callback_f)(livesApp *, void *);



  class livesApp {
    friend set;
    friend clip;
    friend effectKeyMap;
    friend effectKey;
    friend player;
    friend multitrack;
    friend block;

  public:
    livesApp();

    livesApp(int argc, char *argv[]);

    ~livesApp();

    bool isValid() const;

    bool isReady() const;

    bool isPlaying() const;

    const set& getSet();

    const effectKeyMap& getEffectKeyMap();

    const player& getPlayer();

    const multitrack& getMultitrack();

    bool removeCallback(ulong id) const;

    ulong addCallback(lives_callback_t cb_type, modeChanged_callback_f func, void *data) const;

    ulong addCallback(lives_callback_t cb_type, appQuit_callback_f func, void *data) const;

    ulong addCallback(lives_callback_t cb_type, objectDestroyed_callback_f func, void *data) const;

    lives_dialog_response_t showInfo(livesString text, bool blocking=true);

    livesString chooseFileWithPreview(livesString dirname, lives_filechooser_t chooser_type, livesString title=livesString(""));

    clip openFile(livesString fname, bool with_audio=true, double stime=0., int frames=0, bool deinterlace=false);

    livesStringList availableSets();

    livesString chooseSet();

    bool reloadSet(livesString setname);

    bool setInteractive(bool);

    bool interactive();

    bool deinterlaceOption();

    lives_interface_mode_t mode();

    lives_interface_mode_t setMode(lives_interface_mode_t);//, livesMultitrackSettings settings=NULL);

    lives_status_t status() const;

    bool cancel();



#ifndef DOXYGEN_SKIP
    // For internal use only.
    closureList& closures();
    void invalidate();
    void setClosures(closureList cl);
    
    bool setPref(int prefidx, bool val) const;
    bool setPref(int prefidx, int val) const;
    bool setPref(int prefidx, int bitfield, bool val) const;

#endif

  protected:
    ulong addCallback(lives_callback_t cb_type, private_callback_f func, void *data) const;

  private:
    ulong m_id;
    closureList m_closures;
    set * m_set;
    player *m_player;
    effectKeyMap * m_effectKeyMap;
    multitrack *m_multitrack;

    pthread_t *m_thread;

    bool m_deinterlace;

    ulong appendClosure(lives_callback_t cb_type, callback_f func, void *data) const;
    void init(int argc, char *argv[]);

    void operator=(livesApp const&); // Don't implement
    livesApp(const livesApp &other); // Don't implement

  };




  class clip {
    friend livesApp;
    friend set;
    friend block;
    friend multitrack;
    friend player;

  public:

    clip();

    bool isValid() const;

    int frames();

    int width();

    int height();

    double FPS();

    double playbackFPS();

    livesString name();

    int audioRate();

    int playbackAudioRate();

    int audioChannels();

    int audioSampleSize();

    bool audioSigned();

    lives_endian_t audioEndian();


    double audioLength();

    int selectionStart();

    int selectionEnd();


    bool selectAll();

    bool setSelectionStart(unsigned int start);

    bool setSelectionEnd(unsigned int end);

    bool switchTo();

    bool setIsBackground();

    inline bool operator==(const clip& other) {
      return other.m_uid == m_uid && m_lives == other.m_lives;
    }

  protected:
    clip(ulong uid, livesApp *lives=NULL);
    ulong m_uid;

  private:
    livesApp *m_lives;

  };
  


#ifndef DOXYGEN_SKIP
  typedef vector<ulong> clipList;
  typedef vector<ulong>::iterator clipListIterator;
#endif



  class set {
    friend livesApp;

  public:

    bool isValid() const;

    livesString name() const;

    bool setName(livesString name=livesString()) const;

    bool save(livesString name, bool force_append=false) const;

    bool save() const;

    unsigned int numClips() const;

    clip nthClip(unsigned int n) const;

    int indexOf(clip c) const;

    livesStringList layoutNames(unsigned int n) const;

    inline bool operator==(const set& other) const {
      return other.m_lives == m_lives;
    }


  protected:
    set(livesApp *lives=NULL);

  private:
    livesApp *m_lives;
    clipList m_clips;

    void update_clip_list(void);


  };





  class player {
    friend livesApp;

  public:

    bool isValid() const;

    bool isPlaying() const;


    bool isRecording() const;

    void setSepWin(bool) const;

    bool sepWin() const;

    void setFullScreen(bool) const;

    bool fullScreen() const;

    void setFS(bool) const;

    bool play() const;

    bool stop() const;

    bool setForegroundClip(clip c) const;

    clip foregroundClip() const;

    bool setBackgroundClip(clip c) const;

    clip backgroundClip() const;

    double setPlaybackStartTime(double time) const;

    int setVideoPlaybackFrame(int frame, bool background=false) const;

    double videoPlaybackTime(bool background=false) const;

    double setAudioPlaybackTime(double time) const;
       
    double audioPlaybackTime() const;

    double elapsedTime() const;

    double setCurrentFPS(double fps) const;

    double currentFPS() const;

    int currentAudioRate() const;

    lives_loop_mode_t setLoopMode(lives_loop_mode_t) const;

    lives_loop_mode_t loopMode() const;

    bool setPingPong(bool) const;

    bool pingPong() const;

    bool resyncFPS() const;


    inline bool operator==(const player& other) const {
      return other.m_lives == m_lives;
    }


  protected:
    player(livesApp *lives=NULL);

  private:
    livesApp *m_lives;

  };


  class effectKey {
    friend effectKeyMap;
  public:
    effectKey();

    bool isValid() const;

    int key();

    int numModes();

    int numMappedModes();

    int setCurrentMode(int mode);

    int currentMode();

    bool setEnabled(bool);

    bool enabled();

    int appendMapping(effect e);

    bool removeMapping(int mode);

    effect at(int mode);

    inline bool operator==(const effectKey& other) {
      return other.m_key == m_key && m_lives == other.m_lives;
    }

  protected:
    effectKey(livesApp *lives, int key);

  private:
    int m_key;
    livesApp *m_lives;

  };



    class effectKeyMap {
      friend livesApp;
    public:
      bool isValid() const;

      bool clear() const;

      effectKey at(int i) const;

      size_t size() const;

      inline bool operator==(const effectKeyMap& other) const {
        return other.m_lives == m_lives;
      }

      inline effectKey operator [] (int i) const {
        return effectKey(m_lives, i);
      }


    protected:
      effectKeyMap(livesApp *lives);

    private:
      livesApp *m_lives;
    };



  class effect {
    friend effectKey;
    friend multitrack;
  public:
    effect(const livesApp &lives, livesString hashname, bool match_full=false);

    effect(const livesApp &lives, livesString package, livesString fxname, livesString author=livesString(), int version=0);

    bool isValid() const;

    inline bool operator==(const effect& other) {
      return other.m_idx == m_idx && m_lives == other.m_lives;
    }

  protected:
    effect();
    effect(livesApp *m_lives, int idx);
    livesApp *m_lives;
    int m_idx;

  private:

  };



  class block {
    friend multitrack;

  public:

    bool isValid() const;

    block(multitrack m, int track, double time);

    double startTime();
    
    double length();

    clip clipSource();

    int track();

    bool remove();

    bool moveTo(int track, double time);



  protected:
    block(multitrack *m=NULL, ulong uid=0l);


  private:
    ulong m_uid;
    livesApp *m_lives;

    void invalidate();
  };



  class multitrack {
    friend livesApp;
    friend block;

  public:

    bool isValid() const;

    bool isActive() const;

    bool setCurrentTrack(int track) const;

    int currentTrack() const;

    double setCurrentTime(double time) const;

    double currentTime() const;

    livesString trackLabel(int track) const;

    bool setTrackLabel(int track, livesString label=livesString()) const;

    lives_gravity_t gravity() const;

    lives_gravity_t setGravity(lives_gravity_t) const;

    lives_insert_mode_t insertMode() const;

    lives_insert_mode_t setInsertMode(lives_insert_mode_t) const;


    int addVideoTrack(bool in_front) const;


    int numVideoTracks() const;


    int numAudioTracks() const;


    double FPS() const;

    block insertBlock(clip c, bool ignore_selection_limits=false, bool without_audio=false) const;

    livesString wipeLayout(bool force=false) const;

    livesString chooseLayout() const;

    livesStringList availableLayouts() const;

    bool reloadLayout(livesString filename) const;

    livesString saveLayout(livesString name) const;

    livesString saveLayout() const;

    clip render(bool render_audio=true, bool normalise_audio=true) const;

    effect autoTransition() const;

    bool disableAutoTransition() const;

    bool setAutoTransition(effect autotrans) const;

    inline bool operator==(const multitrack& other) const {
      return m_lives == other.m_lives;
    }


  protected:
    multitrack(livesApp *lives=NULL);
    livesApp *m_lives;


  };






  namespace prefs {
    livesString currentVideoLoadDir(const livesApp &lives); 

    livesString currentAudioDir(const livesApp &lives); 

    livesString tmpDir(const livesApp &lives);

    lives_audio_source_t audioSource(const livesApp &lives);

    bool setAudioSource(const livesApp &lives, lives_audio_source_t); 

    lives_audio_player_t audioPlayer(const livesApp &lives);

    int audioPlayerRate(const livesApp &lives);

    bool isRealtimeAudioPlayer(lives_audio_player_t);

    int rteKeysVirtual(const livesApp &lives);

    double maxFPS(const livesApp &lives);

    bool audioFollowsVideoClipChanges(const livesApp &lives);

    bool audioFollowsVideoFPSChanges(const livesApp &lives);

    bool setAudioFollowsVideoFPSChanges(const livesApp &lives, bool);

    bool setAudioFollowsVideoClipChanges(const livesApp &lives, bool);

    bool sepWinSticky(const livesApp &lives);

    bool setSepWinSticky(const livesApp &lives, bool);

    bool mtExitRender(const livesApp &lives);

    bool setMtExitRender(const livesApp &lives, bool);


  }


}

#endif // __cplusplus

#endif //HAS_LIBLIVES_H