html/LiVES/main_8h_source.html

 // main.h

 // LiVES

 // (c) G. Finch (salsaman@gmail.com) 2003 - 2017

 // see file ../COPYING for full licensing details


 /*  This program is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License version 3 or higher as

     published by the Free Software Foundation.


     This program 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 General Public License for more details.


     You should have received a copy of the GNU General Public License

     along with this program; if not, write to the Free Software

     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 */


 // begin legal warning

 /*

     NO WARRANTY


     BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY

       FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN

 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES

       PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED

       OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS

 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE

       PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,

 REPAIR OR CORRECTION.


       IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

       WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR

       REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,

       INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING

       OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED

 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY

 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER

       PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE

 POSSIBILITY OF SUCH DAMAGES.

 */

 // end legal warning


 // Have fun, and let's fight for Free Speech, Open Media and True Creativity !

 // - Salsaman


 // note: preferred coding style is: astyle --style=java -H -Y -s2 -U -k3 -W3 -xC140 -xL


 #ifndef HAS_LIVES_MAIN_H

 #define HAS_LIVES_MAIN_H


 #ifdef __cplusplus

 #undef HAVE_UNICAP

 #endif


 #ifndef GUI_QT

 #define GUI_GTK

 #define PAINTER_CAIRO

 #else

 #define PAINTER_QPAINTER

 #define NO_PROG_LOAD

 #undef ENABLE_GIW

 #endif


 #ifdef GUI_GTK


 #define USE_GLIB


 #include <gtk/gtk.h>

 #include <gdk/gdkkeysyms.h>


 #if GTK_CHECK_VERSION(3, 0, 0)

 #ifdef ENABLE_GIW

 #define ENABLE_GIW_3

 #endif

 #endif


 #endif


 #ifdef HAVE_WAYLAND

 #include <gdk/gdkwayland.h>

 #endif


 #ifdef GDK_WINDOWING_WAYLAND

 #ifndef GDK_IS_WAYLAND_DISPLAY

 #define GDK_IS_WAYLAND_DISPLAY(a) FALSE

 #endif

 #endif


 #ifdef IS_MINGW


 #ifndef WINVER

 #define WINVER 0x0500

 #endif


 #include <windows.h>

 #include <winbase.h>

 #include <tlhelp32.h>

 #include <sddl.h>


 #define O_SYNC (FILE_FLAG_NO_BUFFERING|FILE_FLAG_WRITE_THROUGH)


 typedef PROCESS_INFORMATION *lives_pid_t;

 typedef PROCESS_INFORMATION *lives_pgid_t;


 #ifdef GUI_GTK

 #ifndef GDK_WINDOWING_WIN32

 #define GDK_WINDOWING_WIN32

 #endif

 #endif


 #else // IS_MINGW


 #ifdef GUI_GTK

 #ifndef GDK_WINDOWING_X11

 #define GDK_WINDOWING_X11

 #endif

 #else

 #include <sys/types.h>

 #include <unistd.h>


 #endif // GUI_GTK


 typedef pid_t lives_pid_t;

 typedef int lives_pgid_t;


 #endif // IS_MINGW


 #include <sys/stat.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <unistd.h>

 #include <string.h>

 #include <signal.h>

 #include <assert.h>

 #include <errno.h>


 #ifdef __cplusplus

 #define __STDC_CONSTANT_MACROS

 #ifdef _STDINT_H

 #undef _STDINT_H

 #endif

 #endif


 #include <stdint.h>

 #include <stdarg.h>


 #ifndef ulong

 #define ulong unsigned long

 #endif


 #define QUOTEME(x) #x


 #define MAX_FILES 65535


 #ifndef PREFIX_DEFAULT

 #ifndef IS_MINGW

 #define PREFIX_DEFAULT "/usr"

 #else

 // TODO - get this from the installer

 #define PREFIX_DEFAULT "C:\\Program Files\\LiVES"

 #endif

 #endif


 #ifndef PREFIX

 #define PREFIX PREFIX_DEFAULT

 #endif


 #ifndef IS_MINGW

 #define LIVES_DIR_SEP "/"

 #define LIVES_STATUS_FILE_NAME ".status"

 #define LIVES_INFO_FILE_NAME ".info"

 #define LIVES_BFILE_NAME ".smogrify"

 #define LIVES_SMOGPLUGIN_FILE_NAME ".smogplugin"

 #define LIVES_SMOGVAL_FILE_NAME ".smogval"

 #define LIVES_ENC_DEBUG_FILE_NAME ".debug_out"

 #define LIVES_DEVNULL "/dev/null"


 #define DLL_NAME "so"


 #define DOC_DIR "/share/doc/lives-"


 #define THEME_DIR "/share/lives/themes/"

 #define PLUGIN_SCRIPTS_DIR "/share/lives/plugins/"

 #define PLUGIN_COMPOUND_DIR "/share/lives/plugins/"

 #define PLUGIN_EXEC_DIR "/lives/plugins/"

 #define ICON_DIR "/share/lives/icons/"

 #define DESKTOP_ICON_DIR "/share/icons/hicolor/48x48/apps"

 #define DATA_DIR "/share/lives/"

 #define LIVES_CONFIG_DIR ".lives-dir/"

 #define LIVES_WORK_NAME "livesprojects"


 #else // IS_MINGW

 #define LIVES_DIR_SEP "\\"

 #define LIVES_STATUS_FILE_NAME "status"

 #define LIVES_INFO_FILE_NAME "info"

 #define LIVES_BFILE_NAME "smogrify"

 #define LIVES_SMOGPLUGIN_FILE_NAME "smogplugin"

 #define LIVES_SMOGVAL_FILE_NAME "smogval"

 #define LIVES_ENC_DEBUG_FILE_NAME "debug_out"

 #define LIVES_DEVNULL "NUL"


 #define DLL_NAME "dll"


 #define DOC_DIR "\\Documents/"


 #define THEME_DIR "\\Themes/"

 #define PLUGIN_SCRIPTS_DIR "\\Plugins/"

 #define PLUGIN_COMPOUND_DIR "\\Plugins/"

 #define PLUGIN_EXEC_DIR "\\Plugins/"

 #define ICON_DIR "\\Icons/"

 #define DATA_DIR "\\Data/"

 #define LIVES_CONFIG_DIR "\\Config/"

 #define LIVES_WORK_NAME "livesprojects"

 #endif


 #define LIVES_DEVICE_DIR "/dev/"


 #define LIVES_COPYRIGHT_YEARS "2002 - 2017"


 #define LIVES_WEBSITE PACKAGE_URL

 #define LIVES_MANUAL_URL LIVES_WEBSITE "/manual/"

 #define LIVES_MANUAL_FILENAME "LiVES_manual.html"

 #define LIVES_AUTHOR_EMAIL "salsaman+lives@gmail.com"

 #define LIVES_DONATE_URL "https://sourceforge.net/p/lives/donate/"

 #define LIVES_BUG_URL PACKAGE_BUGREPORT

 #define LIVES_FEATURE_URL "https://sourceforge.net/p/lives/feature-requests/"

 #define LIVES_TRANSLATE_URL "https://translations.launchpad.net/lives/trunk"


 #if defined (IS_DARWIN) || defined (__FreeBSD__)

 #ifndef off64_t

 #define off64_t off_t

 #endif

 #ifndef lseek64

 #define lseek64 lseek

 #endif

 #endif


 #define DEF_FILE_PERMS (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)


 #define WARN_FILE_SIZE 500


 #define FPS_MAX 200.


 #define MAX_FRAME_WIDTH 100000.

 #define MAX_FRAME_HEIGHT 100000.


 #define ENABLE_DVD_GRAB


 #ifdef HAVE_MJPEGTOOLS

 #define HAVE_YUV4MPEG

 #endif


 #ifdef ENABLE_ORC

 #include <orc/orc.h>

 #endif


 #ifdef ENABLE_OIL

 #include <liboil/liboil.h>

 #endif


 #ifndef IS_SOLARIS

 #define LIVES_INLINE inline

 #else

 #define LIVES_INLINE

 #endif


 #include <limits.h>

 #include <float.h>


 #ifndef PATH_MAX

 #ifdef MAX_PATH

 #define PATH_MAX MAX_PATH

 #else

 #define PATH_MAX 4096

 #endif

 #endif


 #ifdef __GNUC__

 #  define WARN_UNUSED  __attribute__((warn_unused_result))

 #  define GNU_PURE  __attribute__((pure))

 #  define GNU_CONST  __attribute__((const))

 #  define GNU_MALLOC  __attribute__((malloc))

 #  define GNU_ALIGN(x) __attribute__((alloc_align(x)))

 #else

 #  define WARN_UNUSED

 #  define GNU_PURE

 #  define GNU_CONST

 #  define GNU_MALLOC

 #  define GNU_ALIGN(x)

 #endif


 #ifdef PRODUCE_LOG

 #define LIVES_LOG "lives.log"

 #endif


 uint64_t lives_random(void);


 typedef struct {

   uint16_t red;

   uint16_t green;

   uint16_t blue;

 } lives_colRGB48_t;


 typedef struct {

   uint16_t red;

   uint16_t green;

   uint16_t blue;

   uint16_t alpha;

 } lives_colRGBA64_t;


 #include "widget-helper.h"


 typedef  void *(*fn_ptr)(void *ptr);


 #define ALLOW_MPV

 #define ALLOW_PNG24


 typedef struct {

   int value;

   int64_t reltime;

 } event;


 typedef struct {

   // processing / busy dialog

   LiVESWidget *processing;

   LiVESWidget *progressbar;

   LiVESWidget *label;

   LiVESWidget *label2;

   LiVESWidget *label3;

   LiVESWidget *stop_button;

   LiVESWidget *pause_button;

   LiVESWidget *preview_button;

   LiVESWidget *cancel_button;

   LiVESWidget *scrolledwindow;

   uint32_t frames_done;

   boolean is_ready;

 } xprocess;


 typedef struct {

   int afile;

   double seek;

   double vel;

 } lives_audio_track_state_t;


 #if HAVE_SYSTEM_WEED

 #include <weed/weed.h>

 #include <weed/weed-events.h>

 #else

 #include "../libweed/weed.h"

 #include "../libweed/weed-events.h"

 #endif


 // see weed event spec. for more info


 #include "events.h"


 #ifdef IS_LIBLIVES

 #include "liblives.hpp"

 #include "lbindings.h"

 #endif


 typedef enum {

   UNDO_NONE = 0,

   UNDO_EFFECT,

   UNDO_RESIZABLE,

   UNDO_MERGE,

   UNDO_RESAMPLE,

   UNDO_TRIM_AUDIO,

   UNDO_CHANGE_SPEED,

   UNDO_AUDIO_RESAMPLE,

   UNDO_APPEND_AUDIO,

   UNDO_INSERT,

   UNDO_CUT,

   UNDO_DELETE,

   UNDO_DELETE_AUDIO,

   UNDO_INSERT_SILENCE,

   UNDO_NEW_AUDIO,


   UNDO_ATOMIC_RESAMPLE_RESIZE,


   UNDO_RENDER,


   UNDO_FADE_AUDIO,


   UNDO_REC_AUDIO,


   UNDO_INSERT_WITH_AUDIO

 } lives_undo_t;


 typedef enum {

   NEVER_STOP = 0,

   STOP_ON_VID_END,

   STOP_ON_AUD_END

 } lives_whentostop_t;


 typedef enum {

   CANCEL_NONE = FALSE,


   CANCEL_USER,


   CANCEL_NO_PROPOGATE,


   CANCEL_PREVIEW_FINISHED,


   CANCEL_APP_QUIT,


   CANCEL_NO_MORE_PREVIEW,


   CANCEL_CAPTURE_ERROR,


   CANCEL_EVENT_LIST_END,


   CANCEL_VID_END,


   CANCEL_GENERATOR_END,


   CANCEL_KEEP,


   CANCEL_AUD_END,


   CANCEL_ERROR,


   CANCEL_USER_PAUSED,


   CANCEL_KEEP_LOOPING = CANCEL_NONE + 100

 } lives_cancel_t;


 typedef enum {

   CANCEL_KILL = 0,

   CANCEL_SOFT

 } lives_cancel_type_t;


 typedef enum {

   CLIP_TYPE_DISK,

   CLIP_TYPE_YUV4MPEG,

   CLIP_TYPE_GENERATOR,

   CLIP_TYPE_FILE,

   CLIP_TYPE_LIVES2LIVES,

   CLIP_TYPE_VIDEODEV

 } lives_clip_type_t;


 typedef enum {

   IMG_TYPE_UNKNOWN = 0,

   IMG_TYPE_JPEG,

   IMG_TYPE_PNG

 } lives_image_type_t;


 #define IMG_TYPE_BEST IMG_TYPE_PNG


 #define AFORM_SIGNED 0

 #define AFORM_LITTLE_ENDIAN 0


 #define AFORM_UNSIGNED 1

 #define AFORM_BIG_ENDIAN (1<<1)

 #define AFORM_UNKNOWN 65536


 typedef enum {

   LIVES_INTERLACE_NONE = 0,

   LIVES_INTERLACE_BOTTOM_FIRST = 1,

   LIVES_INTERLACE_TOP_FIRST = 2

 } lives_interlace_t;


 #include "pangotext.h"


 #define WEED_LEAF_HOST_DEINTERLACE "host_deinterlace" // frame needs deinterlacing

 #define WEED_LEAF_HOST_TC "host_tc" // timecode for deinterlace

 #define WEED_LEAF_HOST_DECODER "host_decoder" // pointer to decoder for a layer

 #define WEED_LEAF_HOST_PTHREAD "host_pthread" // thread for a layer


 #define CLIP_NAME_MAXLEN 256


 typedef struct {

   // basic info (saved during backup)

   int bpp;

   double fps;

   int hsize;

   int vsize;

   int arps;

   uint32_t signed_endian;


   int arate;

   uint64_t unique_id;

   int achans;

   int asampsize;


   int frames;

   char title[256];

   char author[256];

   char comment[256];

   char keywords[256];


   lives_interlace_t interlace;


   // extended info (not saved)

   int header_version;


 #define LIVES_CLIP_HEADER_VERSION 100


   int rowstride;


   xprocess *proc_ptr;


   char handle[256];

   int ohsize;

   int ovsize;

   int64_t f_size;

   int64_t afilesize;

   int old_frames;

   char file_name[PATH_MAX];

   char info_file[PATH_MAX];

   char name[CLIP_NAME_MAXLEN];

   char save_file_name[PATH_MAX];

   char type[64];

   int start;

   int end;

   int insert_start;

   int insert_end;

   int progress_start;

   int progress_end;

   boolean changed;

   LiVESWidget *menuentry;

   ulong menuentry_func;

   boolean orig_file_name;

   boolean was_renamed;

   boolean is_untitled;

   double pb_fps;

   double freeze_fps;

   boolean play_paused;


   //opening/restoring status

   boolean opening;

   boolean opening_audio;

   boolean opening_only_audio;

   boolean opening_loc;

   boolean restoring;

   boolean is_loaded;


   boolean nopreview;


   boolean nokeep;


   // various times; total time is calculated as the longest of video, laudio and raudio

   double total_time;

   double video_time;

   double laudio_time;

   double raudio_time;

   double pointer_time;


   // used only for insert_silence, holds pre-padding length for undo

   double old_laudio_time;

   double old_raudio_time;


   // current and last played index frames for internal player

   int frameno;

   int last_frameno;


   // see resample.c for new events system


   // events

   event *events[1];


   weed_plant_t *event_list;

   weed_plant_t *event_list_back;

   weed_plant_t *next_event;


   LiVESList *layout_map;


   lives_undo_t undo_action;


   int undo_start;

   int undo_end;

   char undo_text[32];

   char redo_text[32];

   boolean undoable;

   boolean redoable;


   // used for storing undo values

   int undo1_int;

   int undo2_int;

   int undo3_int;

   int undo4_int;

   uint32_t undo1_uint;

   double undo1_dbl;

   double undo2_dbl;

   boolean undo1_boolean;

   boolean undo2_boolean;

   boolean undo3_boolean;


   int undo_arate;

   uint32_t undo_signed_endian;

   int undo_achans;

   int undo_asampsize;

   int undo_arps;


   lives_clip_type_t clip_type;


   void *ext_src;


   int *frame_index;


   int *frame_index_back;


   int fx_frame_pump;


 #define FX_FRAME_PUMP_VAL 200


 #define IMG_BUFF_SIZE 4096


   boolean ratio_fps;


   int64_t aseek_pos;


   // decoder data


   char mime_type[256];


   boolean deinterlace;


   lives_image_type_t img_type;


   int stored_layout_frame;

   int stored_layout_idx;

   double stored_layout_audio;

   double stored_layout_fps;


   lives_subtitles_t *subt;


   char *op_dir;

   uint64_t op_ds_warn_level;


   boolean no_proc_sys_errors;

   boolean no_proc_read_errors;

   boolean no_proc_write_errors;


   boolean keep_without_preview;


   lives_painter_surface_t *laudio_drawable;

   lives_painter_surface_t *raudio_drawable;


   int cb_src;


   boolean needs_update;

 } lives_clip_t;


 typedef struct {

   // the following can be assumed TRUE, they are checked on startup

   boolean has_smogrify;

   boolean smog_version_correct;

   boolean can_read_from_config;

   boolean can_write_to_config;

   boolean can_write_to_home;

   boolean can_write_to_workdir;


   // the following may need checking before use

   boolean has_dvgrab;

   boolean has_sox_play;

   boolean has_sox_sox;

   boolean has_autolives;

   boolean has_mplayer;

   boolean has_mplayer2;

   boolean has_mpv;

   boolean has_convert;

   boolean has_composite;

   boolean has_identify;

   boolean has_cdda2wav;

   boolean has_icedax;

   boolean has_midistartstop;

   boolean has_jackd;

   boolean has_pulse_audio;

   boolean has_xwininfo;

   boolean has_gdb;

   boolean has_gconftool_2;

   boolean has_xdg_screensaver;


   char home_dir[PATH_MAX];


   char touch_cmd[PATH_MAX];

   char rm_cmd[PATH_MAX];

   char mv_cmd[PATH_MAX];

   char cp_cmd[PATH_MAX];

   char ln_cmd[PATH_MAX];

   char chmod_cmd[PATH_MAX];

   char cat_cmd[PATH_MAX];

   char echo_cmd[PATH_MAX];

   char eject_cmd[PATH_MAX];

   char rmdir_cmd[PATH_MAX];


   char *rcfile;


   char startup_msg[256];


   // plugins

   boolean has_encoder_plugins;


   boolean has_python;

   uint64_t python_version;


   short cpu_bits;


   char *myname_full;

   char *myname;


   boolean has_stderr;


   int nmonitors;


   int ncpus;


   int byte_order;


   pid_t mainpid;


   mode_t umask;

 } capability;


 extern capability *capable;


 #ifdef HAVE_JACK_JACK_H

 #include "jack.h"

 #endif


 #define __STDC_FORMAT_MACROS

 #include <inttypes.h>


 #ifndef PRId64


 #ifndef __WORDSIZE

 #if defined __x86_64__

 # define __WORDSIZE     64

 #ifndef __WORDSIZE_COMPAT32

 # define __WORDSIZE_COMPAT32    1

 #endif

 #else

 # define __WORDSIZE     32

 #endif

 #endif // __WORDSIZE


 #ifndef __PRI64_PREFIX

 # if __WORDSIZE == 64

 #  define __PRI64_PREFIX        "l"

 # else

 #  define __PRI64_PREFIX        "ll"

 # endif

 #endif


 # define PRId64         __PRI64_PREFIX "d"

 # define PRIu64         __PRI64_PREFIX "u"

 #endif // ifndef PRI64d


 // common defs for mainwindow (retain this order)

 #include "plugins.h"

 #include "colourspace.h"

 #include "paramspecial.h"

 #include "multitrack.h"

 #include "mainwindow.h"

 #include "keyboard.h"

 #include "preferences.h"


 extern mainwindow *mainw;


 // internal player clock

 #include <sys/time.h>

 struct timeval tv;


 extern ssize_t sizint, sizdbl, sizshrt;


 typedef enum {

   CLIP_DETAILS_BPP,

   CLIP_DETAILS_FPS,

   CLIP_DETAILS_PB_FPS,

   CLIP_DETAILS_WIDTH,

   CLIP_DETAILS_HEIGHT,

   CLIP_DETAILS_UNIQUE_ID,

   CLIP_DETAILS_ARATE,

   CLIP_DETAILS_PB_ARATE,

   CLIP_DETAILS_ACHANS,

   CLIP_DETAILS_ASIGNED,

   CLIP_DETAILS_AENDIAN,

   CLIP_DETAILS_ASAMPS,

   CLIP_DETAILS_FRAMES,

   CLIP_DETAILS_TITLE,

   CLIP_DETAILS_AUTHOR,

   CLIP_DETAILS_COMMENT,

   CLIP_DETAILS_PB_FRAMENO,

   CLIP_DETAILS_FILENAME,

   CLIP_DETAILS_CLIPNAME,

   CLIP_DETAILS_HEADER_VERSION,

   CLIP_DETAILS_KEYWORDS,

   CLIP_DETAILS_INTERLACE,

   CLIP_DETAILS_DECODER_NAME

 } lives_clip_details_t;


 // some useful functions


 // dialogs.c

 boolean do_progress_dialog(boolean visible, boolean cancellable, const char *text);

 boolean do_warning_dialog(const char *text);

 boolean do_warning_dialog_with_check(const char *text, int warn_mask_number);

 boolean do_warning_dialog_with_check_transient(const char *text, int warn_mask_number, LiVESWindow *transient);

 boolean do_yesno_dialog(const char *text);

 boolean do_yesno_dialog_with_check(const char *text, int warn_mask_number);

 boolean do_yesno_dialog_with_check_transient(const char *text, int warn_mask_number, LiVESWindow *transient);

 boolean do_yesno_dialog_with_check(const char *text, int warn_mask_number);

 boolean do_yesno_dialog_with_check_transient(const char *text, int warn_mask_number, LiVESWindow *transient);

 int do_abort_cancel_retry_dialog(const char *text, LiVESWindow *transient) WARN_UNUSED;

 int do_error_dialog(const char *text);

 int do_info_dialog(const char *text);

 int do_error_dialog_with_check(const char *text, int warn_mask_number);

 int do_blocking_error_dialog(const char *text);

 int do_blocking_info_dialog(const char *text);

 int do_error_dialog_with_check_transient(const char *text, boolean is_blocking, int warn_mask_number,

     LiVESWindow *transient);

 int do_info_dialog_with_transient(const char *text, boolean is_blocking, LiVESWindow *transient);

 LiVESWidget *create_message_dialog(lives_dialog_t diat, const char *text, LiVESWindow *transient,

                                    int warn_mask_number, boolean is_blocking);

 LiVESWidget *create_question_dialog(const char *title, const char *text, LiVESWindow *parent);

 LiVESWindow *get_transient_full();

 void do_system_failed_error(const char *com, int retval, const char *addinfo);

 int do_write_failed_error_s_with_retry(const char *fname, const char *errtext, LiVESWindow *transient) WARN_UNUSED;

 void do_write_failed_error_s(const char *filename, const char *addinfo);

 int do_read_failed_error_s_with_retry(const char *fname, const char *errtext, LiVESWindow *transient) WARN_UNUSED;

 void do_read_failed_error_s(const char *filename, const char *addinfo);

 boolean do_header_write_error(int clip);

 int do_header_read_error_with_retry(int clip) WARN_UNUSED;

 int do_header_missing_detail_error(int clip, lives_clip_details_t detail) WARN_UNUSED;

 void do_chdir_failed_error(const char *dir);

 void handle_backend_errors(void);

 boolean check_backend_return(lives_clip_t *sfile);


 char *ds_critical_msg(const char *dir, uint64_t dsval);

 char *ds_warning_msg(const char *dir, uint64_t dsval, uint64_t cwarn, uint64_t nwarn);

 boolean check_storage_space(lives_clip_t *sfile, boolean is_processing);


 char *get_upd_msg(int type);

 char *get_new_install_msg(void);


 boolean ask_permission_dialog(int what);

 boolean do_abort_check(void);

 void add_warn_check(LiVESBox *box, int warn_mask_number);

 void do_memory_error_dialog(void);

 void too_many_files(void);

 void workdir_warning(void);

 void do_audio_import_error(void);

 void do_mt_backup_space_error(lives_mt *, int memreq_mb);


 boolean do_clipboard_fps_warning(void);

 void perf_mem_warning(void);

 void do_dvgrab_error(void);

 boolean do_comments_dialog(int fileno, char *filename);

 boolean do_auto_dialog(const char *text, int type);

 void do_encoder_acodec_error(void);

 void do_encoder_sox_error(void);

 boolean rdet_suggest_values(int width, int height, double fps, int fps_num, int fps_denom, int arate,

                             int asigned, boolean swap_endian, boolean anr, boolean ignore_fps);

 boolean do_encoder_restrict_dialog(int width, int height, double fps, int fps_num, int fps_denom,

                                    int arate, int asigned, boolean swap_endian, boolean anr, boolean save_all);

 void do_messages_window(void);

 void do_firstever_dialog(void);

 void do_upgrade_error_dialog(void);

 void do_no_mplayer_sox_error(void);

 void do_need_mplayer_dialog(void);

 void do_need_mplayer_mpv_dialog(void);

 void do_aud_during_play_error(void);

 void do_rendered_fx_dialog(void);

 void do_layout_scrap_file_error(void);

 void do_layout_ascrap_file_error(void);

 void do_lb_composite_error(void);

 void do_lb_convert_error(void);

 void do_ra_convert_error(void);

 void do_set_load_lmap_error(void);

 boolean do_set_duplicate_warning(const char *new_set);

 boolean do_set_rename_old_layouts_warning(const char *new_set);

 boolean do_layout_alter_frames_warning(void);

 boolean do_layout_alter_audio_warning(void);

 boolean do_yuv4m_open_warning(void);

 void do_mt_undo_mem_error(void);

 void do_mt_undo_buf_error(void);

 void do_mt_set_mem_error(boolean has_mt, boolean trans);

 void do_mt_audchan_error(int warn_mask);

 void do_mt_no_audchan_error(void);

 void do_mt_no_jack_error(int warn_mask);

 boolean do_mt_rect_prompt(void);

 void do_audrate_error_dialog(void);

 boolean do_event_list_warning(void);

 void do_nojack_rec_error(void);

 void do_vpp_palette_error(void);

 void do_vpp_fps_error(void);

 void do_decoder_palette_error(void);

 void do_rmem_max_error(int size);

 boolean do_original_lost_warning(const char *fname);

 void do_no_decoder_error(const char *fname);

 void do_jack_noopen_warn(void);

 void do_jack_noopen_warn2(void);

 void do_jack_noopen_warn3(void);

 void do_jack_noopen_warn4(void);

 void do_file_perm_error(const char *file_name);

 void do_dir_perm_error(const char *dir_name);

 void do_dir_perm_access_error(const char *dir_name);

 void do_encoder_img_ftm_error(render_details *rdet);

 void do_after_crash_warning(void);

 void do_bad_layout_error(void);

 void do_card_in_use_error(void);

 void do_dev_busy_error(const char *devstr);

 boolean do_existing_subs_warning(void);

 void do_invalid_subs_error(void);

 boolean do_erase_subs_warning(void);

 boolean do_sub_type_warning(const char *ext, const char *type_ext);

 boolean do_move_workdir_dialog(void);

 void do_set_locked_warning(const char *setname);

 void do_no_in_vdevs_error(void);

 void do_locked_in_vdevs_error(void);

 void do_do_not_close_d(void);

 void do_set_noclips_error(const char *setname);

 void do_no_autolives_error(void);

 void do_autolives_needs_clips_error(void);

 void do_pulse_lost_conn_error(void);

 void do_jack_lost_conn_error(void);

 void do_cd_error_dialog(void);

 void do_bad_theme_error(const char *themefile);

 void do_bad_theme_import_error(const char *theme_file);

 boolean do_theme_exists_warn(const char *themename);


 boolean process_one(boolean visible);

 void do_threaded_dialog(char *translated_text, boolean has_cancel);

 void end_threaded_dialog(void);

 void threaded_dialog_spin(double fraction);

 void response_ok(LiVESButton *button, livespointer user_data);

 void pump_io_chan(LiVESIOChannel *iochan);


 void do_splash_progress(void);


 // d_print shortcuts

 void d_print_cancelled(void);

 void d_print_failed(void);

 void d_print_done(void);

 void d_print_file_error_failed(void);


 // general

 void do_text_window(const char *title, const char *text);


 // saveplay.c

 boolean read_file_details(const char *file_name, boolean only_check_for_audio);

 boolean add_file_info(const char *check_handle, boolean aud_only);

 boolean save_file_comments(int fileno);

 boolean reload_clip(int fileno, int maxframe);

 void wait_for_bg_audio_sync(lives_clip_t *sfile);

 void reget_afilesize(int fileno);

 ulong deduce_file(const char *filename, double start_time, int end);

 ulong open_file(const char *filename);

 ulong open_file_sel(const char *file_name, double start_time, int frames);

 void open_fw_device(void);

 char *get_untitled_name(int number);

 boolean get_new_handle(int index, const char *name);

 boolean get_temp_handle(int index, boolean create);

 boolean get_handle_from_info_file(int index);

 void create_cfile(void);

 void save_file(int clip, int start, int end, const char *filename);

 void play_file(void);

 void save_frame(LiVESMenuItem *menuitem, livespointer user_data);

 boolean save_frame_inner(int clip, int frame, const char *file_name, int width, int height, boolean from_osc);

 void wait_for_stop(const char *stop_command);

 boolean save_clip_values(int which_file);

 void add_to_recovery_file(const char *handle);

 void rewrite_recovery_file(void);

 boolean check_for_recovery_files(boolean auto_recover);

 void recover_layout_map(int numclips);

 const char *get_deinterlace_string(void);


 // saveplay.c backup

 void backup_file(int clip, int start, int end, const char *filename);

 int save_event_frames(void);

 boolean write_headers(lives_clip_t *file);


 // saveplay.c restore

 ulong restore_file(const char *filename);

 boolean read_headers(const char *file_name);


 // saveplay.c sets

 void open_set_file(const char *set_name, int clipnum);


 // saveplay.c scrap file

 boolean open_scrap_file(void);

 boolean open_ascrap_file(void);

 int save_to_scrap_file(weed_plant_t *layer);

 boolean load_from_scrap_file(weed_plant_t *layer, int frame);

 void close_ascrap_file(void);

 void close_scrap_file(void);

 void add_to_ascrap_mb(uint64_t bytes);


 boolean check_for_disk_space(void);


 // main.c

 typedef void (*SignalHandlerPointer)(int);


 void set_signal_handlers(SignalHandlerPointer sigfunc);

 void catch_sigint(int signum);

 void defer_sigint(int signum);

 boolean startup_message_fatal(const char *msg);

 boolean startup_message_choice(const char *msg, int msgtype);

 boolean startup_message_nonfatal(const char *msg);

 boolean startup_message_info(const char *msg);

 boolean startup_message_nonfatal_dismissable(const char *msg, int warning_mask);

 capability *get_capabilities(void);

 void get_monitors(void);

 void set_ce_frame_from_pixbuf(LiVESImage *image, LiVESPixbuf *pixbuf, lives_painter_t *);

 void load_start_image(int frame);

 void load_end_image(int frame);

 void load_preview_image(boolean update_always);


 boolean pull_frame(weed_plant_t *layer, const char *image_ext, weed_timecode_t tc);

 void pull_frame_threaded(weed_plant_t *layer, const char *img_ext, weed_timecode_t tc);

 void check_layer_ready(weed_plant_t *layer);

 boolean pull_frame_at_size(weed_plant_t *layer, const char *image_ext, weed_timecode_t tc,

                            int width, int height, int target_palette);

 LiVESPixbuf *pull_lives_pixbuf_at_size(int clip, int frame, const char *image_ext, weed_timecode_t tc,

                                        int width, int height, LiVESInterpType interp);

 LiVESPixbuf *pull_lives_pixbuf(int clip, int frame, const char *image_ext, weed_timecode_t tc);


 LiVESError *lives_pixbuf_save(LiVESPixbuf *pixbuf, char *fname, lives_image_type_t imgtype,

                               int quality, boolean do_chmod, LiVESError **gerrorptr);


 void init_track_decoders(void);

 void free_track_decoders(void);


 #ifdef USE_LIBPNG

 boolean layer_from_png(FILE *fp, weed_plant_t *layer, boolean prog);

 boolean save_to_png(FILE *fp, weed_plant_t *layer, int comp);

 #endif


 void load_frame_image(int frame);

 void sensitize(void);

 void desensitize(void);

 void procw_desensitize(void);

 void close_current_file(int file_to_switch_to);

 void get_next_free_file(void);

 void switch_to_file(int old_file, int new_file);

 void do_quick_switch(int new_file);

 void switch_audio_clip(int new_file, boolean activate);

 void resize(double scale);

 void do_start_messages(void);

 boolean set_palette_colours(boolean force_reload);

 void set_main_title(const char *filename, int or_untitled_number);

 void set_record(void);


 //gui.c

 void  create_LiVES(void);

 void show_lives(void);

 void set_colours(LiVESWidgetColor *colf, LiVESWidgetColor *colb, LiVESWidgetColor *colf2,

                  LiVESWidgetColor *colb2, LiVESWidgetColor *coli, LiVESWidgetColor *colt);

 void set_preview_box_colours(void);

 void load_theme_images(void);

 void set_interactive(boolean interactive);

 char *get_menu_name(lives_clip_t *sfile);

 void enable_record(void);

 void toggle_record(void);

 void disable_record(void);

 void make_custom_submenus(void);

 void fade_background(void);

 void unfade_background(void);

 void block_expose(void);

 void unblock_expose(void);

 void frame_size_update(void);

 void splash_init(void);

 void splash_end(void);

 void splash_msg(const char *msg, double pct);

 void add_message_scroller(LiVESWidget *conter);

 void resize_widgets_for_monitor(boolean get_play_times);

 #if GTK_CHECK_VERSION(3, 0, 0)

 void calibrate_sepwin_size(void);

 boolean expose_pim(LiVESWidget *widget, lives_painter_t *cr, livespointer user_data);

 boolean expose_sim(LiVESWidget *widget, lives_painter_t *cr, livespointer user_data);

 boolean expose_eim(LiVESWidget *widget, lives_painter_t *cr, livespointer user_data);

 #endif


 // system calls in utils.c

 int lives_system(const char *com, boolean allow_error);

 lives_pid_t lives_fork(const char *com);

 int lives_open3(const char *pathname, int flags, mode_t mode);

 int lives_open2(const char *pathname, int flags);

 int lives_open_buffered_rdonly(const char *pathname);

 int lives_creat_buffered(const char *pathname, int mode);

 int lives_close_buffered(int fd);

 void lives_close_all_file_buffers(void);

 off_t lives_lseek_buffered_rdonly(int fd, off_t offset);

 ssize_t lives_write(int fd, livesconstpointer buf, size_t count, boolean allow_fail);

 ssize_t lives_write_buffered(int fd, const char *buf, size_t count, boolean allow_fail);

 ssize_t lives_write_le(int fd, livesconstpointer buf, size_t count, boolean allow_fail);

 ssize_t lives_write_le_buffered(int fd, livesconstpointer buf, size_t count, boolean allow_fail);

 ssize_t lives_read(int fd, void *buf, size_t count, boolean allow_less);

 ssize_t lives_read_buffered(int fd, void *buf, size_t count, boolean allow_less);

 ssize_t lives_read_le(int fd, void *buf, size_t count, boolean allow_less);

 ssize_t lives_read_le_buffered(int fd, void *buf, size_t count, boolean allow_less);

 int lives_chdir(const char *path, boolean allow_fail);

 int lives_fputs(const char *s, FILE *stream);

 char *lives_fgets(char *s, int size, FILE *stream);

 pid_t lives_getpid(void);

 int lives_getgid(void);

 int lives_getuid(void);

 boolean lives_freep(void **ptr);

 void lives_kill_subprocesses(const char *dirname, boolean kill_parent);

 void lives_suspend_resume_process(const char *dirname, boolean suspend);

 #ifdef IS_MINGW

 boolean lives_win32_suspend_resume_process(DWORD pid, boolean suspend);

 boolean lives_win32_kill_subprocesses(DWORD pid, boolean kill_parent);

 int lives_win32_get_num_logical_cpus(void);

 #endif

 int lives_kill(lives_pid_t pid, int sig);

 int lives_killpg(lives_pgid_t pgrp, int sig);

 void lives_srandom(unsigned int seed);

 ssize_t lives_readlink(const char *path, char *buf, size_t bufsiz);

 boolean lives_setenv(const char *name, const char *value);

 boolean lives_fsync(int fd);

 void lives_sync(void);

 int lives_rmdir(const char *dir, boolean force);

 int lives_rmdir_with_parents(const char *dir);

 int lives_rm(const char *file);

 int lives_rmglob(const char *files);

 int lives_cp(const char *from, const char *to);

 int lives_cp_keep_perms(const char *from, const char *to);

 int lives_mv(const char *from, const char *to);

 int lives_touch(const char *tfile);

 int lives_chmod(const char *target, const char *mode);

 int lives_cat(const char *from, const char *to, boolean append);

 int lives_echo(const char *text, const char *to, boolean append);

 int lives_ln(const char *from, const char *to);


 int lives_utf8_strcasecmp(const char *s1, const char *s2);


 char *filename_from_fd(char *val, int fd);


 float LEFloat_to_BEFloat(float f) GNU_CONST;

 uint64_t lives_10pow(int pow) GNU_CONST;

 double lives_fix(double val, int decimals) GNU_CONST;

 int get_approx_ln(uint32_t val) GNU_CONST;


 int64_t lives_get_current_ticks(void);

 boolean lives_alarm_get(int alarm_handle);

 int lives_alarm_set(int64_t ticks);

 void lives_alarm_clear(int alarm_handle);

 lives_storage_status_t get_storage_status(const char *dir, uint64_t warn_level, uint64_t *dsval);

 char *lives_format_storage_space_string(uint64_t space);

 char *lives_datetime(struct timeval *tv);


 int myround(double n);

 void get_dirname(char *filename);

 char *get_dir(const char *filename);

 void get_basename(char *filename);

 void get_filename(char *filename, boolean strip_dir);

 char *get_extension(const char *filename);

 uint64_t get_version_hash(const char *exe, const char *sep, int piece);

 uint64_t make_version_hash(const char *ver);

 void d_print(const char *fmt, ...);

 void init_clipboard(void);

 boolean cache_file_contents(const char *filename);

 char *get_val_from_cached_list(const char *key, size_t maxlen);


 void get_location(const char *exe, char *val, int maxlen);


 char *make_image_file_name(lives_clip_t *clip, int frame, const char *img_ext);

 const char *get_image_ext_for_type(lives_image_type_t imgtype);

 lives_image_type_t lives_image_ext_to_type(const char *img_ext);

 lives_image_type_t lives_image_type_to_image_type(const char *lives_img_type);


 void set_menu_text(LiVESWidget *menu, const char *text, boolean use_mnemonic);

 void get_menu_text(LiVESWidget *menu, char *text);

 void get_menu_text_long(LiVESWidget *menuitem, char *text);

 void reset_clipmenu(void);

 void get_play_times(void);

 void get_total_time(lives_clip_t *file);

 uint32_t get_signed_endian(boolean is_signed, boolean little_endian);

 void fullscreen_internal(void);

 void switch_to_int_player(void);

 void switch_to_mplayer(void);

 void switch_aud_to_sox(boolean set_pref);

 boolean switch_aud_to_jack(void);

 boolean switch_aud_to_pulse(void);

 void switch_aud_to_mplayer(boolean set_pref);

 void switch_aud_to_mplayer2(boolean set_pref);

 boolean prepare_to_play_foreign(void);

 boolean after_foreign_play(void);

 boolean check_file(const char *file_name, boolean check_exists);

 boolean check_dir_access(const char *dir);

 uint64_t get_file_size(int fd);

 uint64_t sget_file_size(const char *name);

 uint64_t get_fs_free(const char *dir);

 boolean is_writeable_dir(const char *dir);

 boolean ensure_isdir(char *fname);

 char *ensure_extension(const char *fname, const char *ext) WARN_UNUSED;

 boolean check_dev_busy(char *devstr);

 void activate_url_inner(const char *link);

 void activate_url(LiVESAboutDialog *about, const char *link, livespointer data);

 void show_manual_section(const char *lang, const char *section);


 double calc_time_from_frame(int clip, int frame);

 int calc_frame_from_time(int filenum, double time);

 int calc_frame_from_time2(int filenum, double time);

 int calc_frame_from_time3(int filenum, double time);


 boolean check_for_ratio_fps(double fps);

 double get_ratio_fps(const char *string);

 void calc_maxspect(int rwidth, int rheight, int *cwidth, int *cheight);


 char *remove_trailing_zeroes(double val);


 void remove_layout_files(LiVESList *lmap);

 boolean add_lmap_error(lives_lmap_error_t lerror, const char *name, livespointer user_data,

                        int clipno, int frameno, double atime, boolean affects_current);

 void clear_lmap_errors(void);

 boolean prompt_remove_layout_files(void);

 boolean do_std_checks(const char *type_name, const char *type, size_t maxlen, const char *nreject);

 boolean is_legal_set_name(const char *set_name, boolean allow_dupes);

 char *repl_workdir(const char *entry, boolean fwd);

 char *clip_detail_to_string(lives_clip_details_t what, size_t *maxlenp);

 boolean get_clip_value(int which, lives_clip_details_t, void *retval, size_t maxlen);

 void save_clip_value(int which, lives_clip_details_t, void *val);

 boolean check_frame_count(int idx);

 void count_opening_frames(void);

 void get_frame_count(int idx);

 void get_frames_sizes(int fileno, int frame_to_test);

 int count_resampled_frames(int in_frames, double orig_fps, double resampled_fps);

 boolean int_array_contains_value(int *array, int num_elems, int value);

 boolean check_for_lock_file(const char *set_name, int type);

 void lives_list_free_strings(LiVESList *);

 void lives_list_free_all(LiVESList **);

 void lives_slist_free_all(LiVESSList **);


 boolean create_event_space(int length_in_eventsb);

 void add_to_recent(const char *filename, double start, int frames, const char *file_open_params);

 int verhash(char *version);

 void set_undoable(const char *what, boolean sensitive);

 void set_redoable(const char *what, boolean sensitive);

 void zero_spinbuttons(void);

 void draw_little_bars(double ptrtime);

 void set_sel_label(LiVESWidget *label);

 void clear_mainw_msg(void);

 int get_token_count(const char *string, int delim);

 LiVESPixbuf *lives_pixbuf_new_blank(int width, int height, int palette);

 char *lives_strappend(char *string, int len, const char *newbit);

 LiVESList *lives_list_append_unique(LiVESList *xlist, const char *add);

 void find_when_to_stop(void);

 int calc_new_playback_position(int fileno, uint64_t otc, uint64_t *ntc);

 void calc_aframeno(int fileno);

 void minimise_aspect_delta(double allowed_aspect, int hblock, int vblock, int hsize, int vsize, int *width, int *height);

 LiVESInterpType get_interp_value(short quality);


 LiVESList *lives_list_move_to_first(LiVESList *list, LiVESList *item) WARN_UNUSED;

 LiVESList *lives_list_delete_string(LiVESList *, char *string) WARN_UNUSED;

 LiVESList *lives_list_copy_strings(LiVESList *list);

 boolean string_lists_differ(LiVESList *, LiVESList *);


 boolean is_realtime_aplayer(int ptype);


 LiVESList *get_set_list(const char *dir, boolean utf8);


 char *subst(const char *string, const char *from, const char *to);

 char *insert_newlines(const char *text, int maxwidth);


 int hextodec(char *string);

 int get_hex_digit(const char *c);


 uint32_t fastrand(void);

 void fastsrand(uint32_t seed);


 int lives_list_strcmp_index(LiVESList *list, livesconstpointer data);


 lives_cancel_t check_for_bad_ffmpeg(void);


 //callbacks.c


 // paramspecial.c

 LiVESPixbuf *mt_framedraw(lives_mt *, LiVESPixbuf *);


 // effects-weed.c

 livespointer _lives_malloc(size_t size) GNU_MALLOC;

 livespointer lives_memcpy(livespointer dest, livesconstpointer src, size_t n);

 livespointer lives_memset(livespointer s, int c, size_t n);

 void _lives_free(livespointer ptr);

 livespointer lives_calloc(size_t n_blocks, size_t n_block_bytes);

 livespointer _lives_realloc(livespointer ptr, size_t new_size);


 // pangotext.c

 boolean subtitles_init(lives_clip_t *sfile, char *fname, lives_subtitle_type_t);

 void subtitles_free(lives_clip_t *sfile);

 boolean get_srt_text(lives_clip_t *sfile, double xtime);

 boolean get_sub_text(lives_clip_t *sfile, double xtime);

 boolean save_sub_subtitles(lives_clip_t *sfile, double start_time, double end_time, double offset_time, const char *filename);

 boolean save_srt_subtitles(lives_clip_t *sfile, double start_time, double end_time, double offset_time, const char *filename);


 #include "osc_notify.h"


 // inlines

 #define cfile mainw->files[mainw->current_file]

 #define clipboard mainw->files[0]


 #define PREFS_TIMEOUT 10000000


 #define LIVES_TV_CHANNEL1 "http://www.serverwillprovide.com/sorteal/livestvclips/livestv.ogm"


 // round (double) a up to next (integer) multiple of (double) b

 #define CEIL(a, b) ((int)(((double)a + (double)b - .000000001) / ((double)b)) * b)


 #ifdef NEED_ENDIAN_TEST

 #undef NEED_ENDIAN_TEST

 static int32_t testint = 0x12345678;

 #define IS_BIG_ENDIAN (((char *)&testint)[0] == 0x12)

 #endif


 char *dummychar;


 void break_me(void);


 #define LIVES_NO_DEBUG

 #ifndef LIVES_DEBUG

 #ifndef LIVES_NO_DEBUG

 #define LIVES_DEBUG(x)      fprintf(stderr, "LiVES debug: %s\n", x)

 #else // LIVES_NO_DEBUG

 #define LIVES_DEBUG(x)      dummychar = x

 #endif // LIVES_NO_DEBUG

 #endif // LIVES_DEBUG


 #ifndef LIVES_INFO

 #ifndef LIVES_NO_INFO

 #define LIVES_INFO(x)      fprintf(stderr, "LiVES info: %s\n", x)

 #else // LIVES_NO_INFO

 #define LIVES_INFO(x)      dummychar = x

 #endif // LIVES_NO_INFO

 #endif // LIVES_INFO


 #ifndef LIVES_WARN

 #ifndef LIVES_NO_WARN

 #define LIVES_WARN(x)      fprintf(stderr, "LiVES warning: %s\n", x)

 #else // LIVES_NO_WARN

 #define LIVES_WARN(x)      dummychar = x

 #endif // LIVES_NO_WARN

 #endif // LIVES_WARN


 #ifndef LIVES_ERROR

 #ifndef LIVES_NO_ERROR

 #define LIVES_ERROR(x)      {fprintf(stderr, "LiVES error: %s\n", x); break_me();}

 #else // LIVES_NO_ERROR

 #define LIVES_ERROR(x)      dummychar = x

 #endif // LIVES_NO_ERROR

 #endif // LIVES_ERROR


 #ifndef LIVES_FATAL

 #ifndef LIVES_NO_FATAL

 #define LIVES_FATAL(x)      {fprintf(stderr, "LiVES fatal: %s\n", x); raise (LIVES_SIGSEGV);}

 #else // LIVES_NO_FATAL

 #define LIVES_FATAL(x)      dummychar = x

 #endif // LIVES_NO_FATAL

 #endif // LIVES_FATAL


 #endif // #ifndef HAS_LIVES_MAIN_H


