android-8.0.0_r4/s

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.camera.processing.imagebackend;

import android.graphics.Rect;
import com.android.camera.app.OrientationManager;
import com.android.camera.debug.Log;
import com.android.camera.one.v2.camera2proxy.ImageProxy;
import com.android.camera.session.CaptureSession;

import java.util.concurrent.Executor;

import javax.annotation.Nullable;

/**
 * TaskImageContainer are the base class of tasks that wish to run with the
 * ImageBackend class. It contains the basic information required to interact
 * with the ImageBackend class and the ability to identify itself to the UI
 * backend for updates on its progress.
 */
public abstract class TaskImageContainer implements Runnable {

    /**
     * Simple helper class to encapsulate uncompressed payloads. Could be more
     * complex in the future.
     */
    static public class UncompressedPayload {
        final public int[] data;

        UncompressedPayload(int[] passData) {
            data = passData;
        }
    }

    /**
     * Simple helper class to encapsulate compressed payloads. Could be more
     * complex in the future.
     */
    static public class CompressedPayload {
        final public byte[] data;

        CompressedPayload(byte[] passData) {
            data = passData;
        }
    }

    /**
     * Simple helper class to encapsulate all necessary image information that
     * is carried with the data to processing, so that tasks derived off of
     * TaskImageContainer can properly coordinate and optimize its computation.
     */
    static public class TaskImage {
        // Addendum to Android-defined image-format
        public final static int EXTRA_USER_DEFINED_FORMAT_ARGB_8888 = -1;

        // Minimal required knowledge for the image specification.
        public final OrientationManager.DeviceOrientation orientation;

        public final int height;
        public final int width;
        public final int format;
        public final Rect cropApplied;

        TaskImage(OrientationManager.DeviceOrientation anOrientation, int aWidth, int aHeight,
                int aFormat, Rect crop) {
            orientation = anOrientation;
            height = aHeight;
            width = aWidth;
            format = aFormat;
            cropApplied = crop;
        }

    }

    /**
     * Simple helper class to encapsulate input and resultant image
     * specification. TasksImageContainer classes can be uniquely identified by
     * triplet of its content (currently, the global timestamp of when the
     * object was taken), the image specification of the input and the desired
     * output image specification. Added a field to specify the destination of
     * the image artifact, since spawn tasks may created multiple un/compressed
     * artifacts of different size that need to be routed to different
     * components.
     */
    static public class TaskInfo {

        /**
         * A single task graph can often create multiple imaging processing
         * artifacts and the listener needs to distinguish an uncompressed image
         * meant for image destinations. The different destinations are as
         * follows:
         * <ul>
         * <li>FAST_THUMBNAIL: Small image required as soon as possible</li>
         * <li>INTERMEDIATE_THUMBNAIL: Mid-sized image required for filmstrips
         * at approximately 100-500ms latency</li>
         * <li>FINAL_IMAGE: Full-resolution image artifact where latency > 500
         * ms</li>
         * </ul>
         */
        public enum Destination {
            FAST_THUMBNAIL,
            INTERMEDIATE_THUMBNAIL,
            FINAL_IMAGE
        }

        public final Destination destination;
        // The unique Id of the image being processed.
        public final long contentId;

        public final TaskImage input;

        public final TaskImage result;

        TaskInfo(long aContentId, TaskImage inputSpec, TaskImage outputSpec,
                Destination aDestination) {
            contentId = aContentId;
            input = inputSpec;
            result = outputSpec;
            destination = aDestination;
        }

    }

    public enum ProcessingPriority {
        FAST, AVERAGE, SLOW
    }

    protected final static Log.Tag TAG = new Log.Tag("TaskImgContain");

    final protected ImageTaskManager mImageTaskManager;

    final protected Executor mExecutor;

    final protected long mId;

    final protected ProcessingPriority mProcessingPriority;

    final protected ImageToProcess mImage;

    final protected CaptureSession mSession;

    /**
     * Constructor when releasing the image reference.
     *
     * @param otherTask the original task that is spawning this task.
     * @param processingPriority Priority that the derived task will run at.
     */
    public TaskImageContainer(TaskImageContainer otherTask, ProcessingPriority processingPriority) {
        mId = otherTask.mId;
        mExecutor = otherTask.mExecutor;
        mImageTaskManager = otherTask.mImageTaskManager;
        mProcessingPriority = processingPriority;
        mSession = otherTask.mSession;
        mImage = null;
    }

