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

   1 /* video_track.c generated by valac, the Vala compiler
   2  * generated from video_track.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 <stdio.h>
  15 #include <gee.h>
  16 #include <gst/gst.h>
  17 #include <float.h>
  18 #include <math.h>
  19
  20
  21 #define MODEL_TYPE_TRACK (model_track_get_type ())
  22 #define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack))
  23 #define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass))
  24 #define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK))
  25 #define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK))
  26 #define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass))
  27
  28 typedef struct _ModelTrack ModelTrack;
  29 typedef struct _ModelTrackClass ModelTrackClass;
  30 typedef struct _ModelTrackPrivate ModelTrackPrivate;
  31
  32 #define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ())
  33
  34 #define MODEL_TYPE_CLIP (model_clip_get_type ())
  35 #define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip))
  36 #define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass))
  37 #define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP))
  38 #define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP))
  39 #define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass))
  40
  41 typedef struct _ModelClip ModelClip;
  42 typedef struct _ModelClipClass ModelClipClass;
  43
  44 #define MODEL_TYPE_PROJECT (model_project_get_type ())
  45 #define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject))
  46 #define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass))
  47 #define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT))
  48 #define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT))
  49 #define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass))
  50
  51 typedef struct _ModelProject ModelProject;
  52 typedef struct _ModelProjectClass ModelProjectClass;
  53
  54 #define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ())
  55 #define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack))
  56 #define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass))
  57 #define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK))
  58 #define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK))
  59 #define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass))
  60
  61 typedef struct _ModelVideoTrack ModelVideoTrack;
  62 typedef struct _ModelVideoTrackClass ModelVideoTrackClass;
  63 typedef struct _ModelVideoTrackPrivate ModelVideoTrackPrivate;
  64
  65 #define TYPE_FRACTION (fraction_get_type ())
  66 typedef struct _Fraction Fraction;
  67 typedef struct _ModelClipPrivate ModelClipPrivate;
  68
  69 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  70 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  71 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  72 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  73 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  74 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  75
  76 typedef struct _ModelClipFile ModelClipFile;
  77 typedef struct _ModelClipFileClass ModelClipFileClass;
  78 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  79
  80 #define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ())
  81 #define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation))
  82 #define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION))
  83 #define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface))
  84
  85 typedef struct _ModelTempoInformation ModelTempoInformation;
  86 typedef struct _ModelTempoInformationIface ModelTempoInformationIface;
  87 typedef struct _ModelProjectPrivate ModelProjectPrivate;
  88
  89 #define TYPE_TIME_CODE (time_code_get_type ())
  90 typedef struct _TimeCode TimeCode;
  91
  92 #define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ())
  93 #define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine))
  94 #define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
  95 #define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE))
  96 #define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE))
  97 #define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass))
  98
  99 typedef struct _ViewMediaEngine ViewMediaEngine;
 100 typedef struct _ViewMediaEngineClass ViewMediaEngineClass;
 101
 102 #define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ())
 103 #define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader))
 104 #define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 105 #define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER))
 106 #define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER))
 107 #define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass))
 108
 109 typedef struct _ModelProjectLoader ModelProjectLoader;
 110 typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass;
 111
 112 #define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ())
 113 #define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager))
 114 #define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 115 #define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER))
 116 #define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER))
 117 #define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
 118
 119 typedef struct _ModelUndoManager ModelUndoManager;
 120 typedef struct _ModelUndoManagerClass ModelUndoManagerClass;
 121
 122 #define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ())
 123 #define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter))
 124 #define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 125 #define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER))
 126 #define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER))
 127 #define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass))
 128
 129 typedef struct _ModelLibraryImporter ModelLibraryImporter;
 130 typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass;
 131
 132 typedef enum  {
 133         MODEL_MEDIA_TYPE_AUDIO,
 134         MODEL_MEDIA_TYPE_VIDEO
 135 } ModelMediaType;
 136
 137 struct _ModelTrack {
 138         GObject parent_instance;
 139         ModelTrackPrivate * priv;
 140         ModelProject* project;
 141         GeeArrayList* clips;
 142         char* display_name;
 143 };
 144
 145 struct _ModelTrackClass {
 146         GObjectClass parent_class;
 147         char* (*name) (ModelTrack* self);
 148         ModelMediaType (*media_type) (ModelTrack* self);
 149         gboolean (*check) (ModelTrack* self, ModelClip* clip);
 150         void (*on_clip_updated) (ModelTrack* self, ModelClip* clip);
 151         void (*write_attributes) (ModelTrack* self, FILE* f);
 152 };
 153
 154 struct _ModelVideoTrack {
 155         ModelTrack parent_instance;
 156         ModelVideoTrackPrivate * priv;
 157 };
 158
 159 struct _ModelVideoTrackClass {
 160         ModelTrackClass parent_class;
 161 };
 162
 163 struct _Fraction {
 164         gint numerator;
 165         gint denominator;
 166 };
 167
 168 struct _ModelClip {
 169         GObject parent_instance;
 170         ModelClipPrivate * priv;
 171         ModelClipFile* clipfile;
 172         ModelMediaType type;
 173         gboolean is_recording;
 174         char* name;
 175 };
 176
 177 struct _ModelClipClass {
 178         GObjectClass parent_class;
 179 };
 180
 181 struct _ModelTempoInformationIface {
 182         GTypeInterface parent_iface;
 183         void (*get_time_signature) (ModelTempoInformation* self, Fraction* result);
 184         gint (*get_bpm) (ModelTempoInformation* self);
 185 };
 186
 187 struct _TimeCode {
 188         gint hour;
 189         gint minute;
 190         gint second;
 191         gint frame;
 192         gboolean drop_code;
 193 };
 194
 195 struct _ModelProject {
 196         GObject parent_instance;
 197         ModelProjectPrivate * priv;
 198         GeeArrayList* tracks;
 199         GeeArrayList* inactive_tracks;
 200         GeeArrayList* clipfiles;
 201         ViewMediaEngine* media_engine;
 202         char* project_file;
 203         ModelProjectLoader* loader;
 204         ModelUndoManager* undo_manager;
 205         ModelLibraryImporter* importer;
 206         Fraction default_framerate;
 207         gboolean click_during_play;
 208         gboolean click_during_record;
 209         double click_volume;
 210         gboolean library_visible;
 211         gint library_width;
 212         gboolean snap_to_clip;
 213 };
 214
 215 struct _ModelProjectClass {
 216         GObjectClass parent_class;
 217         void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result);
 218         char* (*get_project_file) (ModelProject* self);
 219         void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time);
 220         void (*add_track) (ModelProject* self, ModelTrack* track);
 221         void (*insert_track) (ModelProject* self, gint index, ModelTrack* track);
 222         void (*load) (ModelProject* self, const char* fname);
 223         void (*save) (ModelProject* self, const char* filename);
 224         char* (*get_app_name) (ModelProject* self);
 225         void (*load_complete) (ModelProject* self);
 226 };
 227
 228
 229 extern Fraction model_project_INVALID_FRAME_RATE;
 230 static gpointer model_video_track_parent_class = NULL;
 231
 232 GType model_track_get_type (void);
 233 GType model_media_type_get_type (void);
 234 GType model_clip_get_type (void);
 235 GType model_project_get_type (void);
 236 GType model_video_track_get_type (void);
 237 enum  {
 238         MODEL_VIDEO_TRACK_DUMMY_PROPERTY
 239 };
 240 ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name);
 241 ModelVideoTrack* model_video_track_new (ModelProject* project);
 242 ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project);
 243 static char* model_video_track_real_name (ModelTrack* base);
 244 static ModelMediaType model_video_track_real_media_type (ModelTrack* base);
 245 GType fraction_get_type (void);
 246 Fraction* fraction_dup (const Fraction* self);
 247 void fraction_free (Fraction* self);
 248 GType model_clip_file_get_type (void);
 249 gboolean model_clip_file_is_online (ModelClipFile* self);
 250 gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate);
 251 gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate);
 252 gboolean fraction_equal (Fraction *self, Fraction* f);
 253 static gboolean model_video_track_real_check (ModelTrack* base, ModelClip* clip);
 254 static gint64 model_video_track_frame_to_time (ModelVideoTrack* self, gint frame);
 255 gint time_to_frame_with_rate (gint64 time, Fraction* rate);
 256 static gint model_video_track_time_to_frame (ModelVideoTrack* self, gint64 time);
 257 gint model_video_track_get_current_frame (ModelVideoTrack* self, gint64 time);
 258 gint64 model_video_track_previous_frame (ModelVideoTrack* self, gint64 position);
 259 gint64 model_video_track_next_frame (ModelVideoTrack* self, gint64 position);
 260 GType model_tempo_information_get_type (void);
 261 GType time_code_get_type (void);
 262 TimeCode* time_code_dup (const TimeCode* self);
 263 void time_code_free (TimeCode* self);
 264 GType view_media_engine_get_type (void);
 265 GType model_project_loader_get_type (void);
 266 gpointer model_undo_manager_ref (gpointer instance);
 267 void model_undo_manager_unref (gpointer instance);
 268 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 269 void model_value_set_undo_manager (GValue* value, gpointer v_object);
 270 void model_value_take_undo_manager (GValue* value, gpointer v_object);
 271 gpointer model_value_get_undo_manager (const GValue* value);
 272 GType model_undo_manager_get_type (void);
 273 GType model_library_importer_get_type (void);
 274
 275
 276
 277 #line 11 "video_track.vala"
 278 ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project) {
 279 #line 280 "video_track.c"
 280         ModelVideoTrack * self;
 281 #line 11 "video_track.vala"
 282         g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL);
 283 #line 12 "video_track.vala"
 284         self = (ModelVideoTrack*) model_track_construct (object_type, project, "Video Track");
 285 #line 286 "video_track.c"
 286         return self;
 287 }
 288
 289
 290 #line 11 "video_track.vala"
 291 ModelVideoTrack* model_video_track_new (ModelProject* project) {
 292 #line 11 "video_track.vala"
 293         return model_video_track_construct (MODEL_TYPE_VIDEO_TRACK, project);
 294 #line 295 "video_track.c"
 295 }
 296
 297
 298 #line 15 "video_track.vala"
 299 static char* model_video_track_real_name (ModelTrack* base) {
 300 #line 301 "video_track.c"
 301         ModelVideoTrack * self;
 302         char* result = NULL;
 303         self = MODEL_VIDEO_TRACK (base);
 304         result = g_strdup ("video");
 305 #line 15 "video_track.vala"
 306         return result;
 307 #line 308 "video_track.c"
 308 }
 309
 310
 311 #line 17 "video_track.vala"
 312 static ModelMediaType model_video_track_real_media_type (ModelTrack* base) {
 313 #line 314 "video_track.c"
 314         ModelVideoTrack * self;
 315         ModelMediaType result = 0;
 316         self = MODEL_VIDEO_TRACK (base);
 317         result = MODEL_MEDIA_TYPE_VIDEO;
 318 #line 18 "video_track.vala"
 319         return result;
 320 #line 321 "video_track.c"
 321 }
 322
 323
 324 #line 21 "video_track.vala"
 325 static gboolean model_video_track_real_check (ModelTrack* base, ModelClip* clip) {
 326 #line 327 "video_track.c"
 327         ModelVideoTrack * self;
 328         gboolean result = FALSE;
 329         Fraction rate1 = {0};
 330         Fraction rate2 = {0};
 331         self = MODEL_VIDEO_TRACK (base);
 332 #line 21 "video_track.vala"
 333         g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE);
 334 #line 25 "video_track.vala"
 335         if (!model_clip_file_is_online (clip->clipfile)) {
 336 #line 337 "video_track.c"
 337                 result = TRUE;
 338 #line 26 "video_track.vala"
 339                 return result;
 340 #line 341 "video_track.c"
 341         }
 342 #line 28 "video_track.vala"
 343         if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) {
 344 #line 345 "video_track.c"
 345                 result = TRUE;
 346 #line 29 "video_track.vala"
 347                 return result;
 348 #line 349 "video_track.c"
 349         }
 350 #line 31 "video_track.vala"
 351         if (!model_video_track_get_framerate (self, &rate2)) {
 352 #line 32 "video_track.vala"
 353                 g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "Cannot get initial frame rate!", NULL);
 354 #line 355 "video_track.c"
 355                 result = FALSE;
 356 #line 33 "video_track.vala"
 357                 return result;
 358 #line 359 "video_track.c"
 359         }
 360 #line 36 "video_track.vala"
 361         if (!model_clip_file_get_frame_rate (clip->clipfile, &rate1)) {
 362 #line 37 "video_track.vala"
 363                 g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "can't get frame rate", NULL);
 364 #line 365 "video_track.c"
 365                 result = FALSE;
 366 #line 38 "video_track.vala"
 367                 return result;
 368 #line 369 "video_track.c"
 369         }
 370 #line 41 "video_track.vala"
 371         if (!fraction_equal (&rate1, &rate2)) {
 372 #line 42 "video_track.vala"
 373                 g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "can't insert clip with different frame rate", NULL);
 374 #line 375 "video_track.c"
 375                 result = FALSE;
 376 #line 43 "video_track.vala"
 377                 return result;
 378 #line 379 "video_track.c"
 379         }
 380         result = TRUE;
 381 #line 45 "video_track.vala"
 382         return result;
 383 #line 384 "video_track.c"
 384 }
 385
 386
 387 #line 63 "video_track.vala"
 388 static gint64 model_video_track_frame_to_time (ModelVideoTrack* self, gint frame) {
 389 #line 390 "video_track.c"
 390         gint64 result = 0LL;
 391         Fraction rate = {0};
 392 #line 63 "video_track.vala"
 393         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL);
 394 #line 65 "video_track.vala"
 395         if (!model_video_track_get_framerate (self, &rate)) {
 396 #line 397 "video_track.c"
 397                 result = (gint64) 0;
 398 #line 66 "video_track.vala"
 399                 return result;
 400 #line 401 "video_track.c"
 401         }
 402         result = (gint64) gst_util_uint64_scale ((guint64) frame, (guint64) (GST_SECOND * rate.denominator), (guint64) rate.numerator);
 403 #line 68 "video_track.vala"
 404         return result;
 405 #line 406 "video_track.c"
 406 }
 407
 408
 409 #line 71 "video_track.vala"
 410 static gint model_video_track_time_to_frame (ModelVideoTrack* self, gint64 time) {
 411 #line 412 "video_track.c"
 412         gint result = 0;
 413         Fraction rate = {0};
 414 #line 71 "video_track.vala"
 415         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0);
 416 #line 73 "video_track.vala"
 417         if (!model_video_track_get_framerate (self, &rate)) {
 418 #line 419 "video_track.c"
 419                 result = 0;
 420 #line 74 "video_track.vala"
 421                 return result;
 422 #line 423 "video_track.c"
 423         }
 424         result = time_to_frame_with_rate (time, &rate);
 425 #line 75 "video_track.vala"
 426         return result;
 427 #line 428 "video_track.c"
 428 }
 429
 430
 431 #line 78 "video_track.vala"
 432 gint model_video_track_get_current_frame (ModelVideoTrack* self, gint64 time) {
 433 #line 434 "video_track.c"
 434         gint result = 0;
 435 #line 78 "video_track.vala"
 436         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0);
 437 #line 438 "video_track.c"
 438         result = model_video_track_time_to_frame (self, time);
 439 #line 79 "video_track.vala"
 440         return result;
 441 #line 442 "video_track.c"
 442 }
 443
 444
 445 #line 82 "video_track.vala"
 446 gint64 model_video_track_previous_frame (ModelVideoTrack* self, gint64 position) {
 447 #line 448 "video_track.c"
 448         gint64 result = 0LL;
 449         gint frame;
 450 #line 82 "video_track.vala"
 451         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL);
 452 #line 83 "video_track.vala"
 453         frame = model_video_track_time_to_frame (self, position);
 454 #line 455 "video_track.c"
 455         result = model_video_track_frame_to_time (self, frame - 1);
 456 #line 84 "video_track.vala"
 457         return result;
 458 #line 459 "video_track.c"
 459 }
 460
 461
 462 #line 87 "video_track.vala"
 463 gint64 model_video_track_next_frame (ModelVideoTrack* self, gint64 position) {
 464 #line 465 "video_track.c"
 465         gint64 result = 0LL;
 466         gint frame;
 467 #line 87 "video_track.vala"
 468         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL);
 469 #line 88 "video_track.vala"
 470         frame = model_video_track_time_to_frame (self, position);
 471 #line 472 "video_track.c"
 472         result = model_video_track_frame_to_time (self, frame + 1);
 473 #line 89 "video_track.vala"
 474         return result;
 475 #line 476 "video_track.c"
 476 }
 477
 478
 479 #line 92 "video_track.vala"
 480 gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate) {
 481 #line 482 "video_track.c"
 482         gboolean result = FALSE;
 483 #line 92 "video_track.vala"
 484         g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), FALSE);
 485 #line 93 "video_track.vala"
 486         if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) {
 487 #line 488 "video_track.c"
 488                 result = FALSE;
 489 #line 94 "video_track.vala"
 490                 return result;
 491 #line 492 "video_track.c"
 492         }
 493         {
 494                 GeeIterator* _c_it;
 495                 _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_TRACK (self)->clips));
 496 #line 96 "video_track.vala"
 497                 while (TRUE) {
 498 #line 499 "video_track.c"
 499                         ModelClip* c;
 500 #line 96 "video_track.vala"
 501                         if (!gee_iterator_next (_c_it)) {
 502 #line 96 "video_track.vala"
 503                                 break;
 504 #line 505 "video_track.c"
 505                         }
 506 #line 96 "video_track.vala"
 507                         c = (ModelClip*) gee_iterator_get (_c_it);
 508 #line 97 "video_track.vala"
 509                         if (model_clip_file_is_online (c->clipfile)) {
 510 #line 511 "video_track.c"
 511                                 gboolean can;
 512 #line 98 "video_track.vala"
 513                                 can = model_clip_file_get_frame_rate (c->clipfile, rate);
 514 #line 99 "video_track.vala"
 515                                 g_assert (can);
 516 #line 517 "video_track.c"
 517                                 result = can;
 518                                 _g_object_unref0 (c);
 519                                 _g_object_unref0 (_c_it);
 520 #line 101 "video_track.vala"
 521                                 return result;
 522 #line 523 "video_track.c"
 523                         }
 524                         _g_object_unref0 (c);
 525                 }
 526                 _g_object_unref0 (_c_it);
 527         }
 528 #line 105 "video_track.vala"
 529         if (fraction_equal (&MODEL_TRACK (self)->project->default_framerate, &model_project_INVALID_FRAME_RATE)) {
 530 #line 531 "video_track.c"
 531                 result = FALSE;
 532 #line 106 "video_track.vala"
 533                 return result;
 534 #line 535 "video_track.c"
 535         }
 536 #line 108 "video_track.vala"
 537         *rate = MODEL_TRACK (self)->project->default_framerate;
 538 #line 539 "video_track.c"
 539         result = TRUE;
 540 #line 109 "video_track.vala"
 541         return result;
 542 #line 543 "video_track.c"
 543 }
 544
 545
 546 static void model_video_track_class_init (ModelVideoTrackClass * klass) {
 547         model_video_track_parent_class = g_type_class_peek_parent (klass);
 548         MODEL_TRACK_CLASS (klass)->name = model_video_track_real_name;
 549         MODEL_TRACK_CLASS (klass)->media_type = model_video_track_real_media_type;
 550         MODEL_TRACK_CLASS (klass)->check = model_video_track_real_check;
 551 }
 552
 553
 554 static void model_video_track_instance_init (ModelVideoTrack * self) {
 555 }
 556
 557
 558 GType model_video_track_get_type (void) {
 559         static volatile gsize model_video_track_type_id__volatile = 0;
 560         if (g_once_init_enter (&model_video_track_type_id__volatile)) {
 561                 static const GTypeInfo g_define_type_info = { sizeof (ModelVideoTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_video_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelVideoTrack), 0, (GInstanceInitFunc) model_video_track_instance_init, NULL };
 562                 GType model_video_track_type_id;
 563                 model_video_track_type_id = g_type_register_static (MODEL_TYPE_TRACK, "ModelVideoTrack", &g_define_type_info, 0);
 564                 g_once_init_leave (&model_video_track_type_id__volatile, model_video_track_type_id);
 565         }
 566         return model_video_track_type_id__volatile;
 567 }
 568
 569
 570
 571