do_messages_window
void do_messages_window(void)
Definition: dialogs.c:2408

do_ra_convert_error
void do_ra_convert_error(void)
Definition: dialogs.c:2627

lives_touch
int lives_touch(const char *tfile)
Definition: utils.c:3916

lives_clip_t::undo_arate
int undo_arate
audio playback rate
Definition: main.h:634

do_warning_dialog_with_check_transient
boolean do_warning_dialog_with_check_transient(const char *text, int warn_mask_number, LiVESWindow *transient)
Definition: dialogs.c:380

load_theme_images
void load_theme_images(void)
Definition: gui.c:56

do_encoder_sox_error
void do_encoder_sox_error(void)
Definition: dialogs.c:2116

handle_backend_errors
void handle_backend_errors(void)
Definition: dialogs.c:623

lives_clip_t::frames
int frames
Definition: main.h:524

pull_lives_pixbuf_at_size
LiVESPixbuf * pull_lives_pixbuf_at_size(int clip, int frame, const char *image_ext, weed_timecode_t tc, int width, int height, LiVESInterpType interp)
Definition: main.c:5182

lives_clip_t::undo2_dbl
double undo2_dbl
Definition: main.h:629

lives_audio_track_state_t::afile
int afile
Definition: main.h:355

reget_afilesize
void reget_afilesize(int fileno)
Definition: utils.c:4163

