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

   1 /* clip.c generated by valac, the Vala compiler
   2  * generated from clip.vala, do not modify */
   3
   4 /* Copyright 2009 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 <stdlib.h>
  13 #include <string.h>
  14 #include <gst/gst.h>
  15 #include <gdk-pixbuf/gdk-pixdata.h>
  16 #include <gst/base/gstbasesink.h>
  17 #include <gdk/gdk.h>
  18 #include <stdio.h>
  19 #include <gobject/gvaluecollector.h>
  20
  21
  22 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
  23
  24 #define MODEL_TYPE_GAP (model_gap_get_type ())
  25 #define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap))
  26 #define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass))
  27 #define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP))
  28 #define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP))
  29 #define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass))
  30
  31 typedef struct _ModelGap ModelGap;
  32 typedef struct _ModelGapClass ModelGapClass;
  33 typedef struct _ModelGapPrivate ModelGapPrivate;
  34 typedef struct _ModelParamSpecGap ModelParamSpecGap;
  35
  36 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  37 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  38 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  39 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  40 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  41 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  42
  43 typedef struct _ModelClipFile ModelClipFile;
  44 typedef struct _ModelClipFileClass ModelClipFileClass;
  45 typedef struct _ModelClipFilePrivate ModelClipFilePrivate;
  46 #define _g_free0(var) (var = (g_free (var), NULL))
  47 #define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
  48 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  49
  50 #define LOGGING_TYPE_FACILITY (logging_facility_get_type ())
  51
  52 #define LOGGING_TYPE_LEVEL (logging_level_get_type ())
  53 #define _gst_structure_free0(var) ((var == NULL) ? NULL : (var = (gst_structure_free (var), NULL)))
  54
  55 #define TYPE_FRACTION (fraction_get_type ())
  56 typedef struct _Fraction Fraction;
  57
  58 #define MODEL_TYPE_FETCHER (model_fetcher_get_type ())
  59 #define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher))
  60 #define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass))
  61 #define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER))
  62 #define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER))
  63 #define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass))
  64
  65 typedef struct _ModelFetcher ModelFetcher;
  66 typedef struct _ModelFetcherClass ModelFetcherClass;
  67 typedef struct _ModelFetcherPrivate ModelFetcherPrivate;
  68 #define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
  69 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  70
  71 #define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ())
  72 #define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher))
  73 #define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  74 #define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER))
  75 #define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER))
  76 #define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  77
  78 typedef struct _ModelClipFetcher ModelClipFetcher;
  79 typedef struct _ModelClipFetcherClass ModelClipFetcherClass;
  80 typedef struct _ModelClipFetcherPrivate ModelClipFetcherPrivate;
  81
  82 #define MODEL_TYPE_THUMBNAIL_FETCHER (model_thumbnail_fetcher_get_type ())
  83 #define MODEL_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcher))
  84 #define MODEL_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass))
  85 #define MODEL_IS_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_THUMBNAIL_FETCHER))
  86 #define MODEL_IS_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_THUMBNAIL_FETCHER))
  87 #define MODEL_THUMBNAIL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass))
  88
  89 typedef struct _ModelThumbnailFetcher ModelThumbnailFetcher;
  90 typedef struct _ModelThumbnailFetcherClass ModelThumbnailFetcherClass;
  91 typedef struct _ModelThumbnailFetcherPrivate ModelThumbnailFetcherPrivate;
  92
  93 #define TYPE_THUMBNAIL_SINK (thumbnail_sink_get_type ())
  94 #define THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSink))
  95 #define THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass))
  96 #define IS_THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_THUMBNAIL_SINK))
  97 #define IS_THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_THUMBNAIL_SINK))
  98 #define THUMBNAIL_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass))
  99
 100 typedef struct _ThumbnailSink ThumbnailSink;
 101 typedef struct _ThumbnailSinkClass ThumbnailSinkClass;
 102
 103 #define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ())
 104 #define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin))
 105 #define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
 106 #define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN))
 107 #define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN))
 108 #define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass))
 109
 110 typedef struct _SingleDecodeBin SingleDecodeBin;
 111 typedef struct _SingleDecodeBinClass SingleDecodeBinClass;
 112
 113 #define MODEL_TYPE_CLIP (model_clip_get_type ())
 114 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
 115 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
 116 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
 117 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
 118 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
 119
 120 typedef struct _ModelClip ModelClip;
 121 typedef struct _ModelClipClass ModelClipClass;
 122 typedef struct _ModelClipPrivate ModelClipPrivate;
 123
 124 #define MODEL_TYPE_FETCHER_COMPLETION (model_fetcher_completion_get_type ())
 125 #define MODEL_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletion))
 126 #define MODEL_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass))
 127 #define MODEL_IS_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER_COMPLETION))
 128 #define MODEL_IS_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER_COMPLETION))
 129 #define MODEL_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass))
 130
 131 typedef struct _ModelFetcherCompletion ModelFetcherCompletion;
 132 typedef struct _ModelFetcherCompletionClass ModelFetcherCompletionClass;
 133 typedef struct _ModelFetcherCompletionPrivate ModelFetcherCompletionPrivate;
 134 typedef struct _ModelParamSpecFetcherCompletion ModelParamSpecFetcherCompletion;
 135
 136 typedef enum  {
 137         MODEL_MEDIA_TYPE_AUDIO,
 138         MODEL_MEDIA_TYPE_VIDEO
 139 } ModelMediaType;
 140
 141 struct _ModelGap {
 142         GTypeInstance parent_instance;
 143         volatile int ref_count;
 144         ModelGapPrivate * priv;
 145         gint64 start;
 146         gint64 end;
 147 };
 148
 149 struct _ModelGapClass {
 150         GTypeClass parent_class;
 151         void (*finalize) (ModelGap *self);
 152 };
 153
 154 struct _ModelParamSpecGap {
 155         GParamSpec parent_instance;
 156 };
 157
 158 struct _ModelClipFile {
 159         GObject parent_instance;
 160         ModelClipFilePrivate * priv;
 161         char* filename;
 162         GstCaps* video_caps;
 163         GstCaps* audio_caps;
 164         GdkPixbuf* thumbnail;
 165 };
 166
 167 struct _ModelClipFileClass {
 168         GObjectClass parent_class;
 169 };
 170
 171 struct _ModelClipFilePrivate {
 172         gint64 _length;
 173         gboolean online;
 174 };
 175
 176 typedef enum  {
 177         LOGGING_FACILITY_SIGNAL_HANDLERS,
 178         LOGGING_FACILITY_DEVELOPER_WARNINGS,
 179         LOGGING_FACILITY_GRAPH,
 180         LOGGING_FACILITY_LOADING,
 181         LOGGING_FACILITY_IMPORT,
 182         LOGGING_FACILITY_SINGLEDECODEBIN
 183 } LoggingFacility;
 184
 185 typedef enum  {
 186         LOGGING_LEVEL_CRITICAL,
 187         LOGGING_LEVEL_HIGH,
 188         LOGGING_LEVEL_MEDIUM,
 189         LOGGING_LEVEL_LOW,
 190         LOGGING_LEVEL_INFO,
 191         LOGGING_LEVEL_VERBOSE
 192 } LoggingLevel;
 193
 194 struct _Fraction {
 195         gint numerator;
 196         gint denominator;
 197 };
 198
 199 struct _ModelFetcher {
 200         GObject parent_instance;
 201         ModelFetcherPrivate * priv;
 202         GstElement* filesrc;
 203         GstElement* decodebin;
 204         GstPipeline* pipeline;
 205         ModelClipFile* clipfile;
 206         char* error_string;
 207 };
 208
 209 struct _ModelFetcherClass {
 210         GObjectClass parent_class;
 211         void (*on_pad_added) (ModelFetcher* self, GstPad* pad);
 212         void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message);
 213 };
 214
 215 struct _ModelClipFetcher {
 216         ModelFetcher parent_instance;
 217         ModelClipFetcherPrivate * priv;
 218 };
 219
 220 struct _ModelClipFetcherClass {
 221         ModelFetcherClass parent_class;
 222 };
 223
 224 struct _ModelThumbnailFetcher {
 225         ModelFetcher parent_instance;
 226         ModelThumbnailFetcherPrivate * priv;
 227 };
 228
 229 struct _ModelThumbnailFetcherClass {
 230         ModelFetcherClass parent_class;
 231 };
 232
 233 struct _ModelThumbnailFetcherPrivate {
 234         ThumbnailSink* thumbnail_sink;
 235         GstElement* colorspace;
 236         gint64 seek_position;
 237         gboolean done_seek;
 238         gboolean have_thumbnail;
 239 };
 240
 241 struct _ModelClip {
 242         GObject parent_instance;
 243         ModelClipPrivate * priv;
 244         ModelClipFile* clipfile;
 245         ModelMediaType type;
 246         gboolean is_recording;
 247         char* name;
 248 };
 249
 250 struct _ModelClipClass {
 251         GObjectClass parent_class;
 252 };
 253
 254 struct _ModelClipPrivate {
 255         gint64 _start;
 256         gint64 _media_start;
 257         gint64 _duration;
 258         gboolean connected;
 259 };
 260
 261 struct _ModelFetcherCompletion {
 262         GTypeInstance parent_instance;
 263         volatile int ref_count;
 264         ModelFetcherCompletionPrivate * priv;
 265 };
 266
 267 struct _ModelFetcherCompletionClass {
 268         GTypeClass parent_class;
 269         void (*finalize) (ModelFetcherCompletion *self);
 270         void (*complete) (ModelFetcherCompletion* self, ModelFetcher* fetcher);
 271 };
 272
 273 struct _ModelParamSpecFetcherCompletion {
 274         GParamSpec parent_instance;
 275 };
 276
 277
 278 static gpointer model_gap_parent_class = NULL;
 279 static gpointer model_clip_file_parent_class = NULL;
 280 static gpointer model_fetcher_parent_class = NULL;
 281 static gpointer model_clip_fetcher_parent_class = NULL;
 282 static gpointer model_thumbnail_fetcher_parent_class = NULL;
 283 static gpointer model_clip_parent_class = NULL;
 284 static gpointer model_fetcher_completion_parent_class = NULL;
 285
 286 GType model_media_type_get_type (void);
 287 gpointer model_gap_ref (gpointer instance);
 288 void model_gap_unref (gpointer instance);
 289 GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 290 void model_value_set_gap (GValue* value, gpointer v_object);
 291 void model_value_take_gap (GValue* value, gpointer v_object);
 292 gpointer model_value_get_gap (const GValue* value);
 293 GType model_gap_get_type (void);
 294 enum  {
 295         MODEL_GAP_DUMMY_PROPERTY
 296 };
 297 ModelGap* model_gap_new (gint64 start, gint64 end);
 298 ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end);
 299 gboolean model_gap_is_empty (ModelGap* self);
 300 ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g);
 301 static void model_gap_finalize (ModelGap* obj);
 302 GType model_clip_file_get_type (void);
 303 #define MODEL_CLIP_FILE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FILE, ModelClipFilePrivate))
 304 enum  {
 305         MODEL_CLIP_FILE_DUMMY_PROPERTY,
 306         MODEL_CLIP_FILE_LENGTH
 307 };
 308 void model_clip_file_set_length (ModelClipFile* self, gint64 value);
 309 ModelClipFile* model_clip_file_new (const char* filename, gint64 length);
 310 ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length);
 311 gboolean model_clip_file_is_online (ModelClipFile* self);
 312 GType logging_facility_get_type (void);
 313 GType logging_level_get_type (void);
 314 void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message);
 315 void model_clip_file_set_online (ModelClipFile* self, gboolean o);
 316 void model_clip_file_set_thumbnail (ModelClipFile* self, GdkPixbuf* b);
 317 gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m);
 318 gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t);
 319 static gboolean model_clip_file_get_caps_structure (ModelClipFile* self, ModelMediaType m, GstStructure** s);
 320 GType fraction_get_type (void);
 321 Fraction* fraction_dup (const Fraction* self);
 322 void fraction_free (Fraction* self);
 323 gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate);
 324 gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h);
 325 gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate);
 326 gboolean model_clip_file_get_video_format (ModelClipFile* self, guint32* fourcc);
 327 gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels);
 328 gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s);
 329 gint64 model_clip_file_get_length (ModelClipFile* self);
 330 static void model_clip_file_finalize (GObject* obj);
 331 static void model_clip_file_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 332 static void model_clip_file_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 333 GType model_fetcher_get_type (void);
 334 enum  {
 335         MODEL_FETCHER_DUMMY_PROPERTY
 336 };
 337 void model_fetcher_on_pad_added (ModelFetcher* self, GstPad* pad);
 338 static void model_fetcher_real_on_pad_added (ModelFetcher* self, GstPad* pad);
 339 void model_fetcher_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message);
 340 static void model_fetcher_real_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message);
 341 void model_fetcher_do_error (ModelFetcher* self, const char* _error_);
 342 void model_fetcher_on_warning (ModelFetcher* self, GstBus* bus, GstMessage* message);
 343 void model_fetcher_on_error (ModelFetcher* self, GstBus* bus, GstMessage* message);
 344 ModelFetcher* model_fetcher_construct (GType object_type);
 345 static void model_fetcher_finalize (GObject* obj);
 346 GType model_clip_fetcher_get_type (void);
 347 enum  {
 348         MODEL_CLIP_FETCHER_DUMMY_PROPERTY
 349 };
 350 static void _model_clip_file_set_online_model_clip_fetcher_clipfile_online (ModelClipFetcher* _sender, gboolean online, gpointer self);
 351 GstElement* make_element (const char* name, GError** error);
 352 static void _model_fetcher_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
 353 static void _model_fetcher_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 354 static void _model_fetcher_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 355 static void _model_fetcher_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
 356 ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error);
 357 ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error);
 358 char* model_clip_fetcher_get_filename (ModelClipFetcher* self);
 359 static void model_clip_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad);
 360 static GstPad* model_clip_fetcher_get_pad (ModelClipFetcher* self, const char* prefix);
 361 static void model_clip_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message);
 362 GType model_thumbnail_fetcher_get_type (void);
 363 GType thumbnail_sink_get_type (void);
 364 #define MODEL_THUMBNAIL_FETCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherPrivate))
 365 enum  {
 366         MODEL_THUMBNAIL_FETCHER_DUMMY_PROPERTY
 367 };
 368 SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error);
 369 SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error);
 370 GType single_decode_bin_get_type (void);
 371 ThumbnailSink* thumbnail_sink_new (void);
 372 ThumbnailSink* thumbnail_sink_construct (GType object_type);
 373 static void model_thumbnail_fetcher_on_have_thumbnail (ModelThumbnailFetcher* self, GdkPixbuf* buf);
 374 static void _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail (ThumbnailSink* _sender, GdkPixbuf* b, gpointer self);
 375 ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error);
 376 ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error);
 377 static void model_thumbnail_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad);
 378 static void model_thumbnail_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message);
 379 static void model_thumbnail_fetcher_finalize (GObject* obj);
 380 GType model_clip_get_type (void);
 381 #define MODEL_CLIP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP, ModelClipPrivate))
 382 enum  {
 383         MODEL_CLIP_DUMMY_PROPERTY,
 384         MODEL_CLIP_START,
 385         MODEL_CLIP_MEDIA_START,
 386         MODEL_CLIP_DURATION,
 387         MODEL_CLIP_END
 388 };
 389 void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration);
 390 void model_clip_set_start (ModelClip* self, gint64 value);
 391 static void model_clip_on_clipfile_updated (ModelClip* self, ModelClipFile* f);
 392 static void _model_clip_on_clipfile_updated_model_clip_file_updated (ModelClipFile* _sender, gpointer self);
 393 ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 394 ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording);
 395 void model_clip_gnonlin_connect (ModelClip* self);
 396 void model_clip_gnonlin_disconnect (ModelClip* self);
 397 gint64 model_clip_get_media_start (ModelClip* self);
 398 gint64 model_clip_get_duration (ModelClip* self);
 399 gint64 model_clip_get_start (ModelClip* self);
 400 gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length);
 401 gboolean time_in_range (gint64 time, gint64 center, gint64 delta);
 402 gint64 model_clip_get_end (ModelClip* self);
 403 gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad);
 404 gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span);
 405 ModelClip* model_clip_copy (ModelClip* self);
 406 gboolean model_clip_is_trimmed (ModelClip* self);
 407 void model_clip_set_duration (ModelClip* self, gint64 value);
 408 void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge);
 409 void model_clip_save (ModelClip* self, FILE* f, gint id);
 410 static void model_clip_finalize (GObject* obj);
 411 static void model_clip_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 412 static void model_clip_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 413 gpointer model_fetcher_completion_ref (gpointer instance);
 414 void model_fetcher_completion_unref (gpointer instance);
 415 GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 416 void model_value_set_fetcher_completion (GValue* value, gpointer v_object);
 417 void model_value_take_fetcher_completion (GValue* value, gpointer v_object);
 418 gpointer model_value_get_fetcher_completion (const GValue* value);
 419 GType model_fetcher_completion_get_type (void);
 420 enum  {
 421         MODEL_FETCHER_COMPLETION_DUMMY_PROPERTY
 422 };
 423 ModelFetcherCompletion* model_fetcher_completion_new (void);
 424 ModelFetcherCompletion* model_fetcher_completion_construct (GType object_type);
 425 void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher);
 426 static void model_fetcher_completion_real_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher);
 427 static void model_fetcher_completion_finalize (ModelFetcherCompletion* obj);
 428
 429
 430 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);
 431
 432 GType model_media_type_get_type (void) {
 433         static volatile gsize model_media_type_type_id__volatile = 0;
 434         if (g_once_init_enter (&model_media_type_type_id__volatile)) {
 435                 static const GEnumValue values[] = {{MODEL_MEDIA_TYPE_AUDIO, "MODEL_MEDIA_TYPE_AUDIO", "audio"}, {MODEL_MEDIA_TYPE_VIDEO, "MODEL_MEDIA_TYPE_VIDEO", "video"}, {0, NULL, NULL}};
 436                 GType model_media_type_type_id;
 437                 model_media_type_type_id = g_enum_register_static ("ModelMediaType", values);
 438                 g_once_init_leave (&model_media_type_type_id__volatile, model_media_type_type_id);
 439         }
 440         return model_media_type_type_id__volatile;
 441 }
 442
 443
 444 #line 20 "clip.vala"
 445 ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end) {
 446 #line 447 "clip.c"
 447         ModelGap* self;
 448         self = (ModelGap*) g_type_create_instance (object_type);
 449 #line 21 "clip.vala"
 450         self->start = start;
 451 #line 22 "clip.vala"
 452         self->end = end;
 453 #line 454 "clip.c"
 454         return self;
 455 }
 456
 457
 458 #line 20 "clip.vala"
 459 ModelGap* model_gap_new (gint64 start, gint64 end) {
 460 #line 20 "clip.vala"
 461         return model_gap_construct (MODEL_TYPE_GAP, start, end);
 462 #line 463 "clip.c"
 463 }
 464
 465
 466 #line 25 "clip.vala"
 467 gboolean model_gap_is_empty (ModelGap* self) {
 468 #line 469 "clip.c"
 469         gboolean result = FALSE;
 470 #line 25 "clip.vala"
 471         g_return_val_if_fail (MODEL_IS_GAP (self), FALSE);
 472 #line 473 "clip.c"
 473         result = self->start >= self->end;
 474 #line 26 "clip.vala"
 475         return result;
 476 #line 477 "clip.c"
 477 }
 478
 479
 480 #line 29 "clip.vala"
 481 ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g) {
 482 #line 483 "clip.c"
 483         ModelGap* result = NULL;
 484 #line 29 "clip.vala"
 485         g_return_val_if_fail (MODEL_IS_GAP (self), NULL);
 486 #line 29 "clip.vala"
 487         g_return_val_if_fail (MODEL_IS_GAP (g), NULL);
 488 #line 489 "clip.c"
 489         result = model_gap_new (MAX (self->start, g->start), MIN (self->end, g->end));
 490 #line 30 "clip.vala"
 491         return result;
 492 #line 493 "clip.c"
 493 }
 494
 495
 496 static void model_value_gap_init (GValue* value) {
 497         value->data[0].v_pointer = NULL;
 498 }
 499
 500
 501 static void model_value_gap_free_value (GValue* value) {
 502         if (value->data[0].v_pointer) {
 503                 model_gap_unref (value->data[0].v_pointer);
 504         }
 505 }
 506
 507
 508 static void model_value_gap_copy_value (const GValue* src_value, GValue* dest_value) {
 509         if (src_value->data[0].v_pointer) {
 510                 dest_value->data[0].v_pointer = model_gap_ref (src_value->data[0].v_pointer);
 511         } else {
 512                 dest_value->data[0].v_pointer = NULL;
 513         }
 514 }
 515
 516
 517 static gpointer model_value_gap_peek_pointer (const GValue* value) {
 518         return value->data[0].v_pointer;
 519 }
 520
 521
 522 static gchar* model_value_gap_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 523         if (collect_values[0].v_pointer) {
 524                 ModelGap* object;
 525                 object = collect_values[0].v_pointer;
 526                 if (object->parent_instance.g_class == NULL) {
 527                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 528                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 529                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 530                 }
 531                 value->data[0].v_pointer = model_gap_ref (object);
 532         } else {
 533                 value->data[0].v_pointer = NULL;
 534         }
 535         return NULL;
 536 }
 537
 538
 539 static gchar* model_value_gap_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 540         ModelGap** object_p;
 541         object_p = collect_values[0].v_pointer;
 542         if (!object_p) {
 543                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 544         }
 545         if (!value->data[0].v_pointer) {
 546                 *object_p = NULL;
 547         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 548                 *object_p = value->data[0].v_pointer;
 549         } else {
 550                 *object_p = model_gap_ref (value->data[0].v_pointer);
 551         }
 552         return NULL;
 553 }
 554
 555
 556 GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 557         ModelParamSpecGap* spec;
 558         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_GAP), NULL);
 559         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 560         G_PARAM_SPEC (spec)->value_type = object_type;
 561         return G_PARAM_SPEC (spec);
 562 }
 563
 564
 565 gpointer model_value_get_gap (const GValue* value) {
 566         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP), NULL);
 567         return value->data[0].v_pointer;
 568 }
 569
 570
 571 void model_value_set_gap (GValue* value, gpointer v_object) {
 572         ModelGap* old;
 573         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP));
 574         old = value->data[0].v_pointer;
 575         if (v_object) {
 576                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_GAP));
 577                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 578                 value->data[0].v_pointer = v_object;
 579                 model_gap_ref (value->data[0].v_pointer);
 580         } else {
 581                 value->data[0].v_pointer = NULL;
 582         }
 583         if (old) {
 584                 model_gap_unref (old);
 585         }
 586 }
 587
 588
 589 void model_value_take_gap (GValue* value, gpointer v_object) {
 590         ModelGap* old;
 591         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP));
 592         old = value->data[0].v_pointer;
 593         if (v_object) {
 594                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_GAP));
 595                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 596                 value->data[0].v_pointer = v_object;
 597         } else {
 598                 value->data[0].v_pointer = NULL;
 599         }
 600         if (old) {
 601                 model_gap_unref (old);
 602         }
 603 }
 604
 605
 606 static void model_gap_class_init (ModelGapClass * klass) {
 607         model_gap_parent_class = g_type_class_peek_parent (klass);
 608         MODEL_GAP_CLASS (klass)->finalize = model_gap_finalize;
 609 }
 610
 611
 612 static void model_gap_instance_init (ModelGap * self) {
 613         self->ref_count = 1;
 614 }
 615
 616
 617 static void model_gap_finalize (ModelGap* obj) {
 618         ModelGap * self;
 619         self = MODEL_GAP (obj);
 620 }
 621
 622
 623 GType model_gap_get_type (void) {
 624         static volatile gsize model_gap_type_id__volatile = 0;
 625         if (g_once_init_enter (&model_gap_type_id__volatile)) {
 626                 static const GTypeValueTable g_define_type_value_table = { model_value_gap_init, model_value_gap_free_value, model_value_gap_copy_value, model_value_gap_peek_pointer, "p", model_value_gap_collect_value, "p", model_value_gap_lcopy_value };
 627                 static const GTypeInfo g_define_type_info = { sizeof (ModelGapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_gap_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelGap), 0, (GInstanceInitFunc) model_gap_instance_init, &g_define_type_value_table };
 628                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 629                 GType model_gap_type_id;
 630                 model_gap_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelGap", &g_define_type_info, &g_define_type_fundamental_info, 0);
 631                 g_once_init_leave (&model_gap_type_id__volatile, model_gap_type_id);
 632         }
 633         return model_gap_type_id__volatile;
 634 }
 635
 636
 637 gpointer model_gap_ref (gpointer instance) {
 638         ModelGap* self;
 639         self = instance;
 640         g_atomic_int_inc (&self->ref_count);
 641         return instance;
 642 }
 643
 644
 645 void model_gap_unref (gpointer instance) {
 646         ModelGap* self;
 647         self = instance;
 648         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 649                 MODEL_GAP_GET_CLASS (self)->finalize (self);
 650                 g_type_free_instance ((GTypeInstance *) self);
 651         }
 652 }
 653
 654
 655 #line 58 "clip.vala"
 656 ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length) {
 657 #line 658 "clip.c"
 658         ModelClipFile * self;
 659         char* _tmp0_;
 660 #line 58 "clip.vala"
 661         g_return_val_if_fail (filename != NULL, NULL);
 662 #line 58 "clip.vala"
 663         self = (ModelClipFile*) g_object_new (object_type, NULL);
 664 #line 59 "clip.vala"
 665         self->filename = (_tmp0_ = g_strdup (filename), _g_free0 (self->filename), _tmp0_);
 666 #line 60 "clip.vala"
 667         model_clip_file_set_length (self, length);
 668 #line 61 "clip.vala"
 669         self->priv->online = FALSE;
 670 #line 671 "clip.c"
 671         return self;
 672 }
 673
 674
 675 #line 58 "clip.vala"
 676 ModelClipFile* model_clip_file_new (const char* filename, gint64 length) {
 677 #line 58 "clip.vala"
 678         return model_clip_file_construct (MODEL_TYPE_CLIP_FILE, filename, length);
 679 #line 680 "clip.c"
 680 }
 681
 682
 683 #line 64 "clip.vala"
 684 gboolean model_clip_file_is_online (ModelClipFile* self) {
 685 #line 686 "clip.c"
 686         gboolean result = FALSE;
 687 #line 64 "clip.vala"
 688         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 689 #line 690 "clip.c"
 690         result = self->priv->online;
 691 #line 65 "clip.vala"
 692         return result;
 693 #line 694 "clip.c"
 694 }
 695
 696
 697 #line 68 "clip.vala"
 698 void model_clip_file_set_online (ModelClipFile* self, gboolean o) {
 699 #line 68 "clip.vala"
 700         g_return_if_fail (MODEL_IS_CLIP_FILE (self));
 701 #line 69 "clip.vala"
 702         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "set_online");
 703 #line 70 "clip.vala"
 704         self->priv->online = o;
 705 #line 71 "clip.vala"
 706         g_signal_emit_by_name (self, "updated");
 707 #line 708 "clip.c"
 708 }
 709
 710
 711 #line 74 "clip.vala"
 712 void model_clip_file_set_thumbnail (ModelClipFile* self, GdkPixbuf* b) {
 713 #line 714 "clip.c"
 714         GdkPixbuf* _tmp0_;
 715 #line 74 "clip.vala"
 716         g_return_if_fail (MODEL_IS_CLIP_FILE (self));
 717 #line 74 "clip.vala"
 718         g_return_if_fail (GDK_IS_PIXBUF (b));
 719 #line 79 "clip.vala"
 720         self->thumbnail = (_tmp0_ = gdk_pixbuf_scale_simple (b, 64, 44, GDK_INTERP_BILINEAR), _g_object_unref0 (self->thumbnail), _tmp0_);
 721 #line 722 "clip.c"
 722 }
 723
 724
 725 #line 82 "clip.vala"
 726 gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m) {
 727 #line 728 "clip.c"
 728         gboolean result = FALSE;
 729 #line 82 "clip.vala"
 730         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 731 #line 83 "clip.vala"
 732         if (m == MODEL_MEDIA_TYPE_AUDIO) {
 733 #line 734 "clip.c"
 734                 gboolean _tmp0_ = FALSE;
 735 #line 84 "clip.vala"
 736                 if (self->audio_caps == NULL) {
 737 #line 84 "clip.vala"
 738                         _tmp0_ = TRUE;
 739 #line 740 "clip.c"
 740                 } else {
 741 #line 84 "clip.vala"
 742                         _tmp0_ = gst_caps_get_size (self->audio_caps) < 1;
 743 #line 744 "clip.c"
 744                 }
 745 #line 84 "clip.vala"
 746                 if (_tmp0_) {
 747 #line 748 "clip.c"
 748                         result = FALSE;
 749 #line 85 "clip.vala"
 750                         return result;
 751 #line 752 "clip.c"
 752                 }
 753         } else {
 754 #line 86 "clip.vala"
 755                 if (m == MODEL_MEDIA_TYPE_VIDEO) {
 756 #line 757 "clip.c"
 757                         gboolean _tmp1_ = FALSE;
 758 #line 87 "clip.vala"
 759                         if (self->video_caps == NULL) {
 760 #line 87 "clip.vala"
 761                                 _tmp1_ = TRUE;
 762 #line 763 "clip.c"
 763                         } else {
 764 #line 87 "clip.vala"
 765                                 _tmp1_ = gst_caps_get_size (self->video_caps) < 1;
 766 #line 767 "clip.c"
 767                         }
 768 #line 87 "clip.vala"
 769                         if (_tmp1_) {
 770 #line 771 "clip.c"
 771                                 result = FALSE;
 772 #line 88 "clip.vala"
 773                                 return result;
 774 #line 775 "clip.c"
 775                         }
 776                 }
 777         }
 778         result = TRUE;
 779 #line 90 "clip.vala"
 780         return result;
 781 #line 782 "clip.c"
 782 }
 783
 784
 785 #line 93 "clip.vala"
 786 gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t) {
 787 #line 788 "clip.c"
 788         gboolean result = FALSE;
 789 #line 93 "clip.vala"
 790         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 791 #line 94 "clip.vala"
 792         if (t == MODEL_MEDIA_TYPE_VIDEO) {
 793 #line 794 "clip.c"
 794                 result = self->video_caps != NULL;
 795 #line 95 "clip.vala"
 796                 return result;
 797 #line 798 "clip.c"
 798         }
 799         result = self->audio_caps != NULL;
 800 #line 96 "clip.vala"
 801         return result;
 802 #line 803 "clip.c"
 803 }
 804
 805
 806 static gpointer _gst_structure_copy0 (gpointer self) {
 807         return self ? gst_structure_copy (self) : NULL;
 808 }
 809
 810
 811 #line 99 "clip.vala"
 812 static gboolean model_clip_file_get_caps_structure (ModelClipFile* self, ModelMediaType m, GstStructure** s) {
 813 #line 814 "clip.c"
 814         gboolean result = FALSE;
 815 #line 99 "clip.vala"
 816         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 817 #line 818 "clip.c"
 818         if (s != NULL) {
 819                 *s = NULL;
 820         }
 821 #line 100 "clip.vala"
 822         if (!model_clip_file_has_caps_structure (self, m)) {
 823 #line 824 "clip.c"
 824                 result = FALSE;
 825 #line 101 "clip.vala"
 826                 return result;
 827 #line 828 "clip.c"
 828         }
 829 #line 102 "clip.vala"
 830         if (m == MODEL_MEDIA_TYPE_AUDIO) {
 831 #line 832 "clip.c"
 832                 GstStructure* _tmp0_;
 833 #line 103 "clip.vala"
 834                 *s = (_tmp0_ = _gst_structure_copy0 (gst_caps_get_structure (self->audio_caps, (guint) 0)), _gst_structure_free0 (*s), _tmp0_);
 835 #line 836 "clip.c"
 836         } else {
 837 #line 104 "clip.vala"
 838                 if (m == MODEL_MEDIA_TYPE_VIDEO) {
 839 #line 840 "clip.c"
 840                         GstStructure* _tmp1_;
 841 #line 105 "clip.vala"
 842                         *s = (_tmp1_ = _gst_structure_copy0 (gst_caps_get_structure (self->video_caps, (guint) 0)), _gst_structure_free0 (*s), _tmp1_);
 843 #line 844 "clip.c"
 844                 }
 845         }
 846         result = TRUE;
 847 #line 107 "clip.vala"
 848         return result;
 849 #line 850 "clip.c"
 850 }
 851
 852
 853 #line 110 "clip.vala"
 854 gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate) {
 855 #line 856 "clip.c"
 856         gboolean result = FALSE;
 857         GstStructure* structure;
 858         GstStructure* _tmp2_;
 859         gboolean _tmp1_;
 860         GstStructure* _tmp0_ = NULL;
 861 #line 110 "clip.vala"
 862         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 863 #line 864 "clip.c"
 864         structure = NULL;
 865 #line 112 "clip.vala"
 866         if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), structure = (_tmp2_ = _tmp0_, _gst_structure_free0 (structure), _tmp2_), _tmp1_)) {
 867 #line 868 "clip.c"
 868                 result = FALSE;
 869                 _gst_structure_free0 (structure);
 870 #line 113 "clip.vala"
 871                 return result;
 872 #line 873 "clip.c"
 873         }
 874         result = gst_structure_get_fraction (structure, "framerate", &(*rate).numerator, &(*rate).denominator);
 875         _gst_structure_free0 (structure);
 876 #line 114 "clip.vala"
 877         return result;
 878 #line 879 "clip.c"
 879 }
 880
 881
 882 #line 117 "clip.vala"
 883 gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h) {
 884 #line 885 "clip.c"
 885         gboolean result = FALSE;
 886         GstStructure* s;
 887         GstStructure* _tmp2_;
 888         gboolean _tmp1_;
 889         GstStructure* _tmp0_ = NULL;
 890         gboolean _tmp3_ = FALSE;
 891 #line 117 "clip.vala"
 892         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 893 #line 894 "clip.c"
 894         s = NULL;
 895 #line 120 "clip.vala"
 896         if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) {
 897 #line 898 "clip.c"
 898                 result = FALSE;
 899                 _gst_structure_free0 (s);
 900 #line 121 "clip.vala"
 901                 return result;
 902 #line 903 "clip.c"
 903         }
 904 #line 123 "clip.vala"
 905         if (gst_structure_get_int (s, "width", w)) {
 906 #line 123 "clip.vala"
 907                 _tmp3_ = gst_structure_get_int (s, "height", h);
 908 #line 909 "clip.c"
 909         } else {
 910 #line 123 "clip.vala"
 911                 _tmp3_ = FALSE;
 912 #line 913 "clip.c"
 913         }
 914         result = _tmp3_;
 915         _gst_structure_free0 (s);
 916 #line 123 "clip.vala"
 917         return result;
 918 #line 919 "clip.c"
 919 }
 920
 921
 922 #line 126 "clip.vala"
 923 gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate) {
 924 #line 925 "clip.c"
 925         gboolean result = FALSE;
 926         GstStructure* s;
 927         GstStructure* _tmp2_;
 928         gboolean _tmp1_;
 929         GstStructure* _tmp0_ = NULL;
 930 #line 126 "clip.vala"
 931         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 932 #line 933 "clip.c"
 933         s = NULL;
 934 #line 128 "clip.vala"
 935         if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_AUDIO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) {
 936 #line 937 "clip.c"
 937                 result = FALSE;
 938                 _gst_structure_free0 (s);
 939 #line 129 "clip.vala"
 940                 return result;
 941 #line 942 "clip.c"
 942         }
 943         result = gst_structure_get_int (s, "rate", rate);
 944         _gst_structure_free0 (s);
 945 #line 131 "clip.vala"
 946         return result;
 947 #line 948 "clip.c"
 948 }
 949
 950
 951 #line 134 "clip.vala"
 952 gboolean model_clip_file_get_video_format (ModelClipFile* self, guint32* fourcc) {
 953 #line 954 "clip.c"
 954         gboolean result = FALSE;
 955         GstStructure* s;
 956         GstStructure* _tmp2_;
 957         gboolean _tmp1_;
 958         GstStructure* _tmp0_ = NULL;
 959 #line 134 "clip.vala"
 960         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 961 #line 962 "clip.c"
 962         s = NULL;
 963 #line 137 "clip.vala"
 964         if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) {
 965 #line 966 "clip.c"
 966                 result = FALSE;
 967                 _gst_structure_free0 (s);
 968 #line 138 "clip.vala"
 969                 return result;
 970 #line 971 "clip.c"
 971         }
 972         result = gst_structure_get_fourcc (s, "format", fourcc);
 973         _gst_structure_free0 (s);
 974 #line 140 "clip.vala"
 975         return result;
 976 #line 977 "clip.c"
 977 }
 978
 979
 980 #line 143 "clip.vala"
 981 gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels) {
 982 #line 983 "clip.c"
 983         gboolean result = FALSE;
 984         GstStructure* s;
 985         GstStructure* _tmp2_;
 986         gboolean _tmp1_;
 987         GstStructure* _tmp0_ = NULL;
 988 #line 143 "clip.vala"
 989         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
 990 #line 991 "clip.c"
 991         s = NULL;
 992 #line 145 "clip.vala"
 993         if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_AUDIO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) {
 994 #line 995 "clip.c"
 995                 result = FALSE;
 996                 _gst_structure_free0 (s);
 997 #line 146 "clip.vala"
 998                 return result;
 999 #line 1000 "clip.c"
1000         }
1001         result = gst_structure_get_int (s, "channels", channels);
1002         _gst_structure_free0 (s);
1003 #line 149 "clip.vala"
1004         return result;
1005 #line 1006 "clip.c"
1006 }
1007
1008
1009 #line 152 "clip.vala"
1010 gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s) {
1011 #line 1012 "clip.c"
1012         gboolean result = FALSE;
1013         gint i = 0;
1014 #line 152 "clip.vala"
1015         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE);
1016 #line 1017 "clip.c"
1017         if (s != NULL) {
1018                 *s = NULL;
1019         }
1020 #line 154 "clip.vala"
1021         if (!model_clip_file_get_num_channels (self, &i)) {
1022 #line 1023 "clip.c"
1023                 result = FALSE;
1024 #line 155 "clip.vala"
1025                 return result;
1026 #line 1027 "clip.c"
1027         }
1028 #line 157 "clip.vala"
1029         if (i == 1) {
1030 #line 1031 "clip.c"
1031                 char* _tmp0_;
1032 #line 158 "clip.vala"
1033                 *s = (_tmp0_ = g_strdup ("Mono"), _g_free0 (*s), _tmp0_);
1034 #line 1035 "clip.c"
1035         } else {
1036 #line 159 "clip.vala"
1037                 if (i == 2) {
1038 #line 1039 "clip.c"
1039                         char* _tmp1_;
1040 #line 160 "clip.vala"
1041                         *s = (_tmp1_ = g_strdup ("Stereo"), _g_free0 (*s), _tmp1_);
1042 #line 1043 "clip.c"
1043                 } else {
1044 #line 161 "clip.vala"
1045                         if ((i % 2) == 0) {
1046 #line 1047 "clip.c"
1047                                 char* _tmp2_;
1048 #line 162 "clip.vala"
1049                                 *s = (_tmp2_ = g_strdup_printf ("Surround %d.1", i - 1), _g_free0 (*s), _tmp2_);
1050 #line 1051 "clip.c"
1051                         } else {
1052                                 char* _tmp3_;
1053 #line 164 "clip.vala"
1054                                 *s = (_tmp3_ = g_strdup_printf ("%d", i), _g_free0 (*s), _tmp3_);
1055 #line 1056 "clip.c"
1056                         }
1057                 }
1058         }
1059         result = TRUE;
1060 #line 165 "clip.vala"
1061         return result;
1062 #line 1063 "clip.c"
1063 }
1064
1065
1066 gint64 model_clip_file_get_length (ModelClipFile* self) {
1067         gint64 result;
1068         g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), 0LL);
1069 #line 39 "clip.vala"
1070         if (!self->priv->online) {
1071 #line 40 "clip.vala"
1072                 g_warning ("clip.vala:40: retrieving length while clip offline");
1073 #line 1074 "clip.c"
1074         }
1075         result = self->priv->_length;
1076 #line 42 "clip.vala"
1077         return result;
1078 #line 1079 "clip.c"
1079 }
1080
1081
1082 void model_clip_file_set_length (ModelClipFile* self, gint64 value) {
1083         g_return_if_fail (MODEL_IS_CLIP_FILE (self));
1084 #line 46 "clip.vala"
1085         self->priv->_length = value;
1086 #line 1087 "clip.c"
1087         g_object_notify ((GObject *) self, "length");
1088 }
1089
1090
1091 static void model_clip_file_class_init (ModelClipFileClass * klass) {
1092         model_clip_file_parent_class = g_type_class_peek_parent (klass);
1093         g_type_class_add_private (klass, sizeof (ModelClipFilePrivate));
1094         G_OBJECT_CLASS (klass)->get_property = model_clip_file_get_property;
1095         G_OBJECT_CLASS (klass)->set_property = model_clip_file_set_property;
1096         G_OBJECT_CLASS (klass)->finalize = model_clip_file_finalize;
1097         g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_FILE_LENGTH, g_param_spec_int64 ("length", "length", "length", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
1098         g_signal_new ("updated", MODEL_TYPE_CLIP_FILE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1099 }
1100
1101
1102 static void model_clip_file_instance_init (ModelClipFile * self) {
1103         self->priv = MODEL_CLIP_FILE_GET_PRIVATE (self);
1104         self->thumbnail = NULL;
1105 }
1106
1107
1108 static void model_clip_file_finalize (GObject* obj) {
1109         ModelClipFile * self;
1110         self = MODEL_CLIP_FILE (obj);
1111         _g_free0 (self->filename);
1112         _gst_caps_unref0 (self->video_caps);
1113         _gst_caps_unref0 (self->audio_caps);
1114         _g_object_unref0 (self->thumbnail);
1115         G_OBJECT_CLASS (model_clip_file_parent_class)->finalize (obj);
1116 }
1117
1118
1119 GType model_clip_file_get_type (void) {
1120         static volatile gsize model_clip_file_type_id__volatile = 0;
1121         if (g_once_init_enter (&model_clip_file_type_id__volatile)) {
1122                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFile), 0, (GInstanceInitFunc) model_clip_file_instance_init, NULL };
1123                 GType model_clip_file_type_id;
1124                 model_clip_file_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelClipFile", &g_define_type_info, 0);
1125                 g_once_init_leave (&model_clip_file_type_id__volatile, model_clip_file_type_id);
1126         }
1127         return model_clip_file_type_id__volatile;
1128 }
1129
1130
1131 static void model_clip_file_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1132         ModelClipFile * self;
1133         self = MODEL_CLIP_FILE (object);
1134         switch (property_id) {
1135                 case MODEL_CLIP_FILE_LENGTH:
1136                 g_value_set_int64 (value, model_clip_file_get_length (self));
1137                 break;
1138                 default:
1139                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1140                 break;
1141         }
1142 }
1143
1144
1145 static void model_clip_file_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1146         ModelClipFile * self;
1147         self = MODEL_CLIP_FILE (object);
1148         switch (property_id) {
1149                 case MODEL_CLIP_FILE_LENGTH:
1150                 model_clip_file_set_length (self, g_value_get_int64 (value));
1151                 break;
1152                 default:
1153                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1154                 break;
1155         }
1156 }
1157
1158
1159 #line 177 "clip.vala"
1160 static void model_fetcher_real_on_pad_added (ModelFetcher* self, GstPad* pad) {
1161 #line 1162 "clip.c"
1162         g_return_if_fail (MODEL_IS_FETCHER (self));
1163         g_critical ("Type `%s' does not implement abstract method `model_fetcher_on_pad_added'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1164         return;
1165 }
1166
1167
1168 #line 177 "clip.vala"
1169 void model_fetcher_on_pad_added (ModelFetcher* self, GstPad* pad) {
1170 #line 177 "clip.vala"
1171         MODEL_FETCHER_GET_CLASS (self)->on_pad_added (self, pad);
1172 #line 1173 "clip.c"
1173 }
1174
1175
1176 #line 178 "clip.vala"
1177 static void model_fetcher_real_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message) {
1178 #line 1179 "clip.c"
1179         g_return_if_fail (MODEL_IS_FETCHER (self));
1180         g_critical ("Type `%s' does not implement abstract method `model_fetcher_on_state_change'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1181         return;
1182 }
1183
1184
1185 #line 178 "clip.vala"
1186 void model_fetcher_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message) {
1187 #line 178 "clip.vala"
1188         MODEL_FETCHER_GET_CLASS (self)->on_state_change (self, bus, message);
1189 #line 1190 "clip.c"
1190 }
1191
1192
1193 #line 182 "clip.vala"
1194 void model_fetcher_do_error (ModelFetcher* self, const char* _error_) {
1195 #line 1196 "clip.c"
1196         char* _tmp0_;
1197 #line 182 "clip.vala"
1198         g_return_if_fail (MODEL_IS_FETCHER (self));
1199 #line 182 "clip.vala"
1200         g_return_if_fail (_error_ != NULL);
1201 #line 183 "clip.vala"
1202         self->error_string = (_tmp0_ = g_strdup (_error_), _g_free0 (self->error_string), _tmp0_);
1203 #line 184 "clip.vala"
1204         gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL);
1205 #line 1206 "clip.c"
1206 }
1207
1208
1209 #line 187 "clip.vala"
1210 void model_fetcher_on_warning (ModelFetcher* self, GstBus* bus, GstMessage* message) {
1211 #line 1212 "clip.c"
1212         GError* _error_;
1213         char* text;
1214         char* _tmp3_;
1215         char* _tmp2_ = NULL;
1216         GError* _tmp1_;
1217         GError* _tmp0_ = NULL;
1218 #line 187 "clip.vala"
1219         g_return_if_fail (MODEL_IS_FETCHER (self));
1220 #line 187 "clip.vala"
1221         g_return_if_fail (GST_IS_BUS (bus));
1222 #line 187 "clip.vala"
1223         g_return_if_fail (GST_IS_MESSAGE (message));
1224 #line 188 "clip.vala"
1225         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_warning");
1226 #line 1227 "clip.c"
1227         _error_ = NULL;
1228         text = NULL;
1229 #line 191 "clip.vala"
1230         (gst_message_parse_warning (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_));
1231 #line 191 "clip.vala"
1232         text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_);
1233 #line 192 "clip.vala"
1234         g_warning ("clip.vala:192: %s", text);
1235 #line 1236 "clip.c"
1236         _g_error_free0 (_error_);
1237         _g_free0 (text);
1238 }
1239
1240
1241 #line 195 "clip.vala"
1242 void model_fetcher_on_error (ModelFetcher* self, GstBus* bus, GstMessage* message) {
1243 #line 1244 "clip.c"
1244         GError* _error_;
1245         char* text;
1246         char* _tmp3_;
1247         char* _tmp2_ = NULL;
1248         GError* _tmp1_;
1249         GError* _tmp0_ = NULL;
1250 #line 195 "clip.vala"
1251         g_return_if_fail (MODEL_IS_FETCHER (self));
1252 #line 195 "clip.vala"
1253         g_return_if_fail (GST_IS_BUS (bus));
1254 #line 195 "clip.vala"
1255         g_return_if_fail (GST_IS_MESSAGE (message));
1256 #line 196 "clip.vala"
1257         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error");
1258 #line 1259 "clip.c"
1259         _error_ = NULL;
1260         text = NULL;
1261 #line 199 "clip.vala"
1262         (gst_message_parse_error (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_));
1263 #line 199 "clip.vala"
1264         text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_);
1265 #line 200 "clip.vala"
1266         model_fetcher_do_error (self, text);
1267 #line 1268 "clip.c"
1268         _g_error_free0 (_error_);
1269         _g_free0 (text);
1270 }
1271
1272
1273 #line 169 "clip.vala"
1274 ModelFetcher* model_fetcher_construct (GType object_type) {
1275 #line 1276 "clip.c"
1276         ModelFetcher * self;
1277 #line 169 "clip.vala"
1278         self = (ModelFetcher*) g_object_new (object_type, NULL);
1279 #line 1280 "clip.c"
1280         return self;
1281 }
1282
1283
1284 static void model_fetcher_class_init (ModelFetcherClass * klass) {
1285         model_fetcher_parent_class = g_type_class_peek_parent (klass);
1286         MODEL_FETCHER_CLASS (klass)->on_pad_added = model_fetcher_real_on_pad_added;
1287         MODEL_FETCHER_CLASS (klass)->on_state_change = model_fetcher_real_on_state_change;
1288         G_OBJECT_CLASS (klass)->finalize = model_fetcher_finalize;
1289         g_signal_new ("ready", MODEL_TYPE_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_FETCHER);
1290 }
1291
1292
1293 static void model_fetcher_instance_init (ModelFetcher * self) {
1294 }
1295
1296
1297 static void model_fetcher_finalize (GObject* obj) {
1298         ModelFetcher * self;
1299         self = MODEL_FETCHER (obj);
1300         _gst_object_unref0 (self->filesrc);
1301         _gst_object_unref0 (self->decodebin);
1302         _gst_object_unref0 (self->pipeline);
1303         _g_object_unref0 (self->clipfile);
1304         _g_free0 (self->error_string);
1305         G_OBJECT_CLASS (model_fetcher_parent_class)->finalize (obj);
1306 }
1307
1308
1309 GType model_fetcher_get_type (void) {
1310         static volatile gsize model_fetcher_type_id__volatile = 0;
1311         if (g_once_init_enter (&model_fetcher_type_id__volatile)) {
1312                 static const GTypeInfo g_define_type_info = { sizeof (ModelFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelFetcher), 0, (GInstanceInitFunc) model_fetcher_instance_init, NULL };
1313                 GType model_fetcher_type_id;
1314                 model_fetcher_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelFetcher", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
1315                 g_once_init_leave (&model_fetcher_type_id__volatile, model_fetcher_type_id);
1316         }
1317         return model_fetcher_type_id__volatile;
1318 }
1319
1320
1321 #line 68 "clip.vala"
1322 static void _model_clip_file_set_online_model_clip_fetcher_clipfile_online (ModelClipFetcher* _sender, gboolean online, gpointer self) {
1323 #line 1324 "clip.c"
1324         model_clip_file_set_online (self, online);
1325 }
1326
1327
1328 static gpointer _gst_object_ref0 (gpointer self) {
1329         return self ? gst_object_ref (self) : NULL;
1330 }
1331
1332
1333 #line 177 "clip.vala"
1334 static void _model_fetcher_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
1335 #line 1336 "clip.c"
1336         model_fetcher_on_pad_added (self, pad);
1337 }
1338
1339
1340 #line 178 "clip.vala"
1341 static void _model_fetcher_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
1342 #line 1343 "clip.c"
1343         model_fetcher_on_state_change (self, _sender, message);
1344 }
1345
1346
1347 #line 195 "clip.vala"
1348 static void _model_fetcher_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
1349 #line 1350 "clip.c"
1350         model_fetcher_on_error (self, _sender, message);
1351 }
1352
1353
1354 #line 187 "clip.vala"
1355 static void _model_fetcher_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
1356 #line 1357 "clip.c"
1357         model_fetcher_on_warning (self, _sender, message);
1358 }
1359
1360
1361 #line 207 "clip.vala"
1362 ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error) {
1363 #line 1364 "clip.c"
1364         GError * _inner_error_;
1365         ModelClipFetcher * self;
1366         ModelClipFile* _tmp1_;
1367         ModelClipFile* *_tmp0_;
1368         GstElement* _tmp2_;
1369         GstElement* _tmp4_;
1370         GstElement* *_tmp3_;
1371         GstElement* _tmp5_;
1372         GstElement* _tmp7_;
1373         GstElement* *_tmp6_;
1374         GstPipeline* _tmp9_;
1375         GstPipeline* *_tmp8_;
1376         GstBus* bus;
1377         char* _tmp11_;
1378         char* *_tmp10_;
1379 #line 207 "clip.vala"
1380         g_return_val_if_fail (filename != NULL, NULL);
1381 #line 1382 "clip.c"
1382         _inner_error_ = NULL;
1383 #line 207 "clip.vala"
1384         self = (ModelClipFetcher*) model_fetcher_construct (object_type);
1385 #line 208 "clip.vala"
1386         _tmp0_ = &MODEL_FETCHER (self)->clipfile;
1387 #line 208 "clip.vala"
1388         (*_tmp0_) = (_tmp1_ = model_clip_file_new (filename, 0), _g_object_unref0 ((*_tmp0_)), _tmp1_);
1389 #line 210 "clip.vala"
1390         g_signal_connect_object (self, "clipfile-online", (GCallback) _model_clip_file_set_online_model_clip_fetcher_clipfile_online, MODEL_FETCHER (self)->clipfile, 0);
1391 #line 212 "clip.vala"
1392         _tmp2_ = make_element ("filesrc", &_inner_error_);
1393 #line 1394 "clip.c"
1394         if (_inner_error_ != NULL) {
1395                 g_propagate_error (error, _inner_error_);
1396                 g_object_unref (self);
1397                 return NULL;
1398         }
1399 #line 212 "clip.vala"
1400         _tmp3_ = &MODEL_FETCHER (self)->filesrc;
1401 #line 212 "clip.vala"
1402         (*_tmp3_) = (_tmp4_ = _tmp2_, _gst_object_unref0 ((*_tmp3_)), _tmp4_);
1403 #line 213 "clip.vala"
1404         g_object_set (G_OBJECT (MODEL_FETCHER (self)->filesrc), "location", filename, NULL);
1405 #line 215 "clip.vala"
1406         _tmp5_ = make_element ("decodebin", &_inner_error_);
1407 #line 1408 "clip.c"
1408         if (_inner_error_ != NULL) {
1409                 g_propagate_error (error, _inner_error_);
1410                 g_object_unref (self);
1411                 return NULL;
1412         }
1413 #line 215 "clip.vala"
1414         _tmp6_ = &MODEL_FETCHER (self)->decodebin;
1415 #line 215 "clip.vala"
1416         (*_tmp6_) = (_tmp7_ = GST_ELEMENT (GST_BIN (_tmp5_)), _gst_object_unref0 ((*_tmp6_)), _tmp7_);
1417 #line 216 "clip.vala"
1418         _tmp8_ = &MODEL_FETCHER (self)->pipeline;
1419 #line 216 "clip.vala"
1420         (*_tmp8_) = (_tmp9_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 ((*_tmp8_)), _tmp9_);
1421 #line 217 "clip.vala"
1422         gst_pipeline_set_auto_flush_bus (MODEL_FETCHER (self)->pipeline, FALSE);
1423 #line 218 "clip.vala"
1424         if (MODEL_FETCHER (self)->pipeline == NULL) {
1425 #line 219 "clip.vala"
1426                 g_error ("clip.vala:219: can't construct pipeline");
1427 #line 1428 "clip.c"
1428         }
1429 #line 220 "clip.vala"
1430         gst_bin_add_many (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (MODEL_FETCHER (self)->filesrc), _gst_object_ref0 (MODEL_FETCHER (self)->decodebin), NULL);
1431 #line 222 "clip.vala"
1432         if (!gst_element_link (MODEL_FETCHER (self)->filesrc, MODEL_FETCHER (self)->decodebin)) {
1433 #line 223 "clip.vala"
1434                 g_error ("clip.vala:223: can't link filesrc");
1435 #line 1436 "clip.c"
1436         }
1437 #line 224 "clip.vala"
1438         g_signal_connect_object (MODEL_FETCHER (self)->decodebin, "pad-added", (GCallback) _model_fetcher_on_pad_added_gst_element_pad_added, MODEL_FETCHER (self), 0);
1439 #line 226 "clip.vala"
1440         bus = gst_pipeline_get_bus (MODEL_FETCHER (self)->pipeline);
1441 #line 228 "clip.vala"
1442         gst_bus_add_signal_watch (bus);
1443 #line 229 "clip.vala"
1444         g_signal_connect_object (bus, "message::state-changed", (GCallback) _model_fetcher_on_state_change_gst_bus_message, MODEL_FETCHER (self), 0);
1445 #line 230 "clip.vala"
1446         g_signal_connect_object (bus, "message::error", (GCallback) _model_fetcher_on_error_gst_bus_message, MODEL_FETCHER (self), 0);
1447 #line 231 "clip.vala"
1448         g_signal_connect_object (bus, "message::warning", (GCallback) _model_fetcher_on_warning_gst_bus_message, MODEL_FETCHER (self), 0);
1449 #line 233 "clip.vala"
1450         _tmp10_ = &MODEL_FETCHER (self)->error_string;
1451 #line 233 "clip.vala"
1452         (*_tmp10_) = (_tmp11_ = NULL, _g_free0 ((*_tmp10_)), _tmp11_);
1453 #line 234 "clip.vala"
1454         gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_PLAYING);
1455 #line 1456 "clip.c"
1456         _gst_object_unref0 (bus);
1457         return self;
1458 }
1459
1460
1461 #line 207 "clip.vala"
1462 ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error) {
1463 #line 207 "clip.vala"
1464         return model_clip_fetcher_construct (MODEL_TYPE_CLIP_FETCHER, filename, error);
1465 #line 1466 "clip.c"
1466 }
1467
1468
1469 #line 237 "clip.vala"
1470 char* model_clip_fetcher_get_filename (ModelClipFetcher* self) {
1471 #line 1472 "clip.c"
1472         char* result = NULL;
1473 #line 237 "clip.vala"
1474         g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL);
1475 #line 1476 "clip.c"
1476         result = g_strdup (MODEL_FETCHER (self)->clipfile->filename);
1477 #line 237 "clip.vala"
1478         return result;
1479 #line 1480 "clip.c"
1480 }
1481
1482
1483 #line 239 "clip.vala"
1484 static void model_clip_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad) {
1485 #line 1486 "clip.c"
1486         ModelClipFetcher * self;
1487         GError * _inner_error_;
1488         GstPad* fake_pad;
1489         GstElement* fake_sink;
1490         self = MODEL_CLIP_FETCHER (base);
1491 #line 239 "clip.vala"
1492         g_return_if_fail (GST_IS_PAD (pad));
1493 #line 1494 "clip.c"
1494         _inner_error_ = NULL;
1495 #line 240 "clip.vala"
1496         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added");
1497 #line 1498 "clip.c"
1498         fake_pad = NULL;
1499         fake_sink = NULL;
1500         {
1501                 char* _tmp2_;
1502                 GstCaps* _tmp1_;
1503                 GstCaps* _tmp0_ = NULL;
1504                 gboolean _tmp3_;
1505 #line 244 "clip.vala"
1506                 if ((_tmp3_ = g_str_has_prefix (_tmp2_ = gst_caps_to_string (_tmp1_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_)), "video"), _g_free0 (_tmp2_), _gst_caps_unref0 (_tmp1_), _tmp3_)) {
1507 #line 1508 "clip.c"
1508                         GstElement* _tmp4_;
1509                         GstElement* _tmp5_;
1510                         GstPad* _tmp6_;
1511 #line 245 "clip.vala"
1512                         _tmp4_ = make_element ("fakesink", &_inner_error_);
1513 #line 1514 "clip.c"
1514                         if (_inner_error_ != NULL) {
1515                                 goto __catch4_g_error;
1516                         }
1517 #line 245 "clip.vala"
1518                         fake_sink = (_tmp5_ = _tmp4_, _gst_object_unref0 (fake_sink), _tmp5_);
1519 #line 246 "clip.vala"
1520                         gst_bin_add (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (fake_sink));
1521 #line 247 "clip.vala"
1522                         fake_pad = (_tmp6_ = gst_element_get_static_pad (fake_sink, "sink"), _gst_object_unref0 (fake_pad), _tmp6_);
1523 #line 249 "clip.vala"
1524                         if (!gst_element_sync_state_with_parent (fake_sink)) {
1525 #line 250 "clip.vala"
1526                                 g_error ("clip.vala:250: could not sync state with parent");
1527 #line 1528 "clip.c"
1528                         }
1529                 } else {
1530                         GstElement* _tmp7_;
1531                         GstElement* _tmp8_;
1532                         GstPad* _tmp9_;
1533 #line 253 "clip.vala"
1534                         _tmp7_ = make_element ("fakesink", &_inner_error_);
1535 #line 1536 "clip.c"
1536                         if (_inner_error_ != NULL) {
1537                                 goto __catch4_g_error;
1538                         }
1539 #line 253 "clip.vala"
1540                         fake_sink = (_tmp8_ = _tmp7_, _gst_object_unref0 (fake_sink), _tmp8_);
1541 #line 254 "clip.vala"
1542                         gst_bin_add (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (fake_sink));
1543 #line 255 "clip.vala"
1544                         fake_pad = (_tmp9_ = gst_element_get_static_pad (fake_sink, "sink"), _gst_object_unref0 (fake_pad), _tmp9_);
1545 #line 257 "clip.vala"
1546                         if (!gst_element_sync_state_with_parent (fake_sink)) {
1547 #line 258 "clip.vala"
1548                                 g_error ("clip.vala:258: could not sync state with parent");
1549 #line 1550 "clip.c"
1550                         }
1551                 }
1552 #line 261 "clip.vala"
1553                 gst_pad_link (pad, fake_pad);
1554 #line 1555 "clip.c"
1555         }
1556         goto __finally4;
1557         __catch4_g_error:
1558         {
1559                 GError * e;
1560                 e = _inner_error_;
1561                 _inner_error_ = NULL;
1562                 {
1563                         _g_error_free0 (e);
1564                 }
1565         }
1566         __finally4:
1567         if (_inner_error_ != NULL) {
1568                 _gst_object_unref0 (fake_pad);
1569                 _gst_object_unref0 (fake_sink);
1570                 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);
1571                 g_clear_error (&_inner_error_);
1572                 return;
1573         }
1574         _gst_object_unref0 (fake_pad);
1575         _gst_object_unref0 (fake_sink);
1576 }
1577
1578
1579 #line 267 "clip.vala"
1580 static GstPad* model_clip_fetcher_get_pad (ModelClipFetcher* self, const char* prefix) {
1581 #line 1582 "clip.c"
1582         GstPad* result = NULL;
1583 #line 267 "clip.vala"
1584         g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL);
1585 #line 267 "clip.vala"
1586         g_return_val_if_fail (prefix != NULL, NULL);
1587 #line 1588 "clip.c"
1588         {
1589                 GList* pad_collection;
1590                 GList* pad_it;
1591 #line 268 "clip.vala"
1592                 pad_collection = MODEL_FETCHER (self)->decodebin->pads;
1593 #line 1594 "clip.c"
1594                 for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) {
1595                         GstPad* pad;
1596 #line 268 "clip.vala"
1597                         pad = _gst_object_ref0 ((GstPad*) pad_it->data);
1598 #line 1599 "clip.c"
1599                         {
1600                                 GstCaps* _tmp1_;
1601                                 GstCaps* _tmp0_ = NULL;
1602                                 char* _tmp2_;
1603                                 char* caps;
1604 #line 269 "clip.vala"
1605                                 caps = (_tmp2_ = gst_caps_to_string (_tmp1_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_)), _gst_caps_unref0 (_tmp1_), _tmp2_);
1606 #line 270 "clip.vala"
1607                                 if (g_str_has_prefix (caps, prefix)) {
1608 #line 1609 "clip.c"
1609                                         result = pad;
1610                                         _g_free0 (caps);
1611 #line 271 "clip.vala"
1612                                         return result;
1613 #line 1614 "clip.c"
1614                                 }
1615                                 _gst_object_unref0 (pad);
1616                                 _g_free0 (caps);
1617                         }
1618                 }
1619         }
1620         result = NULL;
1621 #line 274 "clip.vala"
1622         return result;
1623 #line 1624 "clip.c"
1624 }
1625
1626
1627 #line 277 "clip.vala"
1628 static void model_clip_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message) {
1629 #line 1630 "clip.c"
1630         ModelClipFetcher * self;
1631         GstState old_state = 0;
1632         GstState new_state = 0;
1633         GstState pending = 0;
1634         self = MODEL_CLIP_FETCHER (base);
1635 #line 277 "clip.vala"
1636         g_return_if_fail (GST_IS_BUS (bus));
1637 #line 277 "clip.vala"
1638         g_return_if_fail (GST_IS_MESSAGE (message));
1639 #line 278 "clip.vala"
1640         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_state_change");
1641 #line 279 "clip.vala"
1642         if (message->src != GST_OBJECT (MODEL_FETCHER (self)->pipeline)) {
1643 #line 280 "clip.vala"
1644                 return;
1645 #line 1646 "clip.c"
1646         }
1647 #line 286 "clip.vala"
1648         gst_message_parse_state_changed (message, &old_state, &new_state, &pending);
1649 #line 287 "clip.vala"
1650         if (new_state == old_state) {
1651 #line 288 "clip.vala"
1652                 return;
1653 #line 1654 "clip.c"
1654         }
1655 #line 290 "clip.vala"
1656         if (new_state == GST_STATE_PLAYING) {
1657 #line 1658 "clip.c"
1658                 GstPad* pad;
1659                 GstPad* _tmp3_;
1660                 GstFormat format;
1661                 gint64 length = 0LL;
1662                 gboolean _tmp7_ = FALSE;
1663 #line 291 "clip.vala"
1664                 pad = model_clip_fetcher_get_pad (self, "video");
1665 #line 292 "clip.vala"
1666                 if (pad != NULL) {
1667 #line 1668 "clip.c"
1668                         GstCaps* _tmp2_;
1669                         GstCaps* *_tmp1_;
1670                         GstCaps* _tmp0_ = NULL;
1671 #line 293 "clip.vala"
1672                         _tmp1_ = &MODEL_FETCHER (self)->clipfile->video_caps;
1673 #line 293 "clip.vala"
1674                         (*_tmp1_) = (_tmp2_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_), _gst_caps_unref0 ((*_tmp1_)), _tmp2_);
1675 #line 1676 "clip.c"
1676                 }
1677 #line 296 "clip.vala"
1678                 pad = (_tmp3_ = model_clip_fetcher_get_pad (self, "audio"), _gst_object_unref0 (pad), _tmp3_);
1679 #line 297 "clip.vala"
1680                 if (pad != NULL) {
1681 #line 1682 "clip.c"
1682                         GstCaps* _tmp6_;
1683                         GstCaps* *_tmp5_;
1684                         GstCaps* _tmp4_ = NULL;
1685 #line 298 "clip.vala"
1686                         _tmp5_ = &MODEL_FETCHER (self)->clipfile->audio_caps;
1687 #line 298 "clip.vala"
1688                         (*_tmp5_) = (_tmp6_ = (g_object_get (pad, "caps", &_tmp4_, NULL), _tmp4_), _gst_caps_unref0 ((*_tmp5_)), _tmp6_);
1689 #line 1690 "clip.c"
1690                 }
1691 #line 301 "clip.vala"
1692                 format = GST_FORMAT_TIME;
1693 #line 303 "clip.vala"
1694                 if (!gst_element_query_duration (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), &format, &length)) {
1695 #line 303 "clip.vala"
1696                         _tmp7_ = TRUE;
1697 #line 1698 "clip.c"
1698                 } else {
1699 #line 304 "clip.vala"
1700                         _tmp7_ = format != GST_FORMAT_TIME;
1701 #line 1702 "clip.c"
1702                 }
1703 #line 303 "clip.vala"
1704                 if (_tmp7_) {
1705 #line 305 "clip.vala"
1706                         model_fetcher_do_error (MODEL_FETCHER (self), "Can't fetch length");
1707 #line 1708 "clip.c"
1708                         _gst_object_unref0 (pad);
1709 #line 306 "clip.vala"
1710                         return;
1711 #line 1712 "clip.c"
1712                 }
1713 #line 308 "clip.vala"
1714                 model_clip_file_set_length (MODEL_FETCHER (self)->clipfile, length);
1715 #line 310 "clip.vala"
1716                 g_signal_emit_by_name (self, "clipfile-online", TRUE);
1717 #line 311 "clip.vala"
1718                 gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_NULL);
1719 #line 1720 "clip.c"
1720                 _gst_object_unref0 (pad);
1721         } else {
1722 #line 312 "clip.vala"
1723                 if (new_state == GST_STATE_NULL) {
1724 #line 313 "clip.vala"
1725                         g_signal_emit_by_name (MODEL_FETCHER (self), "ready", MODEL_FETCHER (self));
1726 #line 1727 "clip.c"
1727                 }
1728         }
1729 }
1730
1731
1732 static void model_clip_fetcher_class_init (ModelClipFetcherClass * klass) {
1733         model_clip_fetcher_parent_class = g_type_class_peek_parent (klass);
1734         MODEL_FETCHER_CLASS (klass)->on_pad_added = model_clip_fetcher_real_on_pad_added;
1735         MODEL_FETCHER_CLASS (klass)->on_state_change = model_clip_fetcher_real_on_state_change;
1736         g_signal_new ("clipfile_online", MODEL_TYPE_CLIP_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1737 }
1738
1739
1740 static void model_clip_fetcher_instance_init (ModelClipFetcher * self) {
1741 }
1742
1743
1744 GType model_clip_fetcher_get_type (void) {
1745         static volatile gsize model_clip_fetcher_type_id__volatile = 0;
1746         if (g_once_init_enter (&model_clip_fetcher_type_id__volatile)) {
1747                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFetcher), 0, (GInstanceInitFunc) model_clip_fetcher_instance_init, NULL };
1748                 GType model_clip_fetcher_type_id;
1749                 model_clip_fetcher_type_id = g_type_register_static (MODEL_TYPE_FETCHER, "ModelClipFetcher", &g_define_type_info, 0);
1750                 g_once_init_leave (&model_clip_fetcher_type_id__volatile, model_clip_fetcher_type_id);
1751         }
1752         return model_clip_fetcher_type_id__volatile;
1753 }
1754
1755
1756 static gpointer _g_object_ref0 (gpointer self) {
1757         return self ? g_object_ref (self) : NULL;
1758 }
1759
1760
1761 #line 359 "clip.vala"
1762 static void _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail (ThumbnailSink* _sender, GdkPixbuf* b, gpointer self) {
1763 #line 1764 "clip.c"
1764         model_thumbnail_fetcher_on_have_thumbnail (self, b);
1765 }
1766
1767
1768 #line 325 "clip.vala"
1769 ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error) {
1770 #line 1771 "clip.c"
1771         GError * _inner_error_;
1772         ModelThumbnailFetcher * self;
1773         ModelClipFile* _tmp1_;
1774         ModelClipFile* *_tmp0_;
1775         GstCaps* _tmp2_;
1776         SingleDecodeBin* _tmp3_;
1777         SingleDecodeBin* single_bin;
1778         GstPipeline* _tmp5_;
1779         GstPipeline* *_tmp4_;
1780         ThumbnailSink* _tmp6_;
1781         GstElement* _tmp7_;
1782         GstElement* _tmp8_;
1783         GstBus* bus;
1784 #line 325 "clip.vala"
1785         g_return_val_if_fail (MODEL_IS_CLIP_FILE (f), NULL);
1786 #line 1787 "clip.c"
1787         _inner_error_ = NULL;
1788 #line 325 "clip.vala"
1789         self = (ModelThumbnailFetcher*) model_fetcher_construct (object_type);
1790 #line 326 "clip.vala"
1791         _tmp0_ = &MODEL_FETCHER (self)->clipfile;
1792 #line 326 "clip.vala"
1793         (*_tmp0_) = (_tmp1_ = _g_object_ref0 (f), _g_object_unref0 ((*_tmp0_)), _tmp1_);
1794 #line 327 "clip.vala"
1795         self->priv->seek_position = time;
1796 #line 329 "clip.vala"
1797         single_bin = (_tmp3_ = single_decode_bin_new (_tmp2_ = gst_caps_from_string ("video/x-raw-rgb; video/x-raw-yuv"), "singledecoder", f->filename, &_inner_error_), _gst_caps_unref0 (_tmp2_), _tmp3_);
1798 #line 1799 "clip.c"
1799         if (_inner_error_ != NULL) {
1800                 g_propagate_error (error, _inner_error_);
1801                 g_object_unref (self);
1802                 return NULL;
1803         }
1804 #line 333 "clip.vala"
1805         _tmp4_ = &MODEL_FETCHER (self)->pipeline;
1806 #line 333 "clip.vala"
1807         (*_tmp4_) = (_tmp5_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 ((*_tmp4_)), _tmp5_);
1808 #line 334 "clip.vala"
1809         gst_pipeline_set_auto_flush_bus (MODEL_FETCHER (self)->pipeline, FALSE);
1810 #line 336 "clip.vala"
1811         self->priv->thumbnail_sink = (_tmp6_ = thumbnail_sink_new (), _gst_object_unref0 (self->priv->thumbnail_sink), _tmp6_);
1812 #line 337 "clip.vala"
1813         g_signal_connect_object (self->priv->thumbnail_sink, "have-thumbnail", (GCallback) _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail, self, 0);
1814 #line 339 "clip.vala"
1815         _tmp7_ = make_element ("ffmpegcolorspace", &_inner_error_);
1816 #line 1817 "clip.c"
1817         if (_inner_error_ != NULL) {
1818                 g_propagate_error (error, _inner_error_);
1819                 _gst_object_unref0 (single_bin);
1820                 g_object_unref (self);
1821                 return NULL;
1822         }
1823 #line 339 "clip.vala"
1824         self->priv->colorspace = (_tmp8_ = _tmp7_, _gst_object_unref0 (self->priv->colorspace), _tmp8_);
1825 #line 341 "clip.vala"
1826         gst_bin_add_many (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (GST_ELEMENT (single_bin)), _gst_object_ref0 (GST_ELEMENT (self->priv->thumbnail_sink)), _gst_object_ref0 (self->priv->colorspace), NULL);
1827 #line 343 "clip.vala"
1828         g_signal_connect_object (GST_ELEMENT (single_bin), "pad-added", (GCallback) _model_fetcher_on_pad_added_gst_element_pad_added, MODEL_FETCHER (self), 0);
1829 #line 345 "clip.vala"
1830         gst_element_link (self->priv->colorspace, GST_ELEMENT (self->priv->thumbnail_sink));
1831 #line 347 "clip.vala"
1832         bus = gst_pipeline_get_bus (MODEL_FETCHER (self)->pipeline);
1833 #line 349 "clip.vala"
1834         gst_bus_add_signal_watch (bus);
1835 #line 350 "clip.vala"
1836         g_signal_connect_object (bus, "message::state-changed", (GCallback) _model_fetcher_on_state_change_gst_bus_message, MODEL_FETCHER (self), 0);
1837 #line 351 "clip.vala"
1838         g_signal_connect_object (bus, "message::error", (GCallback) _model_fetcher_on_error_gst_bus_message, MODEL_FETCHER (self), 0);
1839 #line 352 "clip.vala"
1840         g_signal_connect_object (bus, "message::warning", (GCallback) _model_fetcher_on_warning_gst_bus_message, MODEL_FETCHER (self), 0);
1841 #line 354 "clip.vala"
1842         self->priv->have_thumbnail = FALSE;
1843 #line 355 "clip.vala"
1844         self->priv->done_seek = FALSE;
1845 #line 356 "clip.vala"
1846         gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_PAUSED);
1847 #line 1848 "clip.c"
1848         _gst_object_unref0 (single_bin);
1849         _gst_object_unref0 (bus);
1850         return self;
1851 }
1852
1853
1854 #line 325 "clip.vala"
1855 ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error) {
1856 #line 325 "clip.vala"
1857         return model_thumbnail_fetcher_construct (MODEL_TYPE_THUMBNAIL_FETCHER, f, time, error);
1858 #line 1859 "clip.c"
1859 }
1860
1861
1862 #line 359 "clip.vala"
1863 static void model_thumbnail_fetcher_on_have_thumbnail (ModelThumbnailFetcher* self, GdkPixbuf* buf) {
1864 #line 359 "clip.vala"
1865         g_return_if_fail (MODEL_IS_THUMBNAIL_FETCHER (self));
1866 #line 359 "clip.vala"
1867         g_return_if_fail (GDK_IS_PIXBUF (buf));
1868 #line 360 "clip.vala"
1869         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_have_thumbnail");
1870 #line 361 "clip.vala"
1871         if (self->priv->done_seek) {
1872 #line 362 "clip.vala"
1873                 self->priv->have_thumbnail = TRUE;
1874 #line 363 "clip.vala"
1875                 model_clip_file_set_thumbnail (MODEL_FETCHER (self)->clipfile, buf);
1876 #line 1877 "clip.c"
1877         }
1878 }
1879
1880
1881 #line 367 "clip.vala"
1882 static void model_thumbnail_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad) {
1883 #line 1884 "clip.c"
1884         ModelThumbnailFetcher * self;
1885         GstCaps* c;
1886         char* _tmp0_;
1887         gboolean _tmp1_;
1888         self = MODEL_THUMBNAIL_FETCHER (base);
1889 #line 367 "clip.vala"
1890         g_return_if_fail (GST_IS_PAD (pad));
1891 #line 368 "clip.vala"
1892         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added");
1893 #line 369 "clip.vala"
1894         c = gst_pad_get_caps (pad);
1895 #line 371 "clip.vala"
1896         if ((_tmp1_ = g_str_has_prefix (_tmp0_ = gst_caps_to_string (c), "video"), _g_free0 (_tmp0_), _tmp1_)) {
1897 #line 1898 "clip.c"
1898                 GstPad* _tmp2_;
1899 #line 372 "clip.vala"
1900                 gst_pad_link (pad, _tmp2_ = gst_element_get_static_pad (self->priv->colorspace, "sink"));
1901 #line 1902 "clip.c"
1902                 _gst_object_unref0 (_tmp2_);
1903         }
1904         _gst_caps_unref0 (c);
1905 }
1906
1907
1908 #line 376 "clip.vala"
1909 static void model_thumbnail_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message) {
1910 #line 1911 "clip.c"
1911         ModelThumbnailFetcher * self;
1912         GstState new_state = 0;
1913         GstState old_state = 0;
1914         GstState pending_state = 0;
1915         gboolean _tmp0_ = FALSE;
1916         self = MODEL_THUMBNAIL_FETCHER (base);
1917 #line 376 "clip.vala"
1918         g_return_if_fail (GST_IS_BUS (bus));
1919 #line 376 "clip.vala"
1920         g_return_if_fail (GST_IS_MESSAGE (message));
1921 #line 377 "clip.vala"
1922         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_state_change");
1923 #line 378 "clip.vala"
1924         if (message->src != GST_OBJECT (MODEL_FETCHER (self)->pipeline)) {
1925 #line 379 "clip.vala"
1926                 return;
1927 #line 1928 "clip.c"
1928         }
1929 #line 385 "clip.vala"
1930         gst_message_parse_state_changed (message, &old_state, &new_state, &pending_state);
1931 #line 386 "clip.vala"
1932         if (new_state == old_state) {
1933 #line 387 "clip.vala"
1934                 _tmp0_ = new_state != GST_STATE_PAUSED;
1935 #line 1936 "clip.c"
1936         } else {
1937 #line 386 "clip.vala"
1938                 _tmp0_ = FALSE;
1939 #line 1940 "clip.c"
1940         }
1941 #line 386 "clip.vala"
1942         if (_tmp0_) {
1943 #line 388 "clip.vala"
1944                 return;
1945 #line 1946 "clip.c"
1946         }
1947 #line 390 "clip.vala"
1948         if (new_state == GST_STATE_PAUSED) {
1949 #line 391 "clip.vala"
1950                 if (!self->priv->done_seek) {
1951 #line 392 "clip.vala"
1952                         self->priv->done_seek = TRUE;
1953 #line 393 "clip.vala"
1954                         gst_element_seek_simple (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->priv->seek_position);
1955 #line 1956 "clip.c"
1956                 } else {
1957 #line 395 "clip.vala"
1958                         if (self->priv->have_thumbnail) {
1959 #line 396 "clip.vala"
1960                                 gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_NULL);
1961 #line 1962 "clip.c"
1962                         }
1963                 }
1964         } else {
1965 #line 398 "clip.vala"
1966                 if (new_state == GST_STATE_NULL) {
1967 #line 399 "clip.vala"
1968                         g_signal_emit_by_name (MODEL_FETCHER (self), "ready", MODEL_FETCHER (self));
1969 #line 1970 "clip.c"
1970                 }
1971         }
1972 }
1973
1974
1975 static void model_thumbnail_fetcher_class_init (ModelThumbnailFetcherClass * klass) {
1976         model_thumbnail_fetcher_parent_class = g_type_class_peek_parent (klass);
1977         g_type_class_add_private (klass, sizeof (ModelThumbnailFetcherPrivate));
1978         MODEL_FETCHER_CLASS (klass)->on_pad_added = model_thumbnail_fetcher_real_on_pad_added;
1979         MODEL_FETCHER_CLASS (klass)->on_state_change = model_thumbnail_fetcher_real_on_state_change;
1980         G_OBJECT_CLASS (klass)->finalize = model_thumbnail_fetcher_finalize;
1981 }
1982
1983
1984 static void model_thumbnail_fetcher_instance_init (ModelThumbnailFetcher * self) {
1985         self->priv = MODEL_THUMBNAIL_FETCHER_GET_PRIVATE (self);
1986 }
1987
1988
1989 static void model_thumbnail_fetcher_finalize (GObject* obj) {
1990         ModelThumbnailFetcher * self;
1991         self = MODEL_THUMBNAIL_FETCHER (obj);
1992         _gst_object_unref0 (self->priv->thumbnail_sink);
1993         _gst_object_unref0 (self->priv->colorspace);
1994         G_OBJECT_CLASS (model_thumbnail_fetcher_parent_class)->finalize (obj);
1995 }
1996
1997
1998 GType model_thumbnail_fetcher_get_type (void) {
1999         static volatile gsize model_thumbnail_fetcher_type_id__volatile = 0;
2000         if (g_once_init_enter (&model_thumbnail_fetcher_type_id__volatile)) {
2001                 static const GTypeInfo g_define_type_info = { sizeof (ModelThumbnailFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_thumbnail_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelThumbnailFetcher), 0, (GInstanceInitFunc) model_thumbnail_fetcher_instance_init, NULL };
2002                 GType model_thumbnail_fetcher_type_id;
2003                 model_thumbnail_fetcher_type_id = g_type_register_static (MODEL_TYPE_FETCHER, "ModelThumbnailFetcher", &g_define_type_info, 0);
2004                 g_once_init_leave (&model_thumbnail_fetcher_type_id__volatile, model_thumbnail_fetcher_type_id);
2005         }
2006         return model_thumbnail_fetcher_type_id__volatile;
2007 }
2008
2009
2010 #line 488 "clip.vala"
2011 static void _model_clip_on_clipfile_updated_model_clip_file_updated (ModelClipFile* _sender, gpointer self) {
2012 #line 2013 "clip.c"
2013         model_clip_on_clipfile_updated (self, _sender);
2014 }
2015
2016
2017 #line 473 "clip.vala"
2018 ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording) {
2019 #line 2020 "clip.c"
2020         ModelClip * self;
2021         ModelClipFile* _tmp0_;
2022         char* _tmp1_;
2023 #line 473 "clip.vala"
2024         g_return_val_if_fail (MODEL_IS_CLIP_FILE (clipfile), NULL);
2025 #line 473 "clip.vala"
2026         g_return_val_if_fail (name != NULL, NULL);
2027 #line 473 "clip.vala"
2028         self = (ModelClip*) g_object_new (object_type, NULL);
2029 #line 475 "clip.vala"
2030         self->is_recording = is_recording;
2031 #line 476 "clip.vala"
2032         self->clipfile = (_tmp0_ = _g_object_ref0 (clipfile), _g_object_unref0 (self->clipfile), _tmp0_);
2033 #line 477 "clip.vala"
2034         self->type = t;
2035 #line 478 "clip.vala"
2036         self->name = (_tmp1_ = g_strdup (name), _g_free0 (self->name), _tmp1_);
2037 #line 479 "clip.vala"
2038         self->priv->connected = model_clip_file_is_online (clipfile);
2039 #line 480 "clip.vala"
2040         model_clip_set_media_start_duration (self, media_start, duration);
2041 #line 481 "clip.vala"
2042         model_clip_set_start (self, start);
2043 #line 482 "clip.vala"
2044         g_signal_connect_object (clipfile, "updated", (GCallback) _model_clip_on_clipfile_updated_model_clip_file_updated, self, 0);
2045 #line 2046 "clip.c"
2046         return self;
2047 }
2048
2049
2050 #line 473 "clip.vala"
2051 ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording) {
2052 #line 473 "clip.vala"
2053         return model_clip_construct (MODEL_TYPE_CLIP, clipfile, t, name, start, media_start, duration, is_recording);
2054 #line 2055 "clip.c"
2055 }
2056
2057
2058 #line 485 "clip.vala"
2059 void model_clip_gnonlin_connect (ModelClip* self) {
2060 #line 485 "clip.vala"
2061         g_return_if_fail (MODEL_IS_CLIP (self));
2062 #line 485 "clip.vala"
2063         self->priv->connected = TRUE;
2064 #line 2065 "clip.c"
2065 }
2066
2067
2068 #line 486 "clip.vala"
2069 void model_clip_gnonlin_disconnect (ModelClip* self) {
2070 #line 486 "clip.vala"
2071         g_return_if_fail (MODEL_IS_CLIP (self));
2072 #line 486 "clip.vala"
2073         self->priv->connected = FALSE;
2074 #line 2075 "clip.c"
2075 }
2076
2077
2078 #line 488 "clip.vala"
2079 static void model_clip_on_clipfile_updated (ModelClip* self, ModelClipFile* f) {
2080 #line 488 "clip.vala"
2081         g_return_if_fail (MODEL_IS_CLIP (self));
2082 #line 488 "clip.vala"
2083         g_return_if_fail (MODEL_IS_CLIP_FILE (f));
2084 #line 489 "clip.vala"
2085         logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clipfile_updated");
2086 #line 490 "clip.vala"
2087         if (model_clip_file_is_online (f)) {
2088 #line 491 "clip.vala"
2089                 if (!self->priv->connected) {
2090 #line 492 "clip.vala"
2091                         self->priv->connected = TRUE;
2092 #line 496 "clip.vala"
2093                         model_clip_set_media_start_duration (self, model_clip_get_media_start (self), model_clip_get_duration (self));
2094 #line 498 "clip.vala"
2095                         model_clip_set_start (self, model_clip_get_start (self));
2096 #line 2097 "clip.c"
2097                 }
2098         } else {
2099 #line 501 "clip.vala"
2100                 if (self->priv->connected) {
2101 #line 502 "clip.vala"
2102                         self->priv->connected = FALSE;
2103 #line 2104 "clip.c"
2104                 }
2105         }
2106 #line 505 "clip.vala"
2107         g_signal_emit_by_name (self, "updated", self);
2108 #line 2109 "clip.c"
2109 }
2110
2111
2112 #line 508 "clip.vala"
2113 gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length) {
2114 #line 2115 "clip.c"
2115         gboolean result = FALSE;
2116         gboolean _tmp0_ = FALSE;
2117 #line 508 "clip.vala"
2118         g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE);
2119 #line 509 "clip.vala"
2120         if (start < (model_clip_get_start (self) + model_clip_get_duration (self))) {
2121 #line 510 "clip.vala"
2122                 _tmp0_ = model_clip_get_start (self) < (start + length);
2123 #line 2124 "clip.c"
2124         } else {
2125 #line 509 "clip.vala"
2126                 _tmp0_ = FALSE;
2127 #line 2128 "clip.c"
2128         }
2129         result = _tmp0_;
2130 #line 509 "clip.vala"
2131         return result;
2132 #line 2133 "clip.c"
2133 }
2134
2135
2136 #line 513 "clip.vala"
2137 gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad) {
2138 #line 2139 "clip.c"
2139         gint64 result = 0LL;
2140 #line 513 "clip.vala"
2141         g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL);
2142 #line 513 "clip.vala"
2143         g_return_val_if_fail (MODEL_IS_CLIP (other), 0LL);
2144 #line 514 "clip.vala"
2145         if (time_in_range (model_clip_get_start (self), model_clip_get_start (other), pad)) {
2146 #line 2147 "clip.c"
2147                 result = model_clip_get_start (other);
2148 #line 515 "clip.vala"
2149                 return result;
2150 #line 2151 "clip.c"
2151         } else {
2152 #line 516 "clip.vala"
2153                 if (time_in_range (model_clip_get_start (self), model_clip_get_end (other), pad)) {
2154 #line 2155 "clip.c"
2155                         result = model_clip_get_end (other);
2156 #line 517 "clip.vala"
2157                         return result;
2158 #line 2159 "clip.c"
2159                 } else {
2160 #line 518 "clip.vala"
2161                         if (time_in_range (model_clip_get_end (self), model_clip_get_start (other), pad)) {
2162 #line 2163 "clip.c"
2163                                 result = model_clip_get_start (other) - model_clip_get_duration (self);
2164 #line 519 "clip.vala"
2165                                 return result;
2166 #line 2167 "clip.c"
2167                         } else {
2168 #line 520 "clip.vala"
2169                                 if (time_in_range (model_clip_get_end (self), model_clip_get_end (other), pad)) {
2170 #line 2171 "clip.c"
2171                                         result = model_clip_get_end (other) - model_clip_get_duration (self);
2172 #line 521 "clip.vala"
2173                                         return result;
2174 #line 2175 "clip.c"
2175                                 }
2176                         }
2177                 }
2178         }
2179         result = model_clip_get_start (self);
2180 #line 523 "clip.vala"
2181         return result;
2182 #line 2183 "clip.c"
2183 }
2184
2185
2186 #line 526 "clip.vala"
2187 gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span) {
2188 #line 2189 "clip.c"
2189         gboolean result = FALSE;
2190 #line 526 "clip.vala"
2191         g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE);
2192 #line 527 "clip.vala"
2193         if (time_in_range (*s, model_clip_get_start (self), span)) {
2194 #line 528 "clip.vala"
2195                 *s = model_clip_get_start (self);
2196 #line 2197 "clip.c"
2197                 result = TRUE;
2198 #line 529 "clip.vala"
2199                 return result;
2200 #line 2201 "clip.c"
2201         } else {
2202 #line 530 "clip.vala"
2203                 if (time_in_range (*s, model_clip_get_end (self), span)) {
2204 #line 531 "clip.vala"
2205                         *s = model_clip_get_end (self);
2206 #line 2207 "clip.c"
2207                         result = TRUE;
2208 #line 532 "clip.vala"
2209                         return result;
2210 #line 2211 "clip.c"
2211                 }
2212         }
2213         result = FALSE;
2214 #line 534 "clip.vala"
2215         return result;
2216 #line 2217 "clip.c"
2217 }
2218
2219
2220 #line 537 "clip.vala"
2221 ModelClip* model_clip_copy (ModelClip* self) {
2222 #line 2223 "clip.c"
2223         ModelClip* result = NULL;
2224 #line 537 "clip.vala"
2225         g_return_val_if_fail (MODEL_IS_CLIP (self), NULL);
2226 #line 2227 "clip.c"
2227         result = model_clip_new (self->clipfile, self->type, self->name, model_clip_get_start (self), model_clip_get_media_start (self), model_clip_get_duration (self), FALSE);
2228 #line 538 "clip.vala"
2229         return result;
2230 #line 2231 "clip.c"
2231 }
2232
2233
2234 #line 541 "clip.vala"
2235 gboolean model_clip_is_trimmed (ModelClip* self) {
2236 #line 2237 "clip.c"
2237         gboolean result = FALSE;
2238 #line 541 "clip.vala"
2239         g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE);
2240 #line 542 "clip.vala"
2241         if (!model_clip_file_is_online (self->clipfile)) {
2242 #line 2243 "clip.c"
2243                 result = FALSE;
2244 #line 543 "clip.vala"
2245                 return result;
2246 #line 2247 "clip.c"
2247         }
2248         result = model_clip_get_duration (self) != model_clip_file_get_length (self->clipfile);
2249 #line 544 "clip.vala"
2250         return result;
2251 #line 2252 "clip.c"
2252 }
2253
2254
2255 #line 547 "clip.vala"
2256 void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge) {
2257 #line 547 "clip.vala"
2258         g_return_if_fail (MODEL_IS_CLIP (self));
2259 #line 548 "clip.vala"
2260         switch (edge) {
2261 #line 2262 "clip.c"
2262                 case GDK_WINDOW_EDGE_WEST:
2263                 {
2264 #line 550 "clip.vala"
2265                         if ((model_clip_get_media_start (self) + delta) < 0) {
2266 #line 551 "clip.vala"
2267                                 delta = -model_clip_get_media_start (self);
2268 #line 2269 "clip.c"
2269                         }
2270 #line 554 "clip.vala"
2271                         if ((model_clip_get_duration (self) - delta) < 0) {
2272 #line 555 "clip.vala"
2273                                 delta = model_clip_get_duration (self);
2274 #line 2275 "clip.c"
2275                         }
2276 #line 558 "clip.vala"
2277                         model_clip_set_start (self, model_clip_get_start (self) + delta);
2278 #line 559 "clip.vala"
2279                         model_clip_set_media_start_duration (self, model_clip_get_media_start (self) + delta, model_clip_get_duration (self) - delta);
2280 #line 560 "clip.vala"
2281                         break;
2282 #line 2283 "clip.c"
2283                 }
2284                 case GDK_WINDOW_EDGE_EAST:
2285                 {
2286 #line 562 "clip.vala"
2287                         model_clip_set_duration (self, model_clip_get_duration (self) + delta);
2288 #line 563 "clip.vala"
2289                         break;
2290 #line 2291 "clip.c"
2291                 }
2292         }
2293 }
2294
2295
2296 #line 567 "clip.vala"
2297 void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration) {
2298 #line 2299 "clip.c"
2299         gboolean _tmp0_ = FALSE;
2300 #line 567 "clip.vala"
2301         g_return_if_fail (MODEL_IS_CLIP (self));
2302 #line 568 "clip.vala"
2303         if (media_start < 0) {
2304 #line 569 "clip.vala"
2305                 media_start = (gint64) 0;
2306 #line 2307 "clip.c"
2307         }
2308 #line 572 "clip.vala"
2309         if (duration < 0) {
2310 #line 573 "clip.vala"
2311                 duration = (gint64) 0;
2312 #line 2313 "clip.c"
2313         }
2314 #line 576 "clip.vala"
2315         if (model_clip_file_is_online (self->clipfile)) {
2316 #line 576 "clip.vala"
2317                 _tmp0_ = (media_start + duration) > model_clip_file_get_length (self->clipfile);
2318 #line 2319 "clip.c"
2319         } else {
2320 #line 576 "clip.vala"
2321                 _tmp0_ = FALSE;
2322 #line 2323 "clip.c"
2323         }
2324 #line 576 "clip.vala"
2325         if (_tmp0_) {
2326 #line 578 "clip.vala"
2327                 media_start = model_clip_file_get_length (self->clipfile) - duration;
2328 #line 2329 "clip.c"
2329         }
2330 #line 581 "clip.vala"
2331         self->priv->_media_start = media_start;
2332 #line 582 "clip.vala"
2333         self->priv->_duration = duration;
2334 #line 584 "clip.vala"
2335         if (self->priv->connected) {
2336 #line 585 "clip.vala"
2337                 g_signal_emit_by_name (self, "media-start-changed", self->priv->_media_start);
2338 #line 586 "clip.vala"
2339                 g_signal_emit_by_name (self, "duration-changed", self->priv->_duration);
2340 #line 2341 "clip.c"
2341         }
2342 #line 589 "clip.vala"
2343         g_signal_emit_by_name (self, "moved", self);
2344 #line 2345 "clip.c"
2345 }
2346
2347
2348 #line 592 "clip.vala"
2349 void model_clip_save (ModelClip* self, FILE* f, gint id) {
2350 #line 592 "clip.vala"
2351         g_return_if_fail (MODEL_IS_CLIP (self));
2352 #line 592 "clip.vala"
2353         g_return_if_fail (f != NULL);
2354 #line 593 "clip.vala"
2355         fprintf (f, "      <clip id=\"%d\" name=\"%s\" start=\"%" G_GINT64_FORMAT "\" " "media-start=\"%" G_GINT64_FORMAT "\" duration=\"%" G_GINT64_FORMAT "\"/>\n", id, self->name, model_clip_get_start (self), model_clip_get_media_start (self), model_clip_get_duration (self));
2356 #line 2357 "clip.c"
2357 }
2358
2359
2360 gint64 model_clip_get_start (ModelClip* self) {
2361         gint64 result;
2362         g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL);
2363         result = self->priv->_start;
2364 #line 414 "clip.vala"
2365         return result;
2366 #line 2367 "clip.c"
2367 }
2368
2369
2370 void model_clip_set_start (ModelClip* self, gint64 value) {
2371         g_return_if_fail (MODEL_IS_CLIP (self));
2372 #line 418 "clip.vala"
2373         self->priv->_start = value;
2374 #line 419 "clip.vala"
2375         if (self->priv->connected) {
2376 #line 420 "clip.vala"
2377                 g_signal_emit_by_name (self, "start-changed", self->priv->_start);
2378 #line 2379 "clip.c"
2379         }
2380 #line 422 "clip.vala"
2381         g_signal_emit_by_name (self, "moved", self);
2382 #line 2383 "clip.c"
2383         g_object_notify ((GObject *) self, "start");
2384 }
2385
2386
2387 gint64 model_clip_get_media_start (ModelClip* self) {
2388         gint64 result;
2389         g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL);
2390         result = self->priv->_media_start;
2391 #line 429 "clip.vala"
2392         return result;
2393 #line 2394 "clip.c"
2394 }
2395
2396
2397 gint64 model_clip_get_duration (ModelClip* self) {
2398         gint64 result;
2399         g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL);
2400         result = self->priv->_duration;
2401 #line 436 "clip.vala"
2402         return result;
2403 #line 2404 "clip.c"
2404 }
2405
2406
2407 void model_clip_set_duration (ModelClip* self, gint64 value) {
2408         g_return_if_fail (MODEL_IS_CLIP (self));
2409 #line 440 "clip.vala"
2410         if (value < 0) {
2411 #line 442 "clip.vala"
2412                 value = (gint64) 0;
2413 #line 2414 "clip.c"
2414         }
2415 #line 445 "clip.vala"
2416         if (!self->is_recording) {
2417 #line 446 "clip.vala"
2418                 if ((value + self->priv->_media_start) > model_clip_file_get_length (self->clipfile)) {
2419 #line 448 "clip.vala"
2420                         value = model_clip_file_get_length (self->clipfile) - model_clip_get_media_start (self);
2421 #line 2422 "clip.c"
2422                 }
2423         }
2424 #line 452 "clip.vala"
2425         self->priv->_duration = value;
2426 #line 453 "clip.vala"
2427         if (self->priv->connected) {
2428 #line 454 "clip.vala"
2429                 g_signal_emit_by_name (self, "duration-changed", self->priv->_duration);
2430 #line 2431 "clip.c"
2431         }
2432 #line 456 "clip.vala"
2433         g_signal_emit_by_name (self, "moved", self);
2434 #line 2435 "clip.c"
2435         g_object_notify ((GObject *) self, "duration");
2436 }
2437
2438
2439 gint64 model_clip_get_end (ModelClip* self) {
2440         gint64 result;
2441         g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL);
2442         result = model_clip_get_start (self) + model_clip_get_duration (self);
2443 #line 463 "clip.vala"
2444         return result;
2445 #line 2446 "clip.c"
2446 }
2447
2448
2449 static void model_clip_class_init (ModelClipClass * klass) {
2450         model_clip_parent_class = g_type_class_peek_parent (klass);
2451         g_type_class_add_private (klass, sizeof (ModelClipPrivate));
2452         G_OBJECT_CLASS (klass)->get_property = model_clip_get_property;
2453         G_OBJECT_CLASS (klass)->set_property = model_clip_set_property;
2454         G_OBJECT_CLASS (klass)->finalize = model_clip_finalize;
2455         g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_START, g_param_spec_int64 ("start", "start", "start", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
2456         g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_MEDIA_START, g_param_spec_int64 ("media-start", "media-start", "media-start", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2457         g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_DURATION, g_param_spec_int64 ("duration", "duration", "duration", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
2458         g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_END, g_param_spec_int64 ("end", "end", "end", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2459         g_signal_new ("moved", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP);
2460         g_signal_new ("updated", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP);
2461         g_signal_new ("media_start_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
2462         g_signal_new ("duration_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
2463         g_signal_new ("start_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64);
2464         g_signal_new ("removed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP);
2465 }
2466
2467
2468 static void model_clip_instance_init (ModelClip * self) {
2469         self->priv = MODEL_CLIP_GET_PRIVATE (self);
2470 }
2471
2472
2473 static void model_clip_finalize (GObject* obj) {
2474         ModelClip * self;
2475         self = MODEL_CLIP (obj);
2476         _g_object_unref0 (self->clipfile);
2477         _g_free0 (self->name);
2478         G_OBJECT_CLASS (model_clip_parent_class)->finalize (obj);
2479 }
2480
2481
2482 GType model_clip_get_type (void) {
2483         static volatile gsize model_clip_type_id__volatile = 0;
2484         if (g_once_init_enter (&model_clip_type_id__volatile)) {
2485                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClip), 0, (GInstanceInitFunc) model_clip_instance_init, NULL };
2486                 GType model_clip_type_id;
2487                 model_clip_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelClip", &g_define_type_info, 0);
2488                 g_once_init_leave (&model_clip_type_id__volatile, model_clip_type_id);
2489         }
2490         return model_clip_type_id__volatile;
2491 }
2492
2493
2494 static void model_clip_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2495         ModelClip * self;
2496         self = MODEL_CLIP (object);
2497         switch (property_id) {
2498                 case MODEL_CLIP_START:
2499                 g_value_set_int64 (value, model_clip_get_start (self));
2500                 break;
2501                 case MODEL_CLIP_MEDIA_START:
2502                 g_value_set_int64 (value, model_clip_get_media_start (self));
2503                 break;
2504                 case MODEL_CLIP_DURATION:
2505                 g_value_set_int64 (value, model_clip_get_duration (self));
2506                 break;
2507                 case MODEL_CLIP_END:
2508                 g_value_set_int64 (value, model_clip_get_end (self));
2509                 break;
2510                 default:
2511                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2512                 break;
2513         }
2514 }
2515
2516
2517 static void model_clip_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2518         ModelClip * self;
2519         self = MODEL_CLIP (object);
2520         switch (property_id) {
2521                 case MODEL_CLIP_START:
2522                 model_clip_set_start (self, g_value_get_int64 (value));
2523                 break;
2524                 case MODEL_CLIP_DURATION:
2525                 model_clip_set_duration (self, g_value_get_int64 (value));
2526                 break;
2527                 default:
2528                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2529                 break;
2530         }
2531 }
2532
2533
2534 #line 601 "clip.vala"
2535 ModelFetcherCompletion* model_fetcher_completion_construct (GType object_type) {
2536 #line 2537 "clip.c"
2537         ModelFetcherCompletion* self;
2538         self = (ModelFetcherCompletion*) g_type_create_instance (object_type);
2539         return self;
2540 }
2541
2542
2543 #line 601 "clip.vala"
2544 ModelFetcherCompletion* model_fetcher_completion_new (void) {
2545 #line 601 "clip.vala"
2546         return model_fetcher_completion_construct (MODEL_TYPE_FETCHER_COMPLETION);
2547 #line 2548 "clip.c"
2548 }
2549
2550
2551 #line 604 "clip.vala"
2552 static void model_fetcher_completion_real_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher) {
2553 #line 604 "clip.vala"
2554         g_return_if_fail (MODEL_IS_FETCHER_COMPLETION (self));
2555 #line 604 "clip.vala"
2556         g_return_if_fail (MODEL_IS_FETCHER (fetcher));
2557 #line 2558 "clip.c"
2558 }
2559
2560
2561 #line 604 "clip.vala"
2562 void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher) {
2563 #line 604 "clip.vala"
2564         MODEL_FETCHER_COMPLETION_GET_CLASS (self)->complete (self, fetcher);
2565 #line 2566 "clip.c"
2566 }
2567
2568
2569 static void model_value_fetcher_completion_init (GValue* value) {
2570         value->data[0].v_pointer = NULL;
2571 }
2572
2573
2574 static void model_value_fetcher_completion_free_value (GValue* value) {
2575         if (value->data[0].v_pointer) {
2576                 model_fetcher_completion_unref (value->data[0].v_pointer);
2577         }
2578 }
2579
2580
2581 static void model_value_fetcher_completion_copy_value (const GValue* src_value, GValue* dest_value) {
2582         if (src_value->data[0].v_pointer) {
2583                 dest_value->data[0].v_pointer = model_fetcher_completion_ref (src_value->data[0].v_pointer);
2584         } else {
2585                 dest_value->data[0].v_pointer = NULL;
2586         }
2587 }
2588
2589
2590 static gpointer model_value_fetcher_completion_peek_pointer (const GValue* value) {
2591         return value->data[0].v_pointer;
2592 }
2593
2594
2595 static gchar* model_value_fetcher_completion_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
2596         if (collect_values[0].v_pointer) {
2597                 ModelFetcherCompletion* object;
2598                 object = collect_values[0].v_pointer;
2599                 if (object->parent_instance.g_class == NULL) {
2600                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2601                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
2602                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2603                 }
2604                 value->data[0].v_pointer = model_fetcher_completion_ref (object);
2605         } else {
2606                 value->data[0].v_pointer = NULL;
2607         }
2608         return NULL;
2609 }
2610
2611
2612 static gchar* model_value_fetcher_completion_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
2613         ModelFetcherCompletion** object_p;
2614         object_p = collect_values[0].v_pointer;
2615         if (!object_p) {
2616                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
2617         }
2618         if (!value->data[0].v_pointer) {
2619                 *object_p = NULL;
2620         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
2621                 *object_p = value->data[0].v_pointer;
2622         } else {
2623                 *object_p = model_fetcher_completion_ref (value->data[0].v_pointer);
2624         }
2625         return NULL;
2626 }
2627
2628
2629 GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
2630         ModelParamSpecFetcherCompletion* spec;
2631         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_FETCHER_COMPLETION), NULL);
2632         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
2633         G_PARAM_SPEC (spec)->value_type = object_type;
2634         return G_PARAM_SPEC (spec);
2635 }
2636
2637
2638 gpointer model_value_get_fetcher_completion (const GValue* value) {
2639         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION), NULL);
2640         return value->data[0].v_pointer;
2641 }
2642
2643
2644 void model_value_set_fetcher_completion (GValue* value, gpointer v_object) {
2645         ModelFetcherCompletion* old;
2646         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION));
2647         old = value->data[0].v_pointer;
2648         if (v_object) {
2649                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_FETCHER_COMPLETION));
2650                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2651                 value->data[0].v_pointer = v_object;
2652                 model_fetcher_completion_ref (value->data[0].v_pointer);
2653         } else {
2654                 value->data[0].v_pointer = NULL;
2655         }
2656         if (old) {
2657                 model_fetcher_completion_unref (old);
2658         }
2659 }
2660
2661
2662 void model_value_take_fetcher_completion (GValue* value, gpointer v_object) {
2663         ModelFetcherCompletion* old;
2664         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION));
2665         old = value->data[0].v_pointer;
2666         if (v_object) {
2667                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_FETCHER_COMPLETION));
2668                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2669                 value->data[0].v_pointer = v_object;
2670         } else {
2671                 value->data[0].v_pointer = NULL;
2672         }
2673         if (old) {
2674                 model_fetcher_completion_unref (old);
2675         }
2676 }
2677
2678
2679 static void model_fetcher_completion_class_init (ModelFetcherCompletionClass * klass) {
2680         model_fetcher_completion_parent_class = g_type_class_peek_parent (klass);
2681         MODEL_FETCHER_COMPLETION_CLASS (klass)->finalize = model_fetcher_completion_finalize;
2682         MODEL_FETCHER_COMPLETION_CLASS (klass)->complete = model_fetcher_completion_real_complete;
2683 }
2684
2685
2686 static void model_fetcher_completion_instance_init (ModelFetcherCompletion * self) {
2687         self->ref_count = 1;
2688 }
2689
2690
2691 static void model_fetcher_completion_finalize (ModelFetcherCompletion* obj) {
2692         ModelFetcherCompletion * self;
2693         self = MODEL_FETCHER_COMPLETION (obj);
2694 }
2695
2696
2697 GType model_fetcher_completion_get_type (void) {
2698         static volatile gsize model_fetcher_completion_type_id__volatile = 0;
2699         if (g_once_init_enter (&model_fetcher_completion_type_id__volatile)) {
2700                 static const GTypeValueTable g_define_type_value_table = { model_value_fetcher_completion_init, model_value_fetcher_completion_free_value, model_value_fetcher_completion_copy_value, model_value_fetcher_completion_peek_pointer, "p", model_value_fetcher_completion_collect_value, "p", model_value_fetcher_completion_lcopy_value };
2701                 static const GTypeInfo g_define_type_info = { sizeof (ModelFetcherCompletionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_fetcher_completion_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelFetcherCompletion), 0, (GInstanceInitFunc) model_fetcher_completion_instance_init, &g_define_type_value_table };
2702                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
2703                 GType model_fetcher_completion_type_id;
2704                 model_fetcher_completion_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelFetcherCompletion", &g_define_type_info, &g_define_type_fundamental_info, 0);
2705                 g_once_init_leave (&model_fetcher_completion_type_id__volatile, model_fetcher_completion_type_id);
2706         }
2707         return model_fetcher_completion_type_id__volatile;
2708 }
2709
2710
2711 gpointer model_fetcher_completion_ref (gpointer instance) {
2712         ModelFetcherCompletion* self;
2713         self = instance;
2714         g_atomic_int_inc (&self->ref_count);
2715         return instance;
2716 }
2717
2718
2719 void model_fetcher_completion_unref (gpointer instance) {
2720         ModelFetcherCompletion* self;
2721         self = instance;
2722         if (g_atomic_int_dec_and_test (&self->ref_count)) {
2723                 MODEL_FETCHER_COMPLETION_GET_CLASS (self)->finalize (self);
2724                 g_type_free_instance ((GTypeInstance *) self);
2725         }
2726 }
2727
2728
2729
2730 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) {
2731         typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1, gint64 arg_1, gpointer data2);
2732         register GMarshalFunc_VOID__INT64 callback;
2733         register GCClosure * cc;
2734         register gpointer data1, data2;
2735         cc = (GCClosure *) closure;
2736         g_return_if_fail (n_param_values == 2);
2737         if (G_CCLOSURE_SWAP_DATA (closure)) {
2738                 data1 = closure->data;
2739                 data2 = param_values->data[0].v_pointer;
2740         } else {
2741                 data1 = param_values->data[0].v_pointer;
2742                 data2 = closure->data;
2743         }
2744         callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);
2745         callback (data1, g_value_get_int64 (param_values + 1), data2);
2746 }
2747
2748
2749