diff options
Diffstat (limited to 'src/video-support/Video.vala')
| -rw-r--r-- | src/video-support/Video.vala | 703 |
1 files changed, 703 insertions, 0 deletions
diff --git a/src/video-support/Video.vala b/src/video-support/Video.vala new file mode 100644 index 0000000..0238d7f --- /dev/null +++ b/src/video-support/Video.vala @@ -0,0 +1,703 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +public class Video : VideoSource, Flaggable, Monitorable, Dateable { + public const string TYPENAME = "video"; + + public const uint64 FLAG_TRASH = 0x0000000000000001; + public const uint64 FLAG_OFFLINE = 0x0000000000000002; + public const uint64 FLAG_FLAGGED = 0x0000000000000004; + + public class InterpretableResults { + internal Video video; + internal bool update_interpretable = false; + internal bool is_interpretable = false; + internal Gdk.Pixbuf? new_thumbnail = null; + + public InterpretableResults(Video video) { + this.video = video; + } + + public void foreground_finish() { + if (update_interpretable) + video.set_is_interpretable(is_interpretable); + + if (new_thumbnail != null) { + try { + ThumbnailCache.replace(video, ThumbnailCache.Size.BIG, new_thumbnail); + ThumbnailCache.replace(video, ThumbnailCache.Size.MEDIUM, new_thumbnail); + + video.notify_thumbnail_altered(); + } catch (Error err) { + message("Unable to update video thumbnails for %s: %s", video.to_string(), + err.message); + } + } + } + } + + private static bool normal_regen_complete; + private static bool offline_regen_complete; + public static VideoSourceCollection global; + + private VideoRow backing_row; + + public Video(VideoRow row) { + this.backing_row = row; + + // normalize user text + this.backing_row.title = prep_title(this.backing_row.title); + + if (((row.flags & FLAG_TRASH) != 0) || ((row.flags & FLAG_OFFLINE) != 0)) + rehydrate_backlinks(global, row.backlinks); + } + + public static void init(ProgressMonitor? monitor = null) { + // Must initialize static variables here. + // TODO: set values at declaration time once the following Vala bug is fixed: + // https://bugzilla.gnome.org/show_bug.cgi?id=655594 + normal_regen_complete = false; + offline_regen_complete = false; + + // initialize GStreamer, but don't pass it our actual command line arguments -- we don't + // want our end users to be able to parameterize the GStreamer configuration + unowned string[] args = null; + Gst.init(ref args); + + var registry = Gst.Registry.@get (); + + /* Update our local registr to not include vaapi stuff. This is basically to + * work-around concurrent access to VAAPI/X11 which it doesn't like, cf + * https://bugzilla.gnome.org/show_bug.cgi?id=762416 + */ + + var features = registry.feature_filter ((f) => { + return f.get_name ().has_prefix ("vaapi"); + }, false); + + foreach (var feature in features) { + debug ("Removing registry feature %s", feature.get_name ()); + registry.remove_feature (feature); + } + + global = new VideoSourceCollection(); + + Gee.ArrayList<VideoRow?> all = VideoTable.get_instance().get_all(); + Gee.ArrayList<Video> all_videos = new Gee.ArrayList<Video>(); + Gee.ArrayList<Video> trashed_videos = new Gee.ArrayList<Video>(); + Gee.ArrayList<Video> offline_videos = new Gee.ArrayList<Video>(); + int count = all.size; + for (int ctr = 0; ctr < count; ctr++) { + Video video = new Video(all.get(ctr)); + + if (video.is_trashed()) + trashed_videos.add(video); + else if (video.is_offline()) + offline_videos.add(video); + else + all_videos.add(video); + + if (monitor != null) + monitor(ctr, count); + } + + global.add_many_to_trash(trashed_videos); + global.add_many_to_offline(offline_videos); + global.add_many(all_videos); + } + + public static void notify_normal_thumbs_regenerated() { + if (normal_regen_complete) + return; + + message("normal video thumbnail regeneration completed"); + + normal_regen_complete = true; + } + + public static void notify_offline_thumbs_regenerated() { + if (offline_regen_complete) + return; + + message("offline video thumbnail regeneration completed"); + + offline_regen_complete = true; + } + + public static void terminate() { + } + + public static ExporterUI? export_many(Gee.Collection<Video> videos, Exporter.CompletionCallback done, + bool export_in_place = false) { + if (videos.size == 0) + return null; + + // in place export is relatively easy -- provide a fast, separate code path for it + if (export_in_place) { + ExporterUI temp_exporter = new ExporterUI(new Exporter.for_temp_file(videos, + Scaling.for_original(), ExportFormatParameters.unmodified())); + temp_exporter.export(done); + return temp_exporter; + } + + // one video + if (videos.size == 1) { + Video video = null; + foreach (Video v in videos) { + video = v; + break; + } + + File save_as = ExportUI.choose_file(video.get_basename()); + if (save_as == null) + return null; + + try { + AppWindow.get_instance().set_busy_cursor(); + video.export(save_as); + AppWindow.get_instance().set_normal_cursor(); + } catch (Error err) { + AppWindow.get_instance().set_normal_cursor(); + export_error_dialog(save_as, false); + } + + return null; + } + + // multiple videos + File export_dir = ExportUI.choose_dir(_("Export Videos")); + if (export_dir == null) + return null; + + ExporterUI exporter = new ExporterUI(new Exporter(videos, export_dir, + Scaling.for_original(), ExportFormatParameters.unmodified())); + exporter.export(done); + + return exporter; + } + + protected override void commit_backlinks(SourceCollection? sources, string? backlinks) { + try { + VideoTable.get_instance().update_backlinks(get_video_id(), backlinks); + lock (backing_row) { + backing_row.backlinks = backlinks; + } + } catch (DatabaseError err) { + warning("Unable to update link state for %s: %s", to_string(), err.message); + } + } + + protected override bool set_event_id(EventID event_id) { + lock (backing_row) { + bool committed = VideoTable.get_instance().set_event(backing_row.video_id, event_id); + + if (committed) + backing_row.event_id = event_id; + + return committed; + } + } + + public static bool is_duplicate(File? file, string? full_md5) { + assert(file != null || full_md5 != null); +#if !NO_DUPE_DETECTION + return VideoTable.get_instance().has_duplicate(file, full_md5); +#else + return false; +#endif + } + + public static ImportResult import_create(VideoImportParams params, out Video video) { + video = null; + + // add to the database + try { + if (VideoTable.get_instance().add(params.row).is_invalid()) + return ImportResult.DATABASE_ERROR; + } catch (DatabaseError err) { + return ImportResult.DATABASE_ERROR; + } + + // create local object but don't add to global until thumbnails generated + video = new Video(params.row); + + return ImportResult.SUCCESS; + } + + public static void import_failed(Video video) { + try { + VideoTable.get_instance().remove(video.get_video_id()); + } catch (DatabaseError err) { + AppWindow.database_error(err); + } + } + + public override BackingFileState[] get_backing_files_state() { + BackingFileState[] backing = new BackingFileState[1]; + lock (backing_row) { + backing[0] = new BackingFileState(backing_row.filepath, backing_row.filesize, + backing_row.timestamp, backing_row.md5); + } + + return backing; + } + + public override Gdk.Pixbuf? get_thumbnail(int scale) throws Error { + return ThumbnailCache.fetch(this, scale); + } + + public override string get_master_md5() { + lock (backing_row) { + return backing_row.md5; + } + } + + public override Gdk.Pixbuf get_preview_pixbuf(Scaling scaling) throws Error { + Gdk.Pixbuf pixbuf = get_thumbnail(ThumbnailCache.Size.BIG); + + return scaling.perform_on_pixbuf(pixbuf, Gdk.InterpType.NEAREST, true); + } + + public override Gdk.Pixbuf? create_thumbnail(int scale) throws Error { + VideoReader reader = new VideoReader(get_file()); + Gdk.Pixbuf? frame = reader.read_preview_frame(); + + return (frame != null) ? frame : Resources.get_noninterpretable_badge_pixbuf().copy(); + } + + public override string get_typename() { + return TYPENAME; + } + + public override int64 get_instance_id() { + return get_video_id().id; + } + + public override ImportID get_import_id() { + lock (backing_row) { + return backing_row.import_id; + } + } + + public override PhotoFileFormat get_preferred_thumbnail_format() { + return PhotoFileFormat.get_system_default_format(); + } + + public override string? get_title() { + lock (backing_row) { + return backing_row.title; + } + } + + public override void set_title(string? title) { + string? new_title = prep_title(title); + + lock (backing_row) { + if (backing_row.title == new_title) + return; + + try { + VideoTable.get_instance().set_title(backing_row.video_id, new_title); + } catch (DatabaseError e) { + AppWindow.database_error(e); + return; + } + // if we didn't short-circuit return in the catch clause above, then the change was + // successfully committed to the database, so update it in the in-memory row cache + backing_row.title = new_title; + } + + notify_altered(new Alteration("metadata", "name")); + } + + public override string? get_comment() { + lock (backing_row) { + return backing_row.comment; + } + } + + public override bool set_comment(string? comment) { + string? new_comment = prep_title(comment); + + lock (backing_row) { + if (backing_row.comment == new_comment) + return true; + + try { + VideoTable.get_instance().set_comment(backing_row.video_id, new_comment); + } catch (DatabaseError e) { + AppWindow.database_error(e); + return false; + } + // if we didn't short-circuit return in the catch clause above, then the change was + // successfully committed to the database, so update it in the in-memory row cache + backing_row.comment = new_comment; + } + + notify_altered(new Alteration("metadata", "comment")); + + return true; + } + + + public override Rating get_rating() { + lock (backing_row) { + return backing_row.rating; + } + } + + public override void set_rating(Rating rating) { + lock (backing_row) { + if ((!rating.is_valid()) || (rating == backing_row.rating)) + return; + + try { + VideoTable.get_instance().set_rating(get_video_id(), rating); + } catch (DatabaseError e) { + AppWindow.database_error(e); + return; + } + // if we didn't short-circuit return in the catch clause above, then the change was + // successfully committed to the database, so update it in the in-memory row cache + backing_row.rating = rating; + } + + notify_altered(new Alteration("metadata", "rating")); + } + + public override void increase_rating() { + lock (backing_row) { + set_rating(backing_row.rating.increase()); + } + } + + public override void decrease_rating() { + lock (backing_row) { + set_rating(backing_row.rating.decrease()); + } + } + + public override bool is_trashed() { + return is_flag_set(FLAG_TRASH); + } + + public override bool is_offline() { + return is_flag_set(FLAG_OFFLINE); + } + + public override void mark_offline() { + add_flags(FLAG_OFFLINE); + } + + public override void mark_online() { + remove_flags(FLAG_OFFLINE); + + if ((!get_is_interpretable())) + check_is_interpretable().foreground_finish(); + } + + public override void trash() { + add_flags(FLAG_TRASH); + } + + public override void untrash() { + remove_flags(FLAG_TRASH); + } + + public bool is_flagged() { + return is_flag_set(FLAG_FLAGGED); + } + + public void mark_flagged() { + add_flags(FLAG_FLAGGED, new Alteration("metadata", "flagged")); + } + + public void mark_unflagged() { + remove_flags(FLAG_FLAGGED, new Alteration("metadata", "flagged")); + } + + public override EventID get_event_id() { + lock (backing_row) { + return backing_row.event_id; + } + } + + public override string to_string() { + lock (backing_row) { + return "[%s] %s".printf(backing_row.video_id.id.to_string(), backing_row.filepath); + } + } + + public VideoID get_video_id() { + lock (backing_row) { + return backing_row.video_id; + } + } + + public override DateTime? get_exposure_time() { + lock (backing_row) { + return backing_row.exposure_time; + } + } + + public void set_exposure_time(DateTime time) { + lock (backing_row) { + try { + VideoTable.get_instance().set_exposure_time(backing_row.video_id, time); + } catch (Error e) { + debug("Warning - %s", e.message); + } + backing_row.exposure_time = time; + } + + notify_altered(new Alteration("metadata", "exposure-time")); + } + + public Dimensions get_frame_dimensions() { + lock (backing_row) { + return Dimensions(backing_row.width, backing_row.height); + } + } + + public override Dimensions get_dimensions(Photo.Exception disallowed_steps = Photo.Exception.NONE) { + return get_frame_dimensions(); + } + + public override uint64 get_filesize() { + return get_master_filesize(); + } + + public override uint64 get_master_filesize() { + lock (backing_row) { + return backing_row.filesize; + } + } + + public override DateTime? get_timestamp() { + lock (backing_row) { + return backing_row.timestamp; + } + } + + public void set_master_timestamp(FileInfo info) { + var time_val = info.get_modification_date_time(); + + try { + lock (backing_row) { + if (backing_row.timestamp.equal(time_val)) + return; + + VideoTable.get_instance().set_timestamp(backing_row.video_id, time_val); + backing_row.timestamp = time_val; + } + } catch (Error err) { + AppWindow.database_error(err); + + return; + } + + notify_altered(new Alteration("metadata", "master-timestamp")); + } + + public string get_filename() { + lock (backing_row) { + return backing_row.filepath; + } + } + + public override File get_file() { + return File.new_for_path(get_filename()); + } + + public override File get_master_file() { + return get_file(); + } + + public void export(File dest_file) throws Error { + File source_file = File.new_for_path(get_filename()); + source_file.copy(dest_file, FileCopyFlags.OVERWRITE | FileCopyFlags.TARGET_DEFAULT_PERMS, + null, null); + } + + public double get_clip_duration() { + lock (backing_row) { + return backing_row.clip_duration; + } + } + + public bool get_is_interpretable() { + lock (backing_row) { + return backing_row.is_interpretable; + } + } + + private void set_is_interpretable(bool is_interpretable) { + lock (backing_row) { + if (backing_row.is_interpretable == is_interpretable) + return; + + backing_row.is_interpretable = is_interpretable; + } + + try { + VideoTable.get_instance().update_is_interpretable(get_video_id(), is_interpretable); + } catch (DatabaseError e) { + AppWindow.database_error(e); + } + } + + // Intended to be called from a background thread but can be called from foreground as well. + // Caller should call InterpretableResults.foreground_process() only from foreground thread, + // however + public InterpretableResults check_is_interpretable() { + InterpretableResults results = new InterpretableResults(this); + + double clip_duration = -1.0; + Gdk.Pixbuf? preview_frame = null; + + VideoReader backing_file_reader = new VideoReader(get_file()); + try { + clip_duration = backing_file_reader.read_clip_duration(); + preview_frame = backing_file_reader.read_preview_frame(); + } catch (VideoError e) { + // if we catch an error on an interpretable video here, then this video is + // non-interpretable (e.g. its codec is not present on the users system). + results.update_interpretable = get_is_interpretable(); + results.is_interpretable = false; + + return results; + } + + // if already marked interpretable, this is only confirming what we already knew + if (get_is_interpretable()) { + results.update_interpretable = false; + results.is_interpretable = true; + + return results; + } + + debug("video %s has become interpretable", get_file().get_basename()); + + // save this here, this can be done in background thread + lock (backing_row) { + backing_row.clip_duration = clip_duration; + } + + results.update_interpretable = true; + results.is_interpretable = true; + results.new_thumbnail = preview_frame; + + return results; + } + + public override void destroy() { + VideoID video_id = get_video_id(); + + ThumbnailCache.remove(this); + + try { + VideoTable.get_instance().remove(video_id); + } catch (DatabaseError err) { + error("failed to remove video %s from video table", to_string()); + } + + base.destroy(); + } + + protected override bool internal_delete_backing() throws Error { + bool ret = delete_original_file(); + + // Return false if parent method failed. + return base.internal_delete_backing() && ret; + } + + private void notify_flags_altered(Alteration? additional_alteration) { + Alteration alteration = new Alteration("metadata", "flags"); + if (additional_alteration != null) + alteration = alteration.compress(additional_alteration); + + notify_altered(alteration); + } + + public uint64 add_flags(uint64 flags_to_add, Alteration? additional_alteration = null) { + uint64 new_flags; + lock (backing_row) { + new_flags = internal_add_flags(backing_row.flags, flags_to_add); + if (backing_row.flags == new_flags) + return backing_row.flags; + + try { + VideoTable.get_instance().set_flags(get_video_id(), new_flags); + } catch (DatabaseError e) { + AppWindow.database_error(e); + return backing_row.flags; + } + + backing_row.flags = new_flags; + } + + notify_flags_altered(additional_alteration); + + return new_flags; + } + + public uint64 remove_flags(uint64 flags_to_remove, Alteration? additional_alteration = null) { + uint64 new_flags; + lock (backing_row) { + new_flags = internal_remove_flags(backing_row.flags, flags_to_remove); + if (backing_row.flags == new_flags) + return backing_row.flags; + + try { + VideoTable.get_instance().set_flags(get_video_id(), new_flags); + } catch (DatabaseError e) { + AppWindow.database_error(e); + return backing_row.flags; + } + + backing_row.flags = new_flags; + } + + notify_flags_altered(additional_alteration); + + return new_flags; + } + + public bool is_flag_set(uint64 flag) { + lock (backing_row) { + return internal_is_flag_set(backing_row.flags, flag); + } + } + + public void set_master_file(File file) { + string new_filepath = file.get_path(); + string? old_filepath = null; + try { + lock (backing_row) { + if (backing_row.filepath == new_filepath) + return; + + old_filepath = backing_row.filepath; + + VideoTable.get_instance().set_filepath(backing_row.video_id, new_filepath); + backing_row.filepath = new_filepath; + } + } catch (Error err) { + AppWindow.database_error(err); + + return; + } + + assert(old_filepath != null); + notify_master_replaced(File.new_for_path(old_filepath), file); + + notify_altered(new Alteration.from_list("backing:master,metadata:name")); + } + + public VideoMetadata read_metadata() throws Error { + return (new VideoReader(get_file())).read_metadata(); + } +} |