ensure_extension
char * ensure_extension(const char *fname, const char *ext) WARN_UNUSED
Definition: utils.c:2416

do_yesno_dialog_with_check
boolean do_yesno_dialog_with_check(const char *text, int warn_mask_number)
Definition: dialogs.c:371

capability::has_stderr
boolean has_stderr
Definition: main.h:755

xprocess::stop_button
LiVESWidget * stop_button
Definition: main.h:345

lives_clip_t::undo1_int
int undo1_int
Definition: main.h:623

lives_clip_t::no_proc_sys_errors
boolean no_proc_sys_errors
skip system error dialogs in processing
Definition: main.h:681

event::value
int value
Definition: main.h:334

capability::python_version
uint64_t python_version
Definition: main.h:748

get_hex_digit
int get_hex_digit(const char *c)
Definition: utils.c:5134

CLIP_DETAILS_AUTHOR
Definition: main.h:836

lives_clip_t::deinterlace
boolean deinterlace
auto deinterlace
Definition: main.h:666

lives_clip_t::opening_audio
boolean opening_audio
Definition: main.h:572

lives_open_buffered_rdonly
int lives_open_buffered_rdonly(const char *pathname)
Definition: utils.c:560

open_file_sel
ulong open_file_sel(const char *file_name, double start_time, int frames)
Definition: saveplay.c:272