    /**
     * Constructor to use when keeping the image reference.
     *
     * @param image Image reference that needs to be released.
     * @param Executor Executor to run the event handling, if required.
     * @param imageTaskManager a reference to the ImageBackend, in case, you
     *            need to spawn other tasks
     * @param preferredLane Priority that the derived task will run at
     * @param captureSession Session that handles image processing events
     */
    public TaskImageContainer(ImageToProcess image, @Nullable Executor Executor,
            ImageTaskManager imageTaskManager,
            ProcessingPriority preferredLane, CaptureSession captureSession) {
        mImage = image;
        mId = mImage.proxy.getTimestamp();
        mExecutor = Executor;
        mImageTaskManager = imageTaskManager;
        mProcessingPriority = preferredLane;
        mSession = captureSession;
    }

    /**
     * Returns rotated crop rectangle in terms of absolute sensor crop
     *
     */
    protected Rect rotateBoundingBox(Rect box, OrientationManager.DeviceOrientation orientation) {
        if(orientation == OrientationManager.DeviceOrientation.CLOCKWISE_0 ||
                orientation == OrientationManager.DeviceOrientation.CLOCKWISE_180) {
            return new Rect(box);
        } else {
            // Switch x/y coordinates.
            return new Rect(box.top, box.left, box.bottom, box.right);
        }
    }

    protected OrientationManager.DeviceOrientation addOrientation(
            OrientationManager.DeviceOrientation orientation1,
            OrientationManager.DeviceOrientation orientation2) {
        return OrientationManager.DeviceOrientation.from(orientation1.getDegrees()
                + orientation2.getDegrees());
    }

    /**
     * Returns a crop rectangle whose points are a strict subset of the points
     * specified by image rectangle. A Null Intersection returns
     * Rectangle(0,0,0,0).
     *
     * @param image image to be cropped
     * @param crop an arbitrary crop rectangle; if null, the crop is assumed to
     *            be set of all points.
     * @return the rectangle produced by the intersection of the image rectangle
     *         with passed-in crop rectangle; a null intersection returns
     *         Rect(0,0,0,0)
     */
    public Rect guaranteedSafeCrop(ImageProxy image, @Nullable Rect crop) {
        return guaranteedSafeCrop(image.getWidth(), image.getHeight(), crop);
    }

    /**
     * Returns a crop rectangle whose points are a strict subset of the points
     * specified by image rectangle. A Null Intersection returns Rectangle(0,0,0,0).
     * Since sometimes the ImageProxy doesn't take into account rotation.  The Image
     * is assumed to have its top-left corner at (0,0).
     *
     * @param width image width
     * @param height image height
     * @param crop an arbitrary crop rectangle; if null, the crop is assumed to
     *            be set of all points.
     * @return the rectangle produced by the intersection of the image rectangle
     *         with passed-in crop rectangle; a null intersection returns
     *         Rect(0,0,0,0)
     */

    public Rect guaranteedSafeCrop(int width, int height, @Nullable Rect crop) {
        if (crop == null) {
            return new Rect(0, 0, width, height);
        }
        Rect safeCrop = new Rect(crop);
        if (crop.top > crop.bottom || crop.left > crop.right || crop.width() <= 0
                || crop.height() <= 0) {
            return new Rect(0, 0, 0, 0);
        }

        safeCrop.left = Math.max(safeCrop.left, 0);
        safeCrop.top = Math.max(safeCrop.top, 0);
        safeCrop.right = Math.max(Math.min(safeCrop.right, width), safeCrop.left);
        safeCrop.bottom = Math.max(Math.min(safeCrop.bottom, height), safeCrop.top);

        if (safeCrop.width() <= 0 || safeCrop.height() <= 0) {
            return new Rect(0, 0, 0, 0);
        }

        return safeCrop;
    }

    /**
     * Returns whether the crop operation is required.
     *
     * @param image Image to be cropped
     * @param crop Crop region
     * @return whether the image needs any more processing to be cropped
     *         properly.
     */
    public boolean requiresCropOperation(ImageProxy image, @Nullable Rect crop) {
        if (crop == null) {
            return false;
        }

        return !(crop.equals(new Rect(0, 0, image.getWidth(), image.getHeight())));
    }

    /**
     * Basic listener function to signal ImageBackend that task has started.
     *
     * @param id Id for image content
     * @param input Image specification for task input
     * @param result Image specification for task result
     * @param aDestination Purpose of image processing artifact
     */
    public void onStart(long id, TaskImage input, TaskImage result,
            TaskInfo.Destination aDestination) {
        TaskInfo job = new TaskInfo(id, input, result, aDestination);
        final ImageProcessorListener listener = mImageTaskManager.getProxyListener();
        listener.onStart(job);
    }

    /**
     * Getter for Processing Priority
     *
     * @return Processing Priority associated with the task.
     */
    public ProcessingPriority getProcessingPriority() {
        return mProcessingPriority;
    }
}