Bitmap.java revision ce217faddb4b40c1b3e698944da1951027080427
19066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/*
29066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Copyright (C) 2006 The Android Open Source Project
39066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project *
49066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License");
59066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * you may not use this file except in compliance with the License.
69066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * You may obtain a copy of the License at
79066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project *
89066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project *      http://www.apache.org/licenses/LICENSE-2.0
99066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project *
109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Unless required by applicable law or agreed to in writing, software
119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS,
129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * See the License for the specific language governing permissions and
149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * limitations under the License.
159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */
169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectpackage android.graphics;
189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
191c2bf03d1082fc6b7eb42cbd163c60c07cf2bcccTor Norbyeimport android.annotation.CheckResult;
2080756e38882720860db52f1fcc21fa1505a02abfTor Norbyeimport android.annotation.ColorInt;
21c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viveretteimport android.annotation.NonNull;
22efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guyimport android.annotation.Nullable;
239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.os.Parcel;
248cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chenimport android.os.Parcelable;
250df3bd5594bbbbfbf6058ecb31e9b94a1cd22f7dJohn Reckimport android.os.Trace;
262784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackbornimport android.util.DisplayMetrics;
2701a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reckimport android.util.Log;
28a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winsonimport libcore.util.NativeAllocationRegistry;
29a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson
308cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chenimport java.io.OutputStream;
319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.nio.Buffer;
329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.nio.ByteBuffer;
339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.nio.IntBuffer;
348cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chenimport java.nio.ShortBuffer;
359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectpublic final class Bitmap implements Parcelable {
3701a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck    private static final String TAG = "Bitmap";
3801a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck
399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Indicates that the bitmap was created for an unknown pixel density.
419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
4211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see Bitmap#getDensity()
4311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see Bitmap#setDensity(int)
449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
4511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public static final int DENSITY_NONE = 0;
46f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
47775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler    // Estimated size of the Bitmap native allocation, not including
48775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler    // pixel data.
49775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler    private static final long NATIVE_ALLOCATION_SIZE = 32;
50775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler
51f29ed28c7b878ef28058bc730715d0d32445bc57John Reck    // Convenience for JNI access
52f29ed28c7b878ef28058bc730715d0d32445bc57John Reck    private final long mNativePtr;
53e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy
549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private final boolean mIsMutable;
551abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik
561abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    /**
5757ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * Represents whether the Bitmap's content is requested to be pre-multiplied.
581abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * Note that isPremultiplied() does not directly return this value, because
5957ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * isPremultiplied() may never return true for a 565 Bitmap or a bitmap
6057ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * without alpha.
611abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
621abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * setPremultiplied() does directly set the value so that setConfig() and
631abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * setPremultiplied() aren't order dependent, despite being setters.
6457ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     *
6557ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * The native bitmap's premultiplication state is kept up to date by
6657ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * pushing down this preference for every config change.
671abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     */
6857ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private boolean mRequestPremultiplied;
698790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III
7047cd8e921db73e894f94ec4729ade90da50996f5Chris Craik    private byte[] mNinePatchChunk; // may be null
7147cd8e921db73e894f94ec4729ade90da50996f5Chris Craik    private NinePatch.InsetStruct mNinePatchInsets; // may be null
721abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    private int mWidth;
731abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    private int mHeight;
749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private boolean mRecycled;
759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
76efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    private ColorSpace mColorSpace;
77efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy
78caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck    /** @hide */
79caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck    public int mDensity = getDefaultDensity();
809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
8111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    private static volatile Matrix sScaleMatrix;
829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
8396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn    private static volatile int sDefaultDensity = -1;
8402890fd0f98b3b8d98baf0bda1ea906afd723d8bRomain Guy
8596e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn    /**
8696e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * For backwards compatibility, allows the app layer to change the default
8796e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * density when running old apps.
8896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * @hide
8996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     */
9096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn    public static void setDefaultDensity(int density) {
9196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        sDefaultDensity = density;
9296e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn    }
933849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy
94f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck    @SuppressWarnings("deprecation")
953849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy    static int getDefaultDensity() {
9696e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        if (sDefaultDensity >= 0) {
9796e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn            return sDefaultDensity;
9896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        }
9996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        sDefaultDensity = DisplayMetrics.DENSITY_DEVICE;
10096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        return sDefaultDensity;
10196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn    }
102dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn
1039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
1049f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * Private constructor that must received an already allocated native bitmap
1059f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * int (pointer).
106ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani     */
107f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck    // called from JNI
1084508218850faedea95371188da587b6734f5f3dasergeyv    Bitmap(long nativeBitmap, int width, int height, int density,
10957ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III            boolean isMutable, boolean requestPremultiplied,
11047cd8e921db73e894f94ec4729ade90da50996f5Chris Craik            byte[] ninePatchChunk, NinePatch.InsetStruct ninePatchInsets) {
1119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (nativeBitmap == 0) {
1129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("internal error: native bitmap is 0");
1139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
1148cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
1151abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        mWidth = width;
1161abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        mHeight = height;
1171abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        mIsMutable = isMutable;
11857ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III        mRequestPremultiplied = requestPremultiplied;
1194cd7dbc90f93893f521dce32d8cd25c02a185a24Chris Craik
1209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        mNinePatchChunk = ninePatchChunk;
12147cd8e921db73e894f94ec4729ade90da50996f5Chris Craik        mNinePatchInsets = ninePatchInsets;
122de0dfb7b65a02d4dd74c271b558adee0973fc267Dianne Hackborn        if (density >= 0) {
123de0dfb7b65a02d4dd74c271b558adee0973fc267Dianne Hackborn            mDensity = density;
124de0dfb7b65a02d4dd74c271b558adee0973fc267Dianne Hackborn        }
1254cd7dbc90f93893f521dce32d8cd25c02a185a24Chris Craik
126f29ed28c7b878ef28058bc730715d0d32445bc57John Reck        mNativePtr = nativeBitmap;
1274508218850faedea95371188da587b6734f5f3dasergeyv        long nativeSize = NATIVE_ALLOCATION_SIZE + getAllocationByteCount();
128775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        NativeAllocationRegistry registry = new NativeAllocationRegistry(
1290ebdbb4a8470bb77f38c33a42c220ecb8a7adcc6Richard Uhler            Bitmap.class.getClassLoader(), nativeGetNativeFinalizer(), nativeSize);
130775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        registry.registerNativeAllocation(this, nativeBitmap);
1319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
1329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
1339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
1344c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger     * Return the pointer to the native object.
135caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck     * @hide
1364c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger     */
137caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck    public long getNativeInstance() {
1384c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger        return mNativePtr;
1394c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger    }
1404c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger
1414c5efe9290543b723b76a8bd48518da1ae1dcb26Derek Sollenberger    /**
1421abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * Native bitmap has been reconfigured, so set premult and cached
1431abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * width/height values
1449f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     */
1459505a6552764461c22ce48f1ac13d025d23e1579Romain Guy    @SuppressWarnings("unused") // called from JNI
14657ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    void reinit(int width, int height, boolean requestPremultiplied) {
1471abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        mWidth = width;
1481abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        mHeight = height;
14957ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III        mRequestPremultiplied = requestPremultiplied;
1505acc476878bce8b72c0059e05cbbd5b43ffee5d5Romain Guy        mColorSpace = null;
1519f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik    }
1529f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik
1539f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik    /**
15411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * <p>Returns the density for this bitmap.</p>
1559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
15696e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * <p>The default density is the same density as the current display,
15796e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * unless the current application does not support different screen
15896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * densities in which case it is
15996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * {@link android.util.DisplayMetrics#DENSITY_DEFAULT}.  Note that
16096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * compatibility mode is determined by the application that was initially
16196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * loaded into a process -- applications that share the same process should
16296e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * all have the same compatibility, or ensure they explicitly set the
16396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * density of their bitmaps appropriately.</p>
1649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
16596e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * @return A scaling factor of the default density or {@link #DENSITY_NONE}
1669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         if the scaling factor is unknown.
1679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
16811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see #setDensity(int)
169a53b828635fce8b6b2d3e3377d74d72070056623Dianne Hackborn     * @see android.util.DisplayMetrics#DENSITY_DEFAULT
17011ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see android.util.DisplayMetrics#densityDpi
17111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see #DENSITY_NONE
1729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
17311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public int getDensity() {
17401a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
17501a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getDensity() on a recycle()'d bitmap! This is undefined behavior!");
17601a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
17711ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return mDensity;
1789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
1799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
1809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
18111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * <p>Specifies the density for this bitmap.  When the bitmap is
18211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * drawn to a Canvas that also has a density, it will be scaled
18311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * appropriately.</p>
1849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
18511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @param density The density scaling factor to use with this bitmap or
18611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     *        {@link #DENSITY_NONE} if the density is unknown.
1879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
18811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see #getDensity()
189a53b828635fce8b6b2d3e3377d74d72070056623Dianne Hackborn     * @see android.util.DisplayMetrics#DENSITY_DEFAULT
19011ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see android.util.DisplayMetrics#densityDpi
19111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @see #DENSITY_NONE
1929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
19311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public void setDensity(int density) {
19411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        mDensity = density;
1959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
196c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
197c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    /**
198c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>Modifies the bitmap to have a specified width, height, and {@link
199c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * Config}, without affecting the underlying allocation backing the bitmap.
200c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * Bitmap pixel data is not re-initialized for the new configuration.</p>
201c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
202c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>This method can be used to avoid allocating a new bitmap, instead
203c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * reusing an existing bitmap's allocation for a new configuration of equal
204c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * or lesser size. If the Bitmap's allocation isn't large enough to support
205c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * the new configuration, an IllegalArgumentException will be thrown and the
206c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * bitmap will not be modified.</p>
207c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
208c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>The result of {@link #getByteCount()} will reflect the new configuration,
209c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * while {@link #getAllocationByteCount()} will reflect that of the initial
210c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * configuration.</p>
211c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
21217a8bfc38a565ae96f43d36b223779be840bb50cLeon Scroggins III     * <p>Note: This may change this result of hasAlpha(). When converting to 565,
21317a8bfc38a565ae96f43d36b223779be840bb50cLeon Scroggins III     * the new bitmap will always be considered opaque. When converting from 565,
21417a8bfc38a565ae96f43d36b223779be840bb50cLeon Scroggins III     * the new bitmap will be considered non-opaque, and will respect the value
21517a8bfc38a565ae96f43d36b223779be840bb50cLeon Scroggins III     * set by setPremultiplied().</p>
21617a8bfc38a565ae96f43d36b223779be840bb50cLeon Scroggins III     *
2176d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * <p>WARNING: This method should NOT be called on a bitmap currently in use
2186d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * by the view system, Canvas, or the AndroidBitmap NDK API. It does not
2196d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * make guarantees about how the underlying pixel buffer is remapped to the
2206d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * new config, just that the allocation is reused. Additionally, the view
2216d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * system does not account for bitmap properties being modifying during use,
2226d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * e.g. while attached to drawables.</p>
2236d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *
2246d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * <p>In order to safely ensure that a Bitmap is no longer in use by the
2256d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * View system it is necessary to wait for a draw pass to occur after
2266d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * invalidate()'ing any view that had previously drawn the Bitmap in the last
2276d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * draw pass due to hardware acceleration's caching of draw commands. As
2286d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * an example, here is how this can be done for an ImageView:
2296d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * <pre class="prettyprint">
2306d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *      ImageView myImageView = ...;
2316d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *      final Bitmap myBitmap = ...;
2326d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *      myImageView.setImageDrawable(null);
2336d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *      myImageView.post(new Runnable() {
2346d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *          public void run() {
2356d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *              // myBitmap is now no longer in use by the ImageView
2366d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *              // and can be safely reconfigured.
2376d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *              myBitmap.reconfigure(...);
2386d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *          }
2396d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     *      });
2406d86e57bdadd56be160eb3e543cc53622cae46f2John Reck     * </pre></p>
241c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
242c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setWidth(int)
243c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setHeight(int)
244c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setConfig(Config)
245c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     */
246c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    public void reconfigure(int width, int height, Config config) {
247c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        checkRecycled("Can't call reconfigure() on a recycled bitmap");
248c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        if (width <= 0 || height <= 0) {
249c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik            throw new IllegalArgumentException("width and height must be > 0");
250c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        }
251c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        if (!isMutable()) {
2529c2cde0583d02ba7551877dbe7a5ecaee6defb56Chris Craik            throw new IllegalStateException("only mutable bitmaps may be reconfigured");
253c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        }
254c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
2554508218850faedea95371188da587b6734f5f3dasergeyv        nativeReconfigure(mNativePtr, width, height, config.nativeInt, mRequestPremultiplied);
256c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        mWidth = width;
257c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        mHeight = height;
2585acc476878bce8b72c0059e05cbbd5b43ffee5d5Romain Guy        mColorSpace = null;
259c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    }
260c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
261c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    /**
262c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>Convenience method for calling {@link #reconfigure(int, int, Config)}
263c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * with the current height and config.</p>
264c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
265c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>WARNING: this method should not be used on bitmaps currently used by
266c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * the view system, see {@link #reconfigure(int, int, Config)} for more
267c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * details.</p>
268c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
269c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #reconfigure(int, int, Config)
270c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setHeight(int)
271c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setConfig(Config)
272c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     */
273c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    public void setWidth(int width) {
274c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        reconfigure(width, getHeight(), getConfig());
275c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    }
276c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
277c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    /**
278c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>Convenience method for calling {@link #reconfigure(int, int, Config)}
279c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * with the current width and config.</p>
280c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
281c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>WARNING: this method should not be used on bitmaps currently used by
282c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * the view system, see {@link #reconfigure(int, int, Config)} for more
283c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * details.</p>
284c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
285c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #reconfigure(int, int, Config)
286c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setWidth(int)
287c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setConfig(Config)
288c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     */
289c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    public void setHeight(int height) {
290c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        reconfigure(getWidth(), height, getConfig());
291c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    }
292c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
293c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    /**
294c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>Convenience method for calling {@link #reconfigure(int, int, Config)}
295c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * with the current height and width.</p>
296c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
297c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>WARNING: this method should not be used on bitmaps currently used by
298c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * the view system, see {@link #reconfigure(int, int, Config)} for more
299c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * details.</p>
300c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
301c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #reconfigure(int, int, Config)
302c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setWidth(int)
303c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #setHeight(int)
304c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     */
305c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    public void setConfig(Config config) {
306c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik        reconfigure(getWidth(), getHeight(), config);
307c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik    }
308c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik
3099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
3109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Sets the nine patch chunk.
3119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
3129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param chunk The definition of the nine patch
3139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
3149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @hide
3159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
3169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public void setNinePatchChunk(byte[] chunk) {
3179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        mNinePatchChunk = chunk;
3189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
3198cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
3209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
321a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * Free the native object associated with this bitmap, and clear the
322a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * reference to the pixel data. This will not free the pixel data synchronously;
323a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * it simply allows it to be garbage collected if there are no other references.
324a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * The bitmap is marked as "dead", meaning it will throw an exception if
325a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * getPixels() or setPixels() is called, and will draw nothing. This operation
326a383b3f646cbc1fd870f2694d4fac24340834916Patrick Dubroy     * cannot be reversed, so it should only be called if you are sure there are no
3279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * further uses for the bitmap. This is an advanced call, and normally need
3289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * not be called, since the normal GC process will free up this memory when
3299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * there are no more references to this bitmap.
3309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
3319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public void recycle() {
332775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        if (!mRecycled && mNativePtr != 0) {
333775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler            if (nativeRecycle(mNativePtr)) {
334547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase                // return value indicates whether native pixel object was actually recycled.
335547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase                // false indicates that it is still in use at the native level and these
336547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase                // objects should not be collected now. They will be collected later when the
337547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase                // Bitmap itself is collected.
338547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase                mNinePatchChunk = null;
339547e66531d521eb1eadac87edb0f79f8c2f1bbe0Chet Haase            }
3409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            mRecycled = true;
3419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
3429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
3439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
3449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
3459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns true if this bitmap has been recycled. If so, then it is an error
3469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * to try to access its pixels, and the bitmap will not draw.
3479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
3489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return true if the bitmap has been recycled
3499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
3509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final boolean isRecycled() {
3519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return mRecycled;
3529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
3538cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
3549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
3550bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy     * Returns the generation ID of this bitmap. The generation ID changes
3560bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy     * whenever the bitmap is modified. This can be used as an efficient way to
3570bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy     * check if a bitmap has changed.
358f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
3590bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy     * @return The current generation ID for this bitmap.
3600bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy     */
3610bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy    public int getGenerationId() {
36201a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
36301a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getGenerationId() on a recycle()'d bitmap! This is undefined behavior!");
36401a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
365775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeGenerationId(mNativePtr);
3660bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy    }
367f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
3680bbae0836426ba2704e38e7f90a9d0ca502ab71dRomain Guy    /**
3699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * This is called by methods that want to throw an exception if the bitmap
3709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * has already been recycled.
3719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
3729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private void checkRecycled(String errorMessage) {
3739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (mRecycled) {
3749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalStateException(errorMessage);
3759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
3769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
3778cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
3789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
379980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv     * This is called by methods that want to throw an exception if the bitmap
380980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv     * is {@link Config#HARDWARE}.
381980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv     */
382980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv    private void checkHardware(String errorMessage) {
383980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        if (getConfig() == Config.HARDWARE) {
384980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv            throw new IllegalStateException(errorMessage);
385980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        }
386980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv    }
387980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv
388980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv    /**
3899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Common code for checking that x and y are >= 0
3909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
3919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x x coordinate to ensure is >= 0
3929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y y coordinate to ensure is >= 0
3939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
3949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private static void checkXYSign(int x, int y) {
3959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (x < 0) {
3969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("x must be >= 0");
3979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
3989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (y < 0) {
3999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("y must be >= 0");
4009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
4019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
4029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
4039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
4049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Common code for checking that width and height are > 0
4059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
4069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width  width to ensure is > 0
4079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height height to ensure is > 0
4089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
4099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private static void checkWidthHeight(int width, int height) {
4109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (width <= 0) {
4119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("width must be > 0");
4129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
4139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (height <= 0) {
4149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("height must be > 0");
4159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
4169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
4179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
418676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy    /**
419676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy     * Possible bitmap configurations. A bitmap configuration describes
420676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy     * how pixels are stored. This affects the quality (color depth) as
421676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy     * well as the ability to display transparent/translucent colors.
422676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy     */
4239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public enum Config {
4249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        // these native values must match up with the enum in SkBitmap.h
425676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy
426676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        /**
427676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * Each pixel is stored as a single translucency (alpha) channel.
428676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * This is very useful to efficiently store masks for instance.
429676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * No color information is stored.
430676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * With this configuration, each pixel requires 1 byte of memory.
431676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         */
432b644a3b84521e2155a5af985a4d4ed305474e567Derek Sollenberger        ALPHA_8     (1),
433676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy
434676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        /**
435676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * Each pixel is stored on 2 bytes and only the RGB channels are
436676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * encoded: red is stored with 5 bits of precision (32 possible
437676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * values), green is stored with 6 bits of precision (64 possible
438676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * values) and blue is stored with 5 bits of precision.
439f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
440676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * This configuration can produce slight visual artifacts depending
441676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * on the configuration of the source. For instance, without
442676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * dithering, the result might show a greenish tint. To get better
443676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * results dithering should be applied.
444f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
445676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * This configuration may be useful when using opaque bitmaps
446676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * that do not require high color fidelity.
447676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         */
448b644a3b84521e2155a5af985a4d4ed305474e567Derek Sollenberger        RGB_565     (3),
449676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy
450676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        /**
451676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * Each pixel is stored on 2 bytes. The three RGB color channels
452676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * and the alpha channel (translucency) are stored with a 4 bits
453676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * precision (16 possible values.)
454f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
455676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * This configuration is mostly useful if the application needs
456676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * to store translucency information but also needs to save
457676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * memory.
458f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
459676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * It is recommended to use {@link #ARGB_8888} instead of this
460676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * configuration.
46125ba1c86945a441428194d9ebcabbf31be75a45aRomain Guy         *
462e8222dddaf2e3da14380101e818d4254899e0c0dChet Haase         * Note: as of {@link android.os.Build.VERSION_CODES#KITKAT},
46325ba1c86945a441428194d9ebcabbf31be75a45aRomain Guy         * any bitmap created with this configuration will be created
46425ba1c86945a441428194d9ebcabbf31be75a45aRomain Guy         * using {@link #ARGB_8888} instead.
465f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
466676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * @deprecated Because of the poor quality of this configuration,
467676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         *             it is advised to use {@link #ARGB_8888} instead.
468676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         */
469676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        @Deprecated
470b644a3b84521e2155a5af985a4d4ed305474e567Derek Sollenberger        ARGB_4444   (4),
471676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy
472676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        /**
473676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * Each pixel is stored on 4 bytes. Each channel (RGB and alpha
474676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * for translucency) is stored with 8 bits of precision (256
475676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * possible values.)
476f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck         *
477676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * This configuration is very flexible and offers the best
478676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         * quality. It should be used whenever possible.
479676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy         */
480da6c8ffcc594493c3936f83255efccdbf964cd21sergeyv        ARGB_8888   (5),
481da6c8ffcc594493c3936f83255efccdbf964cd21sergeyv
4829505a6552764461c22ce48f1ac13d025d23e1579Romain Guy        /**
4839505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         * Each pixels is stored on 8 bytes. Each channel (RGB and alpha
4849505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         * for translucency) is stored as a
4859505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         * {@link android.util.Half half-precision floating point value}.
4869505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         *
4879505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         * This configuration is particularly suited for wide-gamut and
4889505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         * HDR content.
4899505a6552764461c22ce48f1ac13d025d23e1579Romain Guy         */
4909505a6552764461c22ce48f1ac13d025d23e1579Romain Guy        RGBA_F16    (6),
491da6c8ffcc594493c3936f83255efccdbf964cd21sergeyv
492da6c8ffcc594493c3936f83255efccdbf964cd21sergeyv        /**
4939fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv         * Special configuration, when bitmap is stored only in graphic memory.
4949fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv         * Bitmaps in this configuration are always immutable.
4959fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv         *
4969fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv         * It is optimal for cases, when the only operation with the bitmap is to draw it on a
4979fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv         * screen.
498da6c8ffcc594493c3936f83255efccdbf964cd21sergeyv         */
4999505a6552764461c22ce48f1ac13d025d23e1579Romain Guy        HARDWARE    (7);
5009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
501676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        final int nativeInt;
502676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy
503676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        private static Config sConfigs[] = {
5049505a6552764461c22ce48f1ac13d025d23e1579Romain Guy            null, ALPHA_8, null, RGB_565, ARGB_4444, ARGB_8888, RGBA_F16, HARDWARE
505676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        };
506f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
5079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Config(int ni) {
5089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            this.nativeInt = ni;
5099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5108cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
511676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy        static Config nativeToConfig(int ni) {
5129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return sConfigs[ni];
5139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
5158cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
5173849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>Copy the bitmap's pixels into the specified buffer (allocated by the
5189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * caller). An exception is thrown if the buffer is not large enough to
5199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * hold all of the pixels (taking into account the number of bytes per
5209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * pixel) or if the Buffer subclass is not one of the support types
5213849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * (ByteBuffer, ShortBuffer, IntBuffer).</p>
5223849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>The content of the bitmap is copied into the buffer as-is. This means
5233849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * that if this bitmap stores its pixels pre-multiplied
5243849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * (see {@link #isPremultiplied()}, the values in the buffer will also be
525ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * pre-multiplied. The pixels remain in the color space of the bitmap.</p>
5261f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * <p>After this method returns, the current position of the buffer is
5271f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * updated: the position is incremented by the number of elements written
5281f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * in the buffer.</p>
529980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv     * @throws IllegalStateException if the bitmap's config is {@link Config#HARDWARE}
5309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
5319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public void copyPixelsToBuffer(Buffer dst) {
532980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        checkHardware("unable to copyPixelsToBuffer, "
533980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv                + "pixel access is not supported on Config#HARDWARE bitmaps");
5349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int elements = dst.remaining();
5359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int shift;
5369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (dst instanceof ByteBuffer) {
5379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 0;
5389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else if (dst instanceof ShortBuffer) {
5399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 1;
5409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else if (dst instanceof IntBuffer) {
5419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 2;
5429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else {
5439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("unsupported Buffer subclass");
5449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5458cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        long bufferSize = (long)elements << shift;
547f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson        long pixelSize = getByteCount();
5488cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (bufferSize < pixelSize) {
5509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("Buffer not large enough for pixels");
5519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5528cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
553775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeCopyPixelsToBuffer(mNativePtr, dst);
5548cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        // now update the buffer's position
5569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int position = dst.position();
5579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        position += pixelSize >> shift;
5589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        dst.position(position);
5599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
5609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
5619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
5623849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>Copy the pixels from the buffer, beginning at the current position,
5639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * overwriting the bitmap's pixels. The data in the buffer is not changed
5649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * in any way (unlike setPixels(), which converts from unpremultipled 32bit
565ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * to whatever the bitmap's native format is. The pixels in the source
566ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * buffer are assumed to be in the bitmap's color space.</p>
5671f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * <p>After this method returns, the current position of the buffer is
5681f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * updated: the position is incremented by the number of elements read from
5691f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * the buffer. If you need to read the bitmap from the buffer again you must
5701f58497e7dbab1b16e97c73b65559b852d0c2803Romain Guy     * first rewind the buffer.</p>
571980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv     * @throws IllegalStateException if the bitmap's config is {@link Config#HARDWARE}
5729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
5739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public void copyPixelsFromBuffer(Buffer src) {
5749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("copyPixelsFromBuffer called on recycled bitmap");
575980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        checkHardware("unable to copyPixelsFromBuffer, Config#HARDWARE bitmaps are immutable");
5768cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int elements = src.remaining();
5789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int shift;
5799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (src instanceof ByteBuffer) {
5809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 0;
5819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else if (src instanceof ShortBuffer) {
5829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 1;
5839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else if (src instanceof IntBuffer) {
5849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            shift = 2;
5859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else {
5869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("unsupported Buffer subclass");
5879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5888cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5893849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy        long bufferBytes = (long) elements << shift;
590f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson        long bitmapBytes = getByteCount();
5918cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
5929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (bufferBytes < bitmapBytes) {
5939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("Buffer not large enough for pixels");
5949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
5958cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
596775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeCopyPixelsFromBuffer(mNativePtr, src);
59755adc145d460be4b21de0d77be1f6076c3591e3cMarco Nelissen
59855adc145d460be4b21de0d77be1f6076c3591e3cMarco Nelissen        // now update the buffer's position
59955adc145d460be4b21de0d77be1f6076c3591e3cMarco Nelissen        int position = src.position();
60055adc145d460be4b21de0d77be1f6076c3591e3cMarco Nelissen        position += bitmapBytes >> shift;
60155adc145d460be4b21de0d77be1f6076c3591e3cMarco Nelissen        src.position(position);
6029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
6038cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
6049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
6059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Tries to make a new bitmap based on the dimensions of this bitmap,
6069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * setting the new bitmap's config to the one specified, and then copying
6079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * this bitmap's pixels into the new bitmap. If the conversion is not
60896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * supported, or the allocator fails, then this returns NULL.  The returned
60996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * bitmap initially has the same density as the original.
6109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
6119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param config    The desired config for the resulting bitmap
6129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param isMutable True if the resulting bitmap should be mutable (i.e.
6139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                  its pixels can be modified)
6149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return the new bitmap, or null if the copy could not be made.
61505126d151eb3caa85bd3a039cffb6e37940c3fa4sergeyv     * @throws IllegalArgumentException if config is {@link Config#HARDWARE} and isMutable is true
6169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
6179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public Bitmap copy(Config config, boolean isMutable) {
6189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't copy a recycled bitmap");
61905126d151eb3caa85bd3a039cffb6e37940c3fa4sergeyv        if (config == Config.HARDWARE && isMutable) {
62005126d151eb3caa85bd3a039cffb6e37940c3fa4sergeyv            throw new IllegalArgumentException("Hardware bitmaps are always immutable");
62105126d151eb3caa85bd3a039cffb6e37940c3fa4sergeyv        }
622775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        Bitmap b = nativeCopy(mNativePtr, config.nativeInt, isMutable);
62396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        if (b != null) {
62457ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III            b.setPremultiplied(mRequestPremultiplied);
62596e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn            b.mDensity = mDensity;
62696e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        }
62796e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        return b;
6289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
6299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
63002d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick    /**
631721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews     * Creates a new immutable bitmap backed by ashmem which can efficiently
632721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews     * be passed between processes.
633721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews     *
634721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews     * @hide
635721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews     */
636721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews    public Bitmap createAshmemBitmap() {
637721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews        checkRecycled("Can't copy a recycled bitmap");
638775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        Bitmap b = nativeCopyAshmem(mNativePtr);
639721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews        if (b != null) {
640721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews            b.setPremultiplied(mRequestPremultiplied);
641721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews            b.mDensity = mDensity;
642721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews        }
643721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews        return b;
644721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews    }
645721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews
646721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews    /**
647a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson     * Creates a new immutable bitmap backed by ashmem which can efficiently
648a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson     * be passed between processes.
649a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson     *
650a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson     * @hide
651a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson     */
652a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson    public Bitmap createAshmemBitmap(Config config) {
653a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson        checkRecycled("Can't copy a recycled bitmap");
654a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson        Bitmap b = nativeCopyAshmemConfig(mNativePtr, config.nativeInt);
655a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson        if (b != null) {
656a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson            b.setPremultiplied(mRequestPremultiplied);
657a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson            b.mDensity = mDensity;
658a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson        }
659a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson        return b;
660a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson    }
661a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson
662a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson    /**
6630a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     * Create hardware bitmap backed GraphicBuffer.
6640a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     *
6650a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     * @return Bitmap or null if this GraphicBuffer has unsupported PixelFormat.
6660a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     *         currently PIXEL_FORMAT_RGBA_8888 is the only supported format
6670a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     * @hide
6680a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv     */
6690a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv    public static Bitmap createHardwareBitmap(GraphicBuffer graphicBuffer) {
6700a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv        return nativeCreateHardwareBitmap(graphicBuffer);
6710a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv    }
6720a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv
6730a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv    /**
674f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * Creates a new bitmap, scaled from an existing bitmap, when possible. If the
675f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     * specified width and height are the same as the current width and height of
6769f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * the source bitmap, the source bitmap is returned and no new bitmap is
677f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * created.
67802d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     *
67902d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     * @param src       The source bitmap.
68002d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     * @param dstWidth  The new bitmap's desired width.
68102d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     * @param dstHeight The new bitmap's desired height.
68202d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     * @param filter    true if the source should be filtered.
683f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * @return The new scaled bitmap or the source bitmap if no scaling is required.
684790552b240c05d58407f7c14acba656b2e85c523Romain Guy     * @throws IllegalArgumentException if width is <= 0, or height is <= 0
68502d9102b3bdebac6989c2b7d12c080fb7c1f8e2bBrad Fitzpatrick     */
686f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy    public static Bitmap createScaledBitmap(Bitmap src, int dstWidth, int dstHeight,
687f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy            boolean filter) {
6889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Matrix m;
6899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        synchronized (Bitmap.class) {
6909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            // small pool of just 1 matrix
6919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            m = sScaleMatrix;
6929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            sScaleMatrix = null;
6939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
6949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
6959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (m == null) {
6969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            m = new Matrix();
6979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
6988cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
6999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        final int width = src.getWidth();
7009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        final int height = src.getHeight();
7019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        final float sx = dstWidth  / (float)width;
7029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        final float sy = dstHeight / (float)height;
7039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        m.setScale(sx, sy);
7049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Bitmap b = Bitmap.createBitmap(src, 0, 0, width, height, m, filter);
7059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        synchronized (Bitmap.class) {
7079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            // do we need to check for null? why not just assign everytime?
7089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            if (sScaleMatrix == null) {
7099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                sScaleMatrix = m;
7109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            }
7119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
7129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7138cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen        return b;
7149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
7158cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
7169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
7179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns an immutable bitmap from the source bitmap. The new bitmap may
71896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * be the same object as source, or a copy may have been made.  It is
71996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * initialized with the same density as the original bitmap.
7209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
7219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(Bitmap src) {
7229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return createBitmap(src, 0, 0, src.getWidth(), src.getHeight());
7239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
7249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
7269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns an immutable bitmap from the specified subset of the source
7279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * bitmap. The new bitmap may be the same object as source, or a copy may
728f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * have been made. It is initialized with the same density as the original
729f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * bitmap.
7309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
7319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param source   The bitmap we are subsetting
7329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x        The x coordinate of the first pixel in source
7339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y        The y coordinate of the first pixel in source
7349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The number of pixels in each row
7359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The number of rows
736f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * @return A copy of a subset of the source bitmap or the source bitmap itself.
737790552b240c05d58407f7c14acba656b2e85c523Romain Guy     * @throws IllegalArgumentException if the x, y, width, height values are
738790552b240c05d58407f7c14acba656b2e85c523Romain Guy     *         outside of the dimensions of the source bitmap, or width is <= 0,
739790552b240c05d58407f7c14acba656b2e85c523Romain Guy     *         or height is <= 0
7409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
7419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height) {
7429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return createBitmap(source, x, y, width, height, null, false);
7439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
7448cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
7459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
7469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns an immutable bitmap from subset of the source bitmap,
747f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * transformed by the optional matrix. The new bitmap may be the
748f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * same object as source, or a copy may have been made. It is
74996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * initialized with the same density as the original bitmap.
750f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
751f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * If the source bitmap is immutable and the requested subset is the
752f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * same as the source bitmap itself, then the source bitmap is
753f12f6f058f169ead83a546a1c3a51e49452a30b3Romain Guy     * returned and no new bitmap is created.
7549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
7559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param source   The bitmap we are subsetting
7569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x        The x coordinate of the first pixel in source
7579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y        The y coordinate of the first pixel in source
7589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The number of pixels in each row
7599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The number of rows
76060b88edea7132ddce90f2dced07c6706f1502270Ken Shirriff     * @param m        Optional matrix to be applied to the pixels
7619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param filter   true if the source should be filtered.
7629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                   Only applies if the matrix contains more than just
7639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                   translation.
7649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return A bitmap that represents the specified subset of source
7659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if the x, y, width, height values are
766790552b240c05d58407f7c14acba656b2e85c523Romain Guy     *         outside of the dimensions of the source bitmap, or width is <= 0,
767790552b240c05d58407f7c14acba656b2e85c523Romain Guy     *         or height is <= 0
7689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
7699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height,
7709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            Matrix m, boolean filter) {
7719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkXYSign(x, y);
7739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkWidthHeight(width, height);
7749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (x + width > source.getWidth()) {
7759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("x + width must be <= bitmap.width()");
7769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
7779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (y + height > source.getHeight()) {
7789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("y + height must be <= bitmap.height()");
7799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
7809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        // check if we can just return our argument unchanged
7829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (!source.isMutable() && x == 0 && y == 0 && width == source.getWidth() &&
7839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                height == source.getHeight() && (m == null || m.isIdentity())) {
7849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return source;
7859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
7868cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
78781f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv        boolean isHardware = source.getConfig() == Config.HARDWARE;
78881f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv        if (isHardware) {
78981f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv            source = nativeCopyPreserveInternalConfig(source.mNativePtr);
79081f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv        }
79181f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv
7929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int neww = width;
7939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int newh = height;
7949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Canvas canvas = new Canvas();
7959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Bitmap bitmap;
7969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Paint paint;
7979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
7989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Rect srcR = new Rect(x, y, x + width, y + height);
7999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        RectF dstR = new RectF(0, 0, width, height);
8009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
801feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy        Config newConfig = Config.ARGB_8888;
802feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy        final Config config = source.getConfig();
803feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy        // GIF files generate null configs, assume ARGB_8888
804feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy        if (config != null) {
805feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy            switch (config) {
806feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                case RGB_565:
807feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    newConfig = Config.RGB_565;
808feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    break;
809feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                case ALPHA_8:
810feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    newConfig = Config.ALPHA_8;
811feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    break;
8129505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                case RGBA_F16:
8139505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                    newConfig = Config.RGBA_F16;
8149505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                    break;
815676b17391fb6583e5df944c36b1bd4c1be835689Romain Guy                //noinspection deprecation
816feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                case ARGB_4444:
817feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                case ARGB_8888:
818feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                default:
819feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    newConfig = Config.ARGB_8888;
820feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy                    break;
821feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy            }
822feeea8f07c854e6b0ae2fec3aa2d239c17f32b5bRomain Guy        }
823d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (m == null || m.isIdentity()) {
825d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy            bitmap = createBitmap(neww, newh, newConfig, source.hasAlpha());
8269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            paint = null;   // not needed
8279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        } else {
828d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy            final boolean transformed = !m.rectStaysRect();
829d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            RectF deviceR = new RectF();
8319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            m.mapRect(deviceR, dstR);
832d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            neww = Math.round(deviceR.width());
8349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            newh = Math.round(deviceR.height());
835d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8369505a6552764461c22ce48f1ac13d025d23e1579Romain Guy            Config transformedConfig = newConfig;
8379505a6552764461c22ce48f1ac13d025d23e1579Romain Guy            if (transformed) {
8389505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                if (transformedConfig != Config.ARGB_8888 && transformedConfig != Config.RGBA_F16) {
8399505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                    transformedConfig = Config.ARGB_8888;
8409505a6552764461c22ce48f1ac13d025d23e1579Romain Guy                }
8419505a6552764461c22ce48f1ac13d025d23e1579Romain Guy            }
8429505a6552764461c22ce48f1ac13d025d23e1579Romain Guy            bitmap = createBitmap(neww, newh, transformedConfig, transformed || source.hasAlpha());
843d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            canvas.translate(-deviceR.left, -deviceR.top);
8459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            canvas.concat(m);
846d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
8479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            paint = new Paint();
8489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            paint.setFilterBitmap(filter);
849d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy            if (transformed) {
8509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                paint.setAntiAlias(true);
8519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            }
8529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
8538790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III
8549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        // The new bitmap was created from a known bitmap source so assume that
85511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        // they use the same density
85611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        bitmap.mDensity = source.mDensity;
85757ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III        bitmap.setHasAlpha(source.hasAlpha());
85857ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III        bitmap.setPremultiplied(source.mRequestPremultiplied);
8598790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III
86096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        canvas.setBitmap(bitmap);
86196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        canvas.drawBitmap(source, srcR, dstR, paint);
8626311d0a079702b29984c0d31937345be105e1a5eDianne Hackborn        canvas.setBitmap(null);
86381f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv        if (isHardware) {
86481f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv            return bitmap.copy(Config.HARDWARE, false);
86581f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv        }
8669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return bitmap;
8679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
8688cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
8699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
87096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * Returns a mutable bitmap with the specified width and height.  Its
87196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * initial density is as per {@link #getDensity}.
8729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
8739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The width of the bitmap
8749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The height of the bitmap
8759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param config   The bitmap config to create.
8769fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     * @throws IllegalArgumentException if the width or height are <= 0, or if
8779fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     *         Config is Config.HARDWARE, because hardware bitmaps are always immutable
8789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
8799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(int width, int height, Config config) {
880d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy        return createBitmap(width, height, config, true);
881d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy    }
882d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy
883d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy    /**
884d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     * Returns a mutable bitmap with the specified width and height.  Its
885dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * initial density is determined from the given {@link DisplayMetrics}.
886dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *
887dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param display  Display metrics for the display this bitmap will be
888dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 drawn on.
889dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param width    The width of the bitmap
890dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param height   The height of the bitmap
891dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param config   The bitmap config to create.
8929fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     * @throws IllegalArgumentException if the width or height are <= 0, or if
8939fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     *         Config is Config.HARDWARE, because hardware bitmaps are always immutable
894dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     */
895dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    public static Bitmap createBitmap(DisplayMetrics display, int width,
896dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            int height, Config config) {
897dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return createBitmap(display, width, height, config, true);
898dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    }
899dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn
900dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    /**
901dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * Returns a mutable bitmap with the specified width and height.  Its
902d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     * initial density is as per {@link #getDensity}.
903d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     *
904d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     * @param width    The width of the bitmap
905d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     * @param height   The height of the bitmap
906d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     * @param config   The bitmap config to create.
9079505a6552764461c22ce48f1ac13d025d23e1579Romain Guy     * @param hasAlpha If the bitmap is ARGB_8888 or RGBA_16F this flag can be used to
9089505a6552764461c22ce48f1ac13d025d23e1579Romain Guy     *                 mark the bitmap as opaque. Doing so will clear the bitmap in black
909f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *                 instead of transparent.
910f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
9119fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     * @throws IllegalArgumentException if the width or height are <= 0, or if
9129fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     *         Config is Config.HARDWARE, because hardware bitmaps are always immutable
913d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy     */
9149505a6552764461c22ce48f1ac13d025d23e1579Romain Guy    public static Bitmap createBitmap(int width, int height, Config config, boolean hasAlpha) {
915dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return createBitmap(null, width, height, config, hasAlpha);
916dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    }
917dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn
918dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    /**
919dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * Returns a mutable bitmap with the specified width and height.  Its
920dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * initial density is determined from the given {@link DisplayMetrics}.
921dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *
922dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param display  Display metrics for the display this bitmap will be
923dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 drawn on.
924dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param width    The width of the bitmap
925dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param height   The height of the bitmap
926dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param config   The bitmap config to create.
9279505a6552764461c22ce48f1ac13d025d23e1579Romain Guy     * @param hasAlpha If the bitmap is ARGB_8888 or RGBA_16F this flag can be used to
9289505a6552764461c22ce48f1ac13d025d23e1579Romain Guy     *                 mark the bitmap as opaque. Doing so will clear the bitmap in black
929f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *                 instead of transparent.
930f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
9319fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     * @throws IllegalArgumentException if the width or height are <= 0, or if
9329fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv     *         Config is Config.HARDWARE, because hardware bitmaps are always immutable
933dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     */
9349505a6552764461c22ce48f1ac13d025d23e1579Romain Guy    public static Bitmap createBitmap(DisplayMetrics display, int width, int height,
935dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            Config config, boolean hasAlpha) {
936e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy        if (width <= 0 || height <= 0) {
937e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy            throw new IllegalArgumentException("width and height must be > 0");
938e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy        }
9399fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv        if (config == Config.HARDWARE) {
9409fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv            throw new IllegalArgumentException("can't create mutable bitmap with Config.HARDWARE");
9419fbb0b5ab321d86efbc7fa8774052bfb34de9557sergeyv        }
9429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        Bitmap bm = nativeCreate(null, 0, width, width, height, config.nativeInt, true);
943dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        if (display != null) {
944dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            bm.mDensity = display.densityDpi;
945dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        }
9468790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III        bm.setHasAlpha(hasAlpha);
9479505a6552764461c22ce48f1ac13d025d23e1579Romain Guy        if ((config == Config.ARGB_8888 || config == Config.RGBA_F16) && !hasAlpha) {
948775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler            nativeErase(bm.mNativePtr, 0xff000000);
949d90f23e24a4d1768d5a7ed0e7072e67af6330a45Romain Guy        }
9503b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy        // No need to initialize the bitmap to zeroes with other configs;
9513b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy        // it is backed by a VM byte array which is by definition preinitialized
9523b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy        // to all zeroes.
9539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return bm;
9549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
9558cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
9569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
9579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns a immutable bitmap with the specified width and height, with each
95896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * pixel value set to the corresponding value in the colors array.  Its
95996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * initial density is as per {@link #getDensity}.
9609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
9619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param colors   Array of {@link Color} used to initialize the pixels.
9629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param offset   Number of values to skip before the first color in the
9639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 array of colors.
9649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param stride   Number of colors in the array between rows (must be >=
9659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 width or <= -width).
9669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The width of the bitmap
9679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The height of the bitmap
9689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param config   The bitmap config to create. If the config does not
9699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 support per-pixel alpha (e.g. RGB_565), then the alpha
9709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 bytes in the colors[] will be ignored (assumed to be FF)
9719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if the width or height are <= 0, or if
9729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         the color array's length is less than the number of pixels.
9739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
9749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(int colors[], int offset, int stride,
9759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            int width, int height, Config config) {
976dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return createBitmap(null, colors, offset, stride, width, height, config);
977dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    }
978dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn
979dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    /**
980dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * Returns a immutable bitmap with the specified width and height, with each
981dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * pixel value set to the corresponding value in the colors array.  Its
982dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * initial density is determined from the given {@link DisplayMetrics}.
983dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *
984dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param display  Display metrics for the display this bitmap will be
985dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 drawn on.
986dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param colors   Array of {@link Color} used to initialize the pixels.
987dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param offset   Number of values to skip before the first color in the
988dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 array of colors.
989dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param stride   Number of colors in the array between rows (must be >=
990dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 width or <= -width).
991dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param width    The width of the bitmap
992dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param height   The height of the bitmap
993dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param config   The bitmap config to create. If the config does not
994dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 support per-pixel alpha (e.g. RGB_565), then the alpha
995dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 bytes in the colors[] will be ignored (assumed to be FF)
996dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @throws IllegalArgumentException if the width or height are <= 0, or if
997dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *         the color array's length is less than the number of pixels.
998dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     */
999dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    public static Bitmap createBitmap(DisplayMetrics display, int colors[],
1000dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            int offset, int stride, int width, int height, Config config) {
10019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
10029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkWidthHeight(width, height);
10039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (Math.abs(stride) < width) {
10049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("abs(stride) must be >= width");
10059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
10069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int lastScanline = offset + (height - 1) * stride;
10079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int length = colors.length;
10089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (offset < 0 || (offset + width > length) || lastScanline < 0 ||
10099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                (lastScanline + width > length)) {
10109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new ArrayIndexOutOfBoundsException();
10119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
1012e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy        if (width <= 0 || height <= 0) {
1013e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy            throw new IllegalArgumentException("width and height must be > 0");
1014e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy        }
1015dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        Bitmap bm = nativeCreate(colors, offset, stride, width, height,
10169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                            config.nativeInt, false);
1017dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        if (display != null) {
1018dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            bm.mDensity = display.densityDpi;
1019dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        }
1020dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return bm;
10219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
10229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
10239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
10249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns a immutable bitmap with the specified width and height, with each
102596e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * pixel value set to the corresponding value in the colors array.  Its
102696e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * initial density is as per {@link #getDensity}.
10279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
10289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param colors   Array of {@link Color} used to initialize the pixels.
10299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 This array must be at least as large as width * height.
10309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The width of the bitmap
10319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The height of the bitmap
10329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param config   The bitmap config to create. If the config does not
10339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 support per-pixel alpha (e.g. RGB_565), then the alpha
10349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 bytes in the colors[] will be ignored (assumed to be FF)
10359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if the width or height are <= 0, or if
10369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         the color array's length is less than the number of pixels.
10379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
10389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static Bitmap createBitmap(int colors[], int width, int height, Config config) {
1039dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return createBitmap(null, colors, 0, width, width, height, config);
1040dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    }
1041dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn
1042dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    /**
1043dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * Returns a immutable bitmap with the specified width and height, with each
1044dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * pixel value set to the corresponding value in the colors array.  Its
1045dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * initial density is determined from the given {@link DisplayMetrics}.
1046dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *
1047dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param display  Display metrics for the display this bitmap will be
1048dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 drawn on.
1049dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param colors   Array of {@link Color} used to initialize the pixels.
1050dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 This array must be at least as large as width * height.
1051dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param width    The width of the bitmap
1052dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param height   The height of the bitmap
1053dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @param config   The bitmap config to create. If the config does not
1054dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 support per-pixel alpha (e.g. RGB_565), then the alpha
1055dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *                 bytes in the colors[] will be ignored (assumed to be FF)
1056dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     * @throws IllegalArgumentException if the width or height are <= 0, or if
1057dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     *         the color array's length is less than the number of pixels.
1058dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn     */
1059dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn    public static Bitmap createBitmap(DisplayMetrics display, int colors[],
1060dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn            int width, int height, Config config) {
1061dde331cebd87982faded6818ad5f9927ff994c96Dianne Hackborn        return createBitmap(display, colors, 0, width, width, height, config);
10629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
10639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
10649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
10659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns an optional array of private data, used by the UI system for
10669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * some bitmaps. Not intended to be called by applications.
10679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
10689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public byte[] getNinePatchChunk() {
10699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return mNinePatchChunk;
10709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
10719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
10729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
1073c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette     * Populates a rectangle with the bitmap's optical insets.
1074c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette     *
1075c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette     * @param outInsets Rect to populate with optical insets
1076ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani     * @hide
1077ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani     */
1078c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette    public void getOpticalInsets(@NonNull Rect outInsets) {
107947cd8e921db73e894f94ec4729ade90da50996f5Chris Craik        if (mNinePatchInsets == null) {
1080c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette            outInsets.setEmpty();
1081c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette        } else {
108247cd8e921db73e894f94ec4729ade90da50996f5Chris Craik            outInsets.set(mNinePatchInsets.opticalRect);
1083c054966b719c8a7255f7cf4120cca5050acb68bdAlan Viverette        }
1084ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani    }
1085ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani
108647cd8e921db73e894f94ec4729ade90da50996f5Chris Craik    /** @hide */
108747cd8e921db73e894f94ec4729ade90da50996f5Chris Craik    public NinePatch.InsetStruct getNinePatchInsets() {
108847cd8e921db73e894f94ec4729ade90da50996f5Chris Craik        return mNinePatchInsets;
108947cd8e921db73e894f94ec4729ade90da50996f5Chris Craik    }
109047cd8e921db73e894f94ec4729ade90da50996f5Chris Craik
1091ec4a50428d5f26a22df3edaf7e5b08f41d5cb54bAmith Yamasani    /**
10929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Specifies the known formats a bitmap can be compressed into
10939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
10949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public enum CompressFormat {
10959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        JPEG    (0),
10962305ac9e4a262ed09fd034ae417e9b1dda4c0ccbVikas Arora        PNG     (1),
10972305ac9e4a262ed09fd034ae417e9b1dda4c0ccbVikas Arora        WEBP    (2);
10989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
10999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        CompressFormat(int nativeInt) {
11009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            this.nativeInt = nativeInt;
11019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
11029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        final int nativeInt;
11039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
11049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
11059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
11069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Number of bytes of temp storage we use for communicating between the
11079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * native compressor and the java OutputStream.
11089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
11099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private final static int WORKING_COMPRESS_STORAGE = 4096;
11109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
11119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
11129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Write a compressed version of the bitmap to the specified outputstream.
11139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * If this returns true, the bitmap can be reconstructed by passing a
11149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * corresponding inputstream to BitmapFactory.decodeStream(). Note: not
11159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * all Formats support all bitmap configs directly, so it is possible that
11169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * the returned bitmap from BitmapFactory could be in a different bitdepth,
11179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * and/or may have lost per-pixel alpha (e.g. JPEG only supports opaque
11189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * pixels).
11199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
11209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param format   The format of the compressed image
11219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param quality  Hint to the compressor, 0-100. 0 meaning compress for
11229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 small size, 100 meaning compress for max quality. Some
11239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 formats, like PNG which is lossless, will ignore the
11249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 quality setting
11259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param stream   The outputstream to write the compressed data.
11269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return true if successfully compressed to the specified stream.
11279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
11289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public boolean compress(CompressFormat format, int quality, OutputStream stream) {
11299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't compress a recycled bitmap");
11309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        // do explicit check before calling the native method
11319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (stream == null) {
11329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new NullPointerException();
11339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
11349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (quality < 0 || quality > 100) {
11359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("quality must be 0..100");
11369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
11370df3bd5594bbbbfbf6058ecb31e9b94a1cd22f7dJohn Reck        Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "Bitmap.compress");
1138775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        boolean result = nativeCompress(mNativePtr, format.nativeInt,
1139f29ed28c7b878ef28058bc730715d0d32445bc57John Reck                quality, stream, new byte[WORKING_COMPRESS_STORAGE]);
11400df3bd5594bbbbfbf6058ecb31e9b94a1cd22f7dJohn Reck        Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
11410df3bd5594bbbbfbf6058ecb31e9b94a1cd22f7dJohn Reck        return result;
11429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
11438cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
11449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
1145ff236f5fc1a088b1210d37a67b0e88b06c0fbdb2Newton Allen     * Returns true if the bitmap is marked as mutable (i.e.&nbsp;can be drawn into)
11469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
11479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final boolean isMutable() {
11489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return mIsMutable;
11499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
11509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
11513849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy    /**
11523849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>Indicates whether pixels stored in this bitmaps are stored pre-multiplied.
11533849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * When a pixel is pre-multiplied, the RGB components have been multiplied by
11543849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * the alpha component. For instance, if the original color is a 50%
1155f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     * translucent red <code>(128, 255, 0, 0)</code>, the pre-multiplied form is
11563849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <code>(128, 128, 0, 0)</code>.</p>
1157f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
11583849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>This method always returns false if {@link #getConfig()} is
11594ff0cf4b83605bff630c4e6f1fabe4f72a3f93a1Romain Guy     * {@link Bitmap.Config#RGB_565}.</p>
1160f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
116157ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * <p>The return value is undefined if {@link #getConfig()} is
116257ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     * {@link Bitmap.Config#ALPHA_8}.</p>
116357ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III     *
11644ff0cf4b83605bff630c4e6f1fabe4f72a3f93a1Romain Guy     * <p>This method only returns true if {@link #hasAlpha()} returns true.
11654ff0cf4b83605bff630c4e6f1fabe4f72a3f93a1Romain Guy     * A bitmap with no alpha channel can be used both as a pre-multiplied and
11664ff0cf4b83605bff630c4e6f1fabe4f72a3f93a1Romain Guy     * as a non pre-multiplied bitmap.</p>
11671abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
11681abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * <p>Only pre-multiplied bitmaps may be drawn by the view system or
11691abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * {@link Canvas}. If a non-pre-multiplied bitmap with an alpha channel is
11701abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * drawn to a Canvas, a RuntimeException will be thrown.</p>
11711abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
11723849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * @return true if the underlying pixels have been pre-multiplied, false
11733849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     *         otherwise
11741abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
11751abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * @see Bitmap#setPremultiplied(boolean)
11761abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * @see BitmapFactory.Options#inPremultiplied
11773849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     */
11783849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy    public final boolean isPremultiplied() {
117901a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
118001a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called isPremultiplied() on a recycle()'d bitmap! This is undefined behavior!");
118101a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
1182775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeIsPremultiplied(mNativePtr);
11831abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    }
11841abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik
11851abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    /**
11861abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * Sets whether the bitmap should treat its data as pre-multiplied.
11871abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
11881abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * <p>Bitmaps are always treated as pre-multiplied by the view system and
11891abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * {@link Canvas} for performance reasons. Storing un-pre-multiplied data in
11901abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * a Bitmap (through {@link #setPixel}, {@link #setPixels}, or {@link
11911abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * BitmapFactory.Options#inPremultiplied BitmapFactory.Options.inPremultiplied})
11921abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * can lead to incorrect blending if drawn by the framework.</p>
11931abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
11941abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * <p>This method will not affect the behavior of a bitmap without an alpha
11951abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * channel, or if {@link #hasAlpha()} returns false.</p>
11961abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     *
1197889a1ddd00b74933d5f7daa651d98133bcb034baBen Murdoch     * <p>Calling {@link #createBitmap} or {@link #createScaledBitmap} with a source
11988790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III     * Bitmap whose colors are not pre-multiplied may result in a RuntimeException,
11998790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III     * since those functions require drawing the source, which is not supported for
12008790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III     * un-pre-multiplied Bitmaps.</p>
12018790be6de3644e332ec6a17c855da89ffc13a9bfLeon Scroggins III     *
12021abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * @see Bitmap#isPremultiplied()
12031abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     * @see BitmapFactory.Options#inPremultiplied
12041abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik     */
12051abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik    public final void setPremultiplied(boolean premultiplied) {
12063e776dee3e8af646cdcfb7a60e0e301c99f05293John Reck        checkRecycled("setPremultiplied called on a recycled bitmap");
120757ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III        mRequestPremultiplied = premultiplied;
1208775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeSetPremultiplied(mNativePtr, premultiplied);
12093849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy    }
12103849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy
12119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /** Returns the bitmap's width */
12129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final int getWidth() {
121301a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
121401a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getWidth() on a recycle()'d bitmap! This is undefined behavior!");
121501a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
12161abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        return mWidth;
12179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
12189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
12199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /** Returns the bitmap's height */
12209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final int getHeight() {
122101a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
122201a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getHeight() on a recycle()'d bitmap! This is undefined behavior!");
122301a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
12241abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik        return mHeight;
12259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
12268cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
12279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
122811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * Convenience for calling {@link #getScaledWidth(int)} with the target
122911ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * density of the given {@link Canvas}.
12309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
12312784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    public int getScaledWidth(Canvas canvas) {
123211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getWidth(), mDensity, canvas.mDensity);
12332784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    }
12342784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn
12352784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    /**
123611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * Convenience for calling {@link #getScaledHeight(int)} with the target
123711ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * density of the given {@link Canvas}.
12382784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     */
12392784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    public int getScaledHeight(Canvas canvas) {
124011ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getHeight(), mDensity, canvas.mDensity);
124111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    }
124211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn
124311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    /**
124411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * Convenience for calling {@link #getScaledWidth(int)} with the target
124511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * density of the given {@link DisplayMetrics}.
124611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     */
124711ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public int getScaledWidth(DisplayMetrics metrics) {
124811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getWidth(), mDensity, metrics.densityDpi);
124911ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    }
125011ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn
125111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    /**
125211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * Convenience for calling {@link #getScaledHeight(int)} with the target
125311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * density of the given {@link DisplayMetrics}.
125411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     */
125511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public int getScaledHeight(DisplayMetrics metrics) {
125611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getHeight(), mDensity, metrics.densityDpi);
12572784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    }
12582784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn
12592784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn    /**
12602784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     * Convenience method that returns the width of this bitmap divided
12612784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     * by the density scale factor.
12622784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     *
126311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @param targetDensity The density of the target canvas of the bitmap.
12642784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     * @return The scaled width of this bitmap, according to the density scale factor.
12652784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn     */
126611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public int getScaledWidth(int targetDensity) {
126711ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getWidth(), mDensity, targetDensity);
12689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
12699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
12709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
12719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Convenience method that returns the height of this bitmap divided
12729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * by the density scale factor.
12739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
127411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @param targetDensity The density of the target canvas of the bitmap.
12759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return The scaled height of this bitmap, according to the density scale factor.
12769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
127711ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    public int getScaledHeight(int targetDensity) {
127811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        return scaleFromDensity(getHeight(), mDensity, targetDensity);
127911ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    }
1280f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
128111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    /**
128211ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     * @hide
128311ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn     */
128411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn    static public int scaleFromDensity(int size, int sdensity, int tdensity) {
12850b68477f8287fe5ddac1beb1c9d0811ded034dadRomain Guy        if (sdensity == DENSITY_NONE || tdensity == DENSITY_NONE || sdensity == tdensity) {
128611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn            return size;
12872784ff0af88128f66ae690b73d48fb7e4a211e68Dianne Hackborn        }
1288f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
128911ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn        // Scale by tdensity / sdensity, rounding up.
1290366a84056c9a695ee6702d9d30bf9f3b521ba7ccRomain Guy        return ((size * tdensity) + (sdensity >> 1)) / sdensity;
12919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
1292f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
12939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
12949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Return the number of bytes between rows in the bitmap's pixels. Note that
12959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * this refers to the pixels as stored natively by the bitmap. If you call
12969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * getPixels() or setPixels(), then the pixels are uniformly treated as
12979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * 32bit values, packed according to the Color class.
12989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
1299e8222dddaf2e3da14380101e818d4254899e0c0dChet Haase     * <p>As of {@link android.os.Build.VERSION_CODES#KITKAT}, this method
13009f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * should not be used to calculate the memory usage of the bitmap. Instead,
13019f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * see {@link #getAllocationByteCount()}.
13029f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     *
13039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return number of bytes between rows of the native bitmap pixels.
13049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
13059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final int getRowBytes() {
130601a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
130701a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getRowBytes() on a recycle()'d bitmap! This is undefined behavior!");
130801a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
1309775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeRowBytes(mNativePtr);
13109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
13118cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
13129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
13139f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * Returns the minimum number of bytes that can be used to store this bitmap's pixels.
13149f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     *
1315e8222dddaf2e3da14380101e818d4254899e0c0dChet Haase     * <p>As of {@link android.os.Build.VERSION_CODES#KITKAT}, the result of this method can
13169f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * no longer be used to determine memory usage of a bitmap. See {@link
1317c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * #getAllocationByteCount()}.</p>
1318f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson     */
1319f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson    public final int getByteCount() {
13203bdecbf0fd2d4b6137477094e1ea96502c353248John Reck        if (mRecycled) {
13213bdecbf0fd2d4b6137477094e1ea96502c353248John Reck            Log.w(TAG, "Called getByteCount() on a recycle()'d bitmap! "
13223bdecbf0fd2d4b6137477094e1ea96502c353248John Reck                    + "This is undefined behavior!");
13233bdecbf0fd2d4b6137477094e1ea96502c353248John Reck            return 0;
13243bdecbf0fd2d4b6137477094e1ea96502c353248John Reck        }
1325f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson        // int result permits bitmaps up to 46,340 x 46,340
1326f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson        return getRowBytes() * getHeight();
1327f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson    }
1328f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson
1329f7f9d9c39df22ad6929f001f07588469f77e8bf5Jesse Wilson    /**
13309f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * Returns the size of the allocated memory used to store this bitmap's pixels.
13319f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     *
13329f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     * <p>This can be larger than the result of {@link #getByteCount()} if a bitmap is reused to
1333c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * decode other bitmaps of smaller size, or by manual reconfiguration. See {@link
1334c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * #reconfigure(int, int, Config)}, {@link #setWidth(int)}, {@link #setHeight(int)}, {@link
1335c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * #setConfig(Bitmap.Config)}, and {@link BitmapFactory.Options#inBitmap
1336c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * BitmapFactory.Options.inBitmap}. If a bitmap is not modified in this way, this value will be
1337c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * the same as that returned by {@link #getByteCount()}.</p>
1338c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     *
1339c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * <p>This value will not change over the lifetime of a Bitmap.</p>
13409f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     *
1341c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik     * @see #reconfigure(int, int, Config)
13429f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik     */
13439f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik    public final int getAllocationByteCount() {
13443bdecbf0fd2d4b6137477094e1ea96502c353248John Reck        if (mRecycled) {
13453bdecbf0fd2d4b6137477094e1ea96502c353248John Reck            Log.w(TAG, "Called getAllocationByteCount() on a recycle()'d bitmap! "
13463bdecbf0fd2d4b6137477094e1ea96502c353248John Reck                    + "This is undefined behavior!");
13473bdecbf0fd2d4b6137477094e1ea96502c353248John Reck            return 0;
13483bdecbf0fd2d4b6137477094e1ea96502c353248John Reck        }
13494508218850faedea95371188da587b6734f5f3dasergeyv        return nativeGetAllocationByteCount(mNativePtr);
13509f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik    }
13519f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik
13529f58361e98be7386a4eadd3aa254e9b7d09d0a3bChris Craik    /**
13539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * If the bitmap's internal config is in one of the public formats, return
13549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * that config, otherwise return null.
13559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
13569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final Config getConfig() {
135701a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
135801a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called getConfig() on a recycle()'d bitmap! This is undefined behavior!");
135901a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
1360775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return Config.nativeToConfig(nativeConfig(mNativePtr));
13619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
13629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
1363a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed    /** Returns true if the bitmap's config supports per-pixel alpha, and
1364a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * if the pixels may contain non-opaque alpha values. For some configs,
1365a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * this is always false (e.g. RGB_565), since they do not support per-pixel
1366a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * alpha. However, for configs that do, the bitmap may be flagged to be
1367a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * known that all of its pixels are opaque. In this case hasAlpha() will
1368a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * also return false. If a config such as ARGB_8888 is not so flagged,
1369a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * it will return true by default.
1370a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     */
13719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public final boolean hasAlpha() {
137201a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
137301a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called hasAlpha() on a recycle()'d bitmap! This is undefined behavior!");
137401a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
1375775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeHasAlpha(mNativePtr);
13769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
13779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
13789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
1379a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * Tell the bitmap if all of the pixels are known to be opaque (false)
1380a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * or if some of the pixels may contain non-opaque alpha values (true).
1381366a84056c9a695ee6702d9d30bf9f3b521ba7ccRomain Guy     * Note, for some configs (e.g. RGB_565) this call is ignored, since it
1382366a84056c9a695ee6702d9d30bf9f3b521ba7ccRomain Guy     * does not support per-pixel alpha values.
1383a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     *
1384a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * This is meant as a drawing hint, as in some cases a bitmap that is known
1385a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * to be opaque can take a faster drawing case than one that may have
1386a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     * non-opaque per-pixel alpha values.
1387a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed     */
1388a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed    public void setHasAlpha(boolean hasAlpha) {
13893e776dee3e8af646cdcfb7a60e0e301c99f05293John Reck        checkRecycled("setHasAlpha called on a recycled bitmap");
1390775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeSetHasAlpha(mNativePtr, hasAlpha, mRequestPremultiplied);
1391a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed    }
1392a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed
1393a78b0a2d9ebb38b86ed802b3d86de07d0b301262Mike Reed    /**
1394713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * Indicates whether the renderer responsible for drawing this
1395713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * bitmap should attempt to use mipmaps when this bitmap is drawn
1396713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * scaled down.
1397f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
1398713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * If you know that you are going to draw this bitmap at less than
1399713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * 50% of its original size, you may be able to obtain a higher
1400713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * quality
1401f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
1402713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * This property is only a suggestion that can be ignored by the
1403713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * renderer. It is not guaranteed to have any effect.
1404f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
1405713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * @return true if the renderer should attempt to use mipmaps,
1406713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *         false otherwise
1407f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
1408713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * @see #setHasMipMap(boolean)
1409713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     */
1410713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    public final boolean hasMipMap() {
141101a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        if (mRecycled) {
141201a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck            Log.w(TAG, "Called hasMipMap() on a recycle()'d bitmap! This is undefined behavior!");
141301a0af31d7d418f400ce5d3f752eba6a35aa00e2John Reck        }
1414775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeHasMipMap(mNativePtr);
1415713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    }
1416713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy
1417713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    /**
1418713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * Set a hint for the renderer responsible for drawing this bitmap
1419713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * indicating that it should attempt to use mipmaps when this bitmap
1420713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * is drawn scaled down.
1421713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *
1422713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * If you know that you are going to draw this bitmap at less than
1423713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * 50% of its original size, you may be able to obtain a higher
1424713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * quality by turning this property on.
1425f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
1426713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * Note that if the renderer respects this hint it might have to
1427713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * allocate extra memory to hold the mipmap levels for this bitmap.
1428713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *
1429713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * This property is only a suggestion that can be ignored by the
1430713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * renderer. It is not guaranteed to have any effect.
1431713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *
1432713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * @param hasMipMap indicates whether the renderer should attempt
1433713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *                  to use mipmaps
1434713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     *
1435713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     * @see #hasMipMap()
1436713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy     */
1437713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    public final void setHasMipMap(boolean hasMipMap) {
14383e776dee3e8af646cdcfb7a60e0e301c99f05293John Reck        checkRecycled("setHasMipMap called on a recycled bitmap");
1439775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeSetHasMipMap(mNativePtr, hasMipMap);
1440713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    }
1441713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy
1442713e1bb9df6bdfc21bd5c40d1a6ecf6c822a4be5Romain Guy    /**
1443efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy     * Returns the color space associated with this bitmap. If the color
1444efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy     * space is unknown, this method returns null.
1445efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy     */
1446efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    @Nullable
1447efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    public final ColorSpace getColorSpace() {
1448efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        // A reconfigure can change the configuration and rgba16f is
1449efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        // always linear scRGB at this time
1450efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        if (getConfig() == Config.RGBA_F16) {
1451efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            // Reset the color space for potential future reconfigurations
1452efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            mColorSpace = null;
1453efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            return ColorSpace.get(ColorSpace.Named.LINEAR_EXTENDED_SRGB);
1454efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        }
1455efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy
1456efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        // Cache the color space retrieval since it can be fairly expensive
1457efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        if (mColorSpace == null) {
1458efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            if (nativeIsSRGB(mNativePtr)) {
1459efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                mColorSpace = ColorSpace.get(ColorSpace.Named.SRGB);
1460efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            } else {
1461efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                float[] xyz = new float[9];
1462efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                float[] params = new float[7];
1463efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy
1464efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                boolean hasColorSpace = nativeGetColorSpace(mNativePtr, xyz, params);
1465efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                if (hasColorSpace) {
1466efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                    ColorSpace.Rgb.TransferParameters parameters =
1467efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                            new ColorSpace.Rgb.TransferParameters(
1468efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                                    params[0], params[1], params[2],
1469efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                                    params[3], params[4], params[5], params[6]);
1470efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                    ColorSpace cs = ColorSpace.match(xyz, parameters);
1471efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                    if (cs != null) {
1472efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                        mColorSpace = cs;
1473efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                    } else {
1474efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                        mColorSpace = new ColorSpace.Rgb("Unknown", xyz, parameters);
1475efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                    }
1476efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy                }
1477efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy            }
1478efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        }
1479efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy
1480efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy        return mColorSpace;
1481efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    }
1482efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy
1483efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    /**
14849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Fills the bitmap's pixels with the specified {@link Color}.
14859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
14869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalStateException if the bitmap is not mutable.
14879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
148880756e38882720860db52f1fcc21fa1505a02abfTor Norbye    public void eraseColor(@ColorInt int c) {
14899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't erase a recycled bitmap");
14909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (!isMutable()) {
14919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalStateException("cannot erase immutable bitmaps");
14929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
1493775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeErase(mNativePtr, c);
14949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
14959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
14969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
14979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns the {@link Color} at the specified location. Throws an exception
14989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * if x or y are out of bounds (negative or >= to the width or height
1499ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * respectively). The returned color is a non-premultiplied ARGB value in
1500ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * the {@link ColorSpace.Named#SRGB sRGB} color space.
15019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
15029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x    The x coordinate (0...width-1) of the pixel to return
15039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y    The y coordinate (0...height-1) of the pixel to return
15049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return     The argb {@link Color} at the specified coordinate
15059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if x, y exceed the bitmap's bounds
150657eafc6f90a1ce2dd97079dd82b4b2f8dcd9e00fsergeyv     * @throws IllegalStateException if the bitmap's config is {@link Config#HARDWARE}
15079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
150880756e38882720860db52f1fcc21fa1505a02abfTor Norbye    @ColorInt
15099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public int getPixel(int x, int y) {
15109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't call getPixel() on a recycled bitmap");
1511980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        checkHardware("unable to getPixel(), "
1512980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv                + "pixel access is not supported on Config#HARDWARE bitmaps");
15139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkPixelAccess(x, y);
1514775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeGetPixel(mNativePtr, x, y);
15159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
15168cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
15179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
15189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns in pixels[] a copy of the data in the bitmap. Each value is
15199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * a packed int representing a {@link Color}. The stride parameter allows
15209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * the caller to allow for gaps in the returned pixels array between
15219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * rows. For normal packed results, just pass width for the stride value.
1522ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * The returned colors are non-premultiplied ARGB values in the
1523ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * {@link ColorSpace.Named#SRGB sRGB} color space.
15249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
15259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param pixels   The array to receive the bitmap's colors
15269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param offset   The first index to write into pixels[]
15279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param stride   The number of entries in pixels[] to skip between
15289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 rows (must be >= bitmap's width). Can be negative.
15299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x        The x coordinate of the first pixel to read from
15309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 the bitmap
15319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y        The y coordinate of the first pixel to read from
15329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 the bitmap
15339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The number of pixels to read from each row
15349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The number of rows to read
15353849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     *
15369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if x, y, width, height exceed the
15379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         bounds of the bitmap, or if abs(stride) < width.
15389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws ArrayIndexOutOfBoundsException if the pixels array is too small
15399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         to receive the specified number of pixels.
154057eafc6f90a1ce2dd97079dd82b4b2f8dcd9e00fsergeyv     * @throws IllegalStateException if the bitmap's config is {@link Config#HARDWARE}
15419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
154280756e38882720860db52f1fcc21fa1505a02abfTor Norbye    public void getPixels(@ColorInt int[] pixels, int offset, int stride,
15439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                          int x, int y, int width, int height) {
15449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't call getPixels() on a recycled bitmap");
1545980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv        checkHardware("unable to getPixels(), "
1546980bead518fc5ddb52ae8d00258f91b087c1f91asergeyv                + "pixel access is not supported on Config#HARDWARE bitmaps");
15479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (width == 0 || height == 0) {
15489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return; // nothing to do
15499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkPixelsAccess(x, y, width, height, offset, stride, pixels);
1551775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeGetPixels(mNativePtr, pixels, offset, stride,
155257ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                        x, y, width, height);
15539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
15548cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
15559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
15569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Shared code to check for illegal arguments passed to getPixel()
15579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * or setPixel()
1558f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
15599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x x coordinate of the pixel
15609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y y coordinate of the pixel
15619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
15629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private void checkPixelAccess(int x, int y) {
15639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkXYSign(x, y);
15649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (x >= getWidth()) {
15659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("x must be < bitmap.width()");
15669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (y >= getHeight()) {
15689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("y must be < bitmap.height()");
15699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
15719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
15729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
15739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Shared code to check for illegal arguments passed to getPixels()
15749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * or setPixels()
15759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
15769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x left edge of the area of pixels to access
15779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y top edge of the area of pixels to access
15789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width width of the area of pixels to access
15799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height height of the area of pixels to access
15809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param offset offset into pixels[] array
15819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param stride number of elements in pixels[] between each logical row
15829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param pixels array to hold the area of pixels being accessed
15839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    */
15849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private void checkPixelsAccess(int x, int y, int width, int height,
15859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                   int offset, int stride, int pixels[]) {
15869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkXYSign(x, y);
15879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (width < 0) {
15889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("width must be >= 0");
15899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (height < 0) {
15919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("height must be >= 0");
15929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (x + width > getWidth()) {
15949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException(
15959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                    "x + width must be <= bitmap.width()");
15969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
15979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (y + height > getHeight()) {
15989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException(
15999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                    "y + height must be <= bitmap.height()");
16009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (Math.abs(stride) < width) {
16029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalArgumentException("abs(stride) must be >= width");
16039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int lastScanline = offset + (height - 1) * stride;
16059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        int length = pixels.length;
16069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (offset < 0 || (offset + width > length)
16079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                || lastScanline < 0
16089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                || (lastScanline + width > length)) {
16099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new ArrayIndexOutOfBoundsException();
16109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
16128cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
16139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
16143849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>Write the specified {@link Color} into the bitmap (assuming it is
16153849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * mutable) at the x,y coordinate. The color must be a
1616ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * non-premultiplied ARGB value in the {@link ColorSpace.Named#SRGB sRGB}
1617ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * color space.</p>
16189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
16199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x     The x coordinate of the pixel to replace (0...width-1)
16209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y     The y coordinate of the pixel to replace (0...height-1)
16213849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * @param color The ARGB color to write into the bitmap
16223849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     *
16239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalStateException if the bitmap is not mutable
16249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if x, y are outside of the bitmap's
16259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         bounds.
16269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
162780756e38882720860db52f1fcc21fa1505a02abfTor Norbye    public void setPixel(int x, int y, @ColorInt int color) {
16289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't call setPixel() on a recycled bitmap");
16299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (!isMutable()) {
16309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalStateException();
16319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkPixelAccess(x, y);
1633775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeSetPixel(mNativePtr, x, y, color);
16349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
16358cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
16369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
16373849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     * <p>Replace pixels in the bitmap with the colors in the array. Each element
16389505a6552764461c22ce48f1ac13d025d23e1579Romain Guy     * in the array is a packed int representing a non-premultiplied ARGB
1639ce217faddb4b40c1b3e698944da1951027080427Romain Guy     * {@link Color} in the {@link ColorSpace.Named#SRGB sRGB} color space.</p>
16409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
16419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param pixels   The colors to write to the bitmap
16429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param offset   The index of the first color to read from pixels[]
16439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param stride   The number of colors in pixels[] to skip between rows.
16449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 Normally this value will be the same as the width of
16459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 the bitmap, but it can be larger (or negative).
16469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param x        The x coordinate of the first pixel to write to in
16479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 the bitmap.
16489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param y        The y coordinate of the first pixel to write to in
16499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 the bitmap.
16509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param width    The number of colors to copy from pixels[] per row
16519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param height   The number of rows to write to the bitmap
16523849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy     *
16539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalStateException if the bitmap is not mutable
16549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws IllegalArgumentException if x, y, width, height are outside of
16559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         the bitmap's bounds.
16569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @throws ArrayIndexOutOfBoundsException if the pixels array is too small
16579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         to receive the specified number of pixels.
16589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
165980756e38882720860db52f1fcc21fa1505a02abfTor Norbye    public void setPixels(@ColorInt int[] pixels, int offset, int stride,
16603849f93b3c2b29ca3873b602897dccac039a0b98Romain Guy            int x, int y, int width, int height) {
16619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't call setPixels() on a recycled bitmap");
16629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (!isMutable()) {
16639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new IllegalStateException();
16649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (width == 0 || height == 0) {
16669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return; // nothing to do
16679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkPixelsAccess(x, y, width, height, offset, stride, pixels);
1669775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        nativeSetPixels(mNativePtr, pixels, offset, stride,
167057ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                        x, y, width, height);
16719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
16728cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
16739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public static final Parcelable.Creator<Bitmap> CREATOR
16749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            = new Parcelable.Creator<Bitmap>() {
16759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        /**
16769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project         * Rebuilds a bitmap previously stored with writeToParcel().
16779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project         *
16789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project         * @param p    Parcel object to read the bitmap from
16799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project         * @return a new bitmap created from the data in the parcel
16809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project         */
16819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        public Bitmap createFromParcel(Parcel p) {
16829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            Bitmap bm = nativeCreateFromParcel(p);
16839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            if (bm == null) {
16849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                throw new RuntimeException("Failed to unparcel Bitmap");
16859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            }
16869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return bm;
16879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        public Bitmap[] newArray(int size) {
16899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            return new Bitmap[size];
16909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
16919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    };
16929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
16939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
16949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * No special parcel contents.
16959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
16969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public int describeContents() {
1697b6377170960d40e66858d8b4d335a95eac773762Bart Sears        return 0;
16989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
16999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
17009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
17019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Write the bitmap and its pixels to the parcel. The bitmap can be
17029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * rebuilt from the parcel by calling CREATOR.createFromParcel().
1703f161dce70eab5ba1011bd26226c14e31675d5955sergeyv     *
1704f161dce70eab5ba1011bd26226c14e31675d5955sergeyv     * If this bitmap is {@link Config#HARDWARE}, it may be unparceled with a different pixel
1705f161dce70eab5ba1011bd26226c14e31675d5955sergeyv     * format (e.g. 565, 8888), but the content will be preserved to the best quality permitted
1706f161dce70eab5ba1011bd26226c14e31675d5955sergeyv     * by the final pixel format
17079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param p    Parcel object to write the bitmap data into
17089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
17099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public void writeToParcel(Parcel p, int flags) {
17109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't parcel a recycled bitmap");
1711775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        if (!nativeWriteToParcel(mNativePtr, mIsMutable, mDensity, p)) {
17129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("native writeToParcel failed");
17139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
17149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
17159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
17169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
17179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns a new bitmap that captures the alpha values of the original.
17189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * This may be drawn with Canvas.drawBitmap(), where the color(s) will be
17199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * taken from the paint that is passed to the draw call.
17209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *
17219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return new bitmap containing the alpha channel of the original bitmap.
17229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
17231c2bf03d1082fc6b7eb42cbd163c60c07cf2bcccTor Norbye    @CheckResult
17249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public Bitmap extractAlpha() {
17259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return extractAlpha(null, null);
17269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
17278cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
17289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    /**
17299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * Returns a new bitmap that captures the alpha values of the original.
17309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * These values may be affected by the optional Paint parameter, which
17319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * can contain its own alpha, and may also contain a MaskFilter which
17329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * could change the actual dimensions of the resulting bitmap (e.g.
17339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * a blur maskfilter might enlarge the resulting bitmap). If offsetXY
17349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * is not null, it returns the amount to offset the returned bitmap so
17359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * that it will logically align with the original. For example, if the
17369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * paint contains a blur of radius 2, then offsetXY[] would contains
17379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * -2, -2, so that drawing the alpha bitmap offset by (-2, -2) and then
17389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * drawing the original would result in the blur visually aligning with
17399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * the original.
1740f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
174196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn     * <p>The initial density of the returned bitmap is the same as the original's.
1742f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck     *
17439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param paint Optional paint used to modify the alpha values in the
17449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *              resulting bitmap. Pass null for default behavior.
17459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @param offsetXY Optional array that returns the X (index 0) and Y
17469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 (index 1) offset needed to position the returned bitmap
17479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *                 so that it visually lines up with the original.
17489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     * @return new bitmap containing the (optionally modified by paint) alpha
17499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         channel of the original bitmap. This may be drawn with
17509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         Canvas.drawBitmap(), where the color(s) will be taken from the
17519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     *         paint that is passed to the draw call.
17529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project     */
17531c2bf03d1082fc6b7eb42cbd163c60c07cf2bcccTor Norbye    @CheckResult
17549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    public Bitmap extractAlpha(Paint paint, int[] offsetXY) {
17559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        checkRecycled("Can't extractAlpha on a recycled bitmap");
1756dfba4d3d11bbf47dff45f94d61d4d97510b3034aDerek Sollenberger        long nativePaint = paint != null ? paint.getNativeInstance() : 0;
1757775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        Bitmap bm = nativeExtractAlpha(mNativePtr, nativePaint, offsetXY);
17589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        if (bm == null) {
17599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project            throw new RuntimeException("Failed to extractAlpha on Bitmap");
17609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        }
176196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn        bm.mDensity = mDensity;
17629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project        return bm;
17639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    }
17649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
17658cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen    /**
176676d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed     *  Given another bitmap, return true if it has the same dimensions, config,
176776d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed     *  and pixel data as this bitmap. If any of those differ, return false.
176876d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed     *  If other is null, return false.
176976d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed     */
177076d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed    public boolean sameAs(Bitmap other) {
17719298c5414172344f2462beda70e624af5f774483John Reck        checkRecycled("Can't call sameAs on a recycled bitmap!");
17723df4869a77bdeb72d5810bbcf7819ed1b8dd0ec7John Reck        if (this == other) return true;
17733df4869a77bdeb72d5810bbcf7819ed1b8dd0ec7John Reck        if (other == null) return false;
17749298c5414172344f2462beda70e624af5f774483John Reck        if (other.isRecycled()) {
17759298c5414172344f2462beda70e624af5f774483John Reck            throw new IllegalArgumentException("Can't compare to a recycled bitmap!");
17769298c5414172344f2462beda70e624af5f774483John Reck        }
1777775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler        return nativeSameAs(mNativePtr, other.mNativePtr);
177876d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed    }
177976d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed
178076d1e01d5e65c4631c827831e98ad4e300d99eabMike Reed    /**
17818cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * Rebuilds any caches associated with the bitmap that are used for
17828cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * drawing it. In the case of purgeable bitmaps, this call will attempt to
17838cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * ensure that the pixels have been decoded.
17848cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * If this is called on more than one bitmap in sequence, the priority is
17858cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * given in LRU order (i.e. the last bitmap called will be given highest
17868cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * priority).
17878cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     *
17888cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * For bitmaps with no associated caches, this call is effectively a no-op,
17898cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     * and therefore is harmless.
17908cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen     */
17918cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen    public void prepareToDraw() {
1792ad57442fd00e7fd7f1885d23372ec5c85e176820John Reck        checkRecycled("Can't prepareToDraw on a recycled bitmap!");
17934387190d8ec9fe4e953fcfeb093a644b82cf85edJohn Reck        // Kick off an update/upload of the bitmap outside of the normal
17944387190d8ec9fe4e953fcfeb093a644b82cf85edJohn Reck        // draw path.
17954387190d8ec9fe4e953fcfeb093a644b82cf85edJohn Reck        nativePrepareToDraw(mNativePtr);
1796f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck    }
1797f4faeac3525fe1ce3707ab785a1651aec367589dJohn Reck
17986e3658a63843096058ed444d073fbcd191fd7e1bsergeyv    /**
17996e3658a63843096058ed444d073fbcd191fd7e1bsergeyv     *
18006e3658a63843096058ed444d073fbcd191fd7e1bsergeyv     * @return {@link GraphicBuffer} which is internally used by hardware bitmap
18016e3658a63843096058ed444d073fbcd191fd7e1bsergeyv     * @hide
18026e3658a63843096058ed444d073fbcd191fd7e1bsergeyv     */
18036e3658a63843096058ed444d073fbcd191fd7e1bsergeyv    public GraphicBuffer createGraphicBufferHandle() {
18046e3658a63843096058ed444d073fbcd191fd7e1bsergeyv        return nativeCreateGraphicBufferHandle(mNativePtr);
18056e3658a63843096058ed444d073fbcd191fd7e1bsergeyv    }
18066e3658a63843096058ed444d073fbcd191fd7e1bsergeyv
18079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    //////////// native methods
18089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
18099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private static native Bitmap nativeCreate(int[] colors, int offset,
18109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                              int stride, int width, int height,
1811c84d203da21c3ae3ded94c79c035d41b27809b3bChris Craik                                              int nativeConfig, boolean mutable);
181236bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native Bitmap nativeCopy(long nativeSrcBitmap, int nativeConfig,
18139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                            boolean isMutable);
1814721ae5fec5f1fd4f93aa2a361a0ac298e15ce353Riley Andrews    private static native Bitmap nativeCopyAshmem(long nativeSrcBitmap);
1815a5fdde9d15fbdf1aaeb61e1cf0c128af3aeb7b67Winson    private static native Bitmap nativeCopyAshmemConfig(long nativeSrcBitmap, int nativeConfig);
1816775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler    private static native long nativeGetNativeFinalizer();
181736bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeRecycle(long nativeBitmap);
181836bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeReconfigure(long nativeBitmap, int width, int height,
18194508218850faedea95371188da587b6734f5f3dasergeyv                                                 int config, boolean isPremultiplied);
18209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
182136bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeCompress(long nativeBitmap, int format,
18229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                            int quality, OutputStream stream,
18239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                            byte[] tempStorage);
182436bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeErase(long nativeBitmap, int color);
182536bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native int nativeRowBytes(long nativeBitmap);
182636bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native int nativeConfig(long nativeBitmap);
18278cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
182857ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private static native int nativeGetPixel(long nativeBitmap, int x, int y);
182936bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeGetPixels(long nativeBitmap, int[] pixels,
18301abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik                                               int offset, int stride, int x, int y,
183157ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                                               int width, int height);
18328cdcb12752b716d0407733fecefcf1d9e926310aWei-Ta Chen
183357ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private static native void nativeSetPixel(long nativeBitmap, int x, int y, int color);
183436bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeSetPixels(long nativeBitmap, int[] colors,
18351abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik                                               int offset, int stride, int x, int y,
183657ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                                               int width, int height);
183736bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeCopyPixelsToBuffer(long nativeBitmap,
18389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                                        Buffer dst);
183936bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeCopyPixelsFromBuffer(long nativeBitmap, Buffer src);
184036bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native int nativeGenerationId(long nativeBitmap);
18419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
18429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    private static native Bitmap nativeCreateFromParcel(Parcel p);
18439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    // returns true on success
184436bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeWriteToParcel(long nativeBitmap,
18459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                                      boolean isMutable,
1846de0dfb7b65a02d4dd74c271b558adee0973fc267Dianne Hackborn                                                      int density,
18479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                                      Parcel p);
18489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project    // returns a new bitmap built from the native bitmap's alpha, and the paint
184936bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native Bitmap nativeExtractAlpha(long nativeBitmap,
185036bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat                                                    long nativePaint,
18519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project                                                    int[] offsetXY);
18529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project
185336bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeHasAlpha(long nativeBitmap);
185457ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private static native boolean nativeIsPremultiplied(long nativeBitmap);
185557ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private static native void nativeSetPremultiplied(long nativeBitmap,
185657ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                                                      boolean isPremul);
185757ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III    private static native void nativeSetHasAlpha(long nativeBitmap,
185857ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                                                 boolean hasAlpha,
185957ee620ced8caed1eb8651717f6a6d2d5f1f9a5bLeon Scroggins III                                                 boolean requestPremul);
186036bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeHasMipMap(long nativeBitmap);
186136bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native void nativeSetHasMipMap(long nativeBitmap, boolean hasMipMap);
186236bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat    private static native boolean nativeSameAs(long nativeBitmap0, long nativeBitmap1);
18634387190d8ec9fe4e953fcfeb093a644b82cf85edJohn Reck    private static native void nativePrepareToDraw(long nativeBitmap);
18644508218850faedea95371188da587b6734f5f3dasergeyv    private static native int nativeGetAllocationByteCount(long nativeBitmap);
186581f97ee47ccf0d011cdc4f38b6ea5c45b70dedc0sergeyv    private static native Bitmap nativeCopyPreserveInternalConfig(long nativeBitmap);
18660a0f23163a7a62900d46c7f81d109320d73d6c6bsergeyv    private static native Bitmap nativeCreateHardwareBitmap(GraphicBuffer buffer);
18676e3658a63843096058ed444d073fbcd191fd7e1bsergeyv    private static native GraphicBuffer nativeCreateGraphicBufferHandle(long nativeBitmap);
1868efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    private static native boolean nativeGetColorSpace(long nativePtr, float[] xyz, float[] params);
1869efb4b06493fe7b1604c762a448b13c7af2845a8dRomain Guy    private static native boolean nativeIsSRGB(long nativePtr);
18709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project}
1871