lives_clip_t::undo2_int
int undo2_int
Definition: main.h:624

UNDO_RESAMPLE
Definition: main.h:383

CLIP_DETAILS_FRAMES
Definition: main.h:834

lives_clip_t::old_raudio_time
double old_raudio_time
Definition: main.h:593

verhash
int verhash(char *version)
Definition: utils.c:4319

do_mt_audchan_error
void do_mt_audchan_error(int warn_mask)
Definition: dialogs.c:2588

startup_message_fatal
boolean startup_message_fatal(const char *msg)
Definition: main.c:3395

pull_frame_at_size
boolean pull_frame_at_size(weed_plant_t *layer, const char *image_ext, weed_timecode_t tc, int width, int height, int target_palette)
Definition: main.c:4844

perf_mem_warning
void perf_mem_warning(void)
Definition: dialogs.c:2328

lives_clip_t::restoring
boolean restoring
Definition: main.h:575

do_read_failed_error_s
void do_read_failed_error_s(const char *filename, const char *addinfo)
Definition: dialogs.c:2995

draw_little_bars
void draw_little_bars(double ptrtime)
Definition: utils.c:2984

lives_clip_t::frame_index_back
int * frame_index_back
for undo
Definition: main.h:650

lives_system
int lives_system(const char *com, boolean allow_error)
Definition: utils.c:295

osc_notify.h

do_dir_perm_error
void do_dir_perm_error(const char *dir_name)
Definition: dialogs.c:3182

get_untitled_name
char * get_untitled_name(int number)
Definition: saveplay.c:3349

capability::has_pulse_audio
boolean has_pulse_audio
Definition: main.h:719

get_handle_from_info_file
boolean get_handle_from_info_file(int index)
Definition: saveplay.c:1061

hextodec
int hextodec(char *string)
Definition: utils.c:5118

CLIP_DETAILS_ASIGNED
Definition: main.h:831

create_message_dialog
LiVESWidget * create_message_dialog(lives_dialog_t diat, const char *text, LiVESWindow *transient, int warn_mask_number, boolean is_blocking)
Definition: dialogs.c:154

lives_audio_track_state_t::seek
double seek
Definition: main.h:356

lives_clip_t::undo1_uint
uint32_t undo1_uint
Definition: main.h:627

lives_read_le
ssize_t lives_read_le(int fd, void *buf, size_t count, boolean allow_less)
Definition: utils.c:510

capability::has_mpv
boolean has_mpv
Definition: main.h:711

render_details
Definition: events.h:162

do_move_workdir_dialog
boolean do_move_workdir_dialog(void)
Definition: dialogs.c:3273

_lives_free
void _lives_free(livespointer ptr)
Definition: effects-weed.c:107

lives_pixbuf_save
LiVESError * lives_pixbuf_save(LiVESPixbuf *pixbuf, char *fname, lives_image_type_t imgtype, int quality, boolean do_chmod, LiVESError **gerrorptr)
Definition: main.c:6613

do_event_list_warning
boolean do_event_list_warning(void)
Definition: dialogs.c:2637

lives_clip_t::start
int start
Definition: main.h:554

do_header_missing_detail_error
int do_header_missing_detail_error(int clip, lives_clip_details_t detail) WARN_UNUSED
Definition: dialogs.c:3133

do_error_dialog
int do_error_dialog(const char *text)
Definition: dialogs.c:497

PATH_MAX
#define PATH_MAX
Definition: main.h:287

set_main_title
void set_main_title(const char *filename, int or_untitled_number)
Definition: main.c:3443

lives_clip_t::nokeep
boolean nokeep
don't show the 'keep' button - e.g. for operations which resize frames
Definition: main.h:582

lives_clip_t::nopreview
boolean nopreview
don't show preview/pause buttons on processing
Definition: main.h:579

lives_fork
lives_pid_t lives_fork(const char *com)
Definition: utils.c:339

get_fs_free
uint64_t get_fs_free(const char *dir)
Definition: utils.c:5195

lives_pid_t
pid_t lives_pid_t
Definition: main.h:129

load_from_scrap_file
boolean load_from_scrap_file(weed_plant_t *layer, int frame)
Definition: saveplay.c:4745

lives_dialog_t
lives_dialog_t
Definition: mainwindow.h:188

get_play_times
void get_play_times(void)
Definition: utils.c:2647

CANCEL_SOFT
just cancel in GUI (for keep, etc)
Definition: main.h:466

save_frame
void save_frame(LiVESMenuItem *menuitem, livespointer user_data)
Definition: saveplay.c:1120

lives_utf8_strcasecmp
int lives_utf8_strcasecmp(const char *s1, const char *s2)
Definition: utils.c:4999

splash_end
void splash_end(void)
Definition: gui.c:4273

lives_image_ext_to_type
lives_image_type_t lives_image_ext_to_type(const char *img_ext)
Definition: utils.c:2227

find_when_to_stop
void find_when_to_stop(void)
Definition: utils.c:3145

save_clip_value
void save_clip_value(int which, lives_clip_details_t, void *val)
Definition: utils.c:4729

clear_lmap_errors
void clear_lmap_errors(void)
Definition: utils.c:2042

set_pref
void set_pref(const char *key, const char *value)
Definition: preferences.c:297

activate_url
void activate_url(LiVESAboutDialog *about, const char *link, livespointer data)
Definition: utils.c:4109

do_file_perm_error
void do_file_perm_error(const char *file_name)
Definition: dialogs.c:3174

lives_rm
int lives_rm(const char *file)
Definition: utils.c:3862

