~ubuntu-branches/ubuntu/quantal/shotwell/quantal

/* Copyright 2009-2012 Yorba Foundation

 

    // The number of seconds we should hold onto a precached copy of the original image; if

    // it hasn't been accessed in this many seconds, discard it to conserve memory.

    private const int PRECACHE_TIME_TO_LIVE = 180;

 

    // The first time we have to run the pipeline on an image, we'll precache

    // a copy of the unscaled, unmodified version; this allows us to operate

    // directly on the image data quickly without re-fetching it at the top

    // of the pipeline, which can cause significant lag with larger images.

    //

    // This adds a small amount of (automatically garbage-collected) memory

    // overhead, but greatly simplifies the pipeline, since scaling can now

    // be blithely ignored, and most of the pixel operations are fast enough

    // that the app remains responsive, even with 10MP images.

    //

    // In order to make sure we discard unneeded precaches in a timely fashion,

    // we spawn a timer when the unmodified pixbuf is first precached; if the

    // timer elapses and the pixbuf hasn't been needed again since then, we'll

    // discard it and free up the memory.

    private Gdk.Pixbuf unmodified_precached = null;

    private GLib.Timer secs_since_access = null;

        TimeVal timestamp = info.get_modification_time();

        discard_prefetched(true);

        TimeVal timestamp = info.get_modification_time();

        TimeVal modification_time = info.get_modification_time();

        public class DevToReimport {

        TimeVal modification = info.get_modification_time();

        TimeVal modification = info.get_modification_time();

        TimeVal timestamp = info.get_modification_time();

    /**

     * @brief Returns the width and height of the Photo after various

     * arbitrary stages of the pipeline have been applied in

     * the same order they're applied in get_pixbuf_with_options.

     * With no argument passed, it works exactly like the

     * previous incarnation did.

     *

     * @param disallowed_steps Which pipeline steps should NOT

     *      be taken into account when computing image dimensions

     *      (matching the convention set by get_pixbuf_with_options()).

     *      Pipeline steps that do not affect the image geometry are

     *      ignored.

     */

    public override Dimensions get_dimensions(Exception disallowed_steps = Exception.NONE) {

        // The raw dimensions of the incoming image prior to the pipeline.

        Dimensions returned_dims = get_raw_dimensions();

 

        // Compute how much the image would be resized by after rotating and/or mirroring.

        if (disallowed_steps.allows(Exception.ORIENTATION)) {

            Orientation ori_tmp = get_orientation();

 

            // Is this image rotated 90 or 270 degrees?

            switch (ori_tmp) {

                case Orientation.LEFT_TOP:

                case Orientation.RIGHT_TOP:

                case Orientation.LEFT_BOTTOM:

                case Orientation.RIGHT_BOTTOM:

                    // Yes, swap width and height of raw dimensions.

                    int width_tmp = returned_dims.width;

 

                    returned_dims.width = returned_dims.height;

                    returned_dims.height = width_tmp;

                break;

 

                default:

                    // No, only mirrored or rotated 180; do nothing.

                break;

            }

        }

 

        // Compute how much the image would be resized by after straightening.

        if (disallowed_steps.allows(Exception.STRAIGHTEN)) {

            double x_size, y_size;

            double angle = 0.0;

 

            get_straighten(out angle);

 

            compute_arb_rotated_size(returned_dims.width, returned_dims.height, angle, out x_size, out y_size);

 

            returned_dims.width = (int) (x_size);

            returned_dims.height = (int) (y_size);

        }

 

        // Compute how much the image would be resized by after cropping.

        if (disallowed_steps.allows(Exception.CROP)) {

            Box crop;

            if (get_crop(out crop)) {

                returned_dims = crop.get_dimensions();

            }

        }

        return returned_dims;

    public void add_redeye_instance(EditingTools.RedeyeInstance redeye) {

 

 

 

 

 

 

    /**

     * @brief Populates the cached version of the unmodified image.

     */

    public void populate_prefetched() throws Error {

        lock (unmodified_precached) {

            // If we don't have it already, precache the original...

            if (unmodified_precached == null) {

                unmodified_precached = load_raw_pixbuf(Scaling.for_original(), Exception.ALL, BackingFetchMode.SOURCE);

                secs_since_access = new GLib.Timer();

                GLib.Timeout.add_seconds(5, (GLib.SourceFunc)discard_prefetched);

                debug("spawning new precache timeout for %s", this.to_string()); 

            }

        }

    }

 

    /**

     * @brief Get a copy of what's in the cache.

     *

     * @return A Pixbuf with the image data from unmodified_precached.

     */

    public Gdk.Pixbuf? get_prefetched_copy() {

        lock (unmodified_precached) {

            if (unmodified_precached == null) {

                try {

                    populate_prefetched();

                } catch (Error e) {

                    warning("raw pixbuf for %s could not be loaded", this.to_string());

                    return null;

                }

            }

 

            return unmodified_precached.copy();

        }

    }

 

    /**

     * @brief Discards the cached version of the unmodified image.

     *

     * @param immed Whether the cached version should be discarded now, or not.

     */

    public bool discard_prefetched(bool immed = false) {

        lock (unmodified_precached) {

            if (secs_since_access == null)

                return false;

            

            double tmp;

            if ((secs_since_access.elapsed(out tmp) > PRECACHE_TIME_TO_LIVE) || (immed)) {

                debug("pipeline not run in over %d seconds or got immediate command, discarding" + 

                    "cached original for %s",

                    PRECACHE_TIME_TO_LIVE, to_string());

                unmodified_precached = null;

                secs_since_access = null;

                return false;

            }

 

            return true;

        }

    }

    /**

     * @brief Returns a fully transformed and scaled pixbuf.  Transformations may be excluded via

     * the mask. If the image is smaller than the scaling, it will be returned in its actual size.

     * The caller is responsible for scaling thereafter.

     *

     * @param scaling A scaling object that describes the size the output pixbuf should be.

     * @param exceptions The parts of the pipeline that should be skipped; defaults to NONE if

     *      left unset.

     * @param fetch_mode The fetch mode; if left unset, defaults to BASELINE so that

     *      we get the image exactly as it is in the file.

     */ 

 

 

 

        Dimensions scaled_to_viewport;

 

            original = get_dimensions(Exception.ALL);

            scaled = scaling.get_scaled_dimensions(get_dimensions(exceptions));

            scaled_to_viewport = scaled;

            

            is_scaled = !(get_dimensions().equals(scaled));

                        

 

 

        populate_prefetched();

 

        Gdk.Pixbuf pixbuf = get_prefetched_copy();

 

        // remember to delete the cached copy if it isn't being used.

        secs_since_access.start();

        debug("pipeline being run against %s, timer restarted.", this.to_string());

 

        assert(pixbuf != null);

            

            if (is_straightened) {

            

        }

 

                // ensure the crop region stays inside the scaled image boundaries and is

                // at least 1 px by 1 px; this is needed as a work-around for inaccuracies

                // which can occur when zooming.

                crop.left = crop.left.clamp(0, pixbuf.width - 2);

                crop.top = crop.top.clamp(0, pixbuf.height - 2);

 

                crop.right = crop.right.clamp(crop.left + 1, pixbuf.width - 1);

                crop.bottom = crop.bottom.clamp(crop.top + 1, pixbuf.height - 1);

 

                     crop.get_height());

    

        // orientation (all modifications are stored in unrotated coordinate system)

        if (exceptions.allows(Exception.ORIENTATION)) {

#if MEASURE_PIPELINE

            timer.start();

#endif

            pixbuf = orientation.rotate_pixbuf(pixbuf);

#if MEASURE_PIPELINE

            orientation_time = timer.elapsed();

#endif

        }

#if MEASURE_PIPELINE

        debug("PIPELINE %s (%s): redeye=%lf crop=%lf adjustment=%lf orientation=%lf total=%lf",

            to_string(), scaling.to_string(), redeye_time, crop_time, adjustment_time, 

            orientation_time, total_timer.elapsed());

#endif

 

        // scale the scratch image, as needed.

        if (is_scaled) {

            pixbuf = pixbuf.scale_simple(scaled_to_viewport.width, scaled_to_viewport.height, Gdk.InterpType.BILINEAR);

        }

 

        // color adjustment; we do this dead last, since, if an image has been scaled down,

        // it may allow us to reduce the amount of pixel arithmetic, increasing responsiveness.

        }        

 

 

    private void attach_editable(PhotoFileFormat file_format, File file) throws Error { 

            TimeVal timestamp = info.get_modification_time();

 

        // at this point, any image date we have cached is stale,

        // so delete it and force the pipeline to re-fetch it

        discard_prefetched(true);

        // delete old image data and force the pipeline to load new from file.

        discard_prefetched(true);

        

        Dimensions dim = get_dimensions(Exception.CROP | Exception.ORIENTATION);

    public void set_crop(Box crop) {                                                                

        Dimensions dim = get_dimensions(Exception.CROP | Exception.ORIENTATION);

 

        derotated.left = derotated.left.clamp(0, dim.width - 2);

        derotated.right = derotated.right.clamp(derotated.left, dim.width - 1);

 

        derotated.top = derotated.top.clamp(0, dim.height - 2);

        derotated.bottom = derotated.bottom.clamp(derotated.top, dim.height - 1);

        Gdk.Rectangle raw_rect = Gdk.Rectangle();