git.maemo.org Git - fillmore/blob - src/marina/marina/MediaEngine.c

   1 /* MediaEngine.c generated by valac, the Vala compiler
   2  * generated from MediaEngine.vala, do not modify */
   3
   4 /* Copyright 2009-2010 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <gst/gst.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <gee.h>
  16 #include <gdk-pixbuf/gdk-pixdata.h>
  17 #include <gst/controller/gstcontroller.h>
  18 #include <float.h>
  19 #include <math.h>
  20 #include <stdio.h>
  21 #include <gtk/gtk.h>
  22 #include <gdk/gdkx.h>
  23 #include <gdk/gdk.h>
  24 #include <X11/Xlib.h>
  25 #include <X11/Xatom.h>
  26 #include <X11/Xutil.h>
  27 #include <X11/Xregion.h>
  28 #include <gst/interfaces/xoverlay.h>
  29 #include <glib/gstdio.h>
  30
  31
  32 #define TYPE_PLAY_STATE (play_state_get_type ())
  33
  34 #define VIEW_TYPE_MEDIA_CLIP (view_media_clip_get_type ())
  35 #define VIEW_MEDIA_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_CLIP, ViewMediaClip))
  36 #define VIEW_MEDIA_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipClass))
  37 #define VIEW_IS_MEDIA_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_CLIP))
  38 #define VIEW_IS_MEDIA_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_CLIP))
  39 #define VIEW_MEDIA_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipClass))
  40
  41 typedef struct _ViewMediaClip ViewMediaClip;
  42 typedef struct _ViewMediaClipClass ViewMediaClipClass;
  43 typedef struct _ViewMediaClipPrivate ViewMediaClipPrivate;
  44
  45 #define MODEL_TYPE_CLIP (model_clip_get_type ())
  46 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
  47 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
  48 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
  49 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
  50 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
  51
  52 typedef struct _ModelClip ModelClip;
  53 typedef struct _ModelClipClass ModelClipClass;
  54 #define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
  55 typedef struct _ModelClipPrivate ModelClipPrivate;
  56
  57 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  58 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  59 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  60 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  61 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  62 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  63
  64 typedef struct _ModelClipFile ModelClipFile;
  65 typedef struct _ModelClipFileClass ModelClipFileClass;
  66
  67 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
  68
  69 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
  70
  71 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
  72
  73 #define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ())
  74 #define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin))
  75 #define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
  76 #define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN))
  77 #define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN))
  78 #define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
  79
  80 typedef struct _SingleDecodeBin SingleDecodeBin;
  81 typedef struct _SingleDecodeBinClass SingleDecodeBinClass;
  82 #define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
  83
  84 #define VIEW_TYPE_MEDIA_AUDIO_CLIP (view_media_audio_clip_get_type ())
  85 #define VIEW_MEDIA_AUDIO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClip))
  86 #define VIEW_MEDIA_AUDIO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClipClass))
  87 #define VIEW_IS_MEDIA_AUDIO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP))
  88 #define VIEW_IS_MEDIA_AUDIO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_AUDIO_CLIP))
  89 #define VIEW_MEDIA_AUDIO_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClipClass))
  90
  91 typedef struct _ViewMediaAudioClip ViewMediaAudioClip;
  92 typedef struct _ViewMediaAudioClipClass ViewMediaAudioClipClass;
  93 typedef struct _ViewMediaAudioClipPrivate ViewMediaAudioClipPrivate;
  94
  95 #define VIEW_TYPE_MEDIA_VIDEO_CLIP (view_media_video_clip_get_type ())
  96 #define VIEW_MEDIA_VIDEO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClip))
  97 #define VIEW_MEDIA_VIDEO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClipClass))
  98 #define VIEW_IS_MEDIA_VIDEO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP))
  99 #define VIEW_IS_MEDIA_VIDEO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_VIDEO_CLIP))
 100 #define VIEW_MEDIA_VIDEO_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClipClass))
 101
 102 typedef struct _ViewMediaVideoClip ViewMediaVideoClip;
 103 typedef struct _ViewMediaVideoClipClass ViewMediaVideoClipClass;
 104 typedef struct _ViewMediaVideoClipPrivate ViewMediaVideoClipPrivate;
 105
 106 #define VIEW_TYPE_MEDIA_TRACK (view_media_track_get_type ())
 107 #define VIEW_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrack))
 108 #define VIEW_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass))
 109 #define VIEW_IS_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_TRACK))
 110 #define VIEW_IS_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_TRACK))
 111 #define VIEW_MEDIA_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass))
 112
 113 typedef struct _ViewMediaTrack ViewMediaTrack;
 114 typedef struct _ViewMediaTrackClass ViewMediaTrackClass;
 115 typedef struct _ViewMediaTrackPrivate ViewMediaTrackPrivate;
 116
 117 #define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ())
 118 #define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine))
 119 #define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
 120 #define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE))
 121 #define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE))
 122 #define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
 123
 124 typedef struct _ViewMediaEngine ViewMediaEngine;
 125 typedef struct _ViewMediaEngineClass ViewMediaEngineClass;
 126 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 127
 128 #define MODEL_TYPE_TRACK (model_track_get_type ())
 129 #define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack))
 130 #define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass))
 131 #define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK))
 132 #define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK))
 133 #define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass))
 134
 135 typedef struct _ModelTrack ModelTrack;
 136 typedef struct _ModelTrackClass ModelTrackClass;
 137
 138 #define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ())
 139 #define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface))
 140 #define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE))
 141 #define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface))
 142
 143 typedef struct _MultiFileProgressInterface MultiFileProgressInterface;
 144 typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface;
 145 typedef struct _ViewMediaEnginePrivate ViewMediaEnginePrivate;
 146
 147 #define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ())
 148 #define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack))
 149 #define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
 150 #define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK))
 151 #define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK))
 152 #define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass))
 153
 154 typedef struct _ModelAudioTrack ModelAudioTrack;
 155 typedef struct _ModelAudioTrackClass ModelAudioTrackClass;
 156 typedef struct _ModelClipFilePrivate ModelClipFilePrivate;
 157 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 158
 159 #define VIEW_TYPE_MEDIA_VIDEO_TRACK (view_media_video_track_get_type ())
 160 #define VIEW_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrack))
 161 #define VIEW_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass))
 162 #define VIEW_IS_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK))
 163 #define VIEW_IS_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK))
 164 #define VIEW_MEDIA_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass))
 165
 166 typedef struct _ViewMediaVideoTrack ViewMediaVideoTrack;
 167 typedef struct _ViewMediaVideoTrackClass ViewMediaVideoTrackClass;
 168 typedef struct _ViewMediaVideoTrackPrivate ViewMediaVideoTrackPrivate;
 169
 170 #define VIEW_TYPE_CLICK_TRACK (view_click_track_get_type ())
 171 #define VIEW_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrack))
 172 #define VIEW_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass))
 173 #define VIEW_IS_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_CLICK_TRACK))
 174 #define VIEW_IS_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_CLICK_TRACK))
 175 #define VIEW_CLICK_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass))
 176
 177 typedef struct _ViewClickTrack ViewClickTrack;
 178 typedef struct _ViewClickTrackClass ViewClickTrackClass;
 179 typedef struct _ViewClickTrackPrivate ViewClickTrackPrivate;
 180
 181 #define MODEL_TYPE_PROJECT (model_project_get_type ())
 182 #define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject))
 183 #define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass))
 184 #define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT))
 185 #define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT))
 186 #define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass))
 187
 188 typedef struct _ModelProject ModelProject;
 189 typedef struct _ModelProjectClass ModelProjectClass;
 190
 191 #define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ())
 192 #define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation))
 193 #define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION))
 194 #define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface))
 195
 196 typedef struct _ModelTempoInformation ModelTempoInformation;
 197 typedef struct _ModelTempoInformationIface ModelTempoInformationIface;
 198
 199 #define TYPE_FRACTION (fraction_get_type ())
 200 typedef struct _Fraction Fraction;
 201 typedef struct _ModelProjectPrivate ModelProjectPrivate;
 202
 203 #define TYPE_TIME_CODE (time_code_get_type ())
 204 typedef struct _TimeCode TimeCode;
 205
 206 #define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ())
 207 #define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader))
 208 #define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 209 #define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER))
 210 #define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER))
 211 #define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 212
 213 typedef struct _ModelProjectLoader ModelProjectLoader;
 214 typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass;
 215
 216 #define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ())
 217 #define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager))
 218 #define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 219 #define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER))
 220 #define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER))
 221 #define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 222
 223 typedef struct _ModelUndoManager ModelUndoManager;
 224 typedef struct _ModelUndoManagerClass ModelUndoManagerClass;
 225
 226 #define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ())
 227 #define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter))
 228 #define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 229 #define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER))
 230 #define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER))
 231 #define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 232
 233 typedef struct _ModelLibraryImporter ModelLibraryImporter;
 234 typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass;
 235 #define __g_list_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_g_free (var), NULL)))
 236
 237 #define VIEW_TYPE_MEDIA_AUDIO_TRACK (view_media_audio_track_get_type ())
 238 #define VIEW_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrack))
 239 #define VIEW_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass))
 240 #define VIEW_IS_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK))
 241 #define VIEW_IS_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK))
 242 #define VIEW_MEDIA_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass))
 243
 244 typedef struct _ViewMediaAudioTrack ViewMediaAudioTrack;
 245 typedef struct _ViewMediaAudioTrackClass ViewMediaAudioTrackClass;
 246 typedef struct _ViewMediaAudioTrackPrivate ViewMediaAudioTrackPrivate;
 247
 248 #define MODEL_TYPE_PARAMETER (model_parameter_get_type ())
 249
 250 #define VIEW_TYPE_MEDIA_CONNECTOR (view_media_connector_get_type ())
 251 #define VIEW_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnector))
 252 #define VIEW_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass))
 253 #define VIEW_IS_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_CONNECTOR))
 254 #define VIEW_IS_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_CONNECTOR))
 255 #define VIEW_MEDIA_CONNECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass))
 256
 257 typedef struct _ViewMediaConnector ViewMediaConnector;
 258 typedef struct _ViewMediaConnectorClass ViewMediaConnectorClass;
 259 typedef struct _ViewMediaConnectorPrivate ViewMediaConnectorPrivate;
 260
 261 #define VIEW_MEDIA_CONNECTOR_TYPE_MEDIA_TYPES (view_media_connector_media_types_get_type ())
 262
 263 #define VIEW_TYPE_VIDEO_OUTPUT (view_video_output_get_type ())
 264 #define VIEW_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutput))
 265 #define VIEW_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass))
 266 #define VIEW_IS_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_VIDEO_OUTPUT))
 267 #define VIEW_IS_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_VIDEO_OUTPUT))
 268 #define VIEW_VIDEO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass))
 269
 270 typedef struct _ViewVideoOutput ViewVideoOutput;
 271 typedef struct _ViewVideoOutputClass ViewVideoOutputClass;
 272 typedef struct _ViewVideoOutputPrivate ViewVideoOutputPrivate;
 273
 274 #define VIEW_TYPE_AUDIO_OUTPUT (view_audio_output_get_type ())
 275 #define VIEW_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutput))
 276 #define VIEW_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass))
 277 #define VIEW_IS_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_AUDIO_OUTPUT))
 278 #define VIEW_IS_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_AUDIO_OUTPUT))
 279 #define VIEW_AUDIO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass))
 280
 281 typedef struct _ViewAudioOutput ViewAudioOutput;
 282 typedef struct _ViewAudioOutputClass ViewAudioOutputClass;
 283 typedef struct _ViewAudioOutputPrivate ViewAudioOutputPrivate;
 284
 285 #define VIEW_TYPE_OGG_VORBIS_EXPORT (view_ogg_vorbis_export_get_type ())
 286 #define VIEW_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExport))
 287 #define VIEW_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass))
 288 #define VIEW_IS_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT))
 289 #define VIEW_IS_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT))
 290 #define VIEW_OGG_VORBIS_EXPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass))
 291
 292 typedef struct _ViewOggVorbisExport ViewOggVorbisExport;
 293 typedef struct _ViewOggVorbisExportClass ViewOggVorbisExportClass;
 294 typedef struct _ViewOggVorbisExportPrivate ViewOggVorbisExportPrivate;
 295 #define _g_free0(var) (var = (g_free (var), NULL))
 296 typedef struct _ModelTrackPrivate ModelTrackPrivate;
 297
 298 typedef enum  {
 299         PLAY_STATE_STOPPED,
 300         PLAY_STATE_PRE_PLAY,
 301         PLAY_STATE_PLAYING,
 302         PLAY_STATE_PRE_RECORD_NULL,
 303         PLAY_STATE_PRE_RECORD,
 304         PLAY_STATE_RECORDING,
 305         PLAY_STATE_POST_RECORD,
 306         PLAY_STATE_PRE_EXPORT,
 307         PLAY_STATE_EXPORTING,
 308         PLAY_STATE_CANCEL_EXPORT,
 309         PLAY_STATE_LOADING,
 310         PLAY_STATE_CLOSING,
 311         PLAY_STATE_CLOSED
 312 } PlayState;
 313
 314 struct _ViewMediaClip {
 315         GObject parent_instance;
 316         ViewMediaClipPrivate * priv;
 317         GstElement* file_source;
 318 };
 319
 320 struct _ViewMediaClipClass {
 321         GObjectClass parent_class;
 322 };
 323
 324 struct _ViewMediaClipPrivate {
 325         ModelClip* clip;
 326         GstBin* composition;
 327 };
 328
 329 typedef enum  {
 330         MODEL_MEDIA_TYPE_AUDIO,
 331         MODEL_MEDIA_TYPE_VIDEO
 332 } ModelMediaType;
 333
 334 struct _ModelClip {
 335         GObject parent_instance;
 336         ModelClipPrivate * priv;
 337         ModelClipFile* clipfile;
 338         ModelMediaType type;
 339         gboolean is_recording;
 340         char* name;
 341 };
 342
 343 struct _ModelClipClass {
 344         GObjectClass parent_class;
 345 };
 346
 347 typedef enum  {
 348         LOGGING_FACILITY_SIGNAL_HANDLERS,
 349         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 350         LOGGING_FACILITY_GRAPH,
 351         LOGGING_FACILITY_LOADING,
 352         LOGGING_FACILITY_IMPORT,
 353         LOGGING_FACILITY_SINGLEDECODEBIN
 354 } LoggingFacility;
 355
 356 typedef enum  {
 357         LOGGING_LEVEL_CRITICAL,
 358         LOGGING_LEVEL_HIGH,
 359         LOGGING_LEVEL_MEDIUM,
 360         LOGGING_LEVEL_LOW,
 361         LOGGING_LEVEL_INFO,
 362         LOGGING_LEVEL_VERBOSE
 363 } LoggingLevel;
 364
 365 struct _ViewMediaAudioClip {
 366         ViewMediaClip parent_instance;
 367         ViewMediaAudioClipPrivate * priv;
 368 };
 369
 370 struct _ViewMediaAudioClipClass {
 371         ViewMediaClipClass parent_class;
 372 };
 373
 374 struct _ViewMediaVideoClip {
 375         ViewMediaClip parent_instance;
 376         ViewMediaVideoClipPrivate * priv;
 377 };
 378
 379 struct _ViewMediaVideoClipClass {
 380         ViewMediaClipClass parent_class;
 381 };
 382
 383 struct _ViewMediaTrack {
 384         GObject parent_instance;
 385         ViewMediaTrackPrivate * priv;
 386         ViewMediaEngine* media_engine;
 387         GstBin* composition;
 388         GstElement* default_source;
 389         GstElement* sink;
 390 };
 391
 392 struct _ViewMediaTrackClass {
 393         GObjectClass parent_class;
 394         GstElement* (*empty_element) (ViewMediaTrack* self, GError** error);
 395         GstElement* (*get_element) (ViewMediaTrack* self);
 396         void (*link_new_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 397         void (*unlink_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 398 };
 399
 400 struct _ViewMediaTrackPrivate {
 401         GeeArrayList* clips;
 402 };
 403
 404 struct _MultiFileProgressInterfaceIface {
 405         GTypeInterface parent_iface;
 406         void (*cancel) (MultiFileProgressInterface* self);
 407         void (*complete) (MultiFileProgressInterface* self);
 408 };
 409
 410 struct _ViewMediaEngine {
 411         GObject parent_instance;
 412         ViewMediaEnginePrivate * priv;
 413         GstPipeline* pipeline;
 414         GstBin* record_bin;
 415         GstElement* converter;
 416         GstElement* adder;
 417         GstState gst_state;
 418         PlayState play_state;
 419         gint64 position;
 420         gboolean playing;
 421         ModelAudioTrack* record_track;
 422         ModelClip* record_region;
 423 };
 424
 425 struct _ViewMediaEngineClass {
 426         GObjectClass parent_class;
 427         void (*do_null_state_export) (ViewMediaEngine* self, gint64 length);
 428         void (*pause) (ViewMediaEngine* self);
 429 };
 430
 431 struct _ModelClipFile {
 432         GObject parent_instance;
 433         ModelClipFilePrivate * priv;
 434         char* filename;
 435         GstCaps* video_caps;
 436         GstCaps* audio_caps;
 437         GdkPixbuf* thumbnail;
 438 };
 439
 440 struct _ModelClipFileClass {
 441         GObjectClass parent_class;
 442 };
 443
 444 struct _ViewMediaVideoTrack {
 445         ViewMediaTrack parent_instance;
 446         ViewMediaVideoTrackPrivate * priv;
 447 };
 448
 449 struct _ViewMediaVideoTrackClass {
 450         ViewMediaTrackClass parent_class;
 451 };
 452
 453 struct _ViewMediaVideoTrackPrivate {
 454         GstElement* converter;
 455 };
 456
 457 struct _ViewClickTrack {
 458         GObject parent_instance;
 459         ViewClickTrackPrivate * priv;
 460 };
 461
 462 struct _ViewClickTrackClass {
 463         GObjectClass parent_class;
 464 };
 465
 466 struct _ViewClickTrackPrivate {
 467         GstController* click_controller;
 468         GstController* volume_controller;
 469         GstElement* audio_source;
 470         GstElement* audio_convert;
 471         GstElement* volume;
 472         ModelProject* project;
 473 };
 474
 475 struct _Fraction {
 476         gint numerator;
 477         gint denominator;
 478 };
 479
 480 struct _ModelTempoInformationIface {
 481         GTypeInterface parent_iface;
 482         void (*get_time_signature) (ModelTempoInformation* self, Fraction* result);
 483         gint (*get_bpm) (ModelTempoInformation* self);
 484 };
 485
 486 struct _TimeCode {
 487         gint hour;
 488         gint minute;
 489         gint second;
 490         gint frame;
 491         gboolean drop_code;
 492 };
 493
 494 struct _ModelProject {
 495         GObject parent_instance;
 496         ModelProjectPrivate * priv;
 497         GeeArrayList* tracks;
 498         GeeArrayList* inactive_tracks;
 499         GeeArrayList* clipfiles;
 500         ViewMediaEngine* media_engine;
 501         char* project_file;
 502         ModelProjectLoader* loader;
 503         ModelUndoManager* undo_manager;
 504         ModelLibraryImporter* importer;
 505         Fraction default_framerate;
 506         gboolean click_during_play;
 507         gboolean click_during_record;
 508         double click_volume;
 509         gboolean library_visible;
 510         gint library_width;
 511         gboolean snap_to_clip;
 512 };
 513
 514 struct _ModelProjectClass {
 515         GObjectClass parent_class;
 516         void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result);
 517         char* (*get_project_file) (ModelProject* self);
 518         void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 519         void (*add_track) (ModelProject* self, ModelTrack* track);
 520         void (*insert_track) (ModelProject* self, gint index, ModelTrack* track);
 521         void (*load) (ModelProject* self, const char* fname);
 522         void (*save) (ModelProject* self, const char* filename);
 523         char* (*get_app_name) (ModelProject* self);
 524         void (*load_complete) (ModelProject* self);
 525 };
 526
 527 struct _ViewMediaAudioTrack {
 528         ViewMediaTrack parent_instance;
 529         ViewMediaAudioTrackPrivate * priv;
 530 };
 531
 532 struct _ViewMediaAudioTrackClass {
 533         ViewMediaTrackClass parent_class;
 534 };
 535
 536 struct _ViewMediaAudioTrackPrivate {
 537         GstElement* audio_convert;
 538         GstElement* audio_resample;
 539         GstElement* level;
 540         GstElement* pan;
 541         GstElement* volume;
 542         GstPad* adder_pad;
 543 };
 544
 545 typedef enum  {
 546         MODEL_PARAMETER_PAN,
 547         MODEL_PARAMETER_VOLUME
 548 } ModelParameter;
 549
 550 struct _ViewMediaConnector {
 551         GObject parent_instance;
 552         ViewMediaConnectorPrivate * priv;
 553         gint AudioIndex;
 554         gint VideoIndex;
 555 };
 556
 557 struct _ViewMediaConnectorClass {
 558         GObjectClass parent_class;
 559         void (*connect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 560         void (*do_disconnect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 561 };
 562
 563 typedef enum  {
 564         VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio = 1,
 565         VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video = 2
 566 } ViewMediaConnectorMediaTypes;
 567
 568 struct _ViewMediaConnectorPrivate {
 569         ViewMediaConnectorMediaTypes media_types;
 570 };
 571
 572 struct _ViewVideoOutput {
 573         ViewMediaConnector parent_instance;
 574         ViewVideoOutputPrivate * priv;
 575 };
 576
 577 struct _ViewVideoOutputClass {
 578         ViewMediaConnectorClass parent_class;
 579 };
 580
 581 struct _ViewVideoOutputPrivate {
 582         GstElement* sink;
 583         GtkWidget* output_widget;
 584 };
 585
 586 struct _ViewAudioOutput {
 587         ViewMediaConnector parent_instance;
 588         ViewAudioOutputPrivate * priv;
 589 };
 590
 591 struct _ViewAudioOutputClass {
 592         ViewMediaConnectorClass parent_class;
 593 };
 594
 595 struct _ViewAudioOutputPrivate {
 596         GstElement* audio_sink;
 597         GstElement* capsfilter;
 598 };
 599
 600 struct _ViewOggVorbisExport {
 601         ViewMediaConnector parent_instance;
 602         ViewOggVorbisExportPrivate * priv;
 603 };
 604
 605 struct _ViewOggVorbisExportClass {
 606         ViewMediaConnectorClass parent_class;
 607 };
 608
 609 struct _ViewOggVorbisExportPrivate {
 610         GstElement* capsfilter;
 611         GstElement* export_sink;
 612         GstElement* mux;
 613         GstElement* file_sink;
 614         GstElement* video_export_sink;
 615 };
 616
 617 struct _ViewMediaEnginePrivate {
 618         guint callback_id;
 619         GstElement* audio_in;
 620         GstElement* record_capsfilter;
 621         GstElement* wav_encoder;
 622         GstElement* record_sink;
 623         ModelProject* project;
 624         GeeArrayList* tracks;
 625 };
 626
 627 typedef enum  {
 628         MEDIA_ERROR_MISSING_PLUGIN
 629 } MediaError;
 630 #define MEDIA_ERROR media_error_quark ()
 631 struct _ModelTrack {
 632         GObject parent_instance;
 633         ModelTrackPrivate * priv;
 634         ModelProject* project;
 635         GeeArrayList* clips;
 636         char* display_name;
 637 };
 638
 639 struct _ModelTrackClass {
 640         GObjectClass parent_class;
 641         char* (*name) (ModelTrack* self);
 642         ModelMediaType (*media_type) (ModelTrack* self);
 643         gboolean (*check) (ModelTrack* self, ModelClip* clip);
 644         void (*on_clip_updated) (ModelTrack* self, ModelClip* clip);
 645         void (*write_attributes) (ModelTrack* self, FILE* f);
 646 };
 647
 648
 649 static gpointer view_media_clip_parent_class = NULL;
 650 static gpointer view_media_audio_clip_parent_class = NULL;
 651 static gpointer view_media_video_clip_parent_class = NULL;
 652 static gpointer view_media_track_parent_class = NULL;
 653 static gpointer view_media_video_track_parent_class = NULL;
 654 static gpointer view_click_track_parent_class = NULL;
 655 static gpointer view_media_audio_track_parent_class = NULL;
 656 static gpointer view_media_connector_parent_class = NULL;
 657 static gpointer view_video_output_parent_class = NULL;
 658 static gpointer view_audio_output_parent_class = NULL;
 659 static gpointer view_ogg_vorbis_export_parent_class = NULL;
 660 static gpointer view_media_engine_parent_class = NULL;
 661 static MultiFileProgressInterfaceIface* view_media_engine_multi_file_progress_interface_parent_iface = NULL;
 662
 663 GType play_state_get_type (void);
 664 #define CHANNELS_PER_TRACK_PLAYBACK 2
 665 #define CHANNELS_PER_TRACK_RECORD 1
 666 GType view_media_clip_get_type (void);
 667 GType model_clip_get_type (void);
 668 #define VIEW_MEDIA_CLIP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipPrivate))
 669 enum  {
 670         VIEW_MEDIA_CLIP_DUMMY_PROPERTY
 671 };
 672 GstElement* make_element (const char* name, GError** error);
 673 GType model_clip_file_get_type (void);
 674 GType model_media_type_get_type (void);
 675 static void view_media_clip_on_duration_changed (ViewMediaClip* self, gint64 duration);
 676 static void _view_media_clip_on_duration_changed_model_clip_duration_changed (ModelClip* _sender, gint64 duration, gpointer self);
 677 static void view_media_clip_on_media_start_changed (ViewMediaClip* self, gint64 media_start);
 678 static void _view_media_clip_on_media_start_changed_model_clip_media_start_changed (ModelClip* _sender, gint64 media_start, gpointer self);
 679 static void view_media_clip_on_start_changed (ViewMediaClip* self, gint64 start);
 680 static void _view_media_clip_on_start_changed_model_clip_start_changed (ModelClip* _sender, gint64 start, gpointer self);
 681 gint64 model_clip_get_start (ModelClip* self);
 682 gint64 model_clip_get_media_start (ModelClip* self);
 683 gint64 model_clip_get_duration (ModelClip* self);
 684 void view_media_clip_on_clip_removed (ViewMediaClip* self);
 685 static void _view_media_clip_on_clip_removed_model_clip_removed (ModelClip* _sender, ModelClip* clip, gpointer self);
 686 ViewMediaClip* view_media_clip_new (GstBin* composition, ModelClip* clip, GError** error);
 687 ViewMediaClip* view_media_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, GError** error);
 688 GType logging_facility_get_type (void);
 689 GType logging_level_get_type (void);
 690 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 691 SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error);
 692 SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error);
 693 GType single_decode_bin_get_type (void);
 694 void model_clip_file_set_online (ModelClipFile* self, gboolean o);
 695 void view_media_clip_add_single_decode_bin (ViewMediaClip* self, const char* filename, const char* caps, GError** error);
 696 gboolean view_media_clip_is_equal (ViewMediaClip* self, ModelClip* clip);
 697 static void view_media_clip_finalize (GObject* obj);
 698 GType view_media_audio_clip_get_type (void);
 699 enum  {
 700         VIEW_MEDIA_AUDIO_CLIP_DUMMY_PROPERTY
 701 };
 702 ViewMediaAudioClip* view_media_audio_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error);
 703 ViewMediaAudioClip* view_media_audio_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error);
 704 GType view_media_video_clip_get_type (void);
 705 enum  {
 706         VIEW_MEDIA_VIDEO_CLIP_DUMMY_PROPERTY
 707 };
 708 ViewMediaVideoClip* view_media_video_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error);
 709 ViewMediaVideoClip* view_media_video_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error);
 710 GType view_media_track_get_type (void);
 711 GType view_media_engine_get_type (void);
 712 #define VIEW_MEDIA_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackPrivate))
 713 enum  {
 714         VIEW_MEDIA_TRACK_DUMMY_PROPERTY
 715 };
 716 static void view_media_track_on_clip_added (ViewMediaTrack* self, ModelClip* clip);
 717 GType model_track_get_type (void);
 718 static void _view_media_track_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self);
 719 static void view_media_track_on_track_removed (ViewMediaTrack* self, ModelTrack* track);
 720 static void _view_media_track_on_track_removed_model_track_track_removed (ModelTrack* _sender, ModelTrack* track, gpointer self);
 721 static void view_media_track_on_pre_export (ViewMediaTrack* self, gint64 length);
 722 static void _view_media_track_on_pre_export_view_media_engine_pre_export (ViewMediaEngine* _sender, gint64 length, gpointer self);
 723 static void view_media_track_on_post_export (ViewMediaTrack* self, gboolean deleted);
 724 static void _view_media_track_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self);
 725 GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error);
 726 GstElement* view_media_track_empty_element (ViewMediaTrack* self, GError** error);
 727 GType multi_file_progress_interface_get_type (void);
 728 GType model_audio_track_get_type (void);
 729 static void view_media_track_on_pad_added (ViewMediaTrack* self, GstPad* pad);
 730 static void _view_media_track_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
 731 static void view_media_track_on_pad_removed (ViewMediaTrack* self, GstPad* pad);
 732 static void _view_media_track_on_pad_removed_gst_element_pad_removed (GstElement* _sender, GstPad* pad, gpointer self);
 733 ViewMediaTrack* view_media_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GError** error);
 734 static GstElement* view_media_track_real_empty_element (ViewMediaTrack* self, GError** error);
 735 GstElement* view_media_track_get_element (ViewMediaTrack* self);
 736 static GstElement* view_media_track_real_get_element (ViewMediaTrack* self);
 737 void view_media_track_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 738 static void view_media_track_real_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 739 void view_media_track_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 740 static void view_media_track_real_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element);
 741 static void view_media_track_on_clip_updated (ViewMediaTrack* self, ModelClip* clip);
 742 static void _view_media_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self);
 743 gboolean model_clip_file_is_online (ModelClipFile* self);
 744 static void view_media_track_on_media_clip_removed (ViewMediaTrack* self, ViewMediaClip* clip);
 745 static void _view_media_track_on_media_clip_removed_view_media_clip_clip_removed (ViewMediaClip* _sender, ViewMediaClip* clip, gpointer self);
 746 static void view_media_track_finalize (GObject* obj);
 747 GType view_media_video_track_get_type (void);
 748 #define VIEW_MEDIA_VIDEO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackPrivate))
 749 enum  {
 750         VIEW_MEDIA_VIDEO_TRACK_DUMMY_PROPERTY
 751 };
 752 ViewMediaVideoTrack* view_media_video_track_new (ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error);
 753 ViewMediaVideoTrack* view_media_video_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error);
 754 static GstElement* view_media_video_track_real_get_element (ViewMediaTrack* base);
 755 static GstElement* view_media_video_track_real_empty_element (ViewMediaTrack* base, GError** error);
 756 static void view_media_video_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element);
 757 static void view_media_video_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element);
 758 static void view_media_video_track_finalize (GObject* obj);
 759 GType view_click_track_get_type (void);
 760 GType model_project_get_type (void);
 761 #define VIEW_CLICK_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_CLICK_TRACK, ViewClickTrackPrivate))
 762 enum  {
 763         VIEW_CLICK_TRACK_DUMMY_PROPERTY
 764 };
 765 GType fraction_get_type (void);
 766 Fraction* fraction_dup (const Fraction* self);
 767 void fraction_free (Fraction* self);
 768 GType model_tempo_information_get_type (void);
 769 GType time_code_get_type (void);
 770 TimeCode* time_code_dup (const TimeCode* self);
 771 void time_code_free (TimeCode* self);
 772 GType model_project_loader_get_type (void);
 773 gpointer model_undo_manager_ref (gpointer instance);
 774 void model_undo_manager_unref (gpointer instance);
 775 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 776 void model_value_set_undo_manager (GValue* value, gpointer v_object);
 777 void model_value_take_undo_manager (GValue* value, gpointer v_object);
 778 gpointer model_value_get_undo_manager (const GValue* value);
 779 GType model_undo_manager_get_type (void);
 780 GType model_library_importer_get_type (void);
 781 static void view_click_track_on_playstate_changed (ViewClickTrack* self);
 782 static void _view_click_track_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self);
 783 static void _g_list_free_g_free (GList* self);
 784 ViewClickTrack* view_click_track_new (ViewMediaEngine* engine, ModelProject* project, GError** error);
 785 ViewClickTrack* view_click_track_construct (GType object_type, ViewMediaEngine* engine, ModelProject* project, GError** error);
 786 static void view_click_track_clear_controllers (ViewClickTrack* self);
 787 PlayState view_media_engine_get_play_state (ViewMediaEngine* self);
 788 static void view_click_track_setup_clicks (ViewClickTrack* self, gint bpm, Fraction* time_signature);
 789 gint model_tempo_information_get_bpm (ModelTempoInformation* self);
 790 void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result);
 791 static void view_click_track_finalize (GObject* obj);
 792 GType view_media_audio_track_get_type (void);
 793 #define VIEW_MEDIA_AUDIO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackPrivate))
 794 enum  {
 795         VIEW_MEDIA_AUDIO_TRACK_DUMMY_PROPERTY
 796 };
 797 GType model_parameter_get_type (void);
 798 static void view_media_audio_track_on_parameter_changed (ViewMediaAudioTrack* self, ModelParameter parameter, double new_value);
 799 static void _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self);
 800 double model_audio_track_get_pan (ModelAudioTrack* self);
 801 double model_audio_track_get_volume (ModelAudioTrack* self);
 802 static void view_media_audio_track_on_level_changed (ViewMediaAudioTrack* self, GstObject* source, double level_left, double level_right);
 803 static void _view_media_audio_track_on_level_changed_view_media_engine_level_changed (ViewMediaEngine* _sender, GstObject* source, double level_left, double level_right, gpointer self);
 804 void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right);
 805 static void _model_audio_track_on_level_changed_view_media_audio_track_level_changed (ViewMediaAudioTrack* _sender, double level_left, double level_right, gpointer self);
 806 ViewMediaAudioTrack* view_media_audio_track_new (ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error);
 807 ViewMediaAudioTrack* view_media_audio_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error);
 808 GstElement* view_media_engine_get_audio_silence (ViewMediaEngine* self, GError** error);
 809 static GstElement* view_media_audio_track_real_empty_element (ViewMediaTrack* base, GError** error);
 810 static void view_media_audio_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element);
 811 static void view_media_audio_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element);
 812 static GstElement* view_media_audio_track_real_get_element (ViewMediaTrack* base);
 813 static void view_media_audio_track_finalize (GObject* obj);
 814 GType view_media_connector_get_type (void);
 815 GType view_media_connector_media_types_get_type (void);
 816 #define VIEW_MEDIA_CONNECTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorPrivate))
 817 enum  {
 818         VIEW_MEDIA_CONNECTOR_DUMMY_PROPERTY
 819 };
 820 ViewMediaConnector* view_media_connector_construct (GType object_type, ViewMediaConnectorMediaTypes media_types);
 821 gboolean view_media_connector_has_audio (ViewMediaConnector* self);
 822 gboolean view_media_connector_has_video (ViewMediaConnector* self);
 823 void view_media_connector_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 824 static void view_media_connector_real_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 825 void view_media_connector_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 826 static void view_media_connector_real_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 827 static void view_media_connector_finalize (GObject* obj);
 828 GType view_video_output_get_type (void);
 829 #define VIEW_VIDEO_OUTPUT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputPrivate))
 830 enum  {
 831         VIEW_VIDEO_OUTPUT_DUMMY_PROPERTY
 832 };
 833 ViewVideoOutput* view_video_output_new (GtkWidget* output_widget, GError** error);
 834 ViewVideoOutput* view_video_output_construct (GType object_type, GtkWidget* output_widget, GError** error);
 835 static void view_video_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 836 static void view_video_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 837 static void view_video_output_finalize (GObject* obj);
 838 GType view_audio_output_get_type (void);
 839 #define VIEW_AUDIO_OUTPUT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputPrivate))
 840 enum  {
 841         VIEW_AUDIO_OUTPUT_DUMMY_PROPERTY
 842 };
 843 ViewAudioOutput* view_audio_output_new (GstCaps* caps, GError** error);
 844 ViewAudioOutput* view_audio_output_construct (GType object_type, GstCaps* caps, GError** error);
 845 static void view_audio_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 846 static void view_audio_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 847 static void view_audio_output_finalize (GObject* obj);
 848 GType view_ogg_vorbis_export_get_type (void);
 849 #define VIEW_OGG_VORBIS_EXPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportPrivate))
 850 enum  {
 851         VIEW_OGG_VORBIS_EXPORT_DUMMY_PROPERTY
 852 };
 853 ViewOggVorbisExport* view_ogg_vorbis_export_new (ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error);
 854 ViewOggVorbisExport* view_ogg_vorbis_export_construct (GType object_type, ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error);
 855 char* view_ogg_vorbis_export_get_filename (ViewOggVorbisExport* self);
 856 static void view_ogg_vorbis_export_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 857 static void view_ogg_vorbis_export_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1);
 858 static void view_ogg_vorbis_export_finalize (GObject* obj);
 859 #define VIEW_MEDIA_ENGINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEnginePrivate))
 860 enum  {
 861         VIEW_MEDIA_ENGINE_DUMMY_PROPERTY
 862 };
 863 #define VIEW_MEDIA_ENGINE_MIN_GNONLIN "0.10.11"
 864 #define VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_GOOD "0.10.15"
 865 #define VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_BASE "0.10.15"
 866 void model_project_on_playstate_changed (ModelProject* self);
 867 static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self);
 868 static void view_media_engine_on_error (ViewMediaEngine* self, GstBus* bus, GstMessage* message);
 869 static void _view_media_engine_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 870 static void view_media_engine_on_warning (ViewMediaEngine* self, GstBus* bus, GstMessage* message);
 871 static void _view_media_engine_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 872 static void view_media_engine_on_eos (ViewMediaEngine* self, GstBus* bus, GstMessage* message);
 873 static void _view_media_engine_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 874 static void view_media_engine_on_state_change (ViewMediaEngine* self, GstBus* bus, GstMessage* message);
 875 static void _view_media_engine_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 876 static void view_media_engine_on_element (ViewMediaEngine* self, GstBus* bus, GstMessage* message);
 877 static void _view_media_engine_on_element_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 878 ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error);
 879 ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error);
 880 static void view_media_engine_check_version (GstRegistry* registry, const char* plugin_name, const char* package_name, const char* min_version, GError** error);
 881 void view_media_engine_can_run (GError** error);
 882 GQuark media_error_quark (void);
 883 gboolean version_at_least (const char* v, const char* w);
 884 void view_media_engine_connect_output (ViewMediaEngine* self, ViewMediaConnector* connector);
 885 void view_media_engine_disconnect_output (ViewMediaEngine* self, ViewMediaConnector* connector);
 886 GstCaps* view_media_engine_get_project_audio_caps (ViewMediaEngine* self);
 887 gint view_media_engine_get_sample_rate (ViewMediaEngine* self);
 888 gint view_media_engine_get_sample_width (ViewMediaEngine* self);
 889 gint view_media_engine_get_sample_depth (ViewMediaEngine* self);
 890 void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state);
 891 GstCaps* view_media_engine_build_audio_caps (ViewMediaEngine* self, gint num_channels);
 892 GstCaps* view_media_engine_get_project_audio_export_caps (ViewMediaEngine* self);
 893 void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name);
 894 static GValue* _gst_value_dup (GValue* self);
 895 gboolean view_media_engine_do_state_change (ViewMediaEngine* self);
 896 void view_media_engine_go (ViewMediaEngine* self, gint64 pos);
 897 static void view_media_engine_do_paused_state_export (ViewMediaEngine* self);
 898 static void view_media_engine_end_export (ViewMediaEngine* self, gboolean deleted);
 899 void view_media_engine_close (ViewMediaEngine* self);
 900 void view_media_engine_start_record (ViewMediaEngine* self, ModelClip* region, GError** error);
 901 void view_media_engine_do_play (ViewMediaEngine* self, PlayState new_state);
 902 void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state);
 903 void view_media_engine_post_record (ViewMediaEngine* self);
 904 void view_media_engine_do_null_state_export (ViewMediaEngine* self, gint64 length);
 905 static void view_media_engine_real_do_null_state_export (ViewMediaEngine* self, gint64 length);
 906 static gboolean view_media_engine_on_callback (ViewMediaEngine* self);
 907 static gboolean _view_media_engine_on_callback_gsource_func (gpointer self);
 908 gint64 model_project_get_length (ModelProject* self);
 909 void view_media_engine_pause (ViewMediaEngine* self);
 910 gboolean model_project_transport_is_recording (ModelProject* self);
 911 static void view_media_engine_real_pause (ViewMediaEngine* self);
 912 static void view_media_engine_seek (ViewMediaEngine* self, GstSeekFlags flags, gint64 pos);
 913 static void view_media_engine_play (ViewMediaEngine* self);
 914 void view_media_engine_start_export (ViewMediaEngine* self, const char* filename);
 915 static void view_media_engine_real_cancel (MultiFileProgressInterface* base);
 916 static void view_media_engine_real_complete (MultiFileProgressInterface* base);
 917 void view_media_engine_on_load_complete (ViewMediaEngine* self);
 918 void model_clip_set_duration (ModelClip* self, gint64 value);
 919 void view_media_engine_on_callback_pulse (ViewMediaEngine* self);
 920 void _model_track_delete_clip (ModelTrack* self, ModelClip* clip);
 921 static char* view_media_engine_new_audio_filename (ViewMediaEngine* self, ModelTrack* track);
 922 ModelClipFile* model_clip_file_new (const char* filename, gint64 length);
 923 ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length);
 924 ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 925 ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 926 void view_media_engine_record (ViewMediaEngine* self, ModelAudioTrack* track);
 927 gboolean model_project_transport_is_playing (ModelProject* self);
 928 void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos);
 929 GstCaps* view_media_engine_get_record_audio_caps (ViewMediaEngine* self);
 930 char* model_project_get_audio_path (ModelProject* self);
 931 static char* view_media_engine_generate_base (ViewMediaEngine* self, const char* name);
 932 ModelMediaType model_track_media_type (ModelTrack* self);
 933 static ViewMediaTrack* view_media_engine_create_audio_track (ViewMediaEngine* self, ModelTrack* track, GError** error);
 934 static void view_media_engine_on_track_removed (ViewMediaEngine* self, ViewMediaTrack* track);
 935 static void _view_media_engine_on_track_removed_view_media_track_track_removed (ViewMediaTrack* _sender, ViewMediaTrack* track, gpointer self);
 936 static void view_media_engine_on_error_occurred (ViewMediaEngine* self, const char* major_message, const char* minor_message);
 937 static void _view_media_engine_on_error_occurred_view_media_track_error_occurred (ViewMediaTrack* _sender, const char* major_message, const char* minor_message, gpointer self);
 938 void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track);
 939 static void view_media_engine_finalize (GObject* obj);
 940 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 941 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 942 static int _vala_strcmp0 (const char * str1, const char * str2);
 943
 944
 945 static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 946 static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 947 static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 948 static void g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 949
 950 GType play_state_get_type (void) {
 951         static volatile gsize play_state_type_id__volatile = 0;
 952         if (g_once_init_enter (&play_state_type_id__volatile)) {
 953                 static const GEnumValue values[] = {{PLAY_STATE_STOPPED, "PLAY_STATE_STOPPED", "stopped"}, {PLAY_STATE_PRE_PLAY, "PLAY_STATE_PRE_PLAY", "pre-play"}, {PLAY_STATE_PLAYING, "PLAY_STATE_PLAYING", "playing"}, {PLAY_STATE_PRE_RECORD_NULL, "PLAY_STATE_PRE_RECORD_NULL", "pre-record-null"}, {PLAY_STATE_PRE_RECORD, "PLAY_STATE_PRE_RECORD", "pre-record"}, {PLAY_STATE_RECORDING, "PLAY_STATE_RECORDING", "recording"}, {PLAY_STATE_POST_RECORD, "PLAY_STATE_POST_RECORD", "post-record"}, {PLAY_STATE_PRE_EXPORT, "PLAY_STATE_PRE_EXPORT", "pre-export"}, {PLAY_STATE_EXPORTING, "PLAY_STATE_EXPORTING", "exporting"}, {PLAY_STATE_CANCEL_EXPORT, "PLAY_STATE_CANCEL_EXPORT", "cancel-export"}, {PLAY_STATE_LOADING, "PLAY_STATE_LOADING", "loading"}, {PLAY_STATE_CLOSING, "PLAY_STATE_CLOSING", "closing"}, {PLAY_STATE_CLOSED, "PLAY_STATE_CLOSED", "closed"}, {0, NULL, NULL}};
 954                 GType play_state_type_id;
 955                 play_state_type_id = g_enum_register_static ("PlayState", values);
 956                 g_once_init_leave (&play_state_type_id__volatile, play_state_type_id);
 957         }
 958         return play_state_type_id__volatile;
 959 }
 960
 961
 962 static gpointer _gst_object_ref0 (gpointer self) {
 963         return self ? gst_object_ref (self) : NULL;
 964 }
 965
 966
 967 #line 69 "MediaEngine.vala"
 968 static void _view_media_clip_on_duration_changed_model_clip_duration_changed (ModelClip* _sender, gint64 duration, gpointer self) {
 969 #line 970 "MediaEngine.c"
 970         view_media_clip_on_duration_changed (self, duration);
 971 }
 972
 973
 974 #line 64 "MediaEngine.vala"
 975 static void _view_media_clip_on_media_start_changed_model_clip_media_start_changed (ModelClip* _sender, gint64 media_start, gpointer self) {
 976 #line 977 "MediaEngine.c"
 977         view_media_clip_on_media_start_changed (self, media_start);
 978 }
 979
 980
 981 #line 76 "MediaEngine.vala"
 982 static void _view_media_clip_on_start_changed_model_clip_start_changed (ModelClip* _sender, gint64 start, gpointer self) {
 983 #line 984 "MediaEngine.c"
 984         view_media_clip_on_start_changed (self, start);
 985 }
 986
 987
 988 #line 58 "MediaEngine.vala"
 989 static void _view_media_clip_on_clip_removed_model_clip_removed (ModelClip* _sender, ModelClip* clip, gpointer self) {
 990 #line 991 "MediaEngine.c"
 991         view_media_clip_on_clip_removed (self);
 992 }
 993
 994
 995 #line 30 "MediaEngine.vala"
 996 ViewMediaClip* view_media_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, GError** error) {
 997 #line 998 "MediaEngine.c"
 998         GError * _inner_error_;
 999         ViewMediaClip * self;
1000         GstBin* _tmp0_;
1001         GstElement* _tmp1_;
1002         GstElement* _tmp2_;
1003 #line 30 "MediaEngine.vala"
1004         g_return_val_if_fail (GST_IS_BIN (composition), NULL);
1005 #line 30 "MediaEngine.vala"
1006         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1007 #line 1008 "MediaEngine.c"
1008         _inner_error_ = NULL;
1009 #line 30 "MediaEngine.vala"
1010         self = (ViewMediaClip*) g_object_new (object_type, NULL);
1011 #line 31 "MediaEngine.vala"
1012         self->priv->clip = clip;
1013 #line 32 "MediaEngine.vala"
1014         self->priv->composition = (_tmp0_ = _gst_object_ref0 (composition), _gst_object_unref0 (self->priv->composition), _tmp0_);
1015 #line 33 "MediaEngine.vala"
1016         _tmp1_ = make_element ("gnlsource", &_inner_error_);
1017 #line 1018 "MediaEngine.c"
1018         if (_inner_error_ != NULL) {
1019                 g_propagate_error (error, _inner_error_);
1020                 g_object_unref (self);
1021                 return NULL;
1022         }
1023 #line 33 "MediaEngine.vala"
1024         self->file_source = (_tmp2_ = _tmp1_, _gst_object_unref0 (self->file_source), _tmp2_);
1025 #line 34 "MediaEngine.vala"
1026         if (!clip->is_recording) {
1027 #line 35 "MediaEngine.vala"
1028                 g_signal_connect_object (clip, "duration-changed", (GCallback) _view_media_clip_on_duration_changed_model_clip_duration_changed, self, 0);
1029 #line 36 "MediaEngine.vala"
1030                 g_signal_connect_object (clip, "media-start-changed", (GCallback) _view_media_clip_on_media_start_changed_model_clip_media_start_changed, self, 0);
1031 #line 37 "MediaEngine.vala"
1032                 g_signal_connect_object (clip, "start-changed", (GCallback) _view_media_clip_on_start_changed_model_clip_start_changed, self, 0);
1033 #line 39 "MediaEngine.vala"
1034                 gst_bin_add (composition, _gst_object_ref0 (self->file_source));
1035 #line 41 "MediaEngine.vala"
1036                 view_media_clip_on_start_changed (self, model_clip_get_start (clip));
1037 #line 42 "MediaEngine.vala"
1038                 view_media_clip_on_media_start_changed (self, model_clip_get_media_start (clip));
1039 #line 43 "MediaEngine.vala"
1040                 view_media_clip_on_duration_changed (self, model_clip_get_duration (clip));
1041 #line 1042 "MediaEngine.c"
1042         }
1043 #line 45 "MediaEngine.vala"
1044         g_signal_connect_object (clip, "removed", (GCallback) _view_media_clip_on_clip_removed_model_clip_removed, self, 0);
1045 #line 1046 "MediaEngine.c"
1046         return self;
1047 }
1048
1049
1050 #line 30 "MediaEngine.vala"
1051 ViewMediaClip* view_media_clip_new (GstBin* composition, ModelClip* clip, GError** error) {
1052 #line 30 "MediaEngine.vala"
1053         return view_media_clip_construct (VIEW_TYPE_MEDIA_CLIP, composition, clip, error);
1054 #line 1055 "MediaEngine.c"
1055 }
1056
1057
1058 #line 58 "MediaEngine.vala"
1059 void view_media_clip_on_clip_removed (ViewMediaClip* self) {
1060 #line 58 "MediaEngine.vala"
1061         g_return_if_fail (VIEW_IS_MEDIA_CLIP (self));
1062 #line 59 "MediaEngine.vala"
1063         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed");
1064 #line 60 "MediaEngine.vala"
1065         gst_bin_remove (self->priv->composition, GST_ELEMENT (GST_BIN (self->file_source)));
1066 #line 61 "MediaEngine.vala"
1067         g_signal_emit_by_name (self, "clip-removed", self);
1068 #line 1069 "MediaEngine.c"
1069 }
1070
1071
1072 #line 64 "MediaEngine.vala"
1073 static void view_media_clip_on_media_start_changed (ViewMediaClip* self, gint64 media_start) {
1074 #line 64 "MediaEngine.vala"
1075         g_return_if_fail (VIEW_IS_MEDIA_CLIP (self));
1076 #line 65 "MediaEngine.vala"
1077         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_media_start_changed");
1078 #line 66 "MediaEngine.vala"
1079         g_object_set (G_OBJECT (self->file_source), "media-start", media_start, NULL);
1080 #line 1081 "MediaEngine.c"
1081 }
1082
1083
1084 #line 69 "MediaEngine.vala"
1085 static void view_media_clip_on_duration_changed (ViewMediaClip* self, gint64 duration) {
1086 #line 69 "MediaEngine.vala"
1087         g_return_if_fail (VIEW_IS_MEDIA_CLIP (self));
1088 #line 70 "MediaEngine.vala"
1089         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_duration_changed");
1090 #line 71 "MediaEngine.vala"
1091         g_object_set (G_OBJECT (self->file_source), "duration", duration, NULL);
1092 #line 73 "MediaEngine.vala"
1093         g_object_set (G_OBJECT (self->file_source), "media-duration", duration, NULL);
1094 #line 1095 "MediaEngine.c"
1095 }
1096
1097
1098 #line 76 "MediaEngine.vala"
1099 static void view_media_clip_on_start_changed (ViewMediaClip* self, gint64 start) {
1100 #line 76 "MediaEngine.vala"
1101         g_return_if_fail (VIEW_IS_MEDIA_CLIP (self));
1102 #line 77 "MediaEngine.vala"
1103         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_start_changed");
1104 #line 78 "MediaEngine.vala"
1105         g_object_set (G_OBJECT (self->file_source), "start", start, NULL);
1106 #line 1107 "MediaEngine.c"
1107 }
1108
1109
1110 #line 81 "MediaEngine.vala"
1111 void view_media_clip_add_single_decode_bin (ViewMediaClip* self, const char* filename, const char* caps, GError** error) {
1112 #line 1113 "MediaEngine.c"
1113         GError * _inner_error_;
1114         GstCaps* _tmp0_;
1115         GstElement* _tmp1_;
1116         GstElement* sbin;
1117 #line 81 "MediaEngine.vala"
1118         g_return_if_fail (VIEW_IS_MEDIA_CLIP (self));
1119 #line 81 "MediaEngine.vala"
1120         g_return_if_fail (filename != NULL);
1121 #line 81 "MediaEngine.vala"
1122         g_return_if_fail (caps != NULL);
1123 #line 1124 "MediaEngine.c"
1124         _inner_error_ = NULL;
1125 #line 82 "MediaEngine.vala"
1126         sbin = (_tmp1_ = GST_ELEMENT (single_decode_bin_new (_tmp0_ = gst_caps_from_string (caps), "singledecoder", filename, &_inner_error_)), _gst_caps_unref0 (_tmp0_), _tmp1_);
1127 #line 1128 "MediaEngine.c"
1128         if (_inner_error_ != NULL) {
1129                 g_propagate_error (error, _inner_error_);
1130                 return;
1131         }
1132 #line 84 "MediaEngine.vala"
1133         if (gst_bin_add (GST_BIN (self->file_source), _gst_object_ref0 (sbin))) {
1134 #line 85 "MediaEngine.vala"
1135                 if (!gst_element_sync_state_with_parent (self->file_source)) {
1136 #line 86 "MediaEngine.vala"
1137                         model_clip_file_set_online (self->priv->clip->clipfile, FALSE);
1138 #line 1139 "MediaEngine.c"
1139                 }
1140         }
1141         _gst_object_unref0 (sbin);
1142 }
1143
1144
1145 #line 91 "MediaEngine.vala"
1146 gboolean view_media_clip_is_equal (ViewMediaClip* self, ModelClip* clip) {
1147 #line 1148 "MediaEngine.c"
1148         gboolean result = FALSE;
1149 #line 91 "MediaEngine.vala"
1150         g_return_val_if_fail (VIEW_IS_MEDIA_CLIP (self), FALSE);
1151 #line 91 "MediaEngine.vala"
1152         g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE);
1153 #line 1154 "MediaEngine.c"
1154         result = clip == self->priv->clip;
1155 #line 92 "MediaEngine.vala"
1156         return result;
1157 #line 1158 "MediaEngine.c"
1158 }
1159
1160
1161 static void view_media_clip_class_init (ViewMediaClipClass * klass) {
1162         view_media_clip_parent_class = g_type_class_peek_parent (klass);
1163         g_type_class_add_private (klass, sizeof (ViewMediaClipPrivate));
1164         G_OBJECT_CLASS (klass)->finalize = view_media_clip_finalize;
1165         g_signal_new ("clip_removed", VIEW_TYPE_MEDIA_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, VIEW_TYPE_MEDIA_CLIP);
1166 }
1167
1168
1169 static void view_media_clip_instance_init (ViewMediaClip * self) {
1170         self->priv = VIEW_MEDIA_CLIP_GET_PRIVATE (self);
1171 }
1172
1173
1174 static void view_media_clip_finalize (GObject* obj) {
1175         ViewMediaClip * self;
1176         self = VIEW_MEDIA_CLIP (obj);
1177         {
1178                 guint _tmp0_;
1179 #line 49 "MediaEngine.vala"
1180                 g_signal_parse_name ("removed", MODEL_TYPE_CLIP, &_tmp0_, NULL, FALSE);
1181 #line 49 "MediaEngine.vala"
1182                 g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _view_media_clip_on_clip_removed_model_clip_removed, self);
1183 #line 50 "MediaEngine.vala"
1184                 if (!self->priv->clip->is_recording) {
1185 #line 1186 "MediaEngine.c"
1186                         guint _tmp1_;
1187                         guint _tmp2_;
1188                         guint _tmp3_;
1189 #line 51 "MediaEngine.vala"
1190                         g_signal_parse_name ("duration-changed", MODEL_TYPE_CLIP, &_tmp1_, NULL, FALSE);
1191 #line 51 "MediaEngine.vala"
1192                         g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _view_media_clip_on_duration_changed_model_clip_duration_changed, self);
1193 #line 52 "MediaEngine.vala"
1194                         g_signal_parse_name ("media-start-changed", MODEL_TYPE_CLIP, &_tmp2_, NULL, FALSE);
1195 #line 52 "MediaEngine.vala"
1196                         g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _view_media_clip_on_media_start_changed_model_clip_media_start_changed, self);
1197 #line 53 "MediaEngine.vala"
1198                         g_signal_parse_name ("start-changed", MODEL_TYPE_CLIP, &_tmp3_, NULL, FALSE);
1199 #line 53 "MediaEngine.vala"
1200                         g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) _view_media_clip_on_start_changed_model_clip_start_changed, self);
1201 #line 1202 "MediaEngine.c"
1202                 }
1203 #line 55 "MediaEngine.vala"
1204                 gst_element_set_state (self->file_source, GST_STATE_NULL);
1205 #line 1206 "MediaEngine.c"
1206         }
1207         _gst_object_unref0 (self->file_source);
1208         _gst_object_unref0 (self->priv->composition);
1209         G_OBJECT_CLASS (view_media_clip_parent_class)->finalize (obj);
1210 }
1211
1212
1213 GType view_media_clip_get_type (void) {
1214         static volatile gsize view_media_clip_type_id__volatile = 0;
1215         if (g_once_init_enter (&view_media_clip_type_id__volatile)) {
1216                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaClip), 0, (GInstanceInitFunc) view_media_clip_instance_init, NULL };
1217                 GType view_media_clip_type_id;
1218                 view_media_clip_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaClip", &g_define_type_info, 0);
1219                 g_once_init_leave (&view_media_clip_type_id__volatile, view_media_clip_type_id);
1220         }
1221         return view_media_clip_type_id__volatile;
1222 }
1223
1224
1225 #line 97 "MediaEngine.vala"
1226 ViewMediaAudioClip* view_media_audio_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error) {
1227 #line 1228 "MediaEngine.c"
1228         GError * _inner_error_;
1229         ViewMediaAudioClip * self;
1230 #line 97 "MediaEngine.vala"
1231         g_return_val_if_fail (GST_IS_BIN (composition), NULL);
1232 #line 97 "MediaEngine.vala"
1233         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1234 #line 97 "MediaEngine.vala"
1235         g_return_val_if_fail (filename != NULL, NULL);
1236 #line 1237 "MediaEngine.c"
1237         _inner_error_ = NULL;
1238 #line 98 "MediaEngine.vala"
1239         self = (ViewMediaAudioClip*) view_media_clip_construct (object_type, composition, clip, error);
1240 #line 99 "MediaEngine.vala"
1241         if (!clip->is_recording) {
1242 #line 100 "MediaEngine.vala"
1243                 view_media_clip_add_single_decode_bin (VIEW_MEDIA_CLIP (self), filename, "audio/x-raw-float;audio/x-raw-int", &_inner_error_);
1244 #line 1245 "MediaEngine.c"
1245                 if (_inner_error_ != NULL) {
1246                         g_propagate_error (error, _inner_error_);
1247                         g_object_unref (self);
1248                         return NULL;
1249                 }
1250         }
1251         return self;
1252 }
1253
1254
1255 #line 97 "MediaEngine.vala"
1256 ViewMediaAudioClip* view_media_audio_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error) {
1257 #line 97 "MediaEngine.vala"
1258         return view_media_audio_clip_construct (VIEW_TYPE_MEDIA_AUDIO_CLIP, composition, clip, filename, error);
1259 #line 1260 "MediaEngine.c"
1260 }
1261
1262
1263 static void view_media_audio_clip_class_init (ViewMediaAudioClipClass * klass) {
1264         view_media_audio_clip_parent_class = g_type_class_peek_parent (klass);
1265 }
1266
1267
1268 static void view_media_audio_clip_instance_init (ViewMediaAudioClip * self) {
1269 }
1270
1271
1272 GType view_media_audio_clip_get_type (void) {
1273         static volatile gsize view_media_audio_clip_type_id__volatile = 0;
1274         if (g_once_init_enter (&view_media_audio_clip_type_id__volatile)) {
1275                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaAudioClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_audio_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaAudioClip), 0, (GInstanceInitFunc) view_media_audio_clip_instance_init, NULL };
1276                 GType view_media_audio_clip_type_id;
1277                 view_media_audio_clip_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CLIP, "ViewMediaAudioClip", &g_define_type_info, 0);
1278                 g_once_init_leave (&view_media_audio_clip_type_id__volatile, view_media_audio_clip_type_id);
1279         }
1280         return view_media_audio_clip_type_id__volatile;
1281 }
1282
1283
1284 #line 106 "MediaEngine.vala"
1285 ViewMediaVideoClip* view_media_video_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error) {
1286 #line 1287 "MediaEngine.c"
1287         GError * _inner_error_;
1288         ViewMediaVideoClip * self;
1289 #line 106 "MediaEngine.vala"
1290         g_return_val_if_fail (GST_IS_BIN (composition), NULL);
1291 #line 106 "MediaEngine.vala"
1292         g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL);
1293 #line 106 "MediaEngine.vala"
1294         g_return_val_if_fail (filename != NULL, NULL);
1295 #line 1296 "MediaEngine.c"
1296         _inner_error_ = NULL;
1297 #line 107 "MediaEngine.vala"
1298         self = (ViewMediaVideoClip*) view_media_clip_construct (object_type, composition, clip, error);
1299 #line 108 "MediaEngine.vala"
1300         view_media_clip_add_single_decode_bin (VIEW_MEDIA_CLIP (self), filename, "video/x-raw-yuv; video/x-raw-rgb", &_inner_error_);
1301 #line 1302 "MediaEngine.c"
1302         if (_inner_error_ != NULL) {
1303                 g_propagate_error (error, _inner_error_);
1304                 g_object_unref (self);
1305                 return NULL;
1306         }
1307         return self;
1308 }
1309
1310
1311 #line 106 "MediaEngine.vala"
1312 ViewMediaVideoClip* view_media_video_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error) {
1313 #line 106 "MediaEngine.vala"
1314         return view_media_video_clip_construct (VIEW_TYPE_MEDIA_VIDEO_CLIP, composition, clip, filename, error);
1315 #line 1316 "MediaEngine.c"
1316 }
1317
1318
1319 static void view_media_video_clip_class_init (ViewMediaVideoClipClass * klass) {
1320         view_media_video_clip_parent_class = g_type_class_peek_parent (klass);
1321 }
1322
1323
1324 static void view_media_video_clip_instance_init (ViewMediaVideoClip * self) {
1325 }
1326
1327
1328 GType view_media_video_clip_get_type (void) {
1329         static volatile gsize view_media_video_clip_type_id__volatile = 0;
1330         if (g_once_init_enter (&view_media_video_clip_type_id__volatile)) {
1331                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaVideoClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_video_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaVideoClip), 0, (GInstanceInitFunc) view_media_video_clip_instance_init, NULL };
1332                 GType view_media_video_clip_type_id;
1333                 view_media_video_clip_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CLIP, "ViewMediaVideoClip", &g_define_type_info, 0);
1334                 g_once_init_leave (&view_media_video_clip_type_id__volatile, view_media_video_clip_type_id);
1335         }
1336         return view_media_video_clip_type_id__volatile;
1337 }
1338
1339
1340 #line 169 "MediaEngine.vala"
1341 static void _view_media_track_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self) {
1342 #line 1343 "MediaEngine.c"
1343         view_media_track_on_clip_added (self, clip);
1344 }
1345
1346
1347 #line 216 "MediaEngine.vala"
1348 static void _view_media_track_on_track_removed_model_track_track_removed (ModelTrack* _sender, ModelTrack* track, gpointer self) {
1349 #line 1350 "MediaEngine.c"
1350         view_media_track_on_track_removed (self, track);
1351 }
1352
1353
1354 #line 221 "MediaEngine.vala"
1355 static void _view_media_track_on_pre_export_view_media_engine_pre_export (ViewMediaEngine* _sender, gint64 length, gpointer self) {
1356 #line 1357 "MediaEngine.c"
1357         view_media_track_on_pre_export (self, length);
1358 }
1359
1360
1361 #line 227 "MediaEngine.vala"
1362 static void _view_media_track_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self) {
1363 #line 1364 "MediaEngine.c"
1364         view_media_track_on_post_export (self, canceled);
1365 }
1366
1367
1368 #line 206 "MediaEngine.vala"
1369 static void _view_media_track_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
1370 #line 1371 "MediaEngine.c"
1371         view_media_track_on_pad_added (self, pad);
1372 }
1373
1374
1375 #line 211 "MediaEngine.vala"
1376 static void _view_media_track_on_pad_removed_gst_element_pad_removed (GstElement* _sender, GstPad* pad, gpointer self) {
1377 #line 1378 "MediaEngine.c"
1378         view_media_track_on_pad_removed (self, pad);
1379 }
1380
1381
1382 #line 123 "MediaEngine.vala"
1383 ViewMediaTrack* view_media_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GError** error) {
1384 #line 1385 "MediaEngine.c"
1385         GError * _inner_error_;
1386         ViewMediaTrack * self;
1387         GeeArrayList* _tmp0_;
1388         GstElement* _tmp1_;
1389         GstBin* _tmp2_;
1390         GstElement* _tmp3_;
1391         GstElement* _tmp4_;
1392         GstBin* default_source_bin;
1393         GstElement* _tmp5_;
1394 #line 123 "MediaEngine.vala"
1395         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL);
1396 #line 123 "MediaEngine.vala"
1397         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1398 #line 1399 "MediaEngine.c"
1399         _inner_error_ = NULL;
1400 #line 123 "MediaEngine.vala"
1401         self = (ViewMediaTrack*) g_object_new (object_type, NULL);
1402 #line 124 "MediaEngine.vala"
1403         self->priv->clips = (_tmp0_ = gee_array_list_new (VIEW_TYPE_MEDIA_CLIP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->clips), _tmp0_);
1404 #line 125 "MediaEngine.vala"
1405         self->media_engine = media_engine;
1406 #line 126 "MediaEngine.vala"
1407         g_signal_connect_object (track, "clip-added", (GCallback) _view_media_track_on_clip_added_model_track_clip_added, self, 0);
1408 #line 127 "MediaEngine.vala"
1409         g_signal_connect_object (track, "track-removed", (GCallback) _view_media_track_on_track_removed_model_track_track_removed, self, 0);
1410 #line 129 "MediaEngine.vala"
1411         g_signal_connect_object (media_engine, "pre-export", (GCallback) _view_media_track_on_pre_export_view_media_engine_pre_export, self, 0);
1412 #line 130 "MediaEngine.vala"
1413         g_signal_connect_object (media_engine, "post-export", (GCallback) _view_media_track_on_post_export_view_media_engine_post_export, self, 0);
1414 #line 132 "MediaEngine.vala"
1415         _tmp1_ = make_element ("gnlcomposition", &_inner_error_);
1416 #line 1417 "MediaEngine.c"
1417         if (_inner_error_ != NULL) {
1418                 g_propagate_error (error, _inner_error_);
1419                 g_object_unref (self);
1420                 return NULL;
1421         }
1422 #line 132 "MediaEngine.vala"
1423         self->composition = (_tmp2_ = GST_BIN (_tmp1_), _gst_object_unref0 (self->composition), _tmp2_);
1424 #line 134 "MediaEngine.vala"
1425         _tmp3_ = make_element_with_name ("gnlsource", "track_default_source", &_inner_error_);
1426 #line 1427 "MediaEngine.c"
1427         if (_inner_error_ != NULL) {
1428                 g_propagate_error (error, _inner_error_);
1429                 g_object_unref (self);
1430                 return NULL;
1431         }
1432 #line 134 "MediaEngine.vala"
1433         self->default_source = (_tmp4_ = _tmp3_, _gst_object_unref0 (self->default_source), _tmp4_);
1434 #line 135 "MediaEngine.vala"
1435         default_source_bin = _gst_object_ref0 (GST_BIN (self->default_source));
1436 #line 136 "MediaEngine.vala"
1437         _tmp5_ = view_media_track_empty_element (self, &_inner_error_);
1438 #line 1439 "MediaEngine.c"
1439         if (_inner_error_ != NULL) {
1440                 g_propagate_error (error, _inner_error_);
1441                 _gst_object_unref0 (default_source_bin);
1442                 g_object_unref (self);
1443                 return NULL;
1444         }
1445 #line 136 "MediaEngine.vala"
1446         if (!gst_bin_add (default_source_bin, _tmp5_)) {
1447 #line 137 "MediaEngine.vala"
1448                 g_error ("MediaEngine.vala:137: can't add empty element");
1449 #line 1450 "MediaEngine.c"
1450         }
1451 #line 142 "MediaEngine.vala"
1452         g_object_set (G_OBJECT (self->default_source), "priority", 1, NULL);
1453 #line 143 "MediaEngine.vala"
1454         g_object_set (G_OBJECT (self->default_source), "start", 0 * GST_SECOND, NULL);
1455 #line 144 "MediaEngine.vala"
1456         g_object_set (G_OBJECT (self->default_source), "duration", 1000000 * GST_SECOND, NULL);
1457 #line 145 "MediaEngine.vala"
1458         g_object_set (G_OBJECT (self->default_source), "media-start", 0 * GST_SECOND, NULL);
1459 #line 146 "MediaEngine.vala"
1460         g_object_set (G_OBJECT (self->default_source), "media-duration", 1000000 * GST_SECOND, NULL);
1461 #line 148 "MediaEngine.vala"
1462         if (!gst_bin_add (self->composition, _gst_object_ref0 (self->default_source))) {
1463 #line 149 "MediaEngine.vala"
1464                 g_error ("MediaEngine.vala:149: can't add default source");
1465 #line 1466 "MediaEngine.c"
1466         }
1467 #line 152 "MediaEngine.vala"
1468         gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (GST_ELEMENT (self->composition)));
1469 #line 153 "MediaEngine.vala"
1470         g_signal_connect_object (GST_ELEMENT (self->composition), "pad-added", (GCallback) _view_media_track_on_pad_added_gst_element_pad_added, self, 0);
1471 #line 154 "MediaEngine.vala"
1472         g_signal_connect_object (GST_ELEMENT (self->composition), "pad-removed", (GCallback) _view_media_track_on_pad_removed_gst_element_pad_removed, self, 0);
1473 #line 1474 "MediaEngine.c"
1474         _gst_object_unref0 (default_source_bin);
1475         return self;
1476 }
1477
1478
1479 #line 163 "MediaEngine.vala"
1480 static GstElement* view_media_track_real_empty_element (ViewMediaTrack* self, GError** error) {
1481 #line 1482 "MediaEngine.c"
1482         g_return_val_if_fail (VIEW_IS_MEDIA_TRACK (self), NULL);
1483         g_critical ("Type `%s' does not implement abstract method `view_media_track_empty_element'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1484         return NULL;
1485 }
1486
1487
1488 #line 163 "MediaEngine.vala"
1489 GstElement* view_media_track_empty_element (ViewMediaTrack* self, GError** error) {
1490 #line 163 "MediaEngine.vala"
1491         return VIEW_MEDIA_TRACK_GET_CLASS (self)->empty_element (self, error);
1492 #line 1493 "MediaEngine.c"
1493 }
1494
1495
1496 #line 164 "MediaEngine.vala"
1497 static GstElement* view_media_track_real_get_element (ViewMediaTrack* self) {
1498 #line 1499 "MediaEngine.c"
1499         g_return_val_if_fail (VIEW_IS_MEDIA_TRACK (self), NULL);
1500         g_critical ("Type `%s' does not implement abstract method `view_media_track_get_element'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1501         return NULL;
1502 }
1503
1504
1505 #line 164 "MediaEngine.vala"
1506 GstElement* view_media_track_get_element (ViewMediaTrack* self) {
1507 #line 164 "MediaEngine.vala"
1508         return VIEW_MEDIA_TRACK_GET_CLASS (self)->get_element (self);
1509 #line 1510 "MediaEngine.c"
1510 }
1511
1512
1513 #line 166 "MediaEngine.vala"
1514 static void view_media_track_real_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) {
1515 #line 1516 "MediaEngine.c"
1516         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1517         g_critical ("Type `%s' does not implement abstract method `view_media_track_link_new_pad'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1518         return;
1519 }
1520
1521
1522 #line 166 "MediaEngine.vala"
1523 void view_media_track_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) {
1524 #line 166 "MediaEngine.vala"
1525         VIEW_MEDIA_TRACK_GET_CLASS (self)->link_new_pad (self, pad, track_element);
1526 #line 1527 "MediaEngine.c"
1527 }
1528
1529
1530 #line 167 "MediaEngine.vala"
1531 static void view_media_track_real_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) {
1532 #line 1533 "MediaEngine.c"
1533         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1534         g_critical ("Type `%s' does not implement abstract method `view_media_track_unlink_pad'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1535         return;
1536 }
1537
1538
1539 #line 167 "MediaEngine.vala"
1540 void view_media_track_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) {
1541 #line 167 "MediaEngine.vala"
1542         VIEW_MEDIA_TRACK_GET_CLASS (self)->unlink_pad (self, pad, track_element);
1543 #line 1544 "MediaEngine.c"
1544 }
1545
1546
1547 #line 175 "MediaEngine.vala"
1548 static void _view_media_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) {
1549 #line 1550 "MediaEngine.c"
1550         view_media_track_on_clip_updated (self, clip);
1551 }
1552
1553
1554 #line 169 "MediaEngine.vala"
1555 static void view_media_track_on_clip_added (ViewMediaTrack* self, ModelClip* clip) {
1556 #line 169 "MediaEngine.vala"
1557         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1558 #line 169 "MediaEngine.vala"
1559         g_return_if_fail (MODEL_IS_CLIP (clip));
1560 #line 170 "MediaEngine.vala"
1561         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_added");
1562 #line 171 "MediaEngine.vala"
1563         g_signal_connect_object (clip, "updated", (GCallback) _view_media_track_on_clip_updated_model_clip_updated, self, 0);
1564 #line 172 "MediaEngine.vala"
1565         view_media_track_on_clip_updated (self, clip);
1566 #line 1567 "MediaEngine.c"
1567 }
1568
1569
1570 #line 200 "MediaEngine.vala"
1571 static void _view_media_track_on_media_clip_removed_view_media_clip_clip_removed (ViewMediaClip* _sender, ViewMediaClip* clip, gpointer self) {
1572 #line 1573 "MediaEngine.c"
1573         view_media_track_on_media_clip_removed (self, clip);
1574 }
1575
1576
1577 #line 175 "MediaEngine.vala"
1578 static void view_media_track_on_clip_updated (ViewMediaTrack* self, ModelClip* clip) {
1579 #line 1580 "MediaEngine.c"
1580         GError * _inner_error_;
1581 #line 175 "MediaEngine.vala"
1582         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1583 #line 175 "MediaEngine.vala"
1584         g_return_if_fail (MODEL_IS_CLIP (clip));
1585 #line 1586 "MediaEngine.c"
1586         _inner_error_ = NULL;
1587 #line 176 "MediaEngine.vala"
1588         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated");
1589 #line 177 "MediaEngine.vala"
1590         if (model_clip_file_is_online (clip->clipfile)) {
1591 #line 1592 "MediaEngine.c"
1592                 {
1593                         ViewMediaClip* media_clip;
1594                         media_clip = NULL;
1595 #line 180 "MediaEngine.vala"
1596                         if (clip->type == MODEL_MEDIA_TYPE_AUDIO) {
1597 #line 1598 "MediaEngine.c"
1598                                 ViewMediaAudioClip* _tmp0_;
1599                                 ViewMediaClip* _tmp1_;
1600 #line 181 "MediaEngine.vala"
1601                                 _tmp0_ = view_media_audio_clip_new (self->composition, clip, clip->clipfile->filename, &_inner_error_);
1602 #line 1603 "MediaEngine.c"
1603                                 if (_inner_error_ != NULL) {
1604                                         _g_object_unref0 (media_clip);
1605                                         goto __catch9_g_error;
1606                                 }
1607 #line 181 "MediaEngine.vala"
1608                                 media_clip = (_tmp1_ = VIEW_MEDIA_CLIP (_tmp0_), _g_object_unref0 (media_clip), _tmp1_);
1609 #line 1610 "MediaEngine.c"
1610                         } else {
1611                                 ViewMediaVideoClip* _tmp2_;
1612                                 ViewMediaClip* _tmp3_;
1613 #line 183 "MediaEngine.vala"
1614                                 _tmp2_ = view_media_video_clip_new (self->composition, clip, clip->clipfile->filename, &_inner_error_);
1615 #line 1616 "MediaEngine.c"
1616                                 if (_inner_error_ != NULL) {
1617                                         _g_object_unref0 (media_clip);
1618                                         goto __catch9_g_error;
1619                                 }
1620 #line 183 "MediaEngine.vala"
1621                                 media_clip = (_tmp3_ = VIEW_MEDIA_CLIP (_tmp2_), _g_object_unref0 (media_clip), _tmp3_);
1622 #line 1623 "MediaEngine.c"
1623                         }
1624 #line 185 "MediaEngine.vala"
1625                         g_signal_connect_object (media_clip, "clip-removed", (GCallback) _view_media_track_on_media_clip_removed_view_media_clip_clip_removed, self, 0);
1626 #line 187 "MediaEngine.vala"
1627                         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->clips), media_clip);
1628 #line 1629 "MediaEngine.c"
1629                         _g_object_unref0 (media_clip);
1630                 }
1631                 goto __finally9;
1632                 __catch9_g_error:
1633                 {
1634                         GError * e;
1635                         e = _inner_error_;
1636                         _inner_error_ = NULL;
1637                         {
1638 #line 189 "MediaEngine.vala"
1639                                 g_signal_emit_by_name (self, "error-occurred", "Could not create clip", e->message);
1640 #line 1641 "MediaEngine.c"
1641                                 _g_error_free0 (e);
1642                         }
1643                 }
1644                 __finally9:
1645                 if (_inner_error_ != NULL) {
1646                         g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1647                         g_clear_error (&_inner_error_);
1648                         return;
1649                 }
1650         } else {
1651                 {
1652                         GeeIterator* _media_clip_it;
1653                         _media_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->clips));
1654 #line 192 "MediaEngine.vala"
1655                         while (TRUE) {
1656 #line 1657 "MediaEngine.c"
1657                                 ViewMediaClip* media_clip;
1658 #line 192 "MediaEngine.vala"
1659                                 if (!gee_iterator_next (_media_clip_it)) {
1660 #line 192 "MediaEngine.vala"
1661                                         break;
1662 #line 1663 "MediaEngine.c"
1663                                 }
1664 #line 192 "MediaEngine.vala"
1665                                 media_clip = (ViewMediaClip*) gee_iterator_get (_media_clip_it);
1666 #line 193 "MediaEngine.vala"
1667                                 if (view_media_clip_is_equal (media_clip, clip)) {
1668 #line 194 "MediaEngine.vala"
1669                                         view_media_clip_on_clip_removed (media_clip);
1670 #line 1671 "MediaEngine.c"
1671                                 }
1672                                 _g_object_unref0 (media_clip);
1673                         }
1674                         _g_object_unref0 (_media_clip_it);
1675                 }
1676         }
1677 }
1678
1679
1680 #line 200 "MediaEngine.vala"
1681 static void view_media_track_on_media_clip_removed (ViewMediaTrack* self, ViewMediaClip* clip) {
1682 #line 1683 "MediaEngine.c"
1683         guint _tmp0_;
1684 #line 200 "MediaEngine.vala"
1685         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1686 #line 200 "MediaEngine.vala"
1687         g_return_if_fail (VIEW_IS_MEDIA_CLIP (clip));
1688 #line 201 "MediaEngine.vala"
1689         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_media_clip_removed");
1690 #line 202 "MediaEngine.vala"
1691         g_signal_parse_name ("clip-removed", VIEW_TYPE_MEDIA_CLIP, &_tmp0_, NULL, FALSE);
1692 #line 202 "MediaEngine.vala"
1693         g_signal_handlers_disconnect_matched (clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _view_media_track_on_media_clip_removed_view_media_clip_clip_removed, self);
1694 #line 203 "MediaEngine.vala"
1695         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->clips), clip);
1696 #line 1697 "MediaEngine.c"
1697 }
1698
1699
1700 #line 206 "MediaEngine.vala"
1701 static void view_media_track_on_pad_added (ViewMediaTrack* self, GstPad* pad) {
1702 #line 1703 "MediaEngine.c"
1703         GstElement* _tmp0_;
1704 #line 206 "MediaEngine.vala"
1705         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1706 #line 206 "MediaEngine.vala"
1707         g_return_if_fail (GST_IS_PAD (pad));
1708 #line 207 "MediaEngine.vala"
1709         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added");
1710 #line 208 "MediaEngine.vala"
1711         view_media_track_link_new_pad (self, pad, _tmp0_ = view_media_track_get_element (self));
1712 #line 1713 "MediaEngine.c"
1713         _gst_object_unref0 (_tmp0_);
1714 }
1715
1716
1717 #line 211 "MediaEngine.vala"
1718 static void view_media_track_on_pad_removed (ViewMediaTrack* self, GstPad* pad) {
1719 #line 1720 "MediaEngine.c"
1720         GstElement* _tmp0_;
1721 #line 211 "MediaEngine.vala"
1722         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1723 #line 211 "MediaEngine.vala"
1724         g_return_if_fail (GST_IS_PAD (pad));
1725 #line 212 "MediaEngine.vala"
1726         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_removed");
1727 #line 213 "MediaEngine.vala"
1728         view_media_track_unlink_pad (self, pad, _tmp0_ = view_media_track_get_element (self));
1729 #line 1730 "MediaEngine.c"
1730         _gst_object_unref0 (_tmp0_);
1731 }
1732
1733
1734 #line 216 "MediaEngine.vala"
1735 static void view_media_track_on_track_removed (ViewMediaTrack* self, ModelTrack* track) {
1736 #line 216 "MediaEngine.vala"
1737         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1738 #line 216 "MediaEngine.vala"
1739         g_return_if_fail (MODEL_IS_TRACK (track));
1740 #line 217 "MediaEngine.vala"
1741         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed");
1742 #line 218 "MediaEngine.vala"
1743         g_signal_emit_by_name (self, "track-removed", self);
1744 #line 1745 "MediaEngine.c"
1745 }
1746
1747
1748 #line 221 "MediaEngine.vala"
1749 static void view_media_track_on_pre_export (ViewMediaTrack* self, gint64 length) {
1750 #line 221 "MediaEngine.vala"
1751         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1752 #line 222 "MediaEngine.vala"
1753         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pre_export");
1754 #line 223 "MediaEngine.vala"
1755         g_object_set (G_OBJECT (self->default_source), "duration", length, NULL);
1756 #line 224 "MediaEngine.vala"
1757         g_object_set (G_OBJECT (self->default_source), "media-duration", length, NULL);
1758 #line 1759 "MediaEngine.c"
1759 }
1760
1761
1762 #line 227 "MediaEngine.vala"
1763 static void view_media_track_on_post_export (ViewMediaTrack* self, gboolean deleted) {
1764 #line 227 "MediaEngine.vala"
1765         g_return_if_fail (VIEW_IS_MEDIA_TRACK (self));
1766 #line 228 "MediaEngine.vala"
1767         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_post_export");
1768 #line 229 "MediaEngine.vala"
1769         g_object_set (G_OBJECT (self->default_source), "duration", 1000000 * GST_SECOND, NULL);
1770 #line 230 "MediaEngine.vala"
1771         g_object_set (G_OBJECT (self->default_source), "media-duration", 1000000 * GST_SECOND, NULL);
1772 #line 1773 "MediaEngine.c"
1773 }
1774
1775
1776 static void view_media_track_class_init (ViewMediaTrackClass * klass) {
1777         view_media_track_parent_class = g_type_class_peek_parent (klass);
1778         g_type_class_add_private (klass, sizeof (ViewMediaTrackPrivate));
1779         VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_track_real_empty_element;
1780         VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_track_real_get_element;
1781         VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_track_real_link_new_pad;
1782         VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_track_real_unlink_pad;
1783         G_OBJECT_CLASS (klass)->finalize = view_media_track_finalize;
1784         g_signal_new ("track_removed", VIEW_TYPE_MEDIA_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, VIEW_TYPE_MEDIA_TRACK);
1785         g_signal_new ("error_occurred", VIEW_TYPE_MEDIA_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
1786 }
1787
1788
1789 static void view_media_track_instance_init (ViewMediaTrack * self) {
1790         self->priv = VIEW_MEDIA_TRACK_GET_PRIVATE (self);
1791 }
1792
1793
1794 static void view_media_track_finalize (GObject* obj) {
1795         ViewMediaTrack * self;
1796         self = VIEW_MEDIA_TRACK (obj);
1797         {
1798                 gboolean _tmp4_ = FALSE;
1799 #line 158 "MediaEngine.vala"
1800                 if (self->composition != NULL) {
1801 #line 158 "MediaEngine.vala"
1802                         _tmp4_ = !gst_bin_remove (GST_BIN (self->media_engine->pipeline), GST_ELEMENT (self->composition));
1803 #line 1804 "MediaEngine.c"
1804                 } else {
1805 #line 158 "MediaEngine.vala"
1806                         _tmp4_ = FALSE;
1807 #line 1808 "MediaEngine.c"
1808                 }
1809 #line 158 "MediaEngine.vala"
1810                 if (_tmp4_) {
1811 #line 159 "MediaEngine.vala"
1812                         g_error ("MediaEngine.vala:159: couldn't remove composition");
1813 #line 1814 "MediaEngine.c"
1814                 }
1815         }
1816         _g_object_unref0 (self->priv->clips);
1817         _gst_object_unref0 (self->composition);
1818         _gst_object_unref0 (self->default_source);
1819         _gst_object_unref0 (self->sink);
1820         G_OBJECT_CLASS (view_media_track_parent_class)->finalize (obj);
1821 }
1822
1823
1824 GType view_media_track_get_type (void) {
1825         static volatile gsize view_media_track_type_id__volatile = 0;
1826         if (g_once_init_enter (&view_media_track_type_id__volatile)) {
1827                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaTrack), 0, (GInstanceInitFunc) view_media_track_instance_init, NULL };
1828                 GType view_media_track_type_id;
1829                 view_media_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaTrack", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
1830                 g_once_init_leave (&view_media_track_type_id__volatile, view_media_track_type_id);
1831         }
1832         return view_media_track_type_id__volatile;
1833 }
1834
1835
1836 #line 237 "MediaEngine.vala"
1837 ViewMediaVideoTrack* view_media_video_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error) {
1838 #line 1839 "MediaEngine.c"
1839         ViewMediaVideoTrack * self;
1840 #line 237 "MediaEngine.vala"
1841         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL);
1842 #line 237 "MediaEngine.vala"
1843         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
1844 #line 237 "MediaEngine.vala"
1845         g_return_val_if_fail (GST_IS_ELEMENT (converter), NULL);
1846 #line 239 "MediaEngine.vala"
1847         self = (ViewMediaVideoTrack*) view_media_track_construct (object_type, media_engine, track, error);
1848 #line 240 "MediaEngine.vala"
1849         self->priv->converter = converter;
1850 #line 1851 "MediaEngine.c"
1851         return self;
1852 }
1853
1854
1855 #line 237 "MediaEngine.vala"
1856 ViewMediaVideoTrack* view_media_video_track_new (ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error) {
1857 #line 237 "MediaEngine.vala"
1858         return view_media_video_track_construct (VIEW_TYPE_MEDIA_VIDEO_TRACK, media_engine, track, converter, error);
1859 #line 1860 "MediaEngine.c"
1860 }
1861
1862
1863 #line 243 "MediaEngine.vala"
1864 static GstElement* view_media_video_track_real_get_element (ViewMediaTrack* base) {
1865 #line 1866 "MediaEngine.c"
1866         ViewMediaVideoTrack * self;
1867         GstElement* result = NULL;
1868         self = VIEW_MEDIA_VIDEO_TRACK (base);
1869 #line 247 "MediaEngine.vala"
1870         g_assert (self->priv->converter != NULL);
1871 #line 248 "MediaEngine.vala"
1872         g_assert (gst_element_sync_state_with_parent (self->priv->converter));
1873 #line 1874 "MediaEngine.c"
1874         result = _gst_object_ref0 (self->priv->converter);
1875 #line 249 "MediaEngine.vala"
1876         return result;
1877 #line 1878 "MediaEngine.c"
1878 }
1879
1880
1881 #line 252 "MediaEngine.vala"
1882 static GstElement* view_media_video_track_real_empty_element (ViewMediaTrack* base, GError** error) {
1883 #line 1884 "MediaEngine.c"
1884         ViewMediaVideoTrack * self;
1885         GstElement* result = NULL;
1886         GError * _inner_error_;
1887         GstElement* blackness;
1888         self = VIEW_MEDIA_VIDEO_TRACK (base);
1889         _inner_error_ = NULL;
1890 #line 253 "MediaEngine.vala"
1891         blackness = make_element ("videotestsrc", &_inner_error_);
1892 #line 1893 "MediaEngine.c"
1893         if (_inner_error_ != NULL) {
1894                 g_propagate_error (error, _inner_error_);
1895                 return NULL;
1896         }
1897 #line 254 "MediaEngine.vala"
1898         g_object_set (G_OBJECT (blackness), "pattern", 2, NULL);
1899 #line 1900 "MediaEngine.c"
1900         result = blackness;
1901 #line 255 "MediaEngine.vala"
1902         return result;
1903 #line 1904 "MediaEngine.c"
1904 }
1905
1906
1907 #line 258 "MediaEngine.vala"
1908 static void view_media_video_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) {
1909 #line 1910 "MediaEngine.c"
1910         ViewMediaVideoTrack * self;
1911         GstPad* _tmp0_;
1912         gboolean _tmp1_;
1913         self = VIEW_MEDIA_VIDEO_TRACK (base);
1914 #line 258 "MediaEngine.vala"
1915         g_return_if_fail (GST_IS_PAD (pad));
1916 #line 258 "MediaEngine.vala"
1917         g_return_if_fail (GST_IS_ELEMENT (track_element));
1918 #line 259 "MediaEngine.vala"
1919         if ((_tmp1_ = gst_pad_link (pad, _tmp0_ = gst_element_get_static_pad (track_element, "sink")) != GST_PAD_LINK_OK, _gst_object_unref0 (_tmp0_), _tmp1_)) {
1920 #line 260 "MediaEngine.vala"
1921                 g_error ("MediaEngine.vala:260: couldn't link pad to converter");
1922 #line 1923 "MediaEngine.c"
1923         }
1924 }
1925
1926
1927 #line 264 "MediaEngine.vala"
1928 static void view_media_video_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) {
1929 #line 1930 "MediaEngine.c"
1930         ViewMediaVideoTrack * self;
1931         GstPad* _tmp0_;
1932         self = VIEW_MEDIA_VIDEO_TRACK (base);
1933 #line 264 "MediaEngine.vala"
1934         g_return_if_fail (GST_IS_PAD (pad));
1935 #line 264 "MediaEngine.vala"
1936         g_return_if_fail (GST_IS_ELEMENT (track_element));
1937 #line 265 "MediaEngine.vala"
1938         gst_pad_unlink (pad, _tmp0_ = gst_element_get_static_pad (track_element, "sink"));
1939 #line 1940 "MediaEngine.c"
1940         _gst_object_unref0 (_tmp0_);
1941 }
1942
1943
1944 static void view_media_video_track_class_init (ViewMediaVideoTrackClass * klass) {
1945         view_media_video_track_parent_class = g_type_class_peek_parent (klass);
1946         g_type_class_add_private (klass, sizeof (ViewMediaVideoTrackPrivate));
1947         VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_video_track_real_get_element;
1948         VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_video_track_real_empty_element;
1949         VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_video_track_real_link_new_pad;
1950         VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_video_track_real_unlink_pad;
1951         G_OBJECT_CLASS (klass)->finalize = view_media_video_track_finalize;
1952 }
1953
1954
1955 static void view_media_video_track_instance_init (ViewMediaVideoTrack * self) {
1956         self->priv = VIEW_MEDIA_VIDEO_TRACK_GET_PRIVATE (self);
1957 }
1958
1959
1960 static void view_media_video_track_finalize (GObject* obj) {
1961         ViewMediaVideoTrack * self;
1962         self = VIEW_MEDIA_VIDEO_TRACK (obj);
1963         G_OBJECT_CLASS (view_media_video_track_parent_class)->finalize (obj);
1964 }
1965
1966
1967 GType view_media_video_track_get_type (void) {
1968         static volatile gsize view_media_video_track_type_id__volatile = 0;
1969         if (g_once_init_enter (&view_media_video_track_type_id__volatile)) {
1970                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaVideoTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_video_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaVideoTrack), 0, (GInstanceInitFunc) view_media_video_track_instance_init, NULL };
1971                 GType view_media_video_track_type_id;
1972                 view_media_video_track_type_id = g_type_register_static (VIEW_TYPE_MEDIA_TRACK, "ViewMediaVideoTrack", &g_define_type_info, 0);
1973                 g_once_init_leave (&view_media_video_track_type_id__volatile, view_media_video_track_type_id);
1974         }
1975         return view_media_video_track_type_id__volatile;
1976 }
1977
1978
1979 #line 302 "MediaEngine.vala"
1980 static void _view_click_track_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) {
1981 #line 1982 "MediaEngine.c"
1982         view_click_track_on_playstate_changed (self);
1983 }
1984
1985
1986 static void _g_list_free_g_free (GList* self) {
1987         g_list_foreach (self, (GFunc) g_free, NULL);
1988         g_list_free (self);
1989 }
1990
1991
1992 #line 277 "MediaEngine.vala"
1993 ViewClickTrack* view_click_track_construct (GType object_type, ViewMediaEngine* engine, ModelProject* project, GError** error) {
1994 #line 1995 "MediaEngine.c"
1995         GError * _inner_error_;
1996         ViewClickTrack * self;
1997         GstElement* _tmp0_;
1998         GstElement* _tmp1_;
1999         GstElement* _tmp2_;
2000         GstElement* _tmp3_;
2001         GstElement* _tmp4_;
2002         GstElement* _tmp5_;
2003         GList* list;
2004         GstController* _tmp6_;
2005         GstController* _tmp7_;
2006 #line 277 "MediaEngine.vala"
2007         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (engine), NULL);
2008 #line 277 "MediaEngine.vala"
2009         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
2010 #line 2011 "MediaEngine.c"
2011         _inner_error_ = NULL;
2012 #line 277 "MediaEngine.vala"
2013         self = (ViewClickTrack*) g_object_new (object_type, NULL);
2014 #line 278 "MediaEngine.vala"
2015         self->priv->project = project;
2016 #line 279 "MediaEngine.vala"
2017         _tmp0_ = make_element ("audiotestsrc", &_inner_error_);
2018 #line 2019 "MediaEngine.c"
2019         if (_inner_error_ != NULL) {
2020                 g_propagate_error (error, _inner_error_);
2021                 g_object_unref (self);
2022                 return NULL;
2023         }
2024 #line 279 "MediaEngine.vala"
2025         self->priv->audio_source = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_source), _tmp1_);
2026 #line 280 "MediaEngine.vala"
2027         _tmp2_ = make_element ("audioconvert", &_inner_error_);
2028 #line 2029 "MediaEngine.c"
2029         if (_inner_error_ != NULL) {
2030                 g_propagate_error (error, _inner_error_);
2031                 g_object_unref (self);
2032                 return NULL;
2033         }
2034 #line 280 "MediaEngine.vala"
2035         self->priv->audio_convert = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->audio_convert), _tmp3_);
2036 #line 281 "MediaEngine.vala"
2037         _tmp4_ = make_element ("volume", &_inner_error_);
2038 #line 2039 "MediaEngine.c"
2039         if (_inner_error_ != NULL) {
2040                 g_propagate_error (error, _inner_error_);
2041                 g_object_unref (self);
2042                 return NULL;
2043         }
2044 #line 281 "MediaEngine.vala"
2045         self->priv->volume = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->volume), _tmp5_);
2046 #line 282 "MediaEngine.vala"
2047         list = NULL;
2048 #line 283 "MediaEngine.vala"
2049         list = g_list_append (list, g_strdup ("freq"));
2050 #line 284 "MediaEngine.vala"
2051         self->priv->click_controller = (_tmp6_ = gst_controller_new_list (G_OBJECT (self->priv->audio_source), list), _g_object_unref0 (self->priv->click_controller), _tmp6_);
2052 #line 285 "MediaEngine.vala"
2053         list = g_list_remove_all (list, "freq");
2054 #line 286 "MediaEngine.vala"
2055         list = g_list_append (list, g_strdup ("mute"));
2056 #line 287 "MediaEngine.vala"
2057         self->priv->volume_controller = (_tmp7_ = gst_controller_new_list (G_OBJECT (self->priv->volume), list), _g_object_unref0 (self->priv->volume_controller), _tmp7_);
2058 #line 288 "MediaEngine.vala"
2059         gst_bin_add_many (GST_BIN (engine->pipeline), _gst_object_ref0 (self->priv->audio_source), _gst_object_ref0 (self->priv->volume), _gst_object_ref0 (self->priv->audio_convert), NULL);
2060 #line 289 "MediaEngine.vala"
2061         g_object_set (G_OBJECT (self->priv->audio_source), "volume", project->click_volume, NULL);
2062 #line 291 "MediaEngine.vala"
2063         gst_element_link_many (self->priv->audio_source, self->priv->audio_convert, self->priv->volume, engine->adder, NULL);
2064 #line 292 "MediaEngine.vala"
2065         g_signal_connect_object (engine, "playstate-changed", (GCallback) _view_click_track_on_playstate_changed_view_media_engine_playstate_changed, self, 0);
2066 #line 2067 "MediaEngine.c"
2067         __g_list_free_g_free0 (list);
2068         return self;
2069 }
2070
2071
2072 #line 277 "MediaEngine.vala"
2073 ViewClickTrack* view_click_track_new (ViewMediaEngine* engine, ModelProject* project, GError** error) {
2074 #line 277 "MediaEngine.vala"
2075         return view_click_track_construct (VIEW_TYPE_CLICK_TRACK, engine, project, error);
2076 #line 2077 "MediaEngine.c"
2077 }
2078
2079
2080 #line 295 "MediaEngine.vala"
2081 static void view_click_track_clear_controllers (ViewClickTrack* self) {
2082 #line 295 "MediaEngine.vala"
2083         g_return_if_fail (VIEW_IS_CLICK_TRACK (self));
2084 #line 296 "MediaEngine.vala"
2085         gst_controller_unset_all (self->priv->volume_controller, "mute");
2086 #line 297 "MediaEngine.vala"
2087         gst_controller_unset_all (self->priv->click_controller, "freq");
2088 #line 298 "MediaEngine.vala"
2089         g_object_set (G_OBJECT (self->priv->volume), "mute", TRUE, NULL);
2090 #line 299 "MediaEngine.vala"
2091         g_object_set (G_OBJECT (self->priv->volume), "volume", 0.0, NULL);
2092 #line 2093 "MediaEngine.c"
2093 }
2094
2095
2096 #line 302 "MediaEngine.vala"
2097 static void view_click_track_on_playstate_changed (ViewClickTrack* self) {
2098 #line 302 "MediaEngine.vala"
2099         g_return_if_fail (VIEW_IS_CLICK_TRACK (self));
2100 #line 303 "MediaEngine.vala"
2101         switch (view_media_engine_get_play_state (self->priv->project->media_engine)) {
2102 #line 2103 "MediaEngine.c"
2103                 case PLAY_STATE_PRE_EXPORT:
2104                 case PLAY_STATE_STOPPED:
2105                 {
2106 #line 306 "MediaEngine.vala"
2107                         view_click_track_clear_controllers (self);
2108 #line 307 "MediaEngine.vala"
2109                         break;
2110 #line 2111 "MediaEngine.c"
2111                 }
2112                 case PLAY_STATE_PLAYING:
2113                 {
2114                         {
2115 #line 309 "MediaEngine.vala"
2116                                 if (self->priv->project->click_during_play) {
2117 #line 2118 "MediaEngine.c"
2118                                         Fraction _tmp1_;
2119                                         Fraction _tmp0_ = {0};
2120 #line 310 "MediaEngine.vala"
2121                                         view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp1_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp0_), _tmp0_), &_tmp1_));
2122 #line 2123 "MediaEngine.c"
2123                                 } else {
2124 #line 312 "MediaEngine.vala"
2125                                         view_click_track_clear_controllers (self);
2126 #line 2127 "MediaEngine.c"
2127                                 }
2128                         }
2129 #line 315 "MediaEngine.vala"
2130                         break;
2131 #line 2132 "MediaEngine.c"
2132                 }
2133                 case PLAY_STATE_PRE_RECORD:
2134                 {
2135                         {
2136 #line 317 "MediaEngine.vala"
2137                                 if (self->priv->project->click_during_record) {
2138 #line 2139 "MediaEngine.c"
2139                                         Fraction _tmp3_;
2140                                         Fraction _tmp2_ = {0};
2141 #line 318 "MediaEngine.vala"
2142                                         view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp3_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp2_), _tmp2_), &_tmp3_));
2143 #line 2144 "MediaEngine.c"
2144                                 } else {
2145                                         Fraction _tmp5_;
2146                                         Fraction _tmp4_ = {0};
2147 #line 322 "MediaEngine.vala"
2148                                         view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp5_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp4_), _tmp4_), &_tmp5_));
2149 #line 323 "MediaEngine.vala"
2150                                         view_click_track_clear_controllers (self);
2151 #line 2152 "MediaEngine.c"
2152                                 }
2153                         }
2154 #line 326 "MediaEngine.vala"
2155                         break;
2156 #line 2157 "MediaEngine.c"
2157                 }
2158         }
2159 }
2160
2161
2162 #line 330 "MediaEngine.vala"
2163 static void view_click_track_setup_clicks (ViewClickTrack* self, gint bpm, Fraction* time_signature) {
2164 #line 2165 "MediaEngine.c"
2165         GValue double_value = {0};
2166         GValue bool_value = {0};
2167         GstClockTime time;
2168         gint64 conversion;
2169         guint64 current_time;
2170 #line 330 "MediaEngine.vala"
2171         g_return_if_fail (VIEW_IS_CLICK_TRACK (self));
2172 #line 331 "MediaEngine.vala"
2173         view_click_track_clear_controllers (self);
2174 #line 332 "MediaEngine.vala"
2175         g_object_set (G_OBJECT (self->priv->volume), "volume", self->priv->project->click_volume / 10, NULL);
2176 #line 2177 "MediaEngine.c"
2177         memset (&double_value, 0, sizeof (GValue));
2178 #line 335 "MediaEngine.vala"
2179         g_value_init (&double_value, g_type_from_name ("gdouble"));
2180 #line 2181 "MediaEngine.c"
2181         memset (&bool_value, 0, sizeof (GValue));
2182 #line 337 "MediaEngine.vala"
2183         g_value_init (&bool_value, g_type_from_name ("gboolean"));
2184 #line 339 "MediaEngine.vala"
2185         time = (GstClockTime) 0;
2186 #line 340 "MediaEngine.vala"
2187         g_value_set_boolean (&bool_value, TRUE);
2188 #line 341 "MediaEngine.vala"
2189         gst_controller_set (self->priv->volume_controller, "volume", time, &bool_value);
2190 #line 343 "MediaEngine.vala"
2191         conversion = (gint64) ((GST_SECOND * 60) / bpm);
2192 #line 344 "MediaEngine.vala"
2193         current_time = (guint64) 0;
2194 #line 2195 "MediaEngine.c"
2195         {
2196                 gint i;
2197 #line 346 "MediaEngine.vala"
2198                 i = 0;
2199 #line 2200 "MediaEngine.c"
2200                 {
2201                         gboolean _tmp0_;
2202 #line 346 "MediaEngine.vala"
2203                         _tmp0_ = TRUE;
2204 #line 346 "MediaEngine.vala"
2205                         while (TRUE) {
2206 #line 346 "MediaEngine.vala"
2207                                 if (!_tmp0_) {
2208 #line 346 "MediaEngine.vala"
2209                                         i = i + 1;
2210 #line 2211 "MediaEngine.c"
2211                                 }
2212 #line 346 "MediaEngine.vala"
2213                                 _tmp0_ = FALSE;
2214 #line 346 "MediaEngine.vala"
2215                                 if (!(current_time < ((GST_SECOND * 60) * 10))) {
2216 #line 346 "MediaEngine.vala"
2217                                         break;
2218 #line 2219 "MediaEngine.c"
2219                                 }
2220 #line 347 "MediaEngine.vala"
2221                                 current_time = (guint64) (i * conversion);
2222 #line 348 "MediaEngine.vala"
2223                                 if (i > 0) {
2224 #line 349 "MediaEngine.vala"
2225                                         time = (GstClockTime) (current_time - (GST_SECOND / 10));
2226 #line 350 "MediaEngine.vala"
2227                                         g_value_set_boolean (&bool_value, TRUE);
2228 #line 351 "MediaEngine.vala"
2229                                         gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value);
2230 #line 2231 "MediaEngine.c"
2231                                 }
2232 #line 353 "MediaEngine.vala"
2233                                 time = (GstClockTime) current_time;
2234 #line 354 "MediaEngine.vala"
2235                                 if ((i % (*time_signature).numerator) == 0) {
2236 #line 355 "MediaEngine.vala"
2237                                         g_value_set_double (&double_value, 880.0);
2238 #line 2239 "MediaEngine.c"
2239                                 } else {
2240 #line 357 "MediaEngine.vala"
2241                                         g_value_set_double (&double_value, 440.0);
2242 #line 2243 "MediaEngine.c"
2243                                 }
2244 #line 359 "MediaEngine.vala"
2245                                 gst_controller_set (self->priv->click_controller, "freq", time, &double_value);
2246 #line 360 "MediaEngine.vala"
2247                                 g_value_set_boolean (&bool_value, FALSE);
2248 #line 361 "MediaEngine.vala"
2249                                 gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value);
2250 #line 363 "MediaEngine.vala"
2251                                 time = (GstClockTime) (current_time + (GST_SECOND / 10));
2252 #line 364 "MediaEngine.vala"
2253                                 g_value_set_boolean (&bool_value, TRUE);
2254 #line 365 "MediaEngine.vala"
2255                                 gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value);
2256 #line 2257 "MediaEngine.c"
2257                         }
2258                 }
2259         }
2260 }
2261
2262
2263 static void view_click_track_class_init (ViewClickTrackClass * klass) {
2264         view_click_track_parent_class = g_type_class_peek_parent (klass);
2265         g_type_class_add_private (klass, sizeof (ViewClickTrackPrivate));
2266         G_OBJECT_CLASS (klass)->finalize = view_click_track_finalize;
2267 }
2268
2269
2270 static void view_click_track_instance_init (ViewClickTrack * self) {
2271         self->priv = VIEW_CLICK_TRACK_GET_PRIVATE (self);
2272 }
2273
2274
2275 static void view_click_track_finalize (GObject* obj) {
2276         ViewClickTrack * self;
2277         self = VIEW_CLICK_TRACK (obj);
2278         _g_object_unref0 (self->priv->click_controller);
2279         _g_object_unref0 (self->priv->volume_controller);
2280         _gst_object_unref0 (self->priv->audio_source);
2281         _gst_object_unref0 (self->priv->audio_convert);
2282         _gst_object_unref0 (self->priv->volume);
2283         G_OBJECT_CLASS (view_click_track_parent_class)->finalize (obj);
2284 }
2285
2286
2287 GType view_click_track_get_type (void) {
2288         static volatile gsize view_click_track_type_id__volatile = 0;
2289         if (g_once_init_enter (&view_click_track_type_id__volatile)) {
2290                 static const GTypeInfo g_define_type_info = { sizeof (ViewClickTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_click_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewClickTrack), 0, (GInstanceInitFunc) view_click_track_instance_init, NULL };
2291                 GType view_click_track_type_id;
2292                 view_click_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewClickTrack", &g_define_type_info, 0);
2293                 g_once_init_leave (&view_click_track_type_id__volatile, view_click_track_type_id);
2294         }
2295         return view_click_track_type_id__volatile;
2296 }
2297
2298
2299 #line 426 "MediaEngine.vala"
2300 static void _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self) {
2301 #line 2302 "MediaEngine.c"
2302         view_media_audio_track_on_parameter_changed (self, parameter, new_value);
2303 }
2304
2305
2306 #line 438 "MediaEngine.vala"
2307 static void _view_media_audio_track_on_level_changed_view_media_engine_level_changed (ViewMediaEngine* _sender, GstObject* source, double level_left, double level_right, gpointer self) {
2308 #line 2309 "MediaEngine.c"
2309         view_media_audio_track_on_level_changed (self, source, level_left, level_right);
2310 }
2311
2312
2313 #line 610 "track.vala"
2314 static void _model_audio_track_on_level_changed_view_media_audio_track_level_changed (ViewMediaAudioTrack* _sender, double level_left, double level_right, gpointer self) {
2315 #line 2316 "MediaEngine.c"
2316         model_audio_track_on_level_changed (self, level_left, level_right);
2317 }
2318
2319
2320 #line 378 "MediaEngine.vala"
2321 ViewMediaAudioTrack* view_media_audio_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error) {
2322 #line 2323 "MediaEngine.c"
2323         GError * _inner_error_;
2324         ViewMediaAudioTrack * self;
2325         GstElement* _tmp0_;
2326         GstElement* _tmp1_;
2327         GstElement* _tmp2_;
2328         GstElement* _tmp3_;
2329         GstElement* _tmp4_;
2330         GstElement* _tmp5_;
2331         GstElement* _tmp6_;
2332         GstElement* _tmp7_;
2333         GstElement* _tmp8_;
2334         GstElement* _tmp9_;
2335         GValue _tmp10_ = {0};
2336         GValue the_level;
2337         GValue _tmp11_ = {0};
2338         GValue true_value;
2339 #line 378 "MediaEngine.vala"
2340         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL);
2341 #line 378 "MediaEngine.vala"
2342         g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (track), NULL);
2343 #line 2344 "MediaEngine.c"
2344         _inner_error_ = NULL;
2345 #line 379 "MediaEngine.vala"
2346         self = (ViewMediaAudioTrack*) view_media_track_construct (object_type, media_engine, MODEL_TRACK (track), error);
2347 #line 380 "MediaEngine.vala"
2348         g_signal_connect_object (track, "parameter-changed", (GCallback) _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed, self, 0);
2349 #line 382 "MediaEngine.vala"
2350         _tmp0_ = make_element ("audioconvert", &_inner_error_);
2351 #line 2352 "MediaEngine.c"
2352         if (_inner_error_ != NULL) {
2353                 g_propagate_error (error, _inner_error_);
2354                 g_object_unref (self);
2355                 return NULL;
2356         }
2357 #line 382 "MediaEngine.vala"
2358         self->priv->audio_convert = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_convert), _tmp1_);
2359 #line 383 "MediaEngine.vala"
2360         _tmp2_ = make_element ("audioresample", &_inner_error_);
2361 #line 2362 "MediaEngine.c"
2362         if (_inner_error_ != NULL) {
2363                 g_propagate_error (error, _inner_error_);
2364                 g_object_unref (self);
2365                 return NULL;
2366         }
2367 #line 383 "MediaEngine.vala"
2368         self->priv->audio_resample = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->audio_resample), _tmp3_);
2369 #line 384 "MediaEngine.vala"
2370         _tmp4_ = make_element ("level", &_inner_error_);
2371 #line 2372 "MediaEngine.c"
2372         if (_inner_error_ != NULL) {
2373                 g_propagate_error (error, _inner_error_);
2374                 g_object_unref (self);
2375                 return NULL;
2376         }
2377 #line 384 "MediaEngine.vala"
2378         self->priv->level = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->level), _tmp5_);
2379 #line 386 "MediaEngine.vala"
2380         _tmp6_ = make_element ("audiopanorama", &_inner_error_);
2381 #line 2382 "MediaEngine.c"
2382         if (_inner_error_ != NULL) {
2383                 g_propagate_error (error, _inner_error_);
2384                 g_object_unref (self);
2385                 return NULL;
2386         }
2387 #line 386 "MediaEngine.vala"
2388         self->priv->pan = (_tmp7_ = _tmp6_, _gst_object_unref0 (self->priv->pan), _tmp7_);
2389 #line 387 "MediaEngine.vala"
2390         view_media_audio_track_on_parameter_changed (self, MODEL_PARAMETER_PAN, model_audio_track_get_pan (track));
2391 #line 388 "MediaEngine.vala"
2392         _tmp8_ = make_element ("volume", &_inner_error_);
2393 #line 2394 "MediaEngine.c"
2394         if (_inner_error_ != NULL) {
2395                 g_propagate_error (error, _inner_error_);
2396                 g_object_unref (self);
2397                 return NULL;
2398         }
2399 #line 388 "MediaEngine.vala"
2400         self->priv->volume = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->volume), _tmp9_);
2401 #line 389 "MediaEngine.vala"
2402         view_media_audio_track_on_parameter_changed (self, MODEL_PARAMETER_VOLUME, model_audio_track_get_volume (track));
2403 #line 391 "MediaEngine.vala"
2404         the_level = (g_value_init (&_tmp10_, G_TYPE_UINT64), g_value_set_uint64 (&_tmp10_, (guint64) (GST_SECOND / 30)), _tmp10_);
2405 #line 392 "MediaEngine.vala"
2406         g_object_set_property (G_OBJECT (self->priv->level), "interval", &the_level);
2407 #line 393 "MediaEngine.vala"
2408         true_value = (g_value_init (&_tmp11_, G_TYPE_BOOLEAN), g_value_set_boolean (&_tmp11_, TRUE), _tmp11_);
2409 #line 394 "MediaEngine.vala"
2410         g_object_set_property (G_OBJECT (self->priv->level), "message", &true_value);
2411 #line 396 "MediaEngine.vala"
2412         if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->audio_convert))) {
2413 #line 397 "MediaEngine.vala"
2414                 g_error ("MediaEngine.vala:397: could not add audio_convert");
2415 #line 2416 "MediaEngine.c"
2416         }
2417 #line 400 "MediaEngine.vala"
2418         if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->audio_resample))) {
2419 #line 401 "MediaEngine.vala"
2420                 g_error ("MediaEngine.vala:401: could not add audio_resample");
2421 #line 2422 "MediaEngine.c"
2422         }
2423 #line 404 "MediaEngine.vala"
2424         if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->level))) {
2425 #line 405 "MediaEngine.vala"
2426                 g_error ("MediaEngine.vala:405: could not add level");
2427 #line 2428 "MediaEngine.c"
2428         }
2429 #line 408 "MediaEngine.vala"
2430         if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->pan))) {
2431 #line 409 "MediaEngine.vala"
2432                 g_error ("MediaEngine.vala:409: could not add pan");
2433 #line 2434 "MediaEngine.c"
2434         }
2435 #line 412 "MediaEngine.vala"
2436         if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->volume))) {
2437 #line 413 "MediaEngine.vala"
2438                 g_error ("MediaEngine.vala:413: could not add volume");
2439 #line 2440 "MediaEngine.c"
2440         }
2441 #line 415 "MediaEngine.vala"
2442         g_signal_connect_object (media_engine, "level-changed", (GCallback) _view_media_audio_track_on_level_changed_view_media_engine_level_changed, self, 0);
2443 #line 416 "MediaEngine.vala"
2444         g_signal_connect_object (self, "level-changed", (GCallback) _model_audio_track_on_level_changed_view_media_audio_track_level_changed, track, 0);
2445 #line 2446 "MediaEngine.c"
2446         G_IS_VALUE (&the_level) ? (g_value_unset (&the_level), NULL) : NULL;
2447         G_IS_VALUE (&true_value) ? (g_value_unset (&true_value), NULL) : NULL;
2448         return self;
2449 }
2450
2451
2452 #line 378 "MediaEngine.vala"
2453 ViewMediaAudioTrack* view_media_audio_track_new (ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error) {
2454 #line 378 "MediaEngine.vala"
2455         return view_media_audio_track_construct (VIEW_TYPE_MEDIA_AUDIO_TRACK, media_engine, track, error);
2456 #line 2457 "MediaEngine.c"
2457 }
2458
2459
2460 #line 426 "MediaEngine.vala"
2461 static void view_media_audio_track_on_parameter_changed (ViewMediaAudioTrack* self, ModelParameter parameter, double new_value) {
2462 #line 426 "MediaEngine.vala"
2463         g_return_if_fail (VIEW_IS_MEDIA_AUDIO_TRACK (self));
2464 #line 427 "MediaEngine.vala"
2465         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_parameter_changed");
2466 #line 428 "MediaEngine.vala"
2467         switch (parameter) {
2468 #line 2469 "MediaEngine.c"
2469                 case MODEL_PARAMETER_PAN:
2470                 {
2471                         GValue _tmp1_;
2472                         GValue _tmp0_ = {0};
2473 #line 430 "MediaEngine.vala"
2474                         g_object_set_property (G_OBJECT (self->priv->pan), "panorama", (_tmp1_ = (g_value_init (&_tmp0_, G_TYPE_DOUBLE), g_value_set_double (&_tmp0_, new_value), _tmp0_), &_tmp1_));
2475 #line 431 "MediaEngine.vala"
2476                         break;
2477 #line 2478 "MediaEngine.c"
2478                 }
2479                 case MODEL_PARAMETER_VOLUME:
2480                 {
2481                         GValue _tmp3_;
2482                         GValue _tmp2_ = {0};
2483 #line 433 "MediaEngine.vala"
2484                         g_object_set_property (G_OBJECT (self->priv->volume), "volume", (_tmp3_ = (g_value_init (&_tmp2_, G_TYPE_DOUBLE), g_value_set_double (&_tmp2_, new_value), _tmp2_), &_tmp3_));
2485 #line 434 "MediaEngine.vala"
2486                         break;
2487 #line 2488 "MediaEngine.c"
2488                 }
2489         }
2490 }
2491
2492
2493 #line 438 "MediaEngine.vala"
2494 static void view_media_audio_track_on_level_changed (ViewMediaAudioTrack* self, GstObject* source, double level_left, double level_right) {
2495 #line 438 "MediaEngine.vala"
2496         g_return_if_fail (VIEW_IS_MEDIA_AUDIO_TRACK (self));
2497 #line 438 "MediaEngine.vala"
2498         g_return_if_fail (GST_IS_OBJECT (source));
2499 #line 439 "MediaEngine.vala"
2500         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_level_changed");
2501 #line 440 "MediaEngine.vala"
2502         if (source == GST_OBJECT (self->priv->level)) {
2503 #line 441 "MediaEngine.vala"
2504                 g_signal_emit_by_name (self, "level-changed", level_left, level_right);
2505 #line 2506 "MediaEngine.c"
2506         }
2507 }
2508
2509
2510 #line 445 "MediaEngine.vala"
2511 static GstElement* view_media_audio_track_real_empty_element (ViewMediaTrack* base, GError** error) {
2512 #line 2513 "MediaEngine.c"
2513         ViewMediaAudioTrack * self;
2514         GstElement* result = NULL;
2515         GError * _inner_error_;
2516         GstElement* _tmp0_;
2517         self = VIEW_MEDIA_AUDIO_TRACK (base);
2518         _inner_error_ = NULL;
2519 #line 446 "MediaEngine.vala"
2520         _tmp0_ = view_media_engine_get_audio_silence (VIEW_MEDIA_TRACK (self)->media_engine, &_inner_error_);
2521 #line 2522 "MediaEngine.c"
2522         if (_inner_error_ != NULL) {
2523                 g_propagate_error (error, _inner_error_);
2524                 return NULL;
2525         }
2526         result = _tmp0_;
2527 #line 446 "MediaEngine.vala"
2528         return result;
2529 #line 2530 "MediaEngine.c"
2530 }
2531
2532
2533 #line 449 "MediaEngine.vala"
2534 static void view_media_audio_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) {
2535 #line 2536 "MediaEngine.c"
2536         ViewMediaAudioTrack * self;
2537         GstBin* bin;
2538         GstPad* volume_pad;
2539         GstPad* _tmp0_;
2540         self = VIEW_MEDIA_AUDIO_TRACK (base);
2541 #line 449 "MediaEngine.vala"
2542         g_return_if_fail (GST_IS_PAD (pad));
2543 #line 449 "MediaEngine.vala"
2544         g_return_if_fail (GST_IS_ELEMENT (track_element));
2545 #line 450 "MediaEngine.vala"
2546         bin = _gst_object_ref0 (GST_BIN (gst_pad_get_parent_element (pad)));
2547 #line 451 "MediaEngine.vala"
2548         if (!gst_element_link_many (GST_ELEMENT (bin), self->priv->audio_convert, self->priv->audio_resample, self->priv->level, self->priv->pan, self->priv->volume, NULL)) {
2549 #line 452 "MediaEngine.vala"
2550                 fprintf (stderr, "could not link_new_pad for audio track");
2551 #line 2552 "MediaEngine.c"
2552         }
2553 #line 455 "MediaEngine.vala"
2554         volume_pad = gst_element_get_pad (self->priv->volume, "src");
2555 #line 456 "MediaEngine.vala"
2556         self->priv->adder_pad = (_tmp0_ = _gst_object_ref0 (GST_ELEMENT_GET_CLASS (track_element)->request_new_pad (track_element, gst_element_get_compatible_pad_template (track_element, gst_pad_get_pad_template (volume_pad)), NULL)), _gst_object_unref0 (self->priv->adder_pad), _tmp0_);
2557 #line 459 "MediaEngine.vala"
2558         if (gst_pad_link (volume_pad, self->priv->adder_pad) != GST_PAD_LINK_OK) {
2559 #line 460 "MediaEngine.vala"
2560                 g_error ("MediaEngine.vala:460: could not link to adder %s->%s\n", gst_object_get_name (GST_OBJECT (self->priv->volume)), gst_object_get_name (GST_OBJECT (track_element)));
2561 #line 2562 "MediaEngine.c"
2562         }
2563         _gst_object_unref0 (bin);
2564         _gst_object_unref0 (volume_pad);
2565 }
2566
2567
2568 #line 464 "MediaEngine.vala"
2569 static void view_media_audio_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) {
2570 #line 2571 "MediaEngine.c"
2571         ViewMediaAudioTrack * self;
2572         GstBin* bin;
2573         self = VIEW_MEDIA_AUDIO_TRACK (base);
2574 #line 464 "MediaEngine.vala"
2575         g_return_if_fail (GST_IS_PAD (pad));
2576 #line 464 "MediaEngine.vala"
2577         g_return_if_fail (GST_IS_ELEMENT (track_element));
2578 #line 465 "MediaEngine.vala"
2579         bin = _gst_object_ref0 (GST_BIN (gst_pad_get_parent_element (pad)));
2580 #line 466 "MediaEngine.vala"
2581         gst_element_unlink_many (GST_ELEMENT (bin), self->priv->audio_convert, self->priv->audio_resample, self->priv->level, self->priv->pan, self->priv->volume, track_element, NULL);
2582 #line 467 "MediaEngine.vala"
2583         gst_element_release_request_pad (track_element, self->priv->adder_pad);
2584 #line 2585 "MediaEngine.c"
2585         _gst_object_unref0 (bin);
2586 }
2587
2588
2589 #line 470 "MediaEngine.vala"
2590 static GstElement* view_media_audio_track_real_get_element (ViewMediaTrack* base) {
2591 #line 2592 "MediaEngine.c"
2592         ViewMediaAudioTrack * self;
2593         GstElement* result = NULL;
2594         self = VIEW_MEDIA_AUDIO_TRACK (base);
2595         result = _gst_object_ref0 (VIEW_MEDIA_TRACK (self)->media_engine->adder);
2596 #line 471 "MediaEngine.vala"
2597         return result;
2598 #line 2599 "MediaEngine.c"
2599 }
2600
2601
2602 static void view_media_audio_track_class_init (ViewMediaAudioTrackClass * klass) {
2603         view_media_audio_track_parent_class = g_type_class_peek_parent (klass);
2604         g_type_class_add_private (klass, sizeof (ViewMediaAudioTrackPrivate));
2605         VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_audio_track_real_empty_element;
2606         VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_audio_track_real_link_new_pad;
2607         VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_audio_track_real_unlink_pad;
2608         VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_audio_track_real_get_element;
2609         G_OBJECT_CLASS (klass)->finalize = view_media_audio_track_finalize;
2610         g_signal_new ("level_changed", VIEW_TYPE_MEDIA_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE, G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
2611 }
2612
2613
2614 static void view_media_audio_track_instance_init (ViewMediaAudioTrack * self) {
2615         self->priv = VIEW_MEDIA_AUDIO_TRACK_GET_PRIVATE (self);
2616 }
2617
2618
2619 static void view_media_audio_track_finalize (GObject* obj) {
2620         ViewMediaAudioTrack * self;
2621         self = VIEW_MEDIA_AUDIO_TRACK (obj);
2622         {
2623                 guint _tmp5_;
2624 #line 420 "MediaEngine.vala"
2625                 g_signal_parse_name ("level-changed", VIEW_TYPE_MEDIA_ENGINE, &_tmp5_, NULL, FALSE);
2626 #line 420 "MediaEngine.vala"
2627                 g_signal_handlers_disconnect_matched (VIEW_MEDIA_TRACK (self)->media_engine, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp5_, 0, NULL, (GCallback) _view_media_audio_track_on_level_changed_view_media_engine_level_changed, self);
2628 #line 421 "MediaEngine.vala"
2629                 gst_bin_remove_many (GST_BIN (VIEW_MEDIA_TRACK (self)->media_engine->pipeline), self->priv->audio_convert, self->priv->audio_resample, self->priv->pan, self->priv->volume, self->priv->level, NULL);
2630 #line 2631 "MediaEngine.c"
2631         }
2632         _gst_object_unref0 (self->priv->audio_convert);
2633         _gst_object_unref0 (self->priv->audio_resample);
2634         _gst_object_unref0 (self->priv->level);
2635         _gst_object_unref0 (self->priv->pan);
2636         _gst_object_unref0 (self->priv->volume);
2637         _gst_object_unref0 (self->priv->adder_pad);
2638         G_OBJECT_CLASS (view_media_audio_track_parent_class)->finalize (obj);
2639 }
2640
2641
2642 GType view_media_audio_track_get_type (void) {
2643         static volatile gsize view_media_audio_track_type_id__volatile = 0;
2644         if (g_once_init_enter (&view_media_audio_track_type_id__volatile)) {
2645                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaAudioTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_audio_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaAudioTrack), 0, (GInstanceInitFunc) view_media_audio_track_instance_init, NULL };
2646                 GType view_media_audio_track_type_id;
2647                 view_media_audio_track_type_id = g_type_register_static (VIEW_TYPE_MEDIA_TRACK, "ViewMediaAudioTrack", &g_define_type_info, 0);
2648                 g_once_init_leave (&view_media_audio_track_type_id__volatile, view_media_audio_track_type_id);
2649         }
2650         return view_media_audio_track_type_id__volatile;
2651 }
2652
2653
2654 GType view_media_connector_media_types_get_type (void) {
2655         static volatile gsize view_media_connector_media_types_type_id__volatile = 0;
2656         if (g_once_init_enter (&view_media_connector_media_types_type_id__volatile)) {
2657                 static const GEnumValue values[] = {{VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio, "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio", "audio"}, {VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video, "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video", "video"}, {0, NULL, NULL}};
2658                 GType view_media_connector_media_types_type_id;
2659                 view_media_connector_media_types_type_id = g_enum_register_static ("ViewMediaConnectorMediaTypes", values);
2660                 g_once_init_leave (&view_media_connector_media_types_type_id__volatile, view_media_connector_media_types_type_id);
2661         }
2662         return view_media_connector_media_types_type_id__volatile;
2663 }
2664
2665
2666 #line 483 "MediaEngine.vala"
2667 ViewMediaConnector* view_media_connector_construct (GType object_type, ViewMediaConnectorMediaTypes media_types) {
2668 #line 2669 "MediaEngine.c"
2669         ViewMediaConnector * self;
2670 #line 483 "MediaEngine.vala"
2671         self = (ViewMediaConnector*) g_object_new (object_type, NULL);
2672 #line 484 "MediaEngine.vala"
2673         self->priv->media_types = media_types;
2674 #line 2675 "MediaEngine.c"
2675         return self;
2676 }
2677
2678
2679 #line 487 "MediaEngine.vala"
2680 gboolean view_media_connector_has_audio (ViewMediaConnector* self) {
2681 #line 2682 "MediaEngine.c"
2682         gboolean result = FALSE;
2683 #line 487 "MediaEngine.vala"
2684         g_return_val_if_fail (VIEW_IS_MEDIA_CONNECTOR (self), FALSE);
2685 #line 2686 "MediaEngine.c"
2686         result = (self->priv->media_types & VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio) == VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio;
2687 #line 488 "MediaEngine.vala"
2688         return result;
2689 #line 2690 "MediaEngine.c"
2690 }
2691
2692
2693 #line 491 "MediaEngine.vala"
2694 gboolean view_media_connector_has_video (ViewMediaConnector* self) {
2695 #line 2696 "MediaEngine.c"
2696         gboolean result = FALSE;
2697 #line 491 "MediaEngine.vala"
2698         g_return_val_if_fail (VIEW_IS_MEDIA_CONNECTOR (self), FALSE);
2699 #line 2700 "MediaEngine.c"
2700         result = (self->priv->media_types & VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video) == VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video;
2701 #line 492 "MediaEngine.vala"
2702         return result;
2703 #line 2704 "MediaEngine.c"
2704 }
2705
2706
2707 #line 495 "MediaEngine.vala"
2708 static void view_media_connector_real_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2709 #line 2710 "MediaEngine.c"
2710         g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (self));
2711         g_critical ("Type `%s' does not implement abstract method `view_media_connector_connect'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
2712         return;
2713 }
2714
2715
2716 #line 495 "MediaEngine.vala"
2717 void view_media_connector_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2718 #line 495 "MediaEngine.vala"
2719         VIEW_MEDIA_CONNECTOR_GET_CLASS (self)->connect (self, media_engine, pipeline, elements, elements_length1);
2720 #line 2721 "MediaEngine.c"
2721 }
2722
2723
2724 #line 497 "MediaEngine.vala"
2725 static void view_media_connector_real_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2726 #line 2727 "MediaEngine.c"
2727         g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (self));
2728         g_critical ("Type `%s' does not implement abstract method `view_media_connector_do_disconnect'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
2729         return;
2730 }
2731
2732
2733 #line 497 "MediaEngine.vala"
2734 void view_media_connector_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2735 #line 497 "MediaEngine.vala"
2736         VIEW_MEDIA_CONNECTOR_GET_CLASS (self)->do_disconnect (self, media_engine, pipeline, elements, elements_length1);
2737 #line 2738 "MediaEngine.c"
2738 }
2739
2740
2741 static void view_media_connector_class_init (ViewMediaConnectorClass * klass) {
2742         view_media_connector_parent_class = g_type_class_peek_parent (klass);
2743         g_type_class_add_private (klass, sizeof (ViewMediaConnectorPrivate));
2744         VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_media_connector_real_connect;
2745         VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_media_connector_real_do_disconnect;
2746         G_OBJECT_CLASS (klass)->finalize = view_media_connector_finalize;
2747 }
2748
2749
2750 static void view_media_connector_instance_init (ViewMediaConnector * self) {
2751         self->priv = VIEW_MEDIA_CONNECTOR_GET_PRIVATE (self);
2752         self->AudioIndex = 0;
2753         self->VideoIndex = 1;
2754 }
2755
2756
2757 static void view_media_connector_finalize (GObject* obj) {
2758         ViewMediaConnector * self;
2759         self = VIEW_MEDIA_CONNECTOR (obj);
2760         G_OBJECT_CLASS (view_media_connector_parent_class)->finalize (obj);
2761 }
2762
2763
2764 GType view_media_connector_get_type (void) {
2765         static volatile gsize view_media_connector_type_id__volatile = 0;
2766         if (g_once_init_enter (&view_media_connector_type_id__volatile)) {
2767                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaConnectorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_connector_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaConnector), 0, (GInstanceInitFunc) view_media_connector_instance_init, NULL };
2768                 GType view_media_connector_type_id;
2769                 view_media_connector_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaConnector", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
2770                 g_once_init_leave (&view_media_connector_type_id__volatile, view_media_connector_type_id);
2771         }
2772         return view_media_connector_type_id__volatile;
2773 }
2774
2775
2776 static gpointer _g_object_ref0 (gpointer self) {
2777         return self ? g_object_ref (self) : NULL;
2778 }
2779
2780
2781 #line 505 "MediaEngine.vala"
2782 ViewVideoOutput* view_video_output_construct (GType object_type, GtkWidget* output_widget, GError** error) {
2783 #line 2784 "MediaEngine.c"
2784         GError * _inner_error_;
2785         ViewVideoOutput * self;
2786         GstElement* _tmp0_;
2787         GstElement* _tmp1_;
2788         GtkWidget* _tmp2_;
2789 #line 505 "MediaEngine.vala"
2790         g_return_val_if_fail (GTK_IS_WIDGET (output_widget), NULL);
2791 #line 2792 "MediaEngine.c"
2792         _inner_error_ = NULL;
2793 #line 506 "MediaEngine.vala"
2794         self = (ViewVideoOutput*) view_media_connector_construct (object_type, VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video);
2795 #line 507 "MediaEngine.vala"
2796         _tmp0_ = make_element ("xvimagesink", &_inner_error_);
2797 #line 2798 "MediaEngine.c"
2798         if (_inner_error_ != NULL) {
2799                 g_propagate_error (error, _inner_error_);
2800                 g_object_unref (self);
2801                 return NULL;
2802         }
2803 #line 507 "MediaEngine.vala"
2804         self->priv->sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->sink), _tmp1_);
2805 #line 508 "MediaEngine.vala"
2806         g_object_set (G_OBJECT (self->priv->sink), "force-aspect-ratio", TRUE, NULL);
2807 #line 509 "MediaEngine.vala"
2808         self->priv->output_widget = (_tmp2_ = _g_object_ref0 (output_widget), _g_object_unref0 (self->priv->output_widget), _tmp2_);
2809 #line 2810 "MediaEngine.c"
2810         return self;
2811 }
2812
2813
2814 #line 505 "MediaEngine.vala"
2815 ViewVideoOutput* view_video_output_new (GtkWidget* output_widget, GError** error) {
2816 #line 505 "MediaEngine.vala"
2817         return view_video_output_construct (VIEW_TYPE_VIDEO_OUTPUT, output_widget, error);
2818 #line 2819 "MediaEngine.c"
2819 }
2820
2821
2822 #line 512 "MediaEngine.vala"
2823 static void view_video_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2824 #line 2825 "MediaEngine.c"
2825         ViewVideoOutput * self;
2826         XID xid;
2827         GstXOverlay* overlay;
2828         self = VIEW_VIDEO_OUTPUT (base);
2829 #line 512 "MediaEngine.vala"
2830         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
2831 #line 512 "MediaEngine.vala"
2832         g_return_if_fail (GST_IS_PIPELINE (pipeline));
2833 #line 514 "MediaEngine.vala"
2834         logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, "connecting");
2835 #line 516 "MediaEngine.vala"
2836         xid = gdk_x11_drawable_get_xid (GDK_DRAWABLE (self->priv->output_widget->window));
2837 #line 517 "MediaEngine.vala"
2838         overlay = _gst_object_ref0 (GST_X_OVERLAY (self->priv->sink));
2839 #line 518 "MediaEngine.vala"
2840         gst_x_overlay_set_xwindow_id (overlay, (gulong) xid);
2841 #line 522 "MediaEngine.vala"
2842         GTK_WIDGET_UNSET_FLAGS (self->priv->output_widget, GTK_DOUBLE_BUFFERED);
2843 #line 524 "MediaEngine.vala"
2844         if (!gst_bin_add (GST_BIN (pipeline), _gst_object_ref0 (self->priv->sink))) {
2845 #line 525 "MediaEngine.vala"
2846                 g_error ("MediaEngine.vala:525: could not add sink");
2847 #line 2848 "MediaEngine.c"
2848         }
2849 #line 527 "MediaEngine.vala"
2850         if (!gst_element_link (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->sink)) {
2851 #line 528 "MediaEngine.vala"
2852                 g_error ("MediaEngine.vala:528: can't link converter with video sink!");
2853 #line 2854 "MediaEngine.c"
2854         }
2855         _gst_object_unref0 (overlay);
2856 }
2857
2858
2859 #line 532 "MediaEngine.vala"
2860 static void view_video_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2861 #line 2862 "MediaEngine.c"
2862         ViewVideoOutput * self;
2863         self = VIEW_VIDEO_OUTPUT (base);
2864 #line 532 "MediaEngine.vala"
2865         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
2866 #line 532 "MediaEngine.vala"
2867         g_return_if_fail (GST_IS_PIPELINE (pipeline));
2868 #line 534 "MediaEngine.vala"
2869         logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, "disconnecting");
2870 #line 535 "MediaEngine.vala"
2871         gst_element_unlink (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->sink);
2872 #line 536 "MediaEngine.vala"
2873         gst_bin_remove (GST_BIN (pipeline), self->priv->sink);
2874 #line 2875 "MediaEngine.c"
2875 }
2876
2877
2878 static void view_video_output_class_init (ViewVideoOutputClass * klass) {
2879         view_video_output_parent_class = g_type_class_peek_parent (klass);
2880         g_type_class_add_private (klass, sizeof (ViewVideoOutputPrivate));
2881         VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_video_output_real_connect;
2882         VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_video_output_real_do_disconnect;
2883         G_OBJECT_CLASS (klass)->finalize = view_video_output_finalize;
2884 }
2885
2886
2887 static void view_video_output_instance_init (ViewVideoOutput * self) {
2888         self->priv = VIEW_VIDEO_OUTPUT_GET_PRIVATE (self);
2889 }
2890
2891
2892 static void view_video_output_finalize (GObject* obj) {
2893         ViewVideoOutput * self;
2894         self = VIEW_VIDEO_OUTPUT (obj);
2895         _gst_object_unref0 (self->priv->sink);
2896         _g_object_unref0 (self->priv->output_widget);
2897         G_OBJECT_CLASS (view_video_output_parent_class)->finalize (obj);
2898 }
2899
2900
2901 GType view_video_output_get_type (void) {
2902         static volatile gsize view_video_output_type_id__volatile = 0;
2903         if (g_once_init_enter (&view_video_output_type_id__volatile)) {
2904                 static const GTypeInfo g_define_type_info = { sizeof (ViewVideoOutputClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_video_output_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewVideoOutput), 0, (GInstanceInitFunc) view_video_output_instance_init, NULL };
2905                 GType view_video_output_type_id;
2906                 view_video_output_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewVideoOutput", &g_define_type_info, 0);
2907                 g_once_init_leave (&view_video_output_type_id__volatile, view_video_output_type_id);
2908         }
2909         return view_video_output_type_id__volatile;
2910 }
2911
2912
2913 #line 544 "MediaEngine.vala"
2914 ViewAudioOutput* view_audio_output_construct (GType object_type, GstCaps* caps, GError** error) {
2915 #line 2916 "MediaEngine.c"
2916         GError * _inner_error_;
2917         ViewAudioOutput * self;
2918         GstElement* _tmp0_;
2919         GstElement* _tmp1_;
2920         GstElement* _tmp2_;
2921         GstElement* _tmp3_;
2922 #line 544 "MediaEngine.vala"
2923         g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
2924 #line 2925 "MediaEngine.c"
2925         _inner_error_ = NULL;
2926 #line 545 "MediaEngine.vala"
2927         self = (ViewAudioOutput*) view_media_connector_construct (object_type, VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio);
2928 #line 546 "MediaEngine.vala"
2929         _tmp0_ = make_element ("autoaudiosink", &_inner_error_);
2930 #line 2931 "MediaEngine.c"
2931         if (_inner_error_ != NULL) {
2932                 g_propagate_error (error, _inner_error_);
2933                 g_object_unref (self);
2934                 return NULL;
2935         }
2936 #line 546 "MediaEngine.vala"
2937         self->priv->audio_sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_sink), _tmp1_);
2938 #line 547 "MediaEngine.vala"
2939         _tmp2_ = make_element ("capsfilter", &_inner_error_);
2940 #line 2941 "MediaEngine.c"
2941         if (_inner_error_ != NULL) {
2942                 g_propagate_error (error, _inner_error_);
2943                 g_object_unref (self);
2944                 return NULL;
2945         }
2946 #line 547 "MediaEngine.vala"
2947         self->priv->capsfilter = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->capsfilter), _tmp3_);
2948 #line 548 "MediaEngine.vala"
2949         g_object_set (G_OBJECT (self->priv->capsfilter), "caps", caps, NULL);
2950 #line 2951 "MediaEngine.c"
2951         return self;
2952 }
2953
2954
2955 #line 544 "MediaEngine.vala"
2956 ViewAudioOutput* view_audio_output_new (GstCaps* caps, GError** error) {
2957 #line 544 "MediaEngine.vala"
2958         return view_audio_output_construct (VIEW_TYPE_AUDIO_OUTPUT, caps, error);
2959 #line 2960 "MediaEngine.c"
2960 }
2961
2962
2963 #line 551 "MediaEngine.vala"
2964 static void view_audio_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2965 #line 2966 "MediaEngine.c"
2966         ViewAudioOutput * self;
2967         self = VIEW_AUDIO_OUTPUT (base);
2968 #line 551 "MediaEngine.vala"
2969         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
2970 #line 551 "MediaEngine.vala"
2971         g_return_if_fail (GST_IS_PIPELINE (pipeline));
2972 #line 553 "MediaEngine.vala"
2973         gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->capsfilter), _gst_object_ref0 (self->priv->audio_sink), NULL);
2974 #line 555 "MediaEngine.vala"
2975         if (!gst_element_link_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->audio_sink, NULL)) {
2976 #line 556 "MediaEngine.vala"
2977                 g_warning ("MediaEngine.vala:556: could not link audio_sink");
2978 #line 2979 "MediaEngine.c"
2979         }
2980 }
2981
2982
2983 #line 560 "MediaEngine.vala"
2984 static void view_audio_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
2985 #line 2986 "MediaEngine.c"
2986         ViewAudioOutput * self;
2987         self = VIEW_AUDIO_OUTPUT (base);
2988 #line 560 "MediaEngine.vala"
2989         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
2990 #line 560 "MediaEngine.vala"
2991         g_return_if_fail (GST_IS_PIPELINE (pipeline));
2992 #line 562 "MediaEngine.vala"
2993         gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->audio_sink, NULL);
2994 #line 563 "MediaEngine.vala"
2995         gst_bin_remove_many (GST_BIN (pipeline), self->priv->capsfilter, self->priv->audio_sink, NULL);
2996 #line 2997 "MediaEngine.c"
2997 }
2998
2999
3000 static void view_audio_output_class_init (ViewAudioOutputClass * klass) {
3001         view_audio_output_parent_class = g_type_class_peek_parent (klass);
3002         g_type_class_add_private (klass, sizeof (ViewAudioOutputPrivate));
3003         VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_audio_output_real_connect;
3004         VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_audio_output_real_do_disconnect;
3005         G_OBJECT_CLASS (klass)->finalize = view_audio_output_finalize;
3006 }
3007
3008
3009 static void view_audio_output_instance_init (ViewAudioOutput * self) {
3010         self->priv = VIEW_AUDIO_OUTPUT_GET_PRIVATE (self);
3011 }
3012
3013
3014 static void view_audio_output_finalize (GObject* obj) {
3015         ViewAudioOutput * self;
3016         self = VIEW_AUDIO_OUTPUT (obj);
3017         _gst_object_unref0 (self->priv->audio_sink);
3018         _gst_object_unref0 (self->priv->capsfilter);
3019         G_OBJECT_CLASS (view_audio_output_parent_class)->finalize (obj);
3020 }
3021
3022
3023 GType view_audio_output_get_type (void) {
3024         static volatile gsize view_audio_output_type_id__volatile = 0;
3025         if (g_once_init_enter (&view_audio_output_type_id__volatile)) {
3026                 static const GTypeInfo g_define_type_info = { sizeof (ViewAudioOutputClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_audio_output_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewAudioOutput), 0, (GInstanceInitFunc) view_audio_output_instance_init, NULL };
3027                 GType view_audio_output_type_id;
3028                 view_audio_output_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewAudioOutput", &g_define_type_info, 0);
3029                 g_once_init_leave (&view_audio_output_type_id__volatile, view_audio_output_type_id);
3030         }
3031         return view_audio_output_type_id__volatile;
3032 }
3033
3034
3035 #line 574 "MediaEngine.vala"
3036 ViewOggVorbisExport* view_ogg_vorbis_export_construct (GType object_type, ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error) {
3037 #line 3038 "MediaEngine.c"
3038         GError * _inner_error_;
3039         ViewOggVorbisExport * self;
3040         GstElement* _tmp0_;
3041         GstElement* _tmp1_;
3042         GstElement* _tmp2_;
3043         GstElement* _tmp3_;
3044 #line 574 "MediaEngine.vala"
3045         g_return_val_if_fail (filename != NULL, NULL);
3046 #line 574 "MediaEngine.vala"
3047         g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
3048 #line 3049 "MediaEngine.c"
3049         _inner_error_ = NULL;
3050 #line 576 "MediaEngine.vala"
3051         self = (ViewOggVorbisExport*) view_media_connector_construct (object_type, media_types);
3052 #line 578 "MediaEngine.vala"
3053         _tmp0_ = make_element ("filesink", &_inner_error_);
3054 #line 3055 "MediaEngine.c"
3055         if (_inner_error_ != NULL) {
3056                 g_propagate_error (error, _inner_error_);
3057                 g_object_unref (self);
3058                 return NULL;
3059         }
3060 #line 578 "MediaEngine.vala"
3061         self->priv->file_sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->file_sink), _tmp1_);
3062 #line 579 "MediaEngine.vala"
3063         g_object_set (G_OBJECT (self->priv->file_sink), "location", filename, NULL);
3064 #line 580 "MediaEngine.vala"
3065         _tmp2_ = make_element ("oggmux", &_inner_error_);
3066 #line 3067 "MediaEngine.c"
3067         if (_inner_error_ != NULL) {
3068                 g_propagate_error (error, _inner_error_);
3069                 g_object_unref (self);
3070                 return NULL;
3071         }
3072 #line 580 "MediaEngine.vala"
3073         self->priv->mux = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->mux), _tmp3_);
3074 #line 582 "MediaEngine.vala"
3075         if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) {
3076 #line 3077 "MediaEngine.c"
3077                 GstElement* _tmp4_;
3078                 GstElement* _tmp5_;
3079                 GstElement* _tmp6_;
3080                 GstElement* _tmp7_;
3081 #line 583 "MediaEngine.vala"
3082                 _tmp4_ = make_element ("capsfilter", &_inner_error_);
3083 #line 3084 "MediaEngine.c"
3084                 if (_inner_error_ != NULL) {
3085                         g_propagate_error (error, _inner_error_);
3086                         g_object_unref (self);
3087                         return NULL;
3088                 }
3089 #line 583 "MediaEngine.vala"
3090                 self->priv->capsfilter = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->capsfilter), _tmp5_);
3091 #line 584 "MediaEngine.vala"
3092                 g_object_set (G_OBJECT (self->priv->capsfilter), "caps", caps, NULL);
3093 #line 585 "MediaEngine.vala"
3094                 _tmp6_ = make_element ("vorbisenc", &_inner_error_);
3095 #line 3096 "MediaEngine.c"
3096                 if (_inner_error_ != NULL) {
3097                         g_propagate_error (error, _inner_error_);
3098                         g_object_unref (self);
3099                         return NULL;
3100                 }
3101 #line 585 "MediaEngine.vala"
3102                 self->priv->export_sink = (_tmp7_ = _tmp6_, _gst_object_unref0 (self->priv->export_sink), _tmp7_);
3103 #line 3104 "MediaEngine.c"
3104         }
3105 #line 588 "MediaEngine.vala"
3106         if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) {
3107 #line 3108 "MediaEngine.c"
3108                 GstElement* _tmp8_;
3109                 GstElement* _tmp9_;
3110 #line 589 "MediaEngine.vala"
3111                 _tmp8_ = make_element ("theoraenc", &_inner_error_);
3112 #line 3113 "MediaEngine.c"
3113                 if (_inner_error_ != NULL) {
3114                         g_propagate_error (error, _inner_error_);
3115                         g_object_unref (self);
3116                         return NULL;
3117                 }
3118 #line 589 "MediaEngine.vala"
3119                 self->priv->video_export_sink = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->video_export_sink), _tmp9_);
3120 #line 3121 "MediaEngine.c"
3121         }
3122         return self;
3123 }
3124
3125
3126 #line 574 "MediaEngine.vala"
3127 ViewOggVorbisExport* view_ogg_vorbis_export_new (ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error) {
3128 #line 574 "MediaEngine.vala"
3129         return view_ogg_vorbis_export_construct (VIEW_TYPE_OGG_VORBIS_EXPORT, media_types, filename, caps, error);
3130 #line 3131 "MediaEngine.c"
3131 }
3132
3133
3134 #line 593 "MediaEngine.vala"
3135 char* view_ogg_vorbis_export_get_filename (ViewOggVorbisExport* self) {
3136 #line 3137 "MediaEngine.c"
3137         char* result = NULL;
3138         char* filename;
3139 #line 593 "MediaEngine.vala"
3140         g_return_val_if_fail (VIEW_IS_OGG_VORBIS_EXPORT (self), NULL);
3141 #line 3142 "MediaEngine.c"
3142         filename = NULL;
3143 #line 595 "MediaEngine.vala"
3144         g_object_get (G_OBJECT (self->priv->file_sink), "location", &filename, NULL);
3145 #line 3146 "MediaEngine.c"
3146         result = filename;
3147 #line 596 "MediaEngine.vala"
3148         return result;
3149 #line 3150 "MediaEngine.c"
3150 }
3151
3152
3153 #line 599 "MediaEngine.vala"
3154 static void view_ogg_vorbis_export_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
3155 #line 3156 "MediaEngine.c"
3156         ViewOggVorbisExport * self;
3157         self = VIEW_OGG_VORBIS_EXPORT (base);
3158 #line 599 "MediaEngine.vala"
3159         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
3160 #line 599 "MediaEngine.vala"
3161         g_return_if_fail (GST_IS_PIPELINE (pipeline));
3162 #line 601 "MediaEngine.vala"
3163         gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->mux), _gst_object_ref0 (self->priv->file_sink), NULL);
3164 #line 602 "MediaEngine.vala"
3165         gst_element_link (self->priv->mux, self->priv->file_sink);
3166 #line 604 "MediaEngine.vala"
3167         if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) {
3168 #line 605 "MediaEngine.vala"
3169                 gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->capsfilter), _gst_object_ref0 (self->priv->export_sink), NULL);
3170 #line 606 "MediaEngine.vala"
3171                 gst_element_link_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->export_sink, self->priv->mux, NULL);
3172 #line 3173 "MediaEngine.c"
3173         }
3174 #line 609 "MediaEngine.vala"
3175         if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) {
3176 #line 610 "MediaEngine.vala"
3177                 gst_bin_add (GST_BIN (pipeline), _gst_object_ref0 (self->priv->video_export_sink));
3178 #line 612 "MediaEngine.vala"
3179                 if (!gst_element_link (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->video_export_sink)) {
3180 #line 613 "MediaEngine.vala"
3181                         g_error ("MediaEngine.vala:613: could not link converter to video_export_sink");
3182 #line 3183 "MediaEngine.c"
3183                 }
3184 #line 616 "MediaEngine.vala"
3185                 if (!gst_element_link (self->priv->video_export_sink, self->priv->mux)) {
3186 #line 617 "MediaEngine.vala"
3187                         g_error ("MediaEngine.vala:617: could not link video_export with mux");
3188 #line 3189 "MediaEngine.c"
3189                 }
3190         }
3191 }
3192
3193
3194 #line 622 "MediaEngine.vala"
3195 static void view_ogg_vorbis_export_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) {
3196 #line 3197 "MediaEngine.c"
3197         ViewOggVorbisExport * self;
3198         self = VIEW_OGG_VORBIS_EXPORT (base);
3199 #line 622 "MediaEngine.vala"
3200         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine));
3201 #line 622 "MediaEngine.vala"
3202         g_return_if_fail (GST_IS_PIPELINE (pipeline));
3203 #line 624 "MediaEngine.vala"
3204         if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) {
3205 #line 625 "MediaEngine.vala"
3206                 gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->export_sink, self->priv->mux, NULL);
3207 #line 626 "MediaEngine.vala"
3208                 gst_bin_remove_many (GST_BIN (pipeline), self->priv->capsfilter, self->priv->export_sink, NULL);
3209 #line 3210 "MediaEngine.c"
3210         }
3211 #line 629 "MediaEngine.vala"
3212         if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) {
3213 #line 630 "MediaEngine.vala"
3214                 gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->video_export_sink, self->priv->mux, NULL);
3215 #line 631 "MediaEngine.vala"
3216                 gst_bin_remove (GST_BIN (pipeline), self->priv->video_export_sink);
3217 #line 3218 "MediaEngine.c"
3218         }
3219 #line 634 "MediaEngine.vala"
3220         gst_element_unlink (self->priv->mux, self->priv->file_sink);
3221 #line 635 "MediaEngine.vala"
3222         gst_bin_remove_many (GST_BIN (pipeline), self->priv->mux, self->priv->file_sink, NULL);
3223 #line 3224 "MediaEngine.c"
3224 }
3225
3226
3227 static void view_ogg_vorbis_export_class_init (ViewOggVorbisExportClass * klass) {
3228         view_ogg_vorbis_export_parent_class = g_type_class_peek_parent (klass);
3229         g_type_class_add_private (klass, sizeof (ViewOggVorbisExportPrivate));
3230         VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_ogg_vorbis_export_real_connect;
3231         VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_ogg_vorbis_export_real_do_disconnect;
3232         G_OBJECT_CLASS (klass)->finalize = view_ogg_vorbis_export_finalize;
3233 }
3234
3235
3236 static void view_ogg_vorbis_export_instance_init (ViewOggVorbisExport * self) {
3237         self->priv = VIEW_OGG_VORBIS_EXPORT_GET_PRIVATE (self);
3238 }
3239
3240
3241 static void view_ogg_vorbis_export_finalize (GObject* obj) {
3242         ViewOggVorbisExport * self;
3243         self = VIEW_OGG_VORBIS_EXPORT (obj);
3244         _gst_object_unref0 (self->priv->capsfilter);
3245         _gst_object_unref0 (self->priv->export_sink);
3246         _gst_object_unref0 (self->priv->mux);
3247         _gst_object_unref0 (self->priv->file_sink);
3248         _gst_object_unref0 (self->priv->video_export_sink);
3249         G_OBJECT_CLASS (view_ogg_vorbis_export_parent_class)->finalize (obj);
3250 }
3251
3252
3253 GType view_ogg_vorbis_export_get_type (void) {
3254         static volatile gsize view_ogg_vorbis_export_type_id__volatile = 0;
3255         if (g_once_init_enter (&view_ogg_vorbis_export_type_id__volatile)) {
3256                 static const GTypeInfo g_define_type_info = { sizeof (ViewOggVorbisExportClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_ogg_vorbis_export_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewOggVorbisExport), 0, (GInstanceInitFunc) view_ogg_vorbis_export_instance_init, NULL };
3257                 GType view_ogg_vorbis_export_type_id;
3258                 view_ogg_vorbis_export_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewOggVorbisExport", &g_define_type_info, 0);
3259                 g_once_init_leave (&view_ogg_vorbis_export_type_id__volatile, view_ogg_vorbis_export_type_id);
3260         }
3261         return view_ogg_vorbis_export_type_id__volatile;
3262 }
3263
3264
3265 #line 397 "project.vala"
3266 static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) {
3267 #line 3268 "MediaEngine.c"
3268         model_project_on_playstate_changed (self);
3269 }
3270
3271
3272 #line 799 "MediaEngine.vala"
3273 static void _view_media_engine_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
3274 #line 3275 "MediaEngine.c"
3275         view_media_engine_on_error (self, _sender, message);
3276 }
3277
3278
3279 #line 791 "MediaEngine.vala"
3280 static void _view_media_engine_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
3281 #line 3282 "MediaEngine.c"
3282         view_media_engine_on_warning (self, _sender, message);
3283 }
3284
3285
3286 #line 808 "MediaEngine.vala"
3287 static void _view_media_engine_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
3288 #line 3289 "MediaEngine.c"
3289         view_media_engine_on_eos (self, _sender, message);
3290 }
3291
3292
3293 #line 833 "MediaEngine.vala"
3294 static void _view_media_engine_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
3295 #line 3296 "MediaEngine.c"
3296         view_media_engine_on_state_change (self, _sender, message);
3297 }
3298
3299
3300 #line 814 "MediaEngine.vala"
3301 static void _view_media_engine_on_element_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
3302 #line 3303 "MediaEngine.c"
3303         view_media_engine_on_element (self, _sender, message);
3304 }
3305
3306
3307 #line 680 "MediaEngine.vala"
3308 ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error) {
3309 #line 3310 "MediaEngine.c"
3310         GError * _inner_error_;
3311         ViewMediaEngine * self;
3312         GeeArrayList* _tmp0_;
3313         GstPipeline* _tmp1_;
3314         GstElement* silence;
3315         GstElement* _tmp4_;
3316         GstElement* _tmp5_;
3317         GstElement* audio_convert;
3318         GstBus* bus;
3319 #line 680 "MediaEngine.vala"
3320         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
3321 #line 3322 "MediaEngine.c"
3322         _inner_error_ = NULL;
3323 #line 680 "MediaEngine.vala"
3324         self = (ViewMediaEngine*) g_object_new (object_type, NULL);
3325 #line 681 "MediaEngine.vala"
3326         self->priv->tracks = (_tmp0_ = gee_array_list_new (VIEW_TYPE_MEDIA_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->tracks), _tmp0_);
3327 #line 682 "MediaEngine.vala"
3328         self->priv->project = project;
3329 #line 683 "MediaEngine.vala"
3330         g_signal_connect_object (self, "playstate-changed", (GCallback) _model_project_on_playstate_changed_view_media_engine_playstate_changed, project, 0);
3331 #line 684 "MediaEngine.vala"
3332         self->pipeline = (_tmp1_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 (self->pipeline), _tmp1_);
3333 #line 685 "MediaEngine.vala"
3334         gst_pipeline_set_auto_flush_bus (self->pipeline, FALSE);
3335 #line 687 "MediaEngine.vala"
3336         if (include_video) {
3337 #line 3338 "MediaEngine.c"
3338                 GstElement* _tmp2_;
3339                 GstElement* _tmp3_;
3340 #line 688 "MediaEngine.vala"
3341                 _tmp2_ = make_element ("ffmpegcolorspace", &_inner_error_);
3342 #line 3343 "MediaEngine.c"
3343                 if (_inner_error_ != NULL) {
3344                         g_propagate_error (error, _inner_error_);
3345                         g_object_unref (self);
3346                         return NULL;
3347                 }
3348 #line 688 "MediaEngine.vala"
3349                 self->converter = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->converter), _tmp3_);
3350 #line 689 "MediaEngine.vala"
3351                 gst_bin_add (GST_BIN (self->pipeline), _gst_object_ref0 (self->converter));
3352 #line 3353 "MediaEngine.c"
3353         }
3354 #line 692 "MediaEngine.vala"
3355         silence = view_media_engine_get_audio_silence (self, &_inner_error_);
3356 #line 3357 "MediaEngine.c"
3357         if (_inner_error_ != NULL) {
3358                 g_propagate_error (error, _inner_error_);
3359                 g_object_unref (self);
3360                 return NULL;
3361         }
3362 #line 694 "MediaEngine.vala"
3363         _tmp4_ = make_element ("adder", &_inner_error_);
3364 #line 3365 "MediaEngine.c"
3365         if (_inner_error_ != NULL) {
3366                 g_propagate_error (error, _inner_error_);
3367                 _gst_object_unref0 (silence);
3368                 g_object_unref (self);
3369                 return NULL;
3370         }
3371 #line 694 "MediaEngine.vala"
3372         self->adder = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->adder), _tmp5_);
3373 #line 696 "MediaEngine.vala"
3374         audio_convert = make_element_with_name ("audioconvert", "projectconvert", &_inner_error_);
3375 #line 3376 "MediaEngine.c"
3376         if (_inner_error_ != NULL) {
3377                 g_propagate_error (error, _inner_error_);
3378                 _gst_object_unref0 (silence);
3379                 g_object_unref (self);
3380                 return NULL;
3381         }
3382 #line 697 "MediaEngine.vala"
3383         gst_bin_add_many (GST_BIN (self->pipeline), _gst_object_ref0 (silence), _gst_object_ref0 (audio_convert), _gst_object_ref0 (self->adder), NULL);
3384 #line 699 "MediaEngine.vala"
3385         if (!gst_element_link_many (silence, audio_convert, self->adder, NULL)) {
3386 #line 700 "MediaEngine.vala"
3387                 g_error ("MediaEngine.vala:700: silence: couldn't link");
3388 #line 3389 "MediaEngine.c"
3389         }
3390 #line 703 "MediaEngine.vala"
3391         bus = gst_pipeline_get_bus (self->pipeline);
3392 #line 705 "MediaEngine.vala"
3393         gst_bus_add_signal_watch (bus);
3394 #line 706 "MediaEngine.vala"
3395         g_signal_connect_object (bus, "message::error", (GCallback) _view_media_engine_on_error_gst_bus_message, self, 0);
3396 #line 707 "MediaEngine.vala"
3397         g_signal_connect_object (bus, "message::warning", (GCallback) _view_media_engine_on_warning_gst_bus_message, self, 0);
3398 #line 708 "MediaEngine.vala"
3399         g_signal_connect_object (bus, "message::eos", (GCallback) _view_media_engine_on_eos_gst_bus_message, self, 0);
3400 #line 709 "MediaEngine.vala"
3401         g_signal_connect_object (bus, "message::state-changed", (GCallback) _view_media_engine_on_state_change_gst_bus_message, self, 0);
3402 #line 710 "MediaEngine.vala"
3403         g_signal_connect_object (bus, "message::element", (GCallback) _view_media_engine_on_element_gst_bus_message, self, 0);
3404 #line 3405 "MediaEngine.c"
3405         _gst_object_unref0 (silence);
3406         _gst_object_unref0 (audio_convert);
3407         _gst_object_unref0 (bus);
3408         return self;
3409 }
3410
3411
3412 #line 680 "MediaEngine.vala"
3413 ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error) {
3414 #line 680 "MediaEngine.vala"
3415         return view_media_engine_construct (VIEW_TYPE_MEDIA_ENGINE, project, include_video, error);
3416 #line 3417 "MediaEngine.c"
3417 }
3418
3419
3420 #line 713 "MediaEngine.vala"
3421 void view_media_engine_can_run (GError** error) {
3422 #line 3423 "MediaEngine.c"
3423         GError * _inner_error_;
3424         GstRegistry* registry;
3425         _inner_error_ = NULL;
3426 #line 714 "MediaEngine.vala"
3427         registry = _gst_object_ref0 (gst_registry_get_default ());
3428 #line 715 "MediaEngine.vala"
3429         view_media_engine_check_version (registry, "adder", "gst-plugins-base", VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_BASE, &_inner_error_);
3430 #line 3431 "MediaEngine.c"
3431         if (_inner_error_ != NULL) {
3432                 g_propagate_error (error, _inner_error_);
3433                 _gst_object_unref0 (registry);
3434                 return;
3435         }
3436 #line 716 "MediaEngine.vala"
3437         view_media_engine_check_version (registry, "level", "gst-plugins-good", VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_GOOD, &_inner_error_);
3438 #line 3439 "MediaEngine.c"
3439         if (_inner_error_ != NULL) {
3440                 g_propagate_error (error, _inner_error_);
3441                 _gst_object_unref0 (registry);
3442                 return;
3443         }
3444 #line 717 "MediaEngine.vala"
3445         view_media_engine_check_version (registry, "gnonlin", "gnonlin", VIEW_MEDIA_ENGINE_MIN_GNONLIN, &_inner_error_);
3446 #line 3447 "MediaEngine.c"
3447         if (_inner_error_ != NULL) {
3448                 g_propagate_error (error, _inner_error_);
3449                 _gst_object_unref0 (registry);
3450                 return;
3451         }
3452         _gst_object_unref0 (registry);
3453 }
3454
3455
3456 #line 720 "MediaEngine.vala"
3457 static void view_media_engine_check_version (GstRegistry* registry, const char* plugin_name, const char* package_name, const char* min_version, GError** error) {
3458 #line 3459 "MediaEngine.c"
3459         GError * _inner_error_;
3460         GstPlugin* plugin;
3461         char* version;
3462 #line 720 "MediaEngine.vala"
3463         g_return_if_fail (GST_IS_REGISTRY (registry));
3464 #line 720 "MediaEngine.vala"
3465         g_return_if_fail (plugin_name != NULL);
3466 #line 720 "MediaEngine.vala"
3467         g_return_if_fail (package_name != NULL);
3468 #line 720 "MediaEngine.vala"
3469         g_return_if_fail (min_version != NULL);
3470 #line 3471 "MediaEngine.c"
3471         _inner_error_ = NULL;
3472 #line 722 "MediaEngine.vala"
3473         plugin = gst_registry_find_plugin (registry, plugin_name);
3474 #line 723 "MediaEngine.vala"
3475         if (plugin == NULL) {
3476 #line 3477 "MediaEngine.c"
3477                 char* _tmp0_;
3478                 GError* _tmp1_;
3479                 _inner_error_ = (_tmp1_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp0_ = g_strdup_printf ("You must install %s to use this program", package_name)), _g_free0 (_tmp0_), _tmp1_);
3480                 {
3481                         g_propagate_error (error, _inner_error_);
3482                         _gst_object_unref0 (plugin);
3483                         return;
3484                 }
3485         }
3486 #line 728 "MediaEngine.vala"
3487         version = g_strdup (gst_plugin_get_version (plugin));
3488 #line 729 "MediaEngine.vala"
3489         if (!version_at_least (version, min_version)) {
3490 #line 3491 "MediaEngine.c"
3491                 char* _tmp2_;
3492                 GError* _tmp3_;
3493                 _inner_error_ = (_tmp3_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp2_ = g_strdup_printf ("You have %s version %s, but this program requires at least version %s", package_name, version, min_version)), _g_free0 (_tmp2_), _tmp3_);
3494                 {
3495                         g_propagate_error (error, _inner_error_);
3496                         _gst_object_unref0 (plugin);
3497                         _g_free0 (version);
3498                         return;
3499                 }
3500         }
3501         _gst_object_unref0 (plugin);
3502         _g_free0 (version);
3503 }
3504
3505
3506 #line 736 "MediaEngine.vala"
3507 void view_media_engine_connect_output (ViewMediaEngine* self, ViewMediaConnector* connector) {
3508 #line 3509 "MediaEngine.c"
3509         gint _tmp1__length1;
3510         GstElement** _tmp1_;
3511         GstElement** _tmp0_ = NULL;
3512 #line 736 "MediaEngine.vala"
3513         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3514 #line 736 "MediaEngine.vala"
3515         g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (connector));
3516 #line 737 "MediaEngine.vala"
3517         view_media_connector_connect (connector, self, self->pipeline, (_tmp1_ = (_tmp0_ = g_new0 (GstElement*, 2 + 1), _tmp0_[0] = _gst_object_ref0 (self->adder), _tmp0_[1] = _gst_object_ref0 (self->converter), _tmp0_), _tmp1__length1 = 2, _tmp1_), 2);
3518 #line 3519 "MediaEngine.c"
3519         _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) gst_object_unref), NULL);
3520 }
3521
3522
3523 #line 740 "MediaEngine.vala"
3524 void view_media_engine_disconnect_output (ViewMediaEngine* self, ViewMediaConnector* connector) {
3525 #line 3526 "MediaEngine.c"
3526         gint _tmp1__length1;
3527         GstElement** _tmp1_;
3528         GstElement** _tmp0_ = NULL;
3529 #line 740 "MediaEngine.vala"
3530         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3531 #line 740 "MediaEngine.vala"
3532         g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (connector));
3533 #line 741 "MediaEngine.vala"
3534         gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, (gint64) 0);
3535 #line 742 "MediaEngine.vala"
3536         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL);
3537 #line 743 "MediaEngine.vala"
3538         view_media_connector_do_disconnect (connector, self, self->pipeline, (_tmp1_ = (_tmp0_ = g_new0 (GstElement*, 2 + 1), _tmp0_[0] = _gst_object_ref0 (self->adder), _tmp0_[1] = _gst_object_ref0 (self->converter), _tmp0_), _tmp1__length1 = 2, _tmp1_), 2);
3539 #line 3540 "MediaEngine.c"
3540         _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) gst_object_unref), NULL);
3541 }
3542
3543
3544 #line 746 "MediaEngine.vala"
3545 GstElement* view_media_engine_get_audio_silence (ViewMediaEngine* self, GError** error) {
3546 #line 3547 "MediaEngine.c"
3547         GstElement* result = NULL;
3548         GError * _inner_error_;
3549         GstElement* silence;
3550         GstCaps* audio_cap;
3551 #line 746 "MediaEngine.vala"
3552         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
3553 #line 3554 "MediaEngine.c"
3554         _inner_error_ = NULL;
3555 #line 747 "MediaEngine.vala"
3556         silence = make_element ("audiotestsrc", &_inner_error_);
3557 #line 3558 "MediaEngine.c"
3558         if (_inner_error_ != NULL) {
3559                 g_propagate_error (error, _inner_error_);
3560                 return NULL;
3561         }
3562 #line 748 "MediaEngine.vala"
3563         g_object_set (G_OBJECT (silence), "wave", 4, NULL);
3564 #line 749 "MediaEngine.vala"
3565         audio_cap = view_media_engine_get_project_audio_caps (self);
3566 #line 3567 "MediaEngine.c"
3567         {
3568                 GList* pad_collection;
3569                 GList* pad_it;
3570 #line 750 "MediaEngine.vala"
3571                 pad_collection = silence->pads;
3572 #line 3573 "MediaEngine.c"
3573                 for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) {
3574                         GstPad* pad;
3575 #line 750 "MediaEngine.vala"
3576                         pad = _gst_object_ref0 ((GstPad*) pad_it->data);
3577 #line 3578 "MediaEngine.c"
3578                         {
3579 #line 751 "MediaEngine.vala"
3580                                 gst_pad_set_caps (pad, audio_cap);
3581 #line 3582 "MediaEngine.c"
3582                                 _gst_object_unref0 (pad);
3583                         }
3584                 }
3585         }
3586         result = silence;
3587         _gst_caps_unref0 (audio_cap);
3588 #line 753 "MediaEngine.vala"
3589         return result;
3590 #line 3591 "MediaEngine.c"
3591 }
3592
3593
3594 #line 756 "MediaEngine.vala"
3595 gint view_media_engine_get_sample_rate (ViewMediaEngine* self) {
3596 #line 3597 "MediaEngine.c"
3597         gint result = 0;
3598 #line 756 "MediaEngine.vala"
3599         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0);
3600 #line 3601 "MediaEngine.c"
3601         result = 48000;
3602 #line 757 "MediaEngine.vala"
3603         return result;
3604 #line 3605 "MediaEngine.c"
3605 }
3606
3607
3608 #line 760 "MediaEngine.vala"
3609 gint view_media_engine_get_sample_width (ViewMediaEngine* self) {
3610 #line 3611 "MediaEngine.c"
3611         gint result = 0;
3612 #line 760 "MediaEngine.vala"
3613         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0);
3614 #line 3615 "MediaEngine.c"
3615         result = 16;
3616 #line 761 "MediaEngine.vala"
3617         return result;
3618 #line 3619 "MediaEngine.c"
3619 }
3620
3621
3622 #line 764 "MediaEngine.vala"
3623 gint view_media_engine_get_sample_depth (ViewMediaEngine* self) {
3624 #line 3625 "MediaEngine.c"
3625         gint result = 0;
3626 #line 764 "MediaEngine.vala"
3627         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0);
3628 #line 3629 "MediaEngine.c"
3629         result = 16;
3630 #line 765 "MediaEngine.vala"
3631         return result;
3632 #line 3633 "MediaEngine.c"
3633 }
3634
3635
3636 #line 768 "MediaEngine.vala"
3637 PlayState view_media_engine_get_play_state (ViewMediaEngine* self) {
3638 #line 3639 "MediaEngine.c"
3639         PlayState result = 0;
3640 #line 768 "MediaEngine.vala"
3641         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0);
3642 #line 3643 "MediaEngine.c"
3643         result = self->play_state;
3644 #line 769 "MediaEngine.vala"
3645         return result;
3646 #line 3647 "MediaEngine.c"
3647 }
3648
3649
3650 #line 772 "MediaEngine.vala"
3651 void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state) {
3652 #line 772 "MediaEngine.vala"
3653         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3654 #line 773 "MediaEngine.vala"
3655         self->play_state = play_state;
3656 #line 3657 "MediaEngine.c"
3657 }
3658
3659
3660 #line 776 "MediaEngine.vala"
3661 GstCaps* view_media_engine_build_audio_caps (ViewMediaEngine* self, gint num_channels) {
3662 #line 3663 "MediaEngine.c"
3663         GstCaps* result = NULL;
3664         char* caps;
3665         char* _tmp0_;
3666 #line 776 "MediaEngine.vala"
3667         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
3668 #line 777 "MediaEngine.vala"
3669         caps = g_strdup ("audio/x-raw-int,rate=%d,channels=%d,width=%d,depth=%d");
3670 #line 778 "MediaEngine.vala"
3671         caps = (_tmp0_ = g_strdup_printf (caps, view_media_engine_get_sample_rate (self), num_channels, view_media_engine_get_sample_width (self), view_media_engine_get_sample_depth (self)), _g_free0 (caps), _tmp0_);
3672 #line 3673 "MediaEngine.c"
3673         result = gst_caps_from_string (caps);
3674         _g_free0 (caps);
3675 #line 779 "MediaEngine.vala"
3676         return result;
3677 #line 3678 "MediaEngine.c"
3678 }
3679
3680
3681 #line 782 "MediaEngine.vala"
3682 GstCaps* view_media_engine_get_project_audio_caps (ViewMediaEngine* self) {
3683 #line 3684 "MediaEngine.c"
3684         GstCaps* result = NULL;
3685 #line 782 "MediaEngine.vala"
3686         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
3687 #line 3688 "MediaEngine.c"
3688         result = view_media_engine_build_audio_caps (self, CHANNELS_PER_TRACK_PLAYBACK);
3689 #line 783 "MediaEngine.vala"
3690         return result;
3691 #line 3692 "MediaEngine.c"
3692 }
3693
3694
3695 #line 786 "MediaEngine.vala"
3696 GstCaps* view_media_engine_get_project_audio_export_caps (ViewMediaEngine* self) {
3697 #line 3698 "MediaEngine.c"
3698         GstCaps* result = NULL;
3699 #line 786 "MediaEngine.vala"
3700         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
3701 #line 3702 "MediaEngine.c"
3702         result = gst_caps_from_string ("audio/x-raw-float,rate=48000,channels=2,width=32");
3703 #line 787 "MediaEngine.vala"
3704         return result;
3705 #line 3706 "MediaEngine.c"
3706 }
3707
3708
3709 #line 791 "MediaEngine.vala"
3710 static void view_media_engine_on_warning (ViewMediaEngine* self, GstBus* bus, GstMessage* message) {
3711 #line 3712 "MediaEngine.c"
3712         GError* _error_;
3713         char* text;
3714         char* _tmp3_;
3715         char* _tmp2_ = NULL;
3716         GError* _tmp1_;
3717         GError* _tmp0_ = NULL;
3718 #line 791 "MediaEngine.vala"
3719         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3720 #line 791 "MediaEngine.vala"
3721         g_return_if_fail (GST_IS_BUS (bus));
3722 #line 791 "MediaEngine.vala"
3723         g_return_if_fail (GST_IS_MESSAGE (message));
3724 #line 792 "MediaEngine.vala"
3725         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_warning");
3726 #line 3727 "MediaEngine.c"
3727         _error_ = NULL;
3728         text = NULL;
3729 #line 795 "MediaEngine.vala"
3730         (gst_message_parse_warning (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_));
3731 #line 795 "MediaEngine.vala"
3732         text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_);
3733 #line 796 "MediaEngine.vala"
3734         g_warning ("MediaEngine.vala:796: %s", text);
3735 #line 3736 "MediaEngine.c"
3736         _g_error_free0 (_error_);
3737         _g_free0 (text);
3738 }
3739
3740
3741 #line 799 "MediaEngine.vala"
3742 static void view_media_engine_on_error (ViewMediaEngine* self, GstBus* bus, GstMessage* message) {
3743 #line 3744 "MediaEngine.c"
3744         GError* _error_;
3745         char* text;
3746         char* _tmp3_;
3747         char* _tmp2_ = NULL;
3748         GError* _tmp1_;
3749         GError* _tmp0_ = NULL;
3750 #line 799 "MediaEngine.vala"
3751         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3752 #line 799 "MediaEngine.vala"
3753         g_return_if_fail (GST_IS_BUS (bus));
3754 #line 799 "MediaEngine.vala"
3755         g_return_if_fail (GST_IS_MESSAGE (message));
3756 #line 800 "MediaEngine.vala"
3757         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error");
3758 #line 3759 "MediaEngine.c"
3759         _error_ = NULL;
3760         text = NULL;
3761 #line 803 "MediaEngine.vala"
3762         (gst_message_parse_error (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_));
3763 #line 803 "MediaEngine.vala"
3764         text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_);
3765 #line 804 "MediaEngine.vala"
3766         g_warning ("MediaEngine.vala:804: %s", text);
3767 #line 805 "MediaEngine.vala"
3768         model_project_print_graph (self->priv->project, GST_BIN (self->pipeline), "bus_error");
3769 #line 3770 "MediaEngine.c"
3770         _g_error_free0 (_error_);
3771         _g_free0 (text);
3772 }
3773
3774
3775 #line 808 "MediaEngine.vala"
3776 static void view_media_engine_on_eos (ViewMediaEngine* self, GstBus* bus, GstMessage* message) {
3777 #line 808 "MediaEngine.vala"
3778         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3779 #line 808 "MediaEngine.vala"
3780         g_return_if_fail (GST_IS_BUS (bus));
3781 #line 808 "MediaEngine.vala"
3782         g_return_if_fail (GST_IS_MESSAGE (message));
3783 #line 809 "MediaEngine.vala"
3784         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_eos");
3785 #line 810 "MediaEngine.vala"
3786         if (self->play_state == PLAY_STATE_EXPORTING) {
3787 #line 811 "MediaEngine.vala"
3788                 gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL);
3789 #line 3790 "MediaEngine.c"
3790         }
3791 }
3792
3793
3794 #line 1168 "glib-2.0.vapi"
3795 static const char* string_to_string (const char* self) {
3796 #line 3797 "MediaEngine.c"
3797         const char* result = NULL;
3798 #line 1168 "glib-2.0.vapi"
3799         g_return_val_if_fail (self != NULL, NULL);
3800 #line 3801 "MediaEngine.c"
3801         result = self;
3802 #line 1169 "glib-2.0.vapi"
3803         return result;
3804 #line 3805 "MediaEngine.c"
3805 }
3806
3807
3808 static GValue* _gst_value_dup (GValue* self) {
3809         GValue* dup;
3810         dup = g_new0 (GValue, 1);
3811         memcpy (dup, self, sizeof (GValue));
3812         return dup;
3813 }
3814
3815
3816 static gpointer __gst_value_dup0 (gpointer self) {
3817         return self ? _gst_value_dup (self) : NULL;
3818 }
3819
3820
3821 #line 814 "MediaEngine.vala"
3822 static void view_media_engine_on_element (ViewMediaEngine* self, GstBus* bus, GstMessage* message) {
3823 #line 3824 "MediaEngine.c"
3824         const GstStructure* structure;
3825         gboolean _tmp0_ = FALSE;
3826 #line 814 "MediaEngine.vala"
3827         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3828 #line 814 "MediaEngine.vala"
3829         g_return_if_fail (GST_IS_BUS (bus));
3830 #line 814 "MediaEngine.vala"
3831         g_return_if_fail (GST_IS_MESSAGE (message));
3832 #line 815 "MediaEngine.vala"
3833         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_element");
3834 #line 816 "MediaEngine.vala"
3835         structure = gst_message_get_structure (message);
3836 #line 818 "MediaEngine.vala"
3837         if (self->play_state == PLAY_STATE_PLAYING) {
3838 #line 818 "MediaEngine.vala"
3839                 _tmp0_ = _vala_strcmp0 (string_to_string (gst_structure_get_name (structure)), "level") == 0;
3840 #line 3841 "MediaEngine.c"
3841         } else {
3842 #line 818 "MediaEngine.vala"
3843                 _tmp0_ = FALSE;
3844 #line 3845 "MediaEngine.c"
3845         }
3846 #line 818 "MediaEngine.vala"
3847         if (_tmp0_) {
3848 #line 3849 "MediaEngine.c"
3849                 GValue* rms;
3850                 guint size;
3851                 GValue* temp;
3852                 double level_left;
3853                 double level_right;
3854 #line 819 "MediaEngine.vala"
3855                 rms = __gst_value_dup0 (gst_structure_get_value (structure, "rms"));
3856 #line 820 "MediaEngine.vala"
3857                 size = gst_value_list_get_size (rms);
3858 #line 821 "MediaEngine.vala"
3859                 temp = __gst_value_dup0 (gst_value_list_get_value (rms, (guint) 0));
3860 #line 822 "MediaEngine.vala"
3861                 level_left = g_value_get_double (temp);
3862 #line 823 "MediaEngine.vala"
3863                 level_right = level_left;
3864 #line 825 "MediaEngine.vala"
3865                 if (size > 1) {
3866 #line 3867 "MediaEngine.c"
3867                         GValue* _tmp1_;
3868 #line 826 "MediaEngine.vala"
3869                         temp = (_tmp1_ = __gst_value_dup0 (gst_value_list_get_value (rms, (guint) 1)), _g_free0 (temp), _tmp1_);
3870 #line 827 "MediaEngine.vala"
3871                         level_right = g_value_get_double (temp);
3872 #line 3873 "MediaEngine.c"
3873                 }
3874 #line 829 "MediaEngine.vala"
3875                 g_signal_emit_by_name (self, "level-changed", message->src, level_left, level_right);
3876 #line 3877 "MediaEngine.c"
3877                 _g_free0 (rms);
3878                 _g_free0 (temp);
3879         }
3880 }
3881
3882
3883 #line 833 "MediaEngine.vala"
3884 static void view_media_engine_on_state_change (ViewMediaEngine* self, GstBus* bus, GstMessage* message) {
3885 #line 3886 "MediaEngine.c"
3886         GstState old_state = 0;
3887         GstState new_state = 0;
3888         GstState pending = 0;
3889         char* _tmp2_;
3890 #line 833 "MediaEngine.vala"
3891         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
3892 #line 833 "MediaEngine.vala"
3893         g_return_if_fail (GST_IS_BUS (bus));
3894 #line 833 "MediaEngine.vala"
3895         g_return_if_fail (GST_IS_MESSAGE (message));
3896 #line 834 "MediaEngine.vala"
3897         if (message->src != GST_OBJECT (self->pipeline)) {
3898 #line 3899 "MediaEngine.c"
3899                 char* _tmp1_;
3900                 char* _tmp0_;
3901 #line 835 "MediaEngine.vala"
3902                 logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("on_state_change returning.  message from %s", _tmp0_ = gst_object_get_name (message->src)));
3903 #line 3904 "MediaEngine.c"
3904                 _g_free0 (_tmp1_);
3905                 _g_free0 (_tmp0_);
3906 #line 837 "MediaEngine.vala"
3907                 return;
3908 #line 3909 "MediaEngine.c"
3909         }
3910 #line 844 "MediaEngine.vala"
3911         gst_message_parse_state_changed (message, &old_state, &new_state, &pending);
3912 #line 846 "MediaEngine.vala"
3913         logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, _tmp2_ = g_strdup_printf ("on_state_change old(%s) new(%s) pending(%s)", gst_element_state_get_name (old_state), gst_element_state_get_name (new_state), gst_element_state_get_name (pending)));
3914 #line 3915 "MediaEngine.c"
3915         _g_free0 (_tmp2_);
3916 #line 849 "MediaEngine.vala"
3917         if (new_state == self->gst_state) {
3918 #line 850 "MediaEngine.vala"
3919                 return;
3920 #line 3921 "MediaEngine.c"
3921         }
3922 #line 852 "MediaEngine.vala"
3923         self->gst_state = new_state;
3924 #line 853 "MediaEngine.vala"
3925         view_media_engine_do_state_change (self);
3926 #line 3927 "MediaEngine.c"
3927 }
3928
3929
3930 #line 856 "MediaEngine.vala"
3931 gboolean view_media_engine_do_state_change (ViewMediaEngine* self) {
3932 #line 3933 "MediaEngine.c"
3933         gboolean result = FALSE;
3934         GError * _inner_error_;
3935 #line 856 "MediaEngine.vala"
3936         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), FALSE);
3937 #line 3938 "MediaEngine.c"
3938         _inner_error_ = NULL;
3939 #line 857 "MediaEngine.vala"
3940         g_signal_emit_by_name (self, "playstate-changed");
3941 #line 858 "MediaEngine.vala"
3942         switch (self->play_state) {
3943 #line 3944 "MediaEngine.c"
3944                 case PLAY_STATE_STOPPED:
3945                 {
3946 #line 860 "MediaEngine.vala"
3947                         if (self->gst_state != GST_STATE_PAUSED) {
3948 #line 861 "MediaEngine.vala"
3949                                 gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED);
3950 #line 3951 "MediaEngine.c"
3951                         } else {
3952 #line 863 "MediaEngine.vala"
3953                                 view_media_engine_go (self, self->position);
3954 #line 3955 "MediaEngine.c"
3955                         }
3956                         result = TRUE;
3957 #line 865 "MediaEngine.vala"
3958                         return result;
3959 #line 3960 "MediaEngine.c"
3960                 }
3961                 case PLAY_STATE_PRE_EXPORT:
3962                 {
3963 #line 867 "MediaEngine.vala"
3964                         if (self->gst_state != GST_STATE_PAUSED) {
3965 #line 3966 "MediaEngine.c"
3966                                 result = FALSE;
3967 #line 868 "MediaEngine.vala"
3968                                 return result;
3969 #line 3970 "MediaEngine.c"
3970                         }
3971 #line 870 "MediaEngine.vala"
3972                         view_media_engine_do_paused_state_export (self);
3973 #line 3974 "MediaEngine.c"
3974                         result = TRUE;
3975 #line 871 "MediaEngine.vala"
3976                         return result;
3977 #line 3978 "MediaEngine.c"
3978                 }
3979                 case PLAY_STATE_EXPORTING:
3980                 {
3981 #line 873 "MediaEngine.vala"
3982                         if (self->gst_state != GST_STATE_NULL) {
3983 #line 3984 "MediaEngine.c"
3984                                 result = FALSE;
3985 #line 874 "MediaEngine.vala"
3986                                 return result;
3987 #line 3988 "MediaEngine.c"
3988                         }
3989 #line 875 "MediaEngine.vala"
3990                         view_media_engine_end_export (self, FALSE);
3991 #line 3992 "MediaEngine.c"
3992                         result = TRUE;
3993 #line 876 "MediaEngine.vala"
3994                         return result;
3995 #line 3996 "MediaEngine.c"
3996                 }
3997                 case PLAY_STATE_CANCEL_EXPORT:
3998                 {
3999 #line 878 "MediaEngine.vala"
4000                         if (self->gst_state != GST_STATE_NULL) {
4001 #line 4002 "MediaEngine.c"
4002                                 result = FALSE;
4003 #line 879 "MediaEngine.vala"
4004                                 return result;
4005 #line 4006 "MediaEngine.c"
4006                         }
4007 #line 880 "MediaEngine.vala"
4008                         view_media_engine_end_export (self, TRUE);
4009 #line 4010 "MediaEngine.c"
4010                         result = TRUE;
4011 #line 881 "MediaEngine.vala"
4012                         return result;
4013 #line 4014 "MediaEngine.c"
4014                 }
4015                 case PLAY_STATE_CLOSING:
4016                 {
4017 #line 883 "MediaEngine.vala"
4018                         view_media_engine_close (self);
4019 #line 4020 "MediaEngine.c"
4020                         result = TRUE;
4021 #line 884 "MediaEngine.vala"
4022                         return result;
4023 #line 4024 "MediaEngine.c"
4024                 }
4025                 case PLAY_STATE_PRE_RECORD_NULL:
4026                 {
4027 #line 886 "MediaEngine.vala"
4028                         if (self->gst_state == GST_STATE_NULL) {
4029 #line 4030 "MediaEngine.c"
4030                                 {
4031 #line 888 "MediaEngine.vala"
4032                                         view_media_engine_start_record (self, self->record_region, &_inner_error_);
4033 #line 4034 "MediaEngine.c"
4034                                         if (_inner_error_ != NULL) {
4035                                                 goto __catch10_g_error;
4036                                         }
4037                                 }
4038                                 goto __finally10;
4039                                 __catch10_g_error:
4040                                 {
4041                                         GError * _error_;
4042                                         _error_ = _inner_error_;
4043                                         _inner_error_ = NULL;
4044                                         {
4045 #line 890 "MediaEngine.vala"
4046                                                 g_signal_emit_by_name (self, "error-occurred", "An error occurred starting the recording.", NULL);
4047 #line 891 "MediaEngine.vala"
4048                                                 g_warning ("MediaEngine.vala:891: An error occurred starting the recording: %s", _error_->message);
4049 #line 4050 "MediaEngine.c"
4050                                                 _g_error_free0 (_error_);
4051                                         }
4052                                 }
4053                                 __finally10:
4054                                 if (_inner_error_ != NULL) {
4055                                         g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4056                                         g_clear_error (&_inner_error_);
4057                                         return FALSE;
4058                                 }
4059                                 result = TRUE;
4060 #line 893 "MediaEngine.vala"
4061                                 return result;
4062 #line 4063 "MediaEngine.c"
4063                         }
4064 #line 895 "MediaEngine.vala"
4065                         break;
4066 #line 4067 "MediaEngine.c"
4067                 }
4068                 case PLAY_STATE_PRE_RECORD:
4069                 {
4070 #line 897 "MediaEngine.vala"
4071                         if (self->gst_state == GST_STATE_PAUSED) {
4072 #line 898 "MediaEngine.vala"
4073                                 view_media_engine_do_play (self, PLAY_STATE_RECORDING);
4074 #line 4075 "MediaEngine.c"
4075                                 result = TRUE;
4076 #line 899 "MediaEngine.vala"
4077                                 return result;
4078 #line 4079 "MediaEngine.c"
4079                         }
4080 #line 901 "MediaEngine.vala"
4081                         break;
4082 #line 4083 "MediaEngine.c"
4083                 }
4084                 case PLAY_STATE_POST_RECORD:
4085                 {
4086 #line 903 "MediaEngine.vala"
4087                         if (self->gst_state != GST_STATE_NULL) {
4088 #line 904 "MediaEngine.vala"
4089                                 view_media_engine_set_gst_state (self, GST_STATE_NULL);
4090 #line 4091 "MediaEngine.c"
4091                         } else {
4092 #line 906 "MediaEngine.vala"
4093                                 view_media_engine_post_record (self);
4094 #line 907 "MediaEngine.vala"
4095                                 view_media_engine_set_gst_state (self, GST_STATE_PAUSED);
4096 #line 908 "MediaEngine.vala"
4097                                 self->play_state = PLAY_STATE_STOPPED;
4098 #line 4099 "MediaEngine.c"
4099                         }
4100                         result = TRUE;
4101 #line 910 "MediaEngine.vala"
4102                         return result;
4103 #line 4104 "MediaEngine.c"
4104                 }
4105         }
4106         result = FALSE;
4107 #line 912 "MediaEngine.vala"
4108         return result;
4109 #line 4110 "MediaEngine.c"
4110 }
4111
4112
4113 #line 915 "MediaEngine.vala"
4114 static void view_media_engine_real_do_null_state_export (ViewMediaEngine* self, gint64 length) {
4115 #line 915 "MediaEngine.vala"
4116         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4117 #line 916 "MediaEngine.vala"
4118         g_signal_emit_by_name (self, "pre-export", length);
4119 #line 917 "MediaEngine.vala"
4120         self->play_state = PLAY_STATE_PRE_EXPORT;
4121 #line 918 "MediaEngine.vala"
4122         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED);
4123 #line 4124 "MediaEngine.c"
4124 }
4125
4126
4127 #line 915 "MediaEngine.vala"
4128 void view_media_engine_do_null_state_export (ViewMediaEngine* self, gint64 length) {
4129 #line 915 "MediaEngine.vala"
4130         VIEW_MEDIA_ENGINE_GET_CLASS (self)->do_null_state_export (self, length);
4131 #line 4132 "MediaEngine.c"
4132 }
4133
4134
4135 #line 952 "MediaEngine.vala"
4136 static gboolean _view_media_engine_on_callback_gsource_func (gpointer self) {
4137 #line 4138 "MediaEngine.c"
4138         gboolean result;
4139         result = view_media_engine_on_callback (self);
4140         return result;
4141 }
4142
4143
4144 #line 921 "MediaEngine.vala"
4145 static void view_media_engine_do_paused_state_export (ViewMediaEngine* self) {
4146 #line 921 "MediaEngine.vala"
4147         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4148 #line 922 "MediaEngine.vala"
4149         self->play_state = PLAY_STATE_EXPORTING;
4150 #line 924 "MediaEngine.vala"
4151         if (self->priv->callback_id == 0) {
4152 #line 925 "MediaEngine.vala"
4153                 self->priv->callback_id = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _view_media_engine_on_callback_gsource_func, g_object_ref (self), g_object_unref);
4154 #line 4155 "MediaEngine.c"
4155         }
4156 #line 926 "MediaEngine.vala"
4157         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PLAYING);
4158 #line 4159 "MediaEngine.c"
4159 }
4160
4161
4162 #line 929 "MediaEngine.vala"
4163 static void view_media_engine_end_export (ViewMediaEngine* self, gboolean deleted) {
4164 #line 929 "MediaEngine.vala"
4165         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4166 #line 930 "MediaEngine.vala"
4167         self->play_state = PLAY_STATE_STOPPED;
4168 #line 932 "MediaEngine.vala"
4169         self->priv->callback_id = (guint) 0;
4170 #line 933 "MediaEngine.vala"
4171         g_signal_emit_by_name (self, "post-export", deleted);
4172 #line 4173 "MediaEngine.c"
4173 }
4174
4175
4176 #line 936 "MediaEngine.vala"
4177 void view_media_engine_go (ViewMediaEngine* self, gint64 pos) {
4178 #line 936 "MediaEngine.vala"
4179         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4180 #line 937 "MediaEngine.vala"
4181         if (self->position == pos) {
4182 #line 938 "MediaEngine.vala"
4183                 gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->position);
4184 #line 939 "MediaEngine.vala"
4185                 return;
4186 #line 4187 "MediaEngine.c"
4187         }
4188 #line 941 "MediaEngine.vala"
4189         if (pos < 0) {
4190 #line 942 "MediaEngine.vala"
4191                 self->position = (gint64) 0;
4192 #line 4193 "MediaEngine.c"
4193         } else {
4194 #line 944 "MediaEngine.vala"
4195                 self->position = pos;
4196 #line 4197 "MediaEngine.c"
4197         }
4198 #line 948 "MediaEngine.vala"
4199         gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->position);
4200 #line 949 "MediaEngine.vala"
4201         g_signal_emit_by_name (self, "position-changed", self->position);
4202 #line 4203 "MediaEngine.c"
4203 }
4204
4205
4206 #line 952 "MediaEngine.vala"
4207 static gboolean view_media_engine_on_callback (ViewMediaEngine* self) {
4208 #line 4209 "MediaEngine.c"
4209         gboolean result = FALSE;
4210         gboolean _tmp0_ = FALSE;
4211         gboolean _tmp1_ = FALSE;
4212         GstFormat format;
4213         gint64 time;
4214         gboolean _tmp2_ = FALSE;
4215 #line 952 "MediaEngine.vala"
4216         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), FALSE);
4217 #line 953 "MediaEngine.vala"
4218         if (self->play_state == PLAY_STATE_STOPPED) {
4219 #line 953 "MediaEngine.vala"
4220                 _tmp1_ = !self->playing;
4221 #line 4222 "MediaEngine.c"
4222         } else {
4223 #line 953 "MediaEngine.vala"
4224                 _tmp1_ = FALSE;
4225 #line 4226 "MediaEngine.c"
4226         }
4227 #line 953 "MediaEngine.vala"
4228         if (_tmp1_) {
4229 #line 953 "MediaEngine.vala"
4230                 _tmp0_ = TRUE;
4231 #line 4232 "MediaEngine.c"
4232         } else {
4233 #line 954 "MediaEngine.vala"
4234                 _tmp0_ = self->play_state == PLAY_STATE_POST_RECORD;
4235 #line 4236 "MediaEngine.c"
4236         }
4237 #line 953 "MediaEngine.vala"
4238         if (_tmp0_) {
4239 #line 955 "MediaEngine.vala"
4240                 self->priv->callback_id = (guint) 0;
4241 #line 4242 "MediaEngine.c"
4242                 result = FALSE;
4243 #line 956 "MediaEngine.vala"
4244                 return result;
4245 #line 4246 "MediaEngine.c"
4246         }
4247 #line 959 "MediaEngine.vala"
4248         format = GST_FORMAT_TIME;
4249 #line 960 "MediaEngine.vala"
4250         time = (gint64) 0;
4251 #line 961 "MediaEngine.vala"
4252         if (gst_element_query_position (GST_ELEMENT (self->pipeline), &format, &time)) {
4253 #line 961 "MediaEngine.vala"
4254                 _tmp2_ = format == GST_FORMAT_TIME;
4255 #line 4256 "MediaEngine.c"
4256         } else {
4257 #line 961 "MediaEngine.vala"
4258                 _tmp2_ = FALSE;
4259 #line 4260 "MediaEngine.c"
4260         }
4261 #line 961 "MediaEngine.vala"
4262         if (_tmp2_) {
4263 #line 962 "MediaEngine.vala"
4264                 self->position = time;
4265 #line 963 "MediaEngine.vala"
4266                 g_signal_emit_by_name (self, "callback-pulse");
4267 #line 965 "MediaEngine.vala"
4268                 if (self->play_state == PLAY_STATE_PLAYING) {
4269 #line 966 "MediaEngine.vala"
4270                         if (self->position >= model_project_get_length (self->priv->project)) {
4271 #line 967 "MediaEngine.vala"
4272                                 view_media_engine_go (self, model_project_get_length (self->priv->project));
4273 #line 968 "MediaEngine.vala"
4274                                 view_media_engine_pause (self);
4275 #line 4276 "MediaEngine.c"
4276                         }
4277 #line 970 "MediaEngine.vala"
4278                         g_signal_emit_by_name (self, "position-changed", time);
4279 #line 4280 "MediaEngine.c"
4280                 } else {
4281 #line 971 "MediaEngine.vala"
4282                         if (self->play_state == PLAY_STATE_EXPORTING) {
4283 #line 972 "MediaEngine.vala"
4284                                 if (time > model_project_get_length (self->priv->project)) {
4285 #line 973 "MediaEngine.vala"
4286                                         g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", 1.0);
4287 #line 4288 "MediaEngine.c"
4288                                 } else {
4289 #line 976 "MediaEngine.vala"
4290                                         g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", time / ((double) model_project_get_length (self->priv->project)));
4291 #line 4292 "MediaEngine.c"
4292                                 }
4293                         } else {
4294 #line 977 "MediaEngine.vala"
4295                                 if (self->play_state == PLAY_STATE_RECORDING) {
4296 #line 978 "MediaEngine.vala"
4297                                         g_signal_emit_by_name (self, "position-changed", time);
4298 #line 4299 "MediaEngine.c"
4299                                 }
4300                         }
4301                 }
4302         }
4303         result = TRUE;
4304 #line 981 "MediaEngine.vala"
4305         return result;
4306 #line 4307 "MediaEngine.c"
4307 }
4308
4309
4310 #line 984 "MediaEngine.vala"
4311 static void view_media_engine_real_pause (ViewMediaEngine* self) {
4312 #line 984 "MediaEngine.vala"
4313         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4314 #line 985 "MediaEngine.vala"
4315         if (model_project_transport_is_recording (self->priv->project)) {
4316 #line 986 "MediaEngine.vala"
4317                 gst_element_send_event (GST_ELEMENT (self->record_bin), gst_event_new_eos ());
4318 #line 987 "MediaEngine.vala"
4319                 self->play_state = PLAY_STATE_POST_RECORD;
4320 #line 4321 "MediaEngine.c"
4321         } else {
4322 #line 989 "MediaEngine.vala"
4323                 if (!self->playing) {
4324 #line 990 "MediaEngine.vala"
4325                         return;
4326 #line 4327 "MediaEngine.c"
4327                 }
4328 #line 992 "MediaEngine.vala"
4329                 self->play_state = PLAY_STATE_STOPPED;
4330 #line 4331 "MediaEngine.c"
4331         }
4332 #line 994 "MediaEngine.vala"
4333         view_media_engine_set_gst_state (self, GST_STATE_PAUSED);
4334 #line 995 "MediaEngine.vala"
4335         self->playing = FALSE;
4336 #line 4337 "MediaEngine.c"
4337 }
4338
4339
4340 #line 984 "MediaEngine.vala"
4341 void view_media_engine_pause (ViewMediaEngine* self) {
4342 #line 984 "MediaEngine.vala"
4343         VIEW_MEDIA_ENGINE_GET_CLASS (self)->pause (self);
4344 #line 4345 "MediaEngine.c"
4345 }
4346
4347
4348 #line 999 "MediaEngine.vala"
4349 void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state) {
4350 #line 999 "MediaEngine.vala"
4351         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4352 #line 1000 "MediaEngine.vala"
4353         if (gst_element_set_state (GST_ELEMENT (self->pipeline), state) == GST_STATE_CHANGE_FAILURE) {
4354 #line 1001 "MediaEngine.vala"
4355                 g_error ("MediaEngine.vala:1001: can't set state");
4356 #line 4357 "MediaEngine.c"
4357         }
4358 }
4359
4360
4361 #line 1004 "MediaEngine.vala"
4362 static void view_media_engine_seek (ViewMediaEngine* self, GstSeekFlags flags, gint64 pos) {
4363 #line 1004 "MediaEngine.vala"
4364         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4365 #line 1008 "MediaEngine.vala"
4366         gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, flags, pos);
4367 #line 4368 "MediaEngine.c"
4368 }
4369
4370
4371 #line 1011 "MediaEngine.vala"
4372 void view_media_engine_do_play (ViewMediaEngine* self, PlayState new_state) {
4373 #line 1011 "MediaEngine.vala"
4374         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4375 #line 1012 "MediaEngine.vala"
4376         view_media_engine_seek (self, GST_SEEK_FLAG_FLUSH, self->position);
4377 #line 1013 "MediaEngine.vala"
4378         self->play_state = new_state;
4379 #line 1014 "MediaEngine.vala"
4380         view_media_engine_play (self);
4381 #line 4382 "MediaEngine.c"
4382 }
4383
4384
4385 #line 1017 "MediaEngine.vala"
4386 static void view_media_engine_play (ViewMediaEngine* self) {
4387 #line 1017 "MediaEngine.vala"
4388         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4389 #line 1018 "MediaEngine.vala"
4390         if (self->playing) {
4391 #line 1019 "MediaEngine.vala"
4392                 return;
4393 #line 4394 "MediaEngine.c"
4394         }
4395 #line 1021 "MediaEngine.vala"
4396         view_media_engine_set_gst_state (self, GST_STATE_PLAYING);
4397 #line 1022 "MediaEngine.vala"
4398         if (self->priv->callback_id == 0) {
4399 #line 1023 "MediaEngine.vala"
4400                 self->priv->callback_id = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _view_media_engine_on_callback_gsource_func, g_object_ref (self), g_object_unref);
4401 #line 4402 "MediaEngine.c"
4402         }
4403 #line 1024 "MediaEngine.vala"
4404         self->playing = TRUE;
4405 #line 4406 "MediaEngine.c"
4406 }
4407
4408
4409 #line 1027 "MediaEngine.vala"
4410 void view_media_engine_start_export (ViewMediaEngine* self, const char* filename) {
4411 #line 1027 "MediaEngine.vala"
4412         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4413 #line 1027 "MediaEngine.vala"
4414         g_return_if_fail (filename != NULL);
4415 #line 1028 "MediaEngine.vala"
4416         g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "file-updated", filename, 0);
4417 #line 1029 "MediaEngine.vala"
4418         view_media_engine_do_null_state_export (self, model_project_get_length (self->priv->project));
4419 #line 4420 "MediaEngine.c"
4420 }
4421
4422
4423 #line 1032 "MediaEngine.vala"
4424 static void view_media_engine_real_cancel (MultiFileProgressInterface* base) {
4425 #line 4426 "MediaEngine.c"
4426         ViewMediaEngine * self;
4427         self = VIEW_MEDIA_ENGINE (base);
4428 #line 1033 "MediaEngine.vala"
4429         self->play_state = PLAY_STATE_CANCEL_EXPORT;
4430 #line 1034 "MediaEngine.vala"
4431         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL);
4432 #line 4433 "MediaEngine.c"
4433 }
4434
4435
4436 #line 1037 "MediaEngine.vala"
4437 static void view_media_engine_real_complete (MultiFileProgressInterface* base) {
4438 #line 4439 "MediaEngine.c"
4439         ViewMediaEngine * self;
4440         self = VIEW_MEDIA_ENGINE (base);
4441 #line 1038 "MediaEngine.vala"
4442         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL);
4443 #line 4444 "MediaEngine.c"
4444 }
4445
4446
4447 #line 1041 "MediaEngine.vala"
4448 void view_media_engine_on_load_complete (ViewMediaEngine* self) {
4449 #line 1041 "MediaEngine.vala"
4450         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4451 #line 1042 "MediaEngine.vala"
4452         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete");
4453 #line 1043 "MediaEngine.vala"
4454         self->play_state = PLAY_STATE_STOPPED;
4455 #line 1044 "MediaEngine.vala"
4456         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED);
4457 #line 4458 "MediaEngine.c"
4458 }
4459
4460
4461 #line 1047 "MediaEngine.vala"
4462 void view_media_engine_on_callback_pulse (ViewMediaEngine* self) {
4463 #line 1047 "MediaEngine.vala"
4464         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4465 #line 1048 "MediaEngine.vala"
4466         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_callback_pulse");
4467 #line 1049 "MediaEngine.vala"
4468         if (self->record_region != NULL) {
4469 #line 1050 "MediaEngine.vala"
4470                 model_clip_set_duration (self->record_region, self->position - model_clip_get_start (self->record_region));
4471 #line 4472 "MediaEngine.c"
4472         }
4473 }
4474
4475
4476 #line 1054 "MediaEngine.vala"
4477 void view_media_engine_close (ViewMediaEngine* self) {
4478 #line 1054 "MediaEngine.vala"
4479         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4480 #line 1055 "MediaEngine.vala"
4481         if (self->gst_state != GST_STATE_NULL) {
4482 #line 1056 "MediaEngine.vala"
4483                 self->play_state = PLAY_STATE_CLOSING;
4484 #line 1057 "MediaEngine.vala"
4485                 view_media_engine_set_gst_state (self, GST_STATE_NULL);
4486 #line 4487 "MediaEngine.c"
4487         } else {
4488 #line 1059 "MediaEngine.vala"
4489                 self->play_state = PLAY_STATE_CLOSED;
4490 #line 4491 "MediaEngine.c"
4491         }
4492 #line 1061 "MediaEngine.vala"
4493         g_signal_emit_by_name (self, "playstate-changed");
4494 #line 4495 "MediaEngine.c"
4495 }
4496
4497
4498 #line 1064 "MediaEngine.vala"
4499 void view_media_engine_post_record (ViewMediaEngine* self) {
4500 #line 4501 "MediaEngine.c"
4501         GstBin* _tmp0_;
4502         ModelClip* _tmp1_;
4503         ModelAudioTrack* _tmp2_;
4504         GstElement* _tmp4_;
4505         GstElement* _tmp3_;
4506         GstElement* _tmp6_;
4507         GstElement* _tmp5_;
4508 #line 1064 "MediaEngine.vala"
4509         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4510 #line 1065 "MediaEngine.vala"
4511         g_assert (self->gst_state == GST_STATE_NULL);
4512 #line 1067 "MediaEngine.vala"
4513         _model_track_delete_clip (MODEL_TRACK (self->record_track), self->record_region);
4514 #line 1069 "MediaEngine.vala"
4515         gst_element_unlink_many (self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL);
4516 #line 1070 "MediaEngine.vala"
4517         gst_bin_remove_many (self->record_bin, self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL);
4518 #line 1071 "MediaEngine.vala"
4519         gst_bin_remove (GST_BIN (self->pipeline), GST_ELEMENT (self->record_bin));
4520 #line 1072 "MediaEngine.vala"
4521         g_signal_emit_by_name (self, "record-completed");
4522 #line 1073 "MediaEngine.vala"
4523         self->record_bin = (_tmp0_ = NULL, _gst_object_unref0 (self->record_bin), _tmp0_);
4524 #line 1074 "MediaEngine.vala"
4525         self->record_region = (_tmp1_ = NULL, _g_object_unref0 (self->record_region), _tmp1_);
4526 #line 1075 "MediaEngine.vala"
4527         self->record_track = (_tmp2_ = NULL, _g_object_unref0 (self->record_track), _tmp2_);
4528 #line 1076 "MediaEngine.vala"
4529         self->priv->audio_in = (_tmp4_ = _gst_object_ref0 (self->priv->record_capsfilter = (_tmp3_ = NULL, _gst_object_unref0 (self->priv->record_capsfilter), _tmp3_)), _gst_object_unref0 (self->priv->audio_in), _tmp4_);
4530 #line 1077 "MediaEngine.vala"
4531         self->priv->wav_encoder = (_tmp6_ = _gst_object_ref0 (self->priv->record_sink = (_tmp5_ = NULL, _gst_object_unref0 (self->priv->record_sink), _tmp5_)), _gst_object_unref0 (self->priv->wav_encoder), _tmp6_);
4532 #line 1078 "MediaEngine.vala"
4533         view_media_engine_set_gst_state (self, GST_STATE_PAUSED);
4534 #line 4535 "MediaEngine.c"
4535 }
4536
4537
4538 #line 1081 "MediaEngine.vala"
4539 void view_media_engine_record (ViewMediaEngine* self, ModelAudioTrack* track) {
4540 #line 4541 "MediaEngine.c"
4541         ModelAudioTrack* _tmp0_;
4542         char* filename;
4543         ModelClipFile* clip_file;
4544         ModelClip* _tmp1_;
4545 #line 1081 "MediaEngine.vala"
4546         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4547 #line 1081 "MediaEngine.vala"
4548         g_return_if_fail (MODEL_IS_AUDIO_TRACK (track));
4549 #line 1082 "MediaEngine.vala"
4550         g_assert (self->gst_state != GST_STATE_NULL);
4551 #line 1083 "MediaEngine.vala"
4552         self->play_state = PLAY_STATE_PRE_RECORD_NULL;
4553 #line 1084 "MediaEngine.vala"
4554         view_media_engine_set_gst_state (self, GST_STATE_NULL);
4555 #line 1085 "MediaEngine.vala"
4556         self->record_track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->record_track), _tmp0_);
4557 #line 1087 "MediaEngine.vala"
4558         filename = view_media_engine_new_audio_filename (self, MODEL_TRACK (track));
4559 #line 1088 "MediaEngine.vala"
4560         clip_file = model_clip_file_new (filename, 0);
4561 #line 1089 "MediaEngine.vala"
4562         self->record_region = (_tmp1_ = model_clip_new (clip_file, MODEL_MEDIA_TYPE_AUDIO, "", self->position, (gint64) 0, (gint64) 1, TRUE), _g_object_unref0 (self->record_region), _tmp1_);
4563 #line 4564 "MediaEngine.c"
4564         _g_free0 (filename);
4565         _g_object_unref0 (clip_file);
4566 }
4567
4568
4569 #line 1092 "MediaEngine.vala"
4570 void view_media_engine_start_record (ViewMediaEngine* self, ModelClip* region, GError** error) {
4571 #line 4572 "MediaEngine.c"
4572         GError * _inner_error_;
4573         GstBin* _tmp0_;
4574         GstElement* _tmp1_;
4575         GstElement* _tmp2_;
4576         GValue _tmp4_;
4577         GValue _tmp3_ = {0};
4578         GstElement* _tmp5_;
4579         GstElement* _tmp6_;
4580         GstCaps* _tmp7_;
4581         GstElement* _tmp8_;
4582         GstElement* _tmp9_;
4583         GstElement* _tmp10_;
4584         GstElement* _tmp11_;
4585 #line 1092 "MediaEngine.vala"
4586         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4587 #line 1092 "MediaEngine.vala"
4588         g_return_if_fail (MODEL_IS_CLIP (region));
4589 #line 4590 "MediaEngine.c"
4590         _inner_error_ = NULL;
4591 #line 1093 "MediaEngine.vala"
4592         if (model_project_transport_is_recording (self->priv->project)) {
4593 #line 1094 "MediaEngine.vala"
4594                 return;
4595 #line 4596 "MediaEngine.c"
4596         }
4597 #line 1096 "MediaEngine.vala"
4598         if (model_project_transport_is_playing (self->priv->project)) {
4599 #line 1097 "MediaEngine.vala"
4600                 g_error ("MediaEngine.vala:1097: can't switch from playing to recording");
4601 #line 4602 "MediaEngine.c"
4602         }
4603 #line 1099 "MediaEngine.vala"
4604         if (self->gst_state != GST_STATE_NULL) {
4605 #line 1100 "MediaEngine.vala"
4606                 g_error ("MediaEngine.vala:1100: can't record now: %s", gst_element_state_get_name (self->gst_state));
4607 #line 4608 "MediaEngine.c"
4608         }
4609 #line 1101 "MediaEngine.vala"
4610         self->record_bin = (_tmp0_ = (GstBin*) gst_bin_new ("recordingbin"), _gst_object_unref0 (self->record_bin), _tmp0_);
4611 #line 1102 "MediaEngine.vala"
4612         _model_track_move (MODEL_TRACK (self->record_track), self->record_region, self->position);
4613 #line 1103 "MediaEngine.vala"
4614         g_signal_emit_by_name (MODEL_TRACK (self->record_track), "clip-added", self->record_region, TRUE);
4615 #line 1104 "MediaEngine.vala"
4616         _tmp1_ = make_element ("pulsesrc", &_inner_error_);
4617 #line 4618 "MediaEngine.c"
4618         if (_inner_error_ != NULL) {
4619                 g_propagate_error (error, _inner_error_);
4620                 return;
4621         }
4622 #line 1104 "MediaEngine.vala"
4623         self->priv->audio_in = (_tmp2_ = _tmp1_, _gst_object_unref0 (self->priv->audio_in), _tmp2_);
4624 #line 1105 "MediaEngine.vala"
4625         g_object_set_property (G_OBJECT (self->priv->audio_in), "device", (_tmp4_ = (g_value_init (&_tmp3_, G_TYPE_STRING), g_value_set_string (&_tmp3_, "source.hw0"), _tmp3_), &_tmp4_));
4626 #line 1106 "MediaEngine.vala"
4627         _tmp5_ = make_element ("capsfilter", &_inner_error_);
4628 #line 4629 "MediaEngine.c"
4629         if (_inner_error_ != NULL) {
4630                 g_propagate_error (error, _inner_error_);
4631                 return;
4632         }
4633 #line 1106 "MediaEngine.vala"
4634         self->priv->record_capsfilter = (_tmp6_ = _tmp5_, _gst_object_unref0 (self->priv->record_capsfilter), _tmp6_);
4635 #line 1107 "MediaEngine.vala"
4636         g_object_set (G_OBJECT (self->priv->record_capsfilter), "caps", _tmp7_ = view_media_engine_get_record_audio_caps (self), NULL);
4637 #line 4638 "MediaEngine.c"
4638         _gst_caps_unref0 (_tmp7_);
4639 #line 1108 "MediaEngine.vala"
4640         _tmp8_ = make_element ("filesink", &_inner_error_);
4641 #line 4642 "MediaEngine.c"
4642         if (_inner_error_ != NULL) {
4643                 g_propagate_error (error, _inner_error_);
4644                 return;
4645         }
4646 #line 1108 "MediaEngine.vala"
4647         self->priv->record_sink = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->record_sink), _tmp9_);
4648 #line 1109 "MediaEngine.vala"
4649         g_object_set (G_OBJECT (self->priv->record_sink), "location", self->record_region->clipfile->filename, NULL);
4650 #line 1110 "MediaEngine.vala"
4651         _tmp10_ = make_element ("wavenc", &_inner_error_);
4652 #line 4653 "MediaEngine.c"
4653         if (_inner_error_ != NULL) {
4654                 g_propagate_error (error, _inner_error_);
4655                 return;
4656         }
4657 #line 1110 "MediaEngine.vala"
4658         self->priv->wav_encoder = (_tmp11_ = _tmp10_, _gst_object_unref0 (self->priv->wav_encoder), _tmp11_);
4659 #line 1112 "MediaEngine.vala"
4660         gst_bin_add_many (self->record_bin, _gst_object_ref0 (self->priv->audio_in), _gst_object_ref0 (self->priv->record_capsfilter), _gst_object_ref0 (self->priv->wav_encoder), _gst_object_ref0 (self->priv->record_sink), NULL);
4661 #line 1113 "MediaEngine.vala"
4662         if (!gst_element_link_many (self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL)) {
4663 #line 1114 "MediaEngine.vala"
4664                 g_error ("MediaEngine.vala:1114: audio_in: couldn't link");
4665 #line 4666 "MediaEngine.c"
4666         }
4667 #line 1115 "MediaEngine.vala"
4668         gst_bin_add (GST_BIN (self->pipeline), _gst_object_ref0 (GST_ELEMENT (self->record_bin)));
4669 #line 1117 "MediaEngine.vala"
4670         self->play_state = PLAY_STATE_PRE_RECORD;
4671 #line 1118 "MediaEngine.vala"
4672         view_media_engine_set_gst_state (self, GST_STATE_PAUSED);
4673 #line 4674 "MediaEngine.c"
4674 }
4675
4676
4677 #line 1121 "MediaEngine.vala"
4678 GstCaps* view_media_engine_get_record_audio_caps (ViewMediaEngine* self) {
4679 #line 4680 "MediaEngine.c"
4680         GstCaps* result = NULL;
4681 #line 1121 "MediaEngine.vala"
4682         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
4683 #line 4684 "MediaEngine.c"
4684         result = view_media_engine_build_audio_caps (self, CHANNELS_PER_TRACK_RECORD);
4685 #line 1122 "MediaEngine.vala"
4686         return result;
4687 #line 4688 "MediaEngine.c"
4688 }
4689
4690
4691 #line 1125 "MediaEngine.vala"
4692 static char* view_media_engine_new_audio_filename (ViewMediaEngine* self, ModelTrack* track) {
4693 #line 4694 "MediaEngine.c"
4694         char* result = NULL;
4695         gint i;
4696         char* base_path;
4697         char* _tmp0_;
4698         char* _tmp1_;
4699         char* base_name;
4700 #line 1125 "MediaEngine.vala"
4701         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
4702 #line 1125 "MediaEngine.vala"
4703         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
4704 #line 1126 "MediaEngine.vala"
4705         i = 1;
4706 #line 1127 "MediaEngine.vala"
4707         base_path = model_project_get_audio_path (self->priv->project);
4708 #line 1128 "MediaEngine.vala"
4709         g_mkdir (base_path, 0777);
4710 #line 1129 "MediaEngine.vala"
4711         base_name = (_tmp1_ = g_build_filename (base_path, _tmp0_ = view_media_engine_generate_base (self, track->display_name), NULL), _g_free0 (_tmp0_), _tmp1_);
4712 #line 1130 "MediaEngine.vala"
4713         while (TRUE) {
4714 #line 4715 "MediaEngine.c"
4715                 char* name;
4716 #line 1131 "MediaEngine.vala"
4717                 name = g_strdup_printf ("%s_%d.wav", base_name, i);
4718 #line 1132 "MediaEngine.vala"
4719                 if (!g_file_test (name, G_FILE_TEST_EXISTS)) {
4720 #line 4721 "MediaEngine.c"
4721                         result = name;
4722                         _g_free0 (base_path);
4723                         _g_free0 (base_name);
4724 #line 1133 "MediaEngine.vala"
4725                         return result;
4726 #line 4727 "MediaEngine.c"
4727                 }
4728 #line 1135 "MediaEngine.vala"
4729                 i = i + 1;
4730 #line 4731 "MediaEngine.c"
4731                 _g_free0 (name);
4732         }
4733         _g_free0 (base_path);
4734         _g_free0 (base_name);
4735 }
4736
4737
4738 #line 1139 "MediaEngine.vala"
4739 static char* view_media_engine_generate_base (ViewMediaEngine* self, const char* name) {
4740 #line 4741 "MediaEngine.c"
4741         char* result = NULL;
4742         char* base_name;
4743 #line 1139 "MediaEngine.vala"
4744         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
4745 #line 1139 "MediaEngine.vala"
4746         g_return_val_if_fail (name != NULL, NULL);
4747 #line 1140 "MediaEngine.vala"
4748         base_name = g_utf8_strdown (name, -1);
4749 #line 1141 "MediaEngine.vala"
4750         g_strcanon (base_name, "abcdefghijklmnopqrstuvwxyz1234567890", '_');
4751 #line 4752 "MediaEngine.c"
4752         result = base_name;
4753 #line 1142 "MediaEngine.vala"
4754         return result;
4755 #line 4756 "MediaEngine.c"
4756 }
4757
4758
4759 #line 1180 "MediaEngine.vala"
4760 static void _view_media_engine_on_track_removed_view_media_track_track_removed (ViewMediaTrack* _sender, ViewMediaTrack* track, gpointer self) {
4761 #line 4762 "MediaEngine.c"
4762         view_media_engine_on_track_removed (self, track);
4763 }
4764
4765
4766 #line 1185 "MediaEngine.vala"
4767 static void _view_media_engine_on_error_occurred_view_media_track_error_occurred (ViewMediaTrack* _sender, const char* major_message, const char* minor_message, gpointer self) {
4768 #line 4769 "MediaEngine.c"
4769         view_media_engine_on_error_occurred (self, major_message, minor_message);
4770 }
4771
4772
4773 #line 1145 "MediaEngine.vala"
4774 void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track) {
4775 #line 4776 "MediaEngine.c"
4776         GError * _inner_error_;
4777         ViewMediaTrack* media_track;
4778 #line 1145 "MediaEngine.vala"
4779         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4780 #line 1145 "MediaEngine.vala"
4781         g_return_if_fail (MODEL_IS_TRACK (track));
4782 #line 4783 "MediaEngine.c"
4783         _inner_error_ = NULL;
4784 #line 1146 "MediaEngine.vala"
4785         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_added");
4786 #line 1147 "MediaEngine.vala"
4787         media_track = NULL;
4788 #line 4789 "MediaEngine.c"
4789         {
4790 #line 1149 "MediaEngine.vala"
4791                 switch (model_track_media_type (track)) {
4792 #line 4793 "MediaEngine.c"
4793                         case MODEL_MEDIA_TYPE_AUDIO:
4794                         {
4795                                 ViewMediaTrack* _tmp0_;
4796                                 ViewMediaTrack* _tmp1_;
4797 #line 1151 "MediaEngine.vala"
4798                                 _tmp0_ = view_media_engine_create_audio_track (self, track, &_inner_error_);
4799 #line 4800 "MediaEngine.c"
4800                                 if (_inner_error_ != NULL) {
4801                                         goto __catch11_g_error;
4802                                 }
4803 #line 1151 "MediaEngine.vala"
4804                                 media_track = (_tmp1_ = _tmp0_, _g_object_unref0 (media_track), _tmp1_);
4805 #line 1152 "MediaEngine.vala"
4806                                 break;
4807 #line 4808 "MediaEngine.c"
4808                         }
4809                         case MODEL_MEDIA_TYPE_VIDEO:
4810                         {
4811                                 ViewMediaVideoTrack* _tmp2_;
4812                                 ViewMediaTrack* _tmp3_;
4813 #line 1154 "MediaEngine.vala"
4814                                 _tmp2_ = view_media_video_track_new (self, track, self->converter, &_inner_error_);
4815 #line 4816 "MediaEngine.c"
4816                                 if (_inner_error_ != NULL) {
4817                                         goto __catch11_g_error;
4818                                 }
4819 #line 1154 "MediaEngine.vala"
4820                                 media_track = (_tmp3_ = VIEW_MEDIA_TRACK (_tmp2_), _g_object_unref0 (media_track), _tmp3_);
4821 #line 1155 "MediaEngine.vala"
4822                                 break;
4823 #line 4824 "MediaEngine.c"
4824                         }
4825                 }
4826         }
4827         goto __finally11;
4828         __catch11_g_error:
4829         {
4830                 GError * _error_;
4831                 _error_ = _inner_error_;
4832                 _inner_error_ = NULL;
4833                 {
4834 #line 1158 "MediaEngine.vala"
4835                         g_signal_emit_by_name (self, "error-occurred", "An error occurred adding the track.", NULL);
4836 #line 1159 "MediaEngine.vala"
4837                         g_warning ("MediaEngine.vala:1159: An error occurred adding the track: %s", _error_->message);
4838 #line 4839 "MediaEngine.c"
4839                         _g_error_free0 (_error_);
4840                         _g_object_unref0 (media_track);
4841 #line 1160 "MediaEngine.vala"
4842                         return;
4843 #line 4844 "MediaEngine.c"
4844                 }
4845         }
4846         __finally11:
4847         if (_inner_error_ != NULL) {
4848                 _g_object_unref0 (media_track);
4849                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
4850                 g_clear_error (&_inner_error_);
4851                 return;
4852         }
4853 #line 1163 "MediaEngine.vala"
4854         g_signal_connect_object (media_track, "track-removed", (GCallback) _view_media_engine_on_track_removed_view_media_track_track_removed, self, 0);
4855 #line 1164 "MediaEngine.vala"
4856         g_signal_connect_object (media_track, "error-occurred", (GCallback) _view_media_engine_on_error_occurred_view_media_track_error_occurred, self, 0);
4857 #line 1166 "MediaEngine.vala"
4858         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->tracks), media_track);
4859 #line 4860 "MediaEngine.c"
4860         _g_object_unref0 (media_track);
4861 }
4862
4863
4864 #line 1169 "MediaEngine.vala"
4865 static ViewMediaTrack* view_media_engine_create_audio_track (ViewMediaEngine* self, ModelTrack* track, GError** error) {
4866 #line 4867 "MediaEngine.c"
4867         ViewMediaTrack* result = NULL;
4868         GError * _inner_error_;
4869         ModelTrack* _tmp0_;
4870         ModelAudioTrack* model_track;
4871         ViewMediaAudioTrack* audio_track;
4872 #line 1169 "MediaEngine.vala"
4873         g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL);
4874 #line 1169 "MediaEngine.vala"
4875         g_return_val_if_fail (MODEL_IS_TRACK (track), NULL);
4876 #line 4877 "MediaEngine.c"
4877         _inner_error_ = NULL;
4878 #line 1170 "MediaEngine.vala"
4879         model_track = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL));
4880 #line 1171 "MediaEngine.vala"
4881         audio_track = NULL;
4882 #line 1172 "MediaEngine.vala"
4883         if (model_track != NULL) {
4884 #line 4885 "MediaEngine.c"
4885                 ViewMediaAudioTrack* _tmp1_;
4886                 ViewMediaAudioTrack* _tmp2_;
4887 #line 1173 "MediaEngine.vala"
4888                 _tmp1_ = view_media_audio_track_new (self, model_track, &_inner_error_);
4889 #line 4890 "MediaEngine.c"
4890                 if (_inner_error_ != NULL) {
4891                         g_propagate_error (error, _inner_error_);
4892                         _g_object_unref0 (model_track);
4893                         _g_object_unref0 (audio_track);
4894                         return NULL;
4895                 }
4896 #line 1173 "MediaEngine.vala"
4897                 audio_track = (_tmp2_ = _tmp1_, _g_object_unref0 (audio_track), _tmp2_);
4898 #line 4899 "MediaEngine.c"
4899         } else {
4900 #line 1175 "MediaEngine.vala"
4901                 g_assert (FALSE);
4902 #line 4903 "MediaEngine.c"
4903         }
4904         result = VIEW_MEDIA_TRACK (audio_track);
4905         _g_object_unref0 (model_track);
4906 #line 1177 "MediaEngine.vala"
4907         return result;
4908 #line 4909 "MediaEngine.c"
4909 }
4910
4911
4912 #line 1180 "MediaEngine.vala"
4913 static void view_media_engine_on_track_removed (ViewMediaEngine* self, ViewMediaTrack* track) {
4914 #line 1180 "MediaEngine.vala"
4915         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4916 #line 1180 "MediaEngine.vala"
4917         g_return_if_fail (VIEW_IS_MEDIA_TRACK (track));
4918 #line 1181 "MediaEngine.vala"
4919         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed");
4920 #line 1182 "MediaEngine.vala"
4921         gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->tracks), track);
4922 #line 4923 "MediaEngine.c"
4923 }
4924
4925
4926 #line 1185 "MediaEngine.vala"
4927 static void view_media_engine_on_error_occurred (ViewMediaEngine* self, const char* major_message, const char* minor_message) {
4928 #line 1185 "MediaEngine.vala"
4929         g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self));
4930 #line 1185 "MediaEngine.vala"
4931         g_return_if_fail (major_message != NULL);
4932 #line 1186 "MediaEngine.vala"
4933         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred");
4934 #line 1187 "MediaEngine.vala"
4935         g_signal_emit_by_name (self, "error-occurred", major_message, minor_message);
4936 #line 4937 "MediaEngine.c"
4937 }
4938
4939
4940 static void view_media_engine_class_init (ViewMediaEngineClass * klass) {
4941         view_media_engine_parent_class = g_type_class_peek_parent (klass);
4942         g_type_class_add_private (klass, sizeof (ViewMediaEnginePrivate));
4943         VIEW_MEDIA_ENGINE_CLASS (klass)->do_null_state_export = view_media_engine_real_do_null_state_export;
4944         VIEW_MEDIA_ENGINE_CLASS (klass)->pause = view_media_engine_real_pause;
4945         G_OBJECT_CLASS (klass)->finalize = view_media_engine_finalize;
4946         g_signal_new ("playstate_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
4947         g_signal_new ("position_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
4948         g_signal_new ("pre_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
4949         g_signal_new ("post_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
4950         g_signal_new ("callback_pulse", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
4951         g_signal_new ("level_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE, G_TYPE_NONE, 3, GST_TYPE_OBJECT, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
4952         g_signal_new ("record_completed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
4953         g_signal_new ("link_for_playback", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
4954         g_signal_new ("link_for_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
4955         g_signal_new ("prepare_window", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
4956         g_signal_new ("error_occurred", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
4957 }
4958
4959
4960 static void view_media_engine_multi_file_progress_interface_interface_init (MultiFileProgressInterfaceIface * iface) {
4961         view_media_engine_multi_file_progress_interface_parent_iface = g_type_interface_peek_parent (iface);
4962         iface->cancel = view_media_engine_real_cancel;
4963         iface->complete = view_media_engine_real_complete;
4964 }
4965
4966
4967 static void view_media_engine_instance_init (ViewMediaEngine * self) {
4968         self->priv = VIEW_MEDIA_ENGINE_GET_PRIVATE (self);
4969         self->play_state = PLAY_STATE_STOPPED;
4970 }
4971
4972
4973 static void view_media_engine_finalize (GObject* obj) {
4974         ViewMediaEngine * self;
4975         self = VIEW_MEDIA_ENGINE (obj);
4976         _gst_object_unref0 (self->pipeline);
4977         _gst_object_unref0 (self->record_bin);
4978         _gst_object_unref0 (self->converter);
4979         _gst_object_unref0 (self->adder);
4980         _g_object_unref0 (self->record_track);
4981         _g_object_unref0 (self->record_region);
4982         _gst_object_unref0 (self->priv->audio_in);
4983         _gst_object_unref0 (self->priv->record_capsfilter);
4984         _gst_object_unref0 (self->priv->wav_encoder);
4985         _gst_object_unref0 (self->priv->record_sink);
4986         _g_object_unref0 (self->priv->tracks);
4987         G_OBJECT_CLASS (view_media_engine_parent_class)->finalize (obj);
4988 }
4989
4990
4991 GType view_media_engine_get_type (void) {
4992         static volatile gsize view_media_engine_type_id__volatile = 0;
4993         if (g_once_init_enter (&view_media_engine_type_id__volatile)) {
4994                 static const GTypeInfo g_define_type_info = { sizeof (ViewMediaEngineClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_engine_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaEngine), 0, (GInstanceInitFunc) view_media_engine_instance_init, NULL };
4995                 static const GInterfaceInfo multi_file_progress_interface_info = { (GInterfaceInitFunc) view_media_engine_multi_file_progress_interface_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4996                 GType view_media_engine_type_id;
4997                 view_media_engine_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaEngine", &g_define_type_info, 0);
4998                 g_type_add_interface_static (view_media_engine_type_id, TYPE_MULTI_FILE_PROGRESS_INTERFACE, &multi_file_progress_interface_info);
4999                 g_once_init_leave (&view_media_engine_type_id__volatile, view_media_engine_type_id);
5000         }
5001         return view_media_engine_type_id__volatile;
5002 }
5003
5004
5005 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
5006         if ((array != NULL) && (destroy_func != NULL)) {
5007                 int i;
5008                 for (i = 0; i < array_length; i = i + 1) {
5009                         if (((gpointer*) array)[i] != NULL) {
5010                                 destroy_func (((gpointer*) array)[i]);
5011                         }
5012                 }
5013         }
5014 }
5015
5016
5017 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
5018         _vala_array_destroy (array, array_length, destroy_func);
5019         g_free (array);
5020 }
5021
5022
5023 static int _vala_strcmp0 (const char * str1, const char * str2) {
5024         if (str1 == NULL) {
5025                 return -(str1 != str2);
5026         }
5027         if (str2 == NULL) {
5028                 return str1 != str2;
5029         }
5030         return strcmp (str1, str2);
5031 }
5032
5033
5034
5035 static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
5036         typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2);
5037         register GMarshalFunc_VOID__STRING_STRING callback;
5038         register GCClosure * cc;
5039         register gpointer data1, data2;
5040         cc = (GCClosure *) closure;
5041         g_return_if_fail (n_param_values == 3);
5042         if (G_CCLOSURE_SWAP_DATA (closure)) {
5043                 data1 = closure->data;
5044                 data2 = param_values->data[0].v_pointer;
5045         } else {
5046                 data1 = param_values->data[0].v_pointer;
5047                 data2 = closure->data;
5048         }
5049         callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
5050         callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2);
5051 }
5052
5053
5054 static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
5055         typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1, double arg_1, double arg_2, gpointer data2);
5056         register GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
5057         register GCClosure * cc;
5058         register gpointer data1, data2;
5059         cc = (GCClosure *) closure;
5060         g_return_if_fail (n_param_values == 3);
5061         if (G_CCLOSURE_SWAP_DATA (closure)) {
5062                 data1 = closure->data;
5063                 data2 = param_values->data[0].v_pointer;
5064         } else {
5065                 data1 = param_values->data[0].v_pointer;
5066                 data2 = closure->data;
5067         }
5068         callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
5069         callback (data1, g_value_get_double (param_values + 1), g_value_get_double (param_values + 2), data2);
5070 }
5071
5072
5073 static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
5074         typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1, gint64 arg_1, gpointer data2);
5075         register GMarshalFunc_VOID__INT64 callback;
5076         register GCClosure * cc;
5077         register gpointer data1, data2;
5078         cc = (GCClosure *) closure;
5079         g_return_if_fail (n_param_values == 2);
5080         if (G_CCLOSURE_SWAP_DATA (closure)) {
5081                 data1 = closure->data;
5082                 data2 = param_values->data[0].v_pointer;
5083         } else {
5084                 data1 = param_values->data[0].v_pointer;
5085                 data2 = closure->data;
5086         }
5087         callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);
5088         callback (data1, g_value_get_int64 (param_values + 1), data2);
5089 }
5090
5091
5092 static void g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
5093         typedef void (*GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE) (gpointer data1, gpointer arg_1, double arg_2, double arg_3, gpointer data2);
5094         register GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE callback;
5095         register GCClosure * cc;
5096         register gpointer data1, data2;
5097         cc = (GCClosure *) closure;
5098         g_return_if_fail (n_param_values == 4);
5099         if (G_CCLOSURE_SWAP_DATA (closure)) {
5100                 data1 = closure->data;
5101                 data2 = param_values->data[0].v_pointer;
5102         } else {
5103                 data1 = param_values->data[0].v_pointer;
5104                 data2 = closure->data;
5105         }
5106         callback = (GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
5107         callback (data1, g_value_get_object (param_values + 1), g_value_get_double (param_values + 2), g_value_get_double (param_values + 3), data2);
5108 }
5109
5110
5111