is_legal_set_name
boolean is_legal_set_name(const char *set_name, boolean allow_dupes)
Definition: utils.c:2175

do_set_load_lmap_error
void do_set_load_lmap_error(void)

lives_random
uint64_t lives_random(void)
Definition: utils.c:101

capability::has_mplayer
boolean has_mplayer
Definition: main.h:709

xprocess::scrolledwindow
LiVESWidget * scrolledwindow
Definition: main.h:349

lives_memcpy
livespointer lives_memcpy(livespointer dest, livesconstpointer src, size_t n)
Definition: effects-weed.c:74

paramspecial.h

do_existing_subs_warning
boolean do_existing_subs_warning(void)
Definition: dialogs.c:3227

CANCEL_AUD_END
video playback completed
Definition: main.h:452

lives_pgid_t
int lives_pgid_t
Definition: main.h:130

create_event_space
boolean create_event_space(int length_in_eventsb)
Definition: utils.c:4197

do_bad_theme_import_error
void do_bad_theme_import_error(const char *theme_file)
Definition: dialogs.c:3368

close_current_file
void close_current_file(int file_to_switch_to)
close current file, and try to switch to file_to_switch_to
Definition: main.c:6647

recover_layout_map
void recover_layout_map(int numclips)
Definition: saveplay.c:5119

lives_echo
int lives_echo(const char *text, const char *to, boolean append)
Definition: utils.c:3965

UNDO_AUDIO_RESAMPLE
Definition: main.h:386

lives_clip_t::ohsize
int ohsize
Definition: main.h:544

lives_clip_t::was_renamed
boolean was_renamed
Definition: main.h:564

lives_clip_t::raudio_drawable
lives_painter_surface_t * raudio_drawable
Definition: main.h:688

open_fw_device
void open_fw_device(void)

reload_clip
boolean reload_clip(int fileno, int maxframe)
Definition: saveplay.c:5199

remove_trailing_zeroes
char * remove_trailing_zeroes(double val)
Definition: utils.c:4951

lbindings.h

do_autolives_needs_clips_error
void do_autolives_needs_clips_error(void)
Definition: dialogs.c:3348

defer_sigint
void defer_sigint(int signum)
Definition: main.c:177

check_layer_ready
void check_layer_ready(weed_plant_t *layer)
Definition: main.c:5097

CLIP_DETAILS_AENDIAN
Definition: main.h:832

workdir_warning
void workdir_warning(void)
Definition: dialogs.c:2077

CLIP_DETAILS_TITLE
Definition: main.h:835

switch_aud_to_pulse
boolean switch_aud_to_pulse(void)
Definition: utils.c:3294

lives_clip_t::opening
boolean opening
Definition: main.h:571

lives_clip_t::last_frameno
int last_frameno
Definition: main.h:597

get_basename
void get_basename(char *filename)
Definition: utils.c:2383

clear_mainw_msg
void clear_mainw_msg(void)
Definition: utils.c:1224

read_headers
boolean read_headers(const char *file_name)
Definition: saveplay.c:3964

unblock_expose
void unblock_expose(void)
Definition: gui.c:3261

multitrack.h

capability::has_cdda2wav
boolean has_cdda2wav
Definition: main.h:715

fastsrand
void fastsrand(uint32_t seed)
Definition: utils.c:5155

pull_frame_threaded
void pull_frame_threaded(weed_plant_t *layer, const char *img_ext, weed_timecode_t tc)
Definition: main.c:5154

do_error_dialog_with_check_transient
int do_error_dialog_with_check_transient(const char *text, boolean is_blocking, int warn_mask_number, LiVESWindow *transient)
Definition: dialogs.c:532

d_print
void d_print(const char *fmt,...)
Definition: utils.c:1814

capability::can_write_to_config
boolean can_write_to_config
Definition: main.h:700

CLIP_TYPE_DISK
imported video, broken into frames
Definition: main.h:470

lives_clip_t::progress_start
int progress_start
Definition: main.h:558

frame_size_update
void frame_size_update(void)
Definition: gui.c:4080

d_print_file_error_failed
void d_print_file_error_failed(void)
Definition: dialogs.c:2888

sizdbl
ssize_t sizdbl
Definition: main.c:85

lives_image_type_t
lives_image_type_t
Definition: main.h:478

lives_clip_t::redoable
boolean redoable
Definition: main.h:620

lives_list_move_to_first
LiVESList * lives_list_move_to_first(LiVESList *list, LiVESList *item) WARN_UNUSED
Definition: utils.c:5243

do_text_window
void do_text_window(const char *title, const char *text)

lives_clip_t::clip_type
lives_clip_type_t clip_type
Definition: main.h:640

do_splash_progress
void do_splash_progress(void)

keyboard.h

lives_clip_t::undo_action
lives_undo_t undo_action
undo
Definition: main.h:613

IMG_TYPE_UNKNOWN
Definition: main.h:479

get_val_from_cached_list
char * get_val_from_cached_list(const char *key, size_t maxlen)
Definition: utils.c:4482

lives_clip_t::subt
lives_subtitles_t * subt
Definition: main.h:676

_lives_malloc
livespointer _lives_malloc(size_t size) GNU_MALLOC
Definition: effects-weed.c:80

SignalHandlerPointer
void(* SignalHandlerPointer)(int)
Definition: main.h:1048

get_token_count
int get_token_count(const char *string, int delim)
Definition: utils.c:4986

lives_clip_t::total_time
double total_time
Definition: main.h:585

UNDO_NONE
Definition: main.h:379

do_jack_lost_conn_error
void do_jack_lost_conn_error(void)
Definition: dialogs.c:3353

sget_file_size
uint64_t sget_file_size(const char *name)
Definition: utils.c:4133

capability::has_dvgrab
boolean has_dvgrab
Definition: main.h:705

do_auto_dialog
boolean do_auto_dialog(const char *text, int type)
Definition: dialogs.c:1949

reset_clipmenu
void reset_clipmenu(void)
Definition: utils.c:3762

enable_record
void enable_record(void)
Definition: gui.c:3523

do_threaded_dialog
void do_threaded_dialog(char *translated_text, boolean has_cancel)
Definition: dialogs.c:2817

lives_clip_t::op_dir
char * op_dir
Definition: main.h:678

count_opening_frames
void count_opening_frames(void)
Definition: utils.c:2280

lives_colRGBA64_t::red
uint16_t red
Definition: main.h:318

event
Definition: main.h:333

lives_read_buffered
ssize_t lives_read_buffered(int fd, void *buf, size_t count, boolean allow_less)
Definition: utils.c:657

do_layout_alter_frames_warning
boolean do_layout_alter_frames_warning(void)
Definition: dialogs.c:2481

restore_file
ulong restore_file(const char *filename)
Definition: saveplay.c:4411

lives_whentostop_t
lives_whentostop_t
which stream end should cause playback to finish ?
Definition: main.h:410

rdet_suggest_values
boolean rdet_suggest_values(int width, int height, double fps, int fps_num, int fps_denom, int arate, int asigned, boolean swap_endian, boolean anr, boolean ignore_fps)
Definition: dialogs.c:2138

d_print_failed
void d_print_failed(void)
Definition: dialogs.c:2879

minimise_aspect_delta
void minimise_aspect_delta(double allowed_aspect, int hblock, int vblock, int hsize, int vsize, int *width, int *height)
Definition: utils.c:3169

lives_clip_t::undo1_boolean
boolean undo1_boolean
Definition: main.h:630

add_message_scroller
void add_message_scroller(LiVESWidget *conter)
Definition: gui.c:114

do_clipboard_fps_warning
boolean do_clipboard_fps_warning(void)
Definition: dialogs.c:2333

set_sel_label
void set_sel_label(LiVESWidget *label)
Definition: utils.c:4410

lives_fgets
char * lives_fgets(char *s, int size, FILE *stream)
Definition: utils.c:432

lives_write_le
ssize_t lives_write_le(int fd, livesconstpointer buf, size_t count, boolean allow_fail)

sizint
ssize_t sizint
type sizes
Definition: main.c:85

lives_setenv
boolean lives_setenv(const char *name, const char *value)
Definition: utils.c:273

check_storage_space
boolean check_storage_space(lives_clip_t *sfile, boolean is_processing)
Definition: dialogs.c:767

lives_colRGBA64_t
Definition: main.h:317

capability::umask
mode_t umask
Definition: main.h:765

lives_clip_t::ovsize
int ovsize
Definition: main.h:545

GNU_MALLOC
#define GNU_MALLOC
Definition: main.h:301

do_vpp_fps_error
void do_vpp_fps_error(void)
Definition: dialogs.c:2663

startup_message_nonfatal
boolean startup_message_nonfatal(const char *msg)
Definition: main.c:3404

pump_io_chan
void pump_io_chan(LiVESIOChannel *iochan)
Definition: dialogs.c:702

do_mt_undo_buf_error
void do_mt_undo_buf_error(void)
Definition: dialogs.c:2568

CANCEL_NONE
no cancel
Definition: main.h:419

get_transient_full
LiVESWindow * get_transient_full()
Definition: dialogs.c:431

do_read_failed_error_s_with_retry
int do_read_failed_error_s_with_retry(const char *fname, const char *errtext, LiVESWindow *transient) WARN_UNUSED
Definition: dialogs.c:3071

lives_clip_t::asampsize
int asampsize
Definition: main.h:521

lives_write_buffered
ssize_t lives_write_buffered(int fd, const char *buf, size_t count, boolean allow_fail)
Definition: utils.c:721

get_set_list
LiVESList * get_set_list(const char *dir, boolean utf8)
Definition: utils.c:4858

close_scrap_file
void close_scrap_file(void)
Definition: saveplay.c:5078

do_yesno_dialog_with_check_transient
boolean do_yesno_dialog_with_check_transient(const char *text, int warn_mask_number, LiVESWindow *transient)
Definition: dialogs.c:406

lives_clip_t::undo_signed_endian
uint32_t undo_signed_endian
Definition: main.h:635

lives_freep
boolean lives_freep(void **ptr)
Definition: utils.c:842

set_undoable
void set_undoable(const char *what, boolean sensitive)
Definition: utils.c:4358

get_temp_handle
boolean get_temp_handle(int index, boolean create)
Definition: saveplay.c:3196

get_sub_text
boolean get_sub_text(lives_clip_t *sfile, double xtime)
Definition: pangotext.c:554

lives_clip_t::is_untitled
boolean is_untitled
Definition: main.h:565

get_next_free_file
void get_next_free_file(void)
Definition: utils.c:2348

do_firstever_dialog
void do_firstever_dialog(void)

CLIP_TYPE_FILE
unimported video, not or partially broken in frames
Definition: main.h:473

count_resampled_frames
int count_resampled_frames(int in_frames, double orig_fps, double resampled_fps)
Definition: resample.c:56

lives_ln
int lives_ln(const char *from, const char *to)
Definition: utils.c:3924

lives_mv
int lives_mv(const char *from, const char *to)
Definition: utils.c:3908

end_threaded_dialog
void end_threaded_dialog(void)
Definition: dialogs.c:2846

CLIP_DETAILS_HEIGHT
Definition: main.h:826

lives_cat
int lives_cat(const char *from, const char *to, boolean append)
Definition: utils.c:3949

lives_clip_t::stored_layout_idx
int stored_layout_idx
Definition: main.h:672

do_write_failed_error_s
void do_write_failed_error_s(const char *filename, const char *addinfo)
Definition: dialogs.c:2949

is_realtime_aplayer
boolean is_realtime_aplayer(int ptype)
Definition: utils.c:1445

save_frame_inner
boolean save_frame_inner(int clip, int frame, const char *file_name, int width, int height, boolean from_osc)
Definition: saveplay.c:3660

lives_clip_t::signed_endian
uint32_t signed_endian
bitfield
Definition: main.h:516

lives_clip_t::menuentry
LiVESWidget * menuentry
Definition: main.h:561

check_file
boolean check_file(const char *file_name, boolean check_exists)
check if file exists
Definition: utils.c:3784

capability::has_xwininfo
boolean has_xwininfo
Definition: main.h:720

CLIP_DETAILS_DECODER_NAME
Definition: main.h:844

CLIP_TYPE_VIDEODEV
frames from video device
Definition: main.h:475

pull_lives_pixbuf
LiVESPixbuf * pull_lives_pixbuf(int clip, int frame, const char *image_ext, weed_timecode_t tc)
Definition: main.c:5223

ask_permission_dialog
boolean ask_permission_dialog(int what)
Definition: dialogs.c:3384

capability::nmonitors
int nmonitors
Definition: main.h:757

get_storage_status
lives_storage_status_t get_storage_status(const char *dir, uint64_t warn_level, uint64_t *dsval)
Definition: utils.c:812

lives_clip_t::arate
int arate
audio playback rate
Definition: main.h:518

lives_kill
int lives_kill(lives_pid_t pid, int sig)
Definition: utils.c:1191

UNDO_DELETE
Definition: main.h:390

lives_clip_t::no_proc_write_errors
boolean no_proc_write_errors
skip write error dialogs in processing
Definition: main.h:683

lives_clip_t::aseek_pos
int64_t aseek_pos
audio seek posn. (bytes) for when we switch clips
Definition: main.h:660

lives_memset
livespointer lives_memset(livespointer s, int c, size_t n)
Definition: effects-weed.c:131

do_jack_noopen_warn3
void do_jack_noopen_warn3(void)
Definition: dialogs.c:2524

lives_alarm_clear
void lives_alarm_clear(int alarm_handle)
Definition: utils.c:1350

LIVES_INTERLACE_BOTTOM_FIRST
Definition: main.h:495

xprocess::cancel_button
LiVESWidget * cancel_button
Definition: main.h:348

lives_rmdir_with_parents
int lives_rmdir_with_parents(const char *dir)
Definition: utils.c:3854

do_mt_set_mem_error
void do_mt_set_mem_error(boolean has_mt, boolean trans)
Definition: dialogs.c:2572

get_deinterlace_string
const char * get_deinterlace_string(void)
Definition: saveplay.c:206

set_redoable
void set_redoable(const char *what, boolean sensitive)
Definition: utils.c:4386

set_palette_colours
boolean set_palette_colours(boolean force_reload)
Definition: main.c:1931

get_capabilities
capability * get_capabilities(void)
Definition: main.c:2182

capability::can_read_from_config
boolean can_read_from_config
Definition: main.h:699

LIVES_INTERLACE_TOP_FIRST
Definition: main.h:496

lives_colRGBA64_t::alpha
uint16_t alpha
Definition: main.h:321

lives_clip_t::insert_start
int insert_start
Definition: main.h:556

lives_clip_t::keep_without_preview
boolean keep_without_preview
allow keep, even when nopreview is set - TODO use only nopreview and nokeep
Definition: main.h:685

jack.h

switch_to_file
void switch_to_file(int old_file, int new_file)
Definition: main.c:6964

lives_clip_t::undo_achans
int undo_achans
Definition: main.h:636

lives_write_le_buffered
ssize_t lives_write_le_buffered(int fd, livesconstpointer buf, size_t count, boolean allow_fail)

lives_clip_t::layout_map
LiVESList * layout_map
Definition: main.h:609

wait_for_stop
void wait_for_stop(const char *stop_command)
Definition: saveplay.c:3627

lives_clip_t::undo3_boolean
boolean undo3_boolean
Definition: main.h:632

lives_fputs
int lives_fputs(const char *s, FILE *stream)
Definition: utils.c:419

lives_getuid
int lives_getuid(void)
Definition: utils.c:159

lives_clip_t::undo_arps
int undo_arps
audio sample rate
Definition: main.h:638

do_encoder_img_ftm_error
void do_encoder_img_ftm_error(render_details *rdet)
Definition: dialogs.c:3202

get_interp_value
LiVESInterpType get_interp_value(short quality)
Definition: utils.c:5236

widget-helper.h

lives_clip_details_t
lives_clip_details_t
Definition: main.h:821

do_bad_theme_error
void do_bad_theme_error(const char *themefile)
Definition: dialogs.c:3304

version
const char * version(void)

lives_clip_t::rowstride
int rowstride
Definition: main.h:538

lives_clip_t::afilesize
int64_t afilesize
Definition: main.h:547

CLIP_DETAILS_CLIPNAME
Definition: main.h:840

desensitize
void desensitize(void)
Definition: main.c:3662

add_to_recovery_file
void add_to_recovery_file(const char *handle)
Definition: saveplay.c:5691

do_set_locked_warning
void do_set_locked_warning(const char *setname)
Definition: dialogs.c:3278

palette
_palette * palette
Definition: main.c:84

CLIP_TYPE_GENERATOR
frames from generator plugin
Definition: main.h:472

save_event_frames
int save_event_frames(void)
Definition: saveplay.c:4556

do_write_failed_error_s_with_retry
int do_write_failed_error_s_with_retry(const char *fname, const char *errtext, LiVESWindow *transient) WARN_UNUSED
Definition: dialogs.c:3017

lives_strappend
char * lives_strappend(char *string, int len, const char *newbit)
Definition: utils.c:1380

CLIP_DETAILS_COMMENT
Definition: main.h:837

lives_killpg
int lives_killpg(lives_pgid_t pgrp, int sig)
Definition: utils.c:1207

lives_clip_t::interlace
lives_interlace_t interlace
interlace type (if known - none, topfirst, bottomfirst or : see plugins.h)
Definition: main.h:531

load_preview_image
void load_preview_image(boolean update_always)
Definition: main.c:4243

xprocess::label3
LiVESWidget * label3
Definition: main.h:344

set_record
void set_record(void)

lives_clip_t::bpp
int bpp
Definition: main.h:511

capability::mainpid
pid_t mainpid
Definition: main.h:763

do_dir_perm_access_error
void do_dir_perm_access_error(const char *dir_name)
Definition: dialogs.c:3190

get_file_size
uint64_t get_file_size(int fd)
Definition: utils.c:4126

lives_clip_t::stored_layout_audio
double stored_layout_audio
Definition: main.h:673

xprocess::frames_done
uint32_t frames_done
Definition: main.h:350

init_clipboard
void init_clipboard(void)
Definition: utils.c:1767

show_manual_section
void show_manual_section(const char *lang, const char *section)
Definition: utils.c:4113

switch_aud_to_sox
void switch_aud_to_sox(boolean set_pref)
Definition: utils.c:3347

do_mt_backup_space_error
void do_mt_backup_space_error(lives_mt *, int memreq_mb)
Definition: dialogs.c:2545

do_no_decoder_error
void do_no_decoder_error(const char *fname)
Definition: dialogs.c:2502

filename_from_fd
char * filename_from_fd(char *val, int fd)
Definition: utils.c:42

switch_to_int_player
void switch_to_int_player(void)

UNDO_CHANGE_SPEED
Definition: main.h:385

fastrand
uint32_t fastrand(void)
Definition: utils.c:5147

CANCEL_CAPTURE_ERROR
image could not be captured
Definition: main.h:437

resize
void resize(double scale)
Definition: main.c:7527

set_ce_frame_from_pixbuf
void set_ce_frame_from_pixbuf(LiVESImage *image, LiVESPixbuf *pixbuf, lives_painter_t *)
Definition: main.c:3851

do_abort_check
boolean do_abort_check(void)
Definition: dialogs.c:3197

lives_clip_t::opening_only_audio
boolean opening_only_audio
Definition: main.h:573

subst
char * subst(const char *string, const char *from, const char *to)
Definition: utils.c:5009

CLIP_TYPE_YUV4MPEG
yuv4mpeg stream
Definition: main.h:471

CLIP_DETAILS_WIDTH
Definition: main.h:825

lives_rmdir
int lives_rmdir(const char *dir, boolean force)
Definition: utils.c:3829

rdet
render_details * rdet
Definition: events.h:196

lives_list_free_strings
void lives_list_free_strings(LiVESList *)
Definition: utils.c:4436

switch_aud_to_mplayer2
void switch_aud_to_mplayer2(boolean set_pref)
Definition: utils.c:3439

check_for_disk_space
boolean check_for_disk_space(void)
Definition: saveplay.c:4885

mainw
mainwindow * mainw
Definition: main.c:86

UNDO_REC_AUDIO
record audio to selection
Definition: main.h:404

load_frame_image
void load_frame_image(int frame)
Definition: main.c:5413

CLIP_TYPE_LIVES2LIVES
type for LiVES to LiVES streaming
Definition: main.h:474

lives_clip_t::progress_end
int progress_end
Definition: main.h:559

lives_clip_t::menuentry_func
ulong menuentry_func
Definition: main.h:562

get_srt_text
boolean get_srt_text(lives_clip_t *sfile, double xtime)
Definition: pangotext.c:412

lives_clip_t::frame_index
int * frame_index
Definition: main.h:648

do_audrate_error_dialog
void do_audrate_error_dialog(void)
Definition: dialogs.c:2633

capability::rcfile
char * rcfile
Definition: main.h:739

do_abort_cancel_retry_dialog
int do_abort_cancel_retry_dialog(const char *text, LiVESWindow *transient) WARN_UNUSED
Definition: dialogs.c:461

lives_clip_t::stored_layout_fps
double stored_layout_fps
Definition: main.h:674

event::reltime
int64_t reltime
Definition: main.h:335

save_sub_subtitles
boolean save_sub_subtitles(lives_clip_t *sfile, double start_time, double end_time, double offset_time, const char *filename)
Definition: pangotext.c:835

lives_list_free_all
void lives_list_free_all(LiVESList **)
Definition: utils.c:4458

events.h

mt_framedraw
LiVESPixbuf * mt_framedraw(lives_mt *, LiVESPixbuf *)
Definition: paramspecial.c:486

STOP_ON_VID_END
Definition: main.h:412

mainwindow.h

subtitles_free
void subtitles_free(lives_clip_t *sfile)
Definition: pangotext.c:697

add_lmap_error
boolean add_lmap_error(lives_lmap_error_t lerror, const char *name, livespointer user_data, int clipno, int frameno, double atime, boolean affects_current)
Definition: utils.c:1861

do_layout_ascrap_file_error
void do_layout_ascrap_file_error(void)
Definition: dialogs.c:2133

capability::can_write_to_workdir
boolean can_write_to_workdir
Definition: main.h:702

lives_lmap_error_t
lives_lmap_error_t
Definition: multitrack.h:985

capability::has_smogrify
boolean has_smogrify
Definition: main.h:697

do_dev_busy_error
void do_dev_busy_error(const char *devstr)
Definition: dialogs.c:3217

xprocess::processing
LiVESWidget * processing
Definition: main.h:340

CANCEL_KILL
normal - kill background processes working on current clip
Definition: main.h:465

get_extension
char * get_extension(const char *filename)
Definition: utils.c:2404

set_menu_text
void set_menu_text(LiVESWidget *menu, const char *text, boolean use_mnemonic)
Definition: utils.c:3732

lives_open3
int lives_open3(const char *pathname, int flags, mode_t mode)
Definition: utils.c:141

lives_creat_buffered
int lives_creat_buffered(const char *pathname, int mode)
Definition: utils.c:565

lives_clip_t::needs_update
boolean needs_update
loaded values were incorrect, update header
Definition: main.h:692

set_preview_box_colours
void set_preview_box_colours(void)
Definition: gui.c:3273

repl_workdir
char * repl_workdir(const char *entry, boolean fwd)
Definition: utils.c:2502

do_no_autolives_error
void do_no_autolives_error(void)
Definition: dialogs.c:3343

lives_clip_t::play_paused
boolean play_paused
Definition: main.h:568

set_colours
void set_colours(LiVESWidgetColor *colf, LiVESWidgetColor *colb, LiVESWidgetColor *colf2, LiVESWidgetColor *colb2, LiVESWidgetColor *coli, LiVESWidgetColor *colt)
Definition: gui.c:186

capability::has_midistartstop
boolean has_midistartstop
Definition: main.h:717

lives_clip_t::fx_frame_pump
int fx_frame_pump
rfx frame pump for virtual clips (CLIP_TYPE_FILE)
Definition: main.h:652

get_ratio_fps
double get_ratio_fps(const char *string)
Definition: utils.c:4935

CLIP_DETAILS_INTERLACE
Definition: main.h:843

CLIP_DETAILS_ASAMPS
Definition: main.h:833

toggle_record
void toggle_record(void)
Definition: gui.c:3529

get_monitors
void get_monitors(void)
Definition: main.c:229

do_warning_dialog
boolean do_warning_dialog(const char *text)
Definition: dialogs.c:357

after_foreign_play
boolean after_foreign_play(void)
Definition: utils.c:3629

capability
Definition: main.h:695

startup_message_info
boolean startup_message_info(const char *msg)
Definition: main.c:3427

mainwindow
mainw->
Definition: mainwindow.h:393

lives_colRGB48_t::green
uint16_t green
Definition: main.h:313

lives_clip_t::frameno
int frameno
Definition: main.h:596

lives_clip_t::undo1_dbl
double undo1_dbl
Definition: main.h:628

do_yuv4m_open_warning
boolean do_yuv4m_open_warning(void)
Definition: dialogs.c:2344

lives_clip_t::ext_src
void * ext_src
points to opaque source for non-disk types
Definition: main.h:642

process_one
boolean process_one(boolean visible)
Definition: dialogs.c:997

lives_colRGBA64_t::green
uint16_t green
Definition: main.h:319

do_jack_noopen_warn
void do_jack_noopen_warn(void)
Definition: dialogs.c:2516

prompt_remove_layout_files
boolean prompt_remove_layout_files(void)
Definition: dialogs.c:2465

lives_clip_t::proc_ptr
xprocess * proc_ptr
the processing window
Definition: main.h:541

free_track_decoders
void free_track_decoders(void)
Definition: main.c:5383

xprocess::label2
LiVESWidget * label2
Definition: main.h:343

check_frame_count
boolean check_frame_count(int idx)
Definition: utils.c:2246

lives_clip_t::undo2_boolean
boolean undo2_boolean
Definition: main.h:631

write_headers
boolean write_headers(lives_clip_t *file)
Definition: saveplay.c:3889

do_rendered_fx_dialog
void do_rendered_fx_dialog(void)
Definition: dialogs.c:2427

do_audio_import_error
void do_audio_import_error(void)
Definition: dialogs.c:2438

do_cd_error_dialog
void do_cd_error_dialog(void)
Definition: dialogs.c:3363

CANCEL_KEEP
user pressed 'Keep'
Definition: main.h:449

calc_time_from_frame
double calc_time_from_frame(int clip, int frame)
Definition: utils.c:1411

sizshrt
ssize_t sizshrt
Definition: main.c:85

get_menu_text_long
void get_menu_text_long(LiVESWidget *menuitem, char *text)
Definition: utils.c:3749

CANCEL_EVENT_LIST_END
event_list completed
Definition: main.h:440

do_jack_noopen_warn4
void do_jack_noopen_warn4(void)
Definition: dialogs.c:2528

make_version_hash
uint64_t make_version_hash(const char *ver)
Definition: utils.c:2475

get_dirname
void get_dirname(char *filename)
Definition: utils.c:2358

UNDO_TRIM_AUDIO
Definition: main.h:384

lives_close_all_file_buffers
void lives_close_all_file_buffers(void)
Definition: utils.c:459

lives_clip_t::vsize
int vsize
Definition: main.h:514

splash_init
void splash_init(void)
Definition: gui.c:4180

get_new_install_msg
char * get_new_install_msg(void)
Definition: dialogs.c:3335

do_invalid_subs_error
void do_invalid_subs_error(void)
Definition: dialogs.c:3231

capability::has_composite
boolean has_composite
Definition: main.h:713

lives_read
ssize_t lives_read(int fd, void *buf, size_t count, boolean allow_less)
Definition: utils.c:486

lives_clip_t::freeze_fps
double freeze_fps
Definition: main.h:567

do_need_mplayer_dialog
void do_need_mplayer_dialog(void)
Definition: dialogs.c:2096

do_layout_alter_audio_warning
boolean do_layout_alter_audio_warning(void)
Definition: dialogs.c:2486

lives_calloc
livespointer lives_calloc(size_t n_blocks, size_t n_block_bytes)
Definition: effects-weed.c:137

get_dir
char * get_dir(const char *filename)
Definition: utils.c:2375

lives_clip_t::header_version
int header_version
Definition: main.h:534

tv
struct timeval tv
Definition: main.h:816

colourspace.h

lives_lseek_buffered_rdonly
off_t lives_lseek_buffered_rdonly(int fd, off_t offset)
Definition: utils.c:631

calc_frame_from_time3
int calc_frame_from_time3(int filenum, double time)
nearest frame mid
Definition: utils.c:1435

lives_clip_t::raudio_time
double raudio_time
Definition: main.h:588

UNDO_RENDER
resample/reorder/resize/apply effects
Definition: main.h:399

close_ascrap_file
void close_ascrap_file(void)
Definition: saveplay.c:5100

do_no_mplayer_sox_error
void do_no_mplayer_sox_error(void)
Definition: dialogs.c:2090

do_bad_layout_error
void do_bad_layout_error(void)
Definition: dialogs.c:2610

CLIP_DETAILS_FILENAME
Definition: main.h:839

create_question_dialog
LiVESWidget * create_question_dialog(const char *title, const char *text, LiVESWindow *parent)
Definition: dialogs.c:350

lives_interlace_t
lives_interlace_t
Definition: main.h:493

lives_clip_t::event_list_back
weed_plant_t * event_list_back
Definition: main.h:606

set_signal_handlers
void set_signal_handlers(SignalHandlerPointer sigfunc)
Definition: main.c:2943

UNDO_EFFECT
Definition: main.h:380

insert_newlines
char * insert_newlines(const char *text, int maxwidth)
Definition: utils.c:5028

do_card_in_use_error
void do_card_in_use_error(void)
Definition: dialogs.c:3212

capability::has_icedax
boolean has_icedax
Definition: main.h:716

splash_msg
void splash_msg(const char *msg, double pct)
Definition: gui.c:4260

do_erase_subs_warning
boolean do_erase_subs_warning(void)
Definition: dialogs.c:3257

do_mt_undo_mem_error
void do_mt_undo_mem_error(void)
Definition: dialogs.c:2562

lives_undo_t
lives_undo_t
need this for event_list_t *
Definition: main.h:378

lives_clip_t::laudio_drawable
lives_painter_surface_t * laudio_drawable
Definition: main.h:687

lives_clip_t
corresponds to one clip in the GUI
Definition: main.h:509

lives_clip_t::event_list
weed_plant_t * event_list
Definition: main.h:605

capability::has_encoder_plugins
boolean has_encoder_plugins
Definition: main.h:745

UNDO_INSERT
Definition: main.h:388

do_lb_composite_error
void do_lb_composite_error(void)
Definition: dialogs.c:2615

calc_new_playback_position
int calc_new_playback_position(int fileno, uint64_t otc, uint64_t *ntc)
Definition: utils.c:1515

lives_cp_keep_perms
int lives_cp_keep_perms(const char *from, const char *to)
Definition: utils.c:3900

check_backend_return
boolean check_backend_return(lives_clip_t *sfile)
Definition: dialogs.c:685

lives_get_current_ticks
int64_t lives_get_current_ticks(void)
Definition: utils.c:1257

GNU_CONST
#define GNU_CONST
Definition: main.h:300

clip_detail_to_string
char * clip_detail_to_string(lives_clip_details_t what, size_t *maxlenp)
Definition: utils.c:4519

lives_clip_t::stored_layout_frame
int stored_layout_frame
layout map for the current layout
Definition: main.h:671

check_dev_busy
boolean check_dev_busy(char *devstr)
Definition: utils.c:4073

open_set_file
void open_set_file(const char *set_name, int clipnum)
Definition: saveplay.c:4333

save_to_scrap_file
int save_to_scrap_file(weed_plant_t *layer)
Definition: saveplay.c:4910

startup_message_choice
boolean startup_message_choice(const char *msg, int msgtype)
Definition: main.c:3412

do_theme_exists_warn
boolean do_theme_exists_warn(const char *themename)
Definition: dialogs.c:3375

lives_slist_free_all
void lives_slist_free_all(LiVESSList **)
Definition: utils.c:4450

CANCEL_NO_PROPOGATE
cancel but keep opening
Definition: main.h:425

ds_critical_msg
char * ds_critical_msg(const char *dir, uint64_t dsval)
Definition: dialogs.c:574

lives_pixbuf_new_blank
LiVESPixbuf * lives_pixbuf_new_blank(int width, int height, int palette)
Definition: colourspace.c:9803

preferences.h

add_to_recent
void add_to_recent(const char *filename, double start, int frames, const char *file_open_params)
Definition: utils.c:4230

CANCEL_NO_MORE_PREVIEW
ran out of preview frames
Definition: main.h:434

lives_kill_subprocesses
void lives_kill_subprocesses(const char *dirname, boolean kill_parent)
Definition: utils.c:3981

lives_colRGBA64_t::blue
uint16_t blue
Definition: main.h:320

unfade_background
void unfade_background(void)
Definition: gui.c:3059

do_blocking_info_dialog
int do_blocking_info_dialog(const char *text)
Definition: dialogs.c:525

check_for_bad_ffmpeg
lives_cancel_t check_for_bad_ffmpeg(void)
Definition: utils.c:5312

capability::has_xdg_screensaver
boolean has_xdg_screensaver
Definition: main.h:723

check_dir_access
boolean check_dir_access(const char *dir)
Definition: utils.c:4040

do_info_dialog_with_transient
int do_info_dialog_with_transient(const char *text, boolean is_blocking, LiVESWindow *transient)
Definition: dialogs.c:554

do_rmem_max_error
void do_rmem_max_error(int size)
Definition: dialogs.c:2681

lives_clip_t::old_frames
int old_frames
for deordering, etc.
Definition: main.h:548

ulong
#define ulong
Definition: main.h:154

STOP_ON_AUD_END
Definition: main.h:413

do_std_checks
boolean do_std_checks(const char *type_name, const char *type, size_t maxlen, const char *nreject)
Definition: utils.c:2127

CLIP_DETAILS_PB_FRAMENO
Definition: main.h:838

lives_readlink
ssize_t lives_readlink(const char *path, char *buf, size_t bufsiz)
Definition: utils.c:240

disable_record
void disable_record(void)
Definition: gui.c:3534

CLIP_DETAILS_FPS
Definition: main.h:823

CANCEL_ERROR
cancelled because of error
Definition: main.h:455

lives_clip_t::video_time
double video_time
Definition: main.h:586

xprocess
Definition: main.h:338

lives_getpid
pid_t lives_getpid(void)
Definition: utils.c:110

lives_chdir
int lives_chdir(const char *path, boolean allow_fail)
Definition: utils.c:824

wait_for_bg_audio_sync
void wait_for_bg_audio_sync(lives_clip_t *sfile)
Definition: utils.c:4149

lives_clip_t::no_proc_read_errors
boolean no_proc_read_errors
skip read error dialogs in processing
Definition: main.h:682

lives_audio_track_state_t
Definition: main.h:354

get_menu_text
void get_menu_text(LiVESWidget *menu, char *text)
Definition: utils.c:3744

lives_subtitles_t
Definition: pangotext.h:39

add_warn_check
void add_warn_check(LiVESBox *box, int warn_mask_number)
Definition: dialogs.c:109

lives_clip_t::hsize
int hsize
in pixels (NOT macropixels !)
Definition: main.h:513

UNDO_INSERT_WITH_AUDIO
Definition: main.h:406

capability::has_gdb
boolean has_gdb
Definition: main.h:721

get_location
void get_location(const char *exe, char *val, int maxlen)
Definition: utils.c:2442

switch_to_mplayer
void switch_to_mplayer(void)

get_frame_count
void get_frame_count(int idx)
Definition: utils.c:2288

CANCEL_PREVIEW_FINISHED
effect processing finished during preview
Definition: main.h:428

calc_maxspect
void calc_maxspect(int rwidth, int rheight, int *cwidth, int *cheight)
Definition: utils.c:1728

lives_clip_t::img_type
lives_image_type_t img_type
Definition: main.h:668

lives_cancel_type_t
lives_cancel_type_t
Definition: main.h:464

make_custom_submenus
void make_custom_submenus(void)
Definition: gui.c:144

do_need_mplayer_mpv_dialog
void do_need_mplayer_mpv_dialog(void)
Definition: dialogs.c:2102

int_array_contains_value
boolean int_array_contains_value(int *array, int num_elems, int value)
Definition: utils.c:3754

ensure_isdir
boolean ensure_isdir(char *fname)
Definition: utils.c:2422

do_header_read_error_with_retry
int do_header_read_error_with_retry(int clip) WARN_UNUSED
Definition: dialogs.c:3102

get_signed_endian
uint32_t get_signed_endian(boolean is_signed, boolean little_endian)
Definition: utils.c:4964

myround
int myround(double n)
Definition: utils.c:1219

lives_alarm_get
boolean lives_alarm_get(int alarm_handle)
Definition: utils.c:1312

capability::smog_version_correct
boolean smog_version_correct
Definition: main.h:698

CLIP_DETAILS_PB_FPS
Definition: main.h:824

resize_widgets_for_monitor
void resize_widgets_for_monitor(boolean get_play_times)
Definition: gui.c:3569

lives_list_delete_string
LiVESList * lives_list_delete_string(LiVESList *, char *string) WARN_UNUSED
Definition: utils.c:5250

capability::has_mplayer2
boolean has_mplayer2
Definition: main.h:710

do_pulse_lost_conn_error
void do_pulse_lost_conn_error(void)
Definition: dialogs.c:3358

switch_audio_clip
void switch_audio_clip(int new_file, boolean activate)
Definition: main.c:7193

capable
capability * capable
some shared structures
Definition: main.c:83

xprocess::progressbar
LiVESWidget * progressbar
Definition: main.h:341

cache_file_contents
boolean cache_file_contents(const char *filename)
Definition: utils.c:4466

read_file_details
boolean read_file_details(const char *file_name, boolean only_check_for_audio)
Definition: saveplay.c:146

lives_clip_t::end
int end
Definition: main.h:555

lives_getgid
int lives_getgid(void)
Definition: utils.c:230

lives_clip_t::unique_id
uint64_t unique_id
this and the handle can be used to uniquely id a file
Definition: main.h:519

CANCEL_VID_END
video playback completed
Definition: main.h:443

do_upgrade_error_dialog
void do_upgrade_error_dialog(void)
Definition: dialogs.c:2417

do_yesno_dialog
boolean do_yesno_dialog(const char *text)
Definition: dialogs.c:444

activate_url_inner
void activate_url_inner(const char *link)
Definition: utils.c:4097

d_print_done
void d_print_done(void)
Definition: dialogs.c:2884

load_start_image
void load_start_image(int frame)
Definition: main.c:3892

do_mt_no_jack_error
void do_mt_no_jack_error(int warn_mask)
Definition: dialogs.c:2598

pull_frame
boolean pull_frame(weed_plant_t *layer, const char *image_ext, weed_timecode_t tc)
Definition: main.c:5087

too_many_files
void too_many_files(void)
Definition: dialogs.c:2071

do_header_write_error
boolean do_header_write_error(int clip)
Definition: dialogs.c:3116

save_file
void save_file(int clip, int start, int end, const char *filename)
Definition: saveplay.c:1184

do_do_not_close_d
void do_do_not_close_d(void)
Definition: dialogs.c:3297

do_chdir_failed_error
void do_chdir_failed_error(const char *dir)
Definition: dialogs.c:3160

do_layout_scrap_file_error
void do_layout_scrap_file_error(void)
Definition: dialogs.c:2128

add_to_ascrap_mb
void add_to_ascrap_mb(uint64_t bytes)
Definition: saveplay.c:4652

lives_cp
int lives_cp(const char *from, const char *to)
Definition: utils.c:3892

do_set_rename_old_layouts_warning
boolean do_set_rename_old_layouts_warning(const char *new_set)
Definition: dialogs.c:2554

lives_clip_type_t
lives_clip_type_t
Definition: main.h:469

fade_background
void fade_background(void)
Definition: gui.c:2940

play_file
void play_file(void)
Definition: saveplay.c:2047

do_after_crash_warning
void do_after_crash_warning(void)
Definition: dialogs.c:2669

show_lives
void show_lives(void)
Definition: gui.c:2765

lives_rmglob
int lives_rmglob(const char *files)
Definition: utils.c:3877

lives_colRGB48_t::red
uint16_t red
Definition: main.h:312

do_sub_type_warning
boolean do_sub_type_warning(const char *ext, const char *type_ext)
Definition: dialogs.c:3262

rewrite_recovery_file
void rewrite_recovery_file(void)
Definition: saveplay.c:5706

do_encoder_acodec_error
void do_encoder_acodec_error(void)
Definition: dialogs.c:2122

is_writeable_dir
boolean is_writeable_dir(const char *dir)
Definition: utils.c:5160

do_vpp_palette_error
void do_vpp_palette_error(void)
Definition: dialogs.c:2653

backup_file
void backup_file(int clip, int start, int end, const char *filename)
Definition: saveplay.c:3747

capability::has_gconftool_2
boolean has_gconftool_2
Definition: main.h:722

prepare_to_play_foreign
boolean prepare_to_play_foreign(void)
Definition: utils.c:3490

get_menu_name
char * get_menu_name(lives_clip_t *sfile)
Definition: gui.c:4086

do_set_duplicate_warning
boolean do_set_duplicate_warning(const char *new_set)
Definition: dialogs.c:2471

lives_audio_track_state_t::vel
double vel
Definition: main.h:357

lives_clip_t::is_loaded
boolean is_loaded
should we continue loading if we come back to this clip
Definition: main.h:576

lives_list_append_unique
LiVESList * lives_list_append_unique(LiVESList *xlist, const char *add)
Definition: utils.c:1388

save_clip_values
boolean save_clip_values(int which_file)
Definition: saveplay.c:37

lives_clip_t::f_size
int64_t f_size
Definition: main.h:546

lives_clip_t::undo_asampsize
int undo_asampsize
Definition: main.h:637

lives_chmod
int lives_chmod(const char *target, const char *mode)
Definition: utils.c:3940

break_me
void break_me(void)
Definition: main.c:132

lives_fsync
boolean lives_fsync(int fd)
Definition: utils.c:252

do_quick_switch
void do_quick_switch(int new_file)
Definition: main.c:7391

get_frames_sizes
void get_frames_sizes(int fileno, int frame_to_test)
Definition: utils.c:2336

do_set_noclips_error
void do_set_noclips_error(const char *setname)
Definition: dialogs.c:3311

UNDO_CUT
Definition: main.h:389

deduce_file
ulong deduce_file(const char *filename, double start_time, int end)
Definition: saveplay.c:212

lives_colRGB48_t
Definition: main.h:311

capability::ncpus
int ncpus
Definition: main.h:759

response_ok
void response_ok(LiVESButton *button, livespointer user_data)
Definition: dialogs.c:2869

lives_clip_t::op_ds_warn_level
uint64_t op_ds_warn_level
current disk space warning level for any output directory
Definition: main.h:679

do_memory_error_dialog
void do_memory_error_dialog(void)
Definition: dialogs.c:617

CANCEL_KEEP_LOOPING
special cancel for TV toy
Definition: main.h:461

procw_desensitize
void procw_desensitize(void)
Definition: main.c:3779

do_system_failed_error
void do_system_failed_error(const char *com, int retval, const char *addinfo)
Definition: dialogs.c:2893

lives_10pow
uint64_t lives_10pow(int pow) GNU_CONST
Definition: utils.c:1229

startup_message_nonfatal_dismissable
boolean startup_message_nonfatal_dismissable(const char *msg, int warning_mask)
Definition: main.c:3435

remove_layout_files
void remove_layout_files(LiVESList *lmap)
Definition: utils.c:2526

lives_close_buffered
int lives_close_buffered(int fd)
Definition: utils.c:570

lives_open2
int lives_open2(const char *pathname, int flags)
Definition: utils.c:150

set_interactive
void set_interactive(boolean interactive)
Definition: gui.c:2825

UNDO_INSERT_SILENCE
Definition: main.h:392

lives_clip_t::changed
boolean changed
Definition: main.h:560

lives_colRGB48_t::blue
uint16_t blue
Definition: main.h:314

lives_clip_t::insert_end
int insert_end
Definition: main.h:557

capability::has_sox_sox
boolean has_sox_sox
Definition: main.h:707

lives_alarm_set
int lives_alarm_set(int64_t ticks)
Definition: utils.c:1273

plugins.h

get_approx_ln
int get_approx_ln(uint32_t val) GNU_CONST
Definition: utils.c:1243

capability::can_write_to_home
boolean can_write_to_home
Definition: main.h:701

lives_cancel_t
lives_cancel_t
cancel reason
Definition: main.h:417

do_mt_rect_prompt
boolean do_mt_rect_prompt(void)
Definition: dialogs.c:2604

open_ascrap_file
boolean open_ascrap_file(void)
Definition: saveplay.c:4699

lives_clip_t::achans
int achans
Definition: main.h:520

NEVER_STOP
Definition: main.h:411

lives_clip_t::next_event
weed_plant_t * next_event
Definition: main.h:607

xprocess::is_ready
boolean is_ready
Definition: main.h:351

pangotext.h

LEFloat_to_BEFloat
float LEFloat_to_BEFloat(float f) GNU_CONST
Definition: utils.c:1395

UNDO_APPEND_AUDIO
Definition: main.h:387

lives_datetime
char * lives_datetime(struct timeval *tv)
Definition: utils.c:1364

check_for_ratio_fps
boolean check_for_ratio_fps(double fps)
Definition: utils.c:4917

do_dvgrab_error
void do_dvgrab_error(void)
Definition: dialogs.c:2642

do_progress_dialog
boolean do_progress_dialog(boolean visible, boolean cancellable, const char *text)
Definition: dialogs.c:1424

block_expose
void block_expose(void)
Definition: gui.c:3245

get_new_handle
boolean get_new_handle(int index, const char *name)
Definition: saveplay.c:3355

xprocess::preview_button
LiVESWidget * preview_button
Definition: main.h:347

capability::has_sox_play
boolean has_sox_play
Definition: main.h:706

get_filename
void get_filename(char *filename, boolean strip_dir)
Definition: utils.c:2393

CLIP_DETAILS_ARATE
Definition: main.h:828

UNDO_NEW_AUDIO
Definition: main.h:393

xprocess::pause_button
LiVESWidget * pause_button
Definition: main.h:346

make_image_file_name
char * make_image_file_name(lives_clip_t *clip, int frame, const char *img_ext)
Definition: utils.c:2241

CANCEL_USER_PAUSED
cancelled and paused
Definition: main.h:458

do_jack_noopen_warn2
void do_jack_noopen_warn2(void)
Definition: dialogs.c:2540

lives_clip_t::orig_file_name
boolean orig_file_name
Definition: main.h:563

save_srt_subtitles
boolean save_srt_subtitles(lives_clip_t *sfile, double start_time, double end_time, double offset_time, const char *filename)
Definition: pangotext.c:768

calc_aframeno
void calc_aframeno(int fileno)
Definition: utils.c:1494

lives_storage_status_t
lives_storage_status_t
disk/storage status values
Definition: mainwindow.h:216

do_start_messages
void do_start_messages(void)
Definition: main.c:1820

capability::has_identify
boolean has_identify
Definition: main.h:714

IMG_TYPE_JPEG
Definition: main.h:480

do_locked_in_vdevs_error
void do_locked_in_vdevs_error(void)
Definition: dialogs.c:3292

IMG_TYPE_PNG
Definition: main.h:481

sensitize
void sensitize(void)
Definition: main.c:3479

xprocess::label
LiVESWidget * label
Definition: main.h:342

capability::has_autolives
boolean has_autolives
Definition: main.h:708

catch_sigint
void catch_sigint(int signum)
Definition: main.c:183

UNDO_DELETE_AUDIO
Definition: main.h:391

CLIP_DETAILS_HEADER_VERSION
Definition: main.h:841

lives_image_type_to_image_type
lives_image_type_t lives_image_type_to_image_type(const char *lives_img_type)
Definition: utils.c:2234

do_aud_during_play_error
void do_aud_during_play_error(void)
Definition: dialogs.c:612

check_for_recovery_files
boolean check_for_recovery_files(boolean auto_recover)
Definition: saveplay.c:5759

get_clip_value
boolean get_clip_value(int which, lives_clip_details_t, void *retval, size_t maxlen)
Definition: utils.c:4613

calc_frame_from_time
int calc_frame_from_time(int filenum, double time)
nearest frame start
Definition: utils.c:1416

do_no_in_vdevs_error
void do_no_in_vdevs_error(void)
Definition: dialogs.c:3287

get_upd_msg
char * get_upd_msg(int type)
Definition: dialogs.c:3319

lives_clip_t::undo_end
int undo_end
Definition: main.h:616

lives_srandom
void lives_srandom(unsigned int seed)
Definition: utils.c:92

create_cfile
void create_cfile(void)
Definition: saveplay.c:3255

capability::byte_order
int byte_order
Definition: main.h:761

init_track_decoders
void init_track_decoders(void)
Definition: main.c:5372

lives_clip_t::undo4_int
int undo4_int
Definition: main.h:626

lives_clip_t::pointer_time
double pointer_time
Definition: main.h:589

do_mt_no_audchan_error
void do_mt_no_audchan_error(void)
Definition: dialogs.c:2594

get_image_ext_for_type
const char * get_image_ext_for_type(lives_image_type_t imgtype)
Definition: utils.c:2215

lives_clip_t::fps
double fps
Definition: main.h:512

lives_format_storage_space_string
char * lives_format_storage_space_string(uint64_t space)
Definition: utils.c:783

lives_clip_t::cb_src
int cb_src
source clip for clipboard
Definition: main.h:690

do_nojack_rec_error
void do_nojack_rec_error(void)
Definition: dialogs.c:2647

get_total_time
void get_total_time(lives_clip_t *file)
Definition: utils.c:3114

open_file
ulong open_file(const char *filename)
Definition: saveplay.c:235

lives_suspend_resume_process
void lives_suspend_resume_process(const char *dirname, boolean suspend)
Definition: utils.c:4009

capability::myname_full
char * myname_full
Definition: main.h:752

lives_clip_t::ratio_fps
boolean ratio_fps
if the fps was set by a ratio
Definition: main.h:658

CANCEL_APP_QUIT
application quit
Definition: main.h:431

capability::has_convert
boolean has_convert
Definition: main.h:712

CANCEL_GENERATOR_END
generator was stopped
Definition: main.h:446

lives_fix
double lives_fix(double val, int decimals) GNU_CONST
Definition: utils.c:1237

create_LiVES
void create_LiVES(void)
Definition: gui.c:340

UNDO_ATOMIC_RESAMPLE_RESIZE
resample/resize and resample audio for encoding
Definition: main.h:396

lives_clip_t::undo_start
int undo_start
Definition: main.h:615

do_info_dialog
int do_info_dialog(const char *text)
Definition: dialogs.c:504

do_encoder_restrict_dialog
boolean do_encoder_restrict_dialog(int width, int height, double fps, int fps_num, int fps_denom, int arate, int asigned, boolean swap_endian, boolean anr, boolean save_all)
Definition: dialogs.c:2231

UNDO_FADE_AUDIO
Definition: main.h:401

open_scrap_file
boolean open_scrap_file(void)
Definition: saveplay.c:4657

CLIP_DETAILS_ACHANS
Definition: main.h:830

check_for_lock_file
boolean check_for_lock_file(const char *set_name, int type)
Definition: utils.c:2068

UNDO_RESIZABLE
Definition: main.h:381

lives_clip_t::undo3_int
int undo3_int
Definition: main.h:625

subtitles_init
boolean subtitles_init(lives_clip_t *sfile, char *fname, lives_subtitle_type_t)
Definition: pangotext.c:718

switch_aud_to_mplayer
void switch_aud_to_mplayer(boolean set_pref)
Definition: utils.c:3388

capability::cpu_bits
short cpu_bits
Definition: main.h:750

get_version_hash
uint64_t get_version_hash(const char *exe, const char *sep, int piece)
Definition: utils.c:2456

ds_warning_msg
char * ds_warning_msg(const char *dir, uint64_t dsval, uint64_t cwarn, uint64_t nwarn)
Definition: dialogs.c:592

do_decoder_palette_error
void do_decoder_palette_error(void)
Definition: dialogs.c:2658

threaded_dialog_spin
void threaded_dialog_spin(double fraction)
Definition: dialogs.c:2774

calc_frame_from_time2
int calc_frame_from_time2(int filenum, double time)
nearest frame end
Definition: utils.c:1425

_lives_realloc
livespointer _lives_realloc(livespointer ptr, size_t new_size)
Definition: effects-weed.c:90

save_file_comments
boolean save_file_comments(int fileno)
Definition: saveplay.c:3587

lives_clip_t::pb_fps
double pb_fps
Definition: main.h:566

lives_write
ssize_t lives_write(int fd, livesconstpointer buf, size_t count, boolean allow_fail)

WARN_UNUSED
#define WARN_UNUSED
Definition: main.h:298

CLIP_DETAILS_PB_ARATE
Definition: main.h:829

do_comments_dialog
boolean do_comments_dialog(int fileno, char *filename)
Definition: dialogs.c:2360

dummychar
char * dummychar
Definition: main.h:1363

fullscreen_internal
void fullscreen_internal(void)
Definition: gui.c:3190

CLIP_NAME_MAXLEN
#define CLIP_NAME_MAXLEN
Definition: main.h:506

capability::myname
char * myname
Definition: main.h:753

capability::has_python
boolean has_python
Definition: main.h:747

CLIP_DETAILS_BPP
Definition: main.h:822

CLIP_DETAILS_KEYWORDS
Definition: main.h:842

lives_subtitle_type_t
lives_subtitle_type_t
Definition: pangotext.h:13

lives_list_copy_strings
LiVESList * lives_list_copy_strings(LiVESList *list)
Definition: utils.c:5266

FALSE
#define FALSE
Definition: videoplugin.h:56

do_warning_dialog_with_check
boolean do_warning_dialog_with_check(const char *text, int warn_mask_number)
Definition: dialogs.c:362

load_end_image
void load_end_image(int frame)
Definition: main.c:4067

UNDO_MERGE
Definition: main.h:382

lives_sync
void lives_sync(void)
Definition: utils.c:262

lives_read_le_buffered
ssize_t lives_read_le_buffered(int fd, void *buf, size_t count, boolean allow_less)
Definition: utils.c:708

do_original_lost_warning
boolean do_original_lost_warning(const char *fname)
Definition: dialogs.c:2491

do_blocking_error_dialog
int do_blocking_error_dialog(const char *text)
Definition: dialogs.c:518

lives_list_strcmp_index
int lives_list_strcmp_index(LiVESList *list, livesconstpointer data)
Definition: utils.c:4215

capability::has_jackd
boolean has_jackd
Definition: main.h:718

add_file_info
boolean add_file_info(const char *check_handle, boolean aud_only)
Definition: saveplay.c:3386

lives_clip_t::laudio_time
double laudio_time
Definition: main.h:587

string_lists_differ
boolean string_lists_differ(LiVESList *, LiVESList *)
Definition: utils.c:5280

lives_clip_t::undoable
boolean undoable
Definition: main.h:619

liblives.hpp

LIVES_INTERLACE_NONE
Definition: main.h:494

do_lb_convert_error
void do_lb_convert_error(void)
Definition: dialogs.c:2621

lives_clip_t::old_laudio_time
double old_laudio_time
Definition: main.h:592

CLIP_DETAILS_UNIQUE_ID
Definition: main.h:827

do_error_dialog_with_check
int do_error_dialog_with_check(const char *text, int warn_mask_number)
Definition: dialogs.c:511

d_print_cancelled
void d_print_cancelled(void)
Definition: dialogs.c:2874

zero_spinbuttons
void zero_spinbuttons(void)
Definition: utils.c:3226

CANCEL_USER
user pressed stop
Definition: main.h:422

lives_clip_t::arps
int arps
audio sample rate
Definition: main.h:515

lives_clip_t::opening_loc
boolean opening_loc
Definition: main.h:574

switch_aud_to_jack
boolean switch_aud_to_jack(void)
Definition: utils.c:3238