| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.media.cts; |
| |
| import android.media.cts.R; |
| |
| import android.content.pm.PackageManager; |
| import android.content.res.AssetFileDescriptor; |
| import android.content.res.Resources; |
| import android.media.MediaDataSource; |
| import android.media.MediaExtractor; |
| import android.media.MediaFormat; |
| import android.media.MediaMetadataRetriever; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Color; |
| import android.graphics.Rect; |
| import android.platform.test.annotations.AppModeFull; |
| import android.support.test.filters.SmallTest; |
| import android.platform.test.annotations.RequiresDevice; |
| import android.test.AndroidTestCase; |
| import android.util.Log; |
| |
| import com.android.compatibility.common.util.MediaUtils; |
| |
| import static android.content.pm.PackageManager.FEATURE_WATCH; |
| import static android.media.MediaMetadataRetriever.OPTION_CLOSEST; |
| import static android.media.MediaMetadataRetriever.OPTION_CLOSEST_SYNC; |
| import static android.media.MediaMetadataRetriever.OPTION_NEXT_SYNC; |
| import static android.media.MediaMetadataRetriever.OPTION_PREVIOUS_SYNC; |
| |
| import java.io.InputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.function.Function; |
| |
| @SmallTest |
| @RequiresDevice |
| @AppModeFull(reason = "No interaction with system server") |
| public class MediaMetadataRetrieverTest extends AndroidTestCase { |
| private static final String TAG = "MediaMetadataRetrieverTest"; |
| private static final boolean SAVE_BITMAP_OUTPUT = false; |
| |
| protected Resources mResources; |
| protected MediaMetadataRetriever mRetriever; |
| private PackageManager mPackageManager; |
| |
| private static int BORDER_WIDTH = 16; |
| private static Color COLOR_BLOCK = |
| Color.valueOf(1.0f, 1.0f, 1.0f); |
| private static Color[] COLOR_BARS = { |
| Color.valueOf(0.0f, 0.0f, 0.0f), |
| Color.valueOf(0.0f, 0.0f, 0.64f), |
| Color.valueOf(0.0f, 0.64f, 0.0f), |
| Color.valueOf(0.0f, 0.64f, 0.64f), |
| Color.valueOf(0.64f, 0.0f, 0.0f), |
| Color.valueOf(0.64f, 0.0f, 0.64f), |
| Color.valueOf(0.64f, 0.64f, 0.0f), |
| }; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| mResources = getContext().getResources(); |
| mRetriever = new MediaMetadataRetriever(); |
| mPackageManager = getContext().getPackageManager(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| mRetriever.release(); |
| } |
| |
| protected void setDataSourceFd(int resid) { |
| try { |
| AssetFileDescriptor afd = mResources.openRawResourceFd(resid); |
| mRetriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| afd.close(); |
| } catch (Exception e) { |
| fail("Unable to open file"); |
| } |
| } |
| |
| protected TestMediaDataSource setDataSourceCallback(int resid) { |
| TestMediaDataSource ds = null; |
| try { |
| AssetFileDescriptor afd = mResources.openRawResourceFd(resid); |
| ds = TestMediaDataSource.fromAssetFd(afd); |
| mRetriever.setDataSource(ds); |
| } catch (Exception e) { |
| fail("Unable to open file"); |
| } |
| return ds; |
| } |
| |
| protected TestMediaDataSource getFaultyDataSource(int resid, boolean throwing) { |
| TestMediaDataSource ds = null; |
| try { |
| AssetFileDescriptor afd = mResources.openRawResourceFd(resid); |
| ds = TestMediaDataSource.fromAssetFd(afd); |
| if (throwing) { |
| ds.throwFromReadAt(); |
| } else { |
| ds.returnFromReadAt(-2); |
| } |
| } catch (Exception e) { |
| fail("Unable to open file"); |
| } |
| return ds; |
| } |
| |
| public void test3gppMetadata() { |
| setDataSourceCallback(R.raw.testvideo); |
| |
| assertEquals("Title was other than expected", |
| "Title", mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE)); |
| |
| assertEquals("Artist was other than expected", |
| "UTF16LE エンディアン ", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)); |
| |
| assertEquals("Album was other than expected", |
| "Test album", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM)); |
| |
| assertEquals("Track number was other than expected", |
| "10", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER)); |
| |
| assertEquals("Year was other than expected", |
| "2013", mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR)); |
| |
| assertEquals("Date was other than expected", |
| "19040101T000000.000Z", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE)); |
| |
| assertNull("Writer was unexpected present", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_WRITER)); |
| } |
| |
| public void testID3v2Metadata() { |
| setDataSourceFd(R.raw.video_480x360_mp4_h264_500kbps_25fps_aac_stereo_128kbps_44100hz_id3v2); |
| |
| assertEquals("Title was other than expected", |
| "Title", mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE)); |
| |
| assertEquals("Artist was other than expected", |
| "UTF16LE エンディアン ", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)); |
| |
| assertEquals("Album was other than expected", |
| "Test album", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM)); |
| |
| assertEquals("Track number was other than expected", |
| "10", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER)); |
| |
| assertEquals("Year was other than expected", |
| "2013", mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR)); |
| |
| assertEquals("Date was other than expected", |
| "19700101T000000.000Z", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE)); |
| |
| assertNull("Writer was unexpectedly present", |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_WRITER)); |
| } |
| |
| public void testLargeAlbumArt() { |
| setDataSourceFd(R.raw.largealbumart); |
| |
| assertNotNull("couldn't retrieve album art", mRetriever.getEmbeddedPicture()); |
| } |
| |
| public void testSetDataSourceNullPath() { |
| try { |
| mRetriever.setDataSource((String)null); |
| fail("Expected IllegalArgumentException."); |
| } catch (IllegalArgumentException ex) { |
| // Expected, test passed. |
| } |
| } |
| |
| public void testNullMediaDataSourceIsRejected() { |
| try { |
| mRetriever.setDataSource((MediaDataSource)null); |
| fail("Expected IllegalArgumentException."); |
| } catch (IllegalArgumentException ex) { |
| // Expected, test passed. |
| } |
| } |
| |
| public void testMediaDataSourceIsClosedOnRelease() throws Exception { |
| TestMediaDataSource dataSource = setDataSourceCallback(R.raw.testvideo); |
| mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE); |
| mRetriever.release(); |
| assertTrue(dataSource.isClosed()); |
| } |
| |
| public void testRetrieveFailsIfMediaDataSourceThrows() throws Exception { |
| TestMediaDataSource ds = getFaultyDataSource(R.raw.testvideo, true /* throwing */); |
| try { |
| mRetriever.setDataSource(ds); |
| fail("Failed to throw exceptions"); |
| } catch (RuntimeException e) { |
| assertTrue(mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE) == null); |
| } |
| } |
| |
| public void testRetrieveFailsIfMediaDataSourceReturnsAnError() throws Exception { |
| TestMediaDataSource ds = getFaultyDataSource(R.raw.testvideo, false /* throwing */); |
| try { |
| mRetriever.setDataSource(ds); |
| fail("Failed to throw exceptions"); |
| } catch (RuntimeException e) { |
| assertTrue(mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE) == null); |
| } |
| } |
| |
| private void testThumbnail(int resId) { |
| if (!MediaUtils.hasCodecForResourceAndDomain(getContext(), resId, "video/")) { |
| MediaUtils.skipTest("no video codecs for resource"); |
| return; |
| } |
| |
| MediaMetadataRetriever retriever = new MediaMetadataRetriever(); |
| Resources resources = getContext().getResources(); |
| AssetFileDescriptor afd = resources.openRawResourceFd(resId); |
| |
| retriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| |
| try { |
| afd.close(); |
| } catch (IOException e) { |
| fail("Unable to open file"); |
| } |
| |
| assertNotNull(retriever.getFrameAtTime(-1 /* timeUs (any) */)); |
| } |
| |
| public void testThumbnailH264() { |
| testThumbnail(R.raw.bbb_s4_1280x720_mp4_h264_mp31_8mbps_30fps_aac_he_mono_40kbps_44100hz); |
| } |
| |
| public void testThumbnailH263() { |
| testThumbnail(R.raw.video_176x144_3gp_h263_56kbps_12fps_aac_mono_24kbps_11025hz); |
| } |
| |
| public void testThumbnailMPEG4() { |
| testThumbnail(R.raw.video_1280x720_mp4_mpeg4_1000kbps_25fps_aac_stereo_128kbps_44100hz); |
| } |
| |
| public void testThumbnailVP8() { |
| testThumbnail(R.raw.bbb_s1_640x360_webm_vp8_2mbps_30fps_vorbis_5ch_320kbps_48000hz); |
| } |
| |
| public void testThumbnailVP9() { |
| testThumbnail(R.raw.bbb_s1_640x360_webm_vp9_0p21_1600kbps_30fps_vorbis_stereo_128kbps_48000hz); |
| } |
| |
| public void testThumbnailHEVC() { |
| testThumbnail(R.raw.bbb_s1_720x480_mp4_hevc_mp3_1600kbps_30fps_aac_he_6ch_240kbps_48000hz); |
| } |
| |
| |
| /** |
| * The following tests verifies MediaMetadataRetriever.getFrameAtTime behavior. |
| * |
| * We use a simple stream with binary counter at the top to check which frame |
| * is actually captured. The stream is 30fps with 600 frames in total. It has |
| * I/P/B frames, with I interval of 30. Due to the encoding structure, pts starts |
| * at 66666 (instead of 0), so we have I frames at 66666, 1066666, ..., etc.. |
| * |
| * For each seek option, we check the following five cases: |
| * 1) frame time falls right on a sync frame |
| * 2) frame time is near the middle of two sync frames but closer to the previous one |
| * 3) frame time is near the middle of two sync frames but closer to the next one |
| * 4) frame time is shortly before a sync frame |
| * 5) frame time is shortly after a sync frame |
| */ |
| public void testGetFrameAtTimePreviousSync() { |
| int[][] testCases = { |
| { 2066666, 60 }, { 2500000, 60 }, { 2600000, 60 }, { 3000000, 60 }, { 3200000, 90}}; |
| testGetFrameAtTime(OPTION_PREVIOUS_SYNC, testCases); |
| } |
| |
| public void testGetFrameAtTimeNextSync() { |
| int[][] testCases = { |
| { 2066666, 60 }, { 2500000, 90 }, { 2600000, 90 }, { 3000000, 90 }, { 3200000, 120}}; |
| testGetFrameAtTime(OPTION_NEXT_SYNC, testCases); |
| } |
| |
| public void testGetFrameAtTimeClosestSync() { |
| int[][] testCases = { |
| { 2066666, 60 }, { 2500000, 60 }, { 2600000, 90 }, { 3000000, 90 }, { 3200000, 90}}; |
| testGetFrameAtTime(OPTION_CLOSEST_SYNC, testCases); |
| } |
| |
| public void testGetFrameAtTimeClosest() { |
| int[][] testCases = { |
| { 2066666, 60 }, { 2500001, 73 }, { 2599999, 76 }, { 3016000, 88 }, { 3184000, 94}}; |
| testGetFrameAtTime(OPTION_CLOSEST, testCases); |
| } |
| |
| private void testGetFrameAtTime(int option, int[][] testCases) { |
| testGetFrameAt(testCases, (r) -> { |
| List<Bitmap> bitmaps = new ArrayList<>(); |
| for (int i = 0; i < testCases.length; i++) { |
| bitmaps.add(r.getFrameAtTime(testCases[i][0], option)); |
| } |
| return bitmaps; |
| }); |
| } |
| |
| public void testGetFrameAtIndex() { |
| int[][] testCases = { { 60, 60 }, { 73, 73 }, { 76, 76 }, { 88, 88 }, { 94, 94} }; |
| |
| testGetFrameAt(testCases, (r) -> { |
| List<Bitmap> bitmaps = new ArrayList<>(); |
| for (int i = 0; i < testCases.length; i++) { |
| bitmaps.add(r.getFrameAtIndex(testCases[i][0])); |
| } |
| return bitmaps; |
| }); |
| |
| MediaMetadataRetriever.BitmapParams params = new MediaMetadataRetriever.BitmapParams(); |
| params.setPreferredConfig(Bitmap.Config.RGB_565); |
| assertEquals("Failed to set preferred config", |
| Bitmap.Config.RGB_565, params.getPreferredConfig()); |
| |
| testGetFrameAt(testCases, (r) -> { |
| List<Bitmap> bitmaps = new ArrayList<>(); |
| for (int i = 0; i < testCases.length; i++) { |
| Bitmap bitmap = r.getFrameAtIndex(testCases[i][0], params); |
| assertEquals(Bitmap.Config.RGB_565, params.getActualConfig()); |
| bitmaps.add(bitmap); |
| } |
| return bitmaps; |
| }); |
| } |
| |
| public void testGetFramesAtIndex() { |
| int[][] testCases = { { 27, 27 }, { 28, 28 }, { 29, 29 }, { 30, 30 }, { 31, 31} }; |
| |
| testGetFrameAt(testCases, (r) -> { |
| return r.getFramesAtIndex(testCases[0][0], testCases.length); |
| }); |
| |
| MediaMetadataRetriever.BitmapParams params = new MediaMetadataRetriever.BitmapParams(); |
| params.setPreferredConfig(Bitmap.Config.RGB_565); |
| assertEquals("Failed to set preferred config", |
| Bitmap.Config.RGB_565, params.getPreferredConfig()); |
| |
| testGetFrameAt(testCases, (r) -> { |
| List<Bitmap> bitmaps = r.getFramesAtIndex(testCases[0][0], testCases.length, params); |
| assertEquals(Bitmap.Config.RGB_565, params.getActualConfig()); |
| return bitmaps; |
| }); |
| } |
| |
| private void testGetFrameAt(int[][] testCases, |
| Function<MediaMetadataRetriever, List<Bitmap> > bitmapRetriever) { |
| int resId = R.raw.binary_counter_320x240_30fps_600frames; |
| if (!MediaUtils.hasCodecForResourceAndDomain(getContext(), resId, "video/") |
| && mPackageManager.hasSystemFeature(PackageManager.FEATURE_WATCH)) { |
| MediaUtils.skipTest("no video codecs for resource on watch"); |
| return; |
| } |
| |
| MediaMetadataRetriever retriever = new MediaMetadataRetriever(); |
| Resources resources = getContext().getResources(); |
| AssetFileDescriptor afd = resources.openRawResourceFd(resId); |
| |
| retriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| try { |
| afd.close(); |
| } catch (IOException e) { |
| fail("Unable to close file"); |
| } |
| |
| List<Bitmap> bitmaps = bitmapRetriever.apply(retriever); |
| |
| for (int i = 0; i < testCases.length; i++) { |
| verifyVideoFrame(bitmaps.get(i), testCases[i]); |
| } |
| retriever.release(); |
| } |
| |
| private void verifyVideoFrame(Bitmap bitmap, int[] testCase) { |
| try { |
| assertTrue("Failed to get bitmap for " + testCase[0], bitmap != null); |
| assertEquals("Counter value incorrect for " + testCase[0], |
| testCase[1], CodecUtils.readBinaryCounterFromBitmap(bitmap)); |
| |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_" + testCase[0] + ".jpg"); |
| } |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| } |
| |
| /** |
| * The following tests verifies MediaMetadataRetriever.getScaledFrameAtTime behavior. |
| */ |
| public void testGetScaledFrameAtTime() { |
| int resId = R.raw.binary_counter_320x240_30fps_600frames; |
| if (!MediaUtils.hasCodecForResourceAndDomain(getContext(), resId, "video/") |
| && mPackageManager.hasSystemFeature(PackageManager.FEATURE_WATCH)) { |
| MediaUtils.skipTest("no video codecs for resource on watch"); |
| return; |
| } |
| |
| MediaMetadataRetriever retriever = new MediaMetadataRetriever(); |
| Resources resources = getContext().getResources(); |
| AssetFileDescriptor afd = resources.openRawResourceFd(resId); |
| |
| retriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| try { |
| afd.close(); |
| } catch (IOException e) { |
| fail("Unable to close file"); |
| } |
| |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs*/ , OPTION_CLOSEST, 0 /*width*/, 120 /*height*/); |
| fail("Failed to receive exception"); |
| } catch (IllegalArgumentException e) { |
| // Expect exception |
| } |
| |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs*/ , OPTION_CLOSEST, -1 /*width*/, 0 /*height*/); |
| fail("Failed to receive exception"); |
| } catch (IllegalArgumentException e) { |
| // Expect exception |
| } |
| |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs*/ , OPTION_CLOSEST, -1 /*width*/, 120 /*height*/); |
| fail("Failed to receive exception"); |
| } catch (IllegalArgumentException e) { |
| // Expect exception |
| } |
| |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 140 /*width*/, -1 /*height*/); |
| fail("Failed to receive exception"); |
| } catch (IllegalArgumentException e) { |
| // Expect exception |
| } |
| |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, -1 /*width*/, -1 /*height*/); |
| fail("Failed to receive exception"); |
| } catch (IllegalArgumentException e) { |
| // Expect exception |
| } |
| |
| // Test desided size of 160 x 120. Return should be 160 x 120 |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 160 /*width*/, 120 /*height*/); |
| if (bitmap == null) { |
| fail("Failed to get scaled bitmap"); |
| } |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_160x120" + ".jpg"); |
| } |
| |
| if (bitmap.getWidth() != 160 /* width */) { |
| fail("Bitmap width is " + bitmap.getWidth() + "Expect: 160"); |
| } |
| if (bitmap.getHeight() != 120 /* height */) { |
| fail("Bitmap height is " + bitmap.getHeight() + "Expect: 120"); |
| } |
| |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| |
| // Test scaled up bitmap to 640 x 480. Return should be 640 x 480 |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 640 /*width*/, 480 /*height*/); |
| if (bitmap == null) { |
| fail("Failed to get scaled bitmap"); |
| } |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_640x480" + ".jpg"); |
| } |
| |
| if (bitmap.getWidth() != 640 /* width */) { |
| fail("Bitmap width is " + bitmap.getWidth() + "Expect: 640"); |
| } |
| if (bitmap.getHeight() != 480 /* height */) { |
| fail("Bitmap height is " + bitmap.getHeight() + "Expect: 480"); |
| } |
| |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| |
| // Test scaled up bitmap to 320 x 120. Return should be 160 x 120 |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 320 /*width*/, 120 /*height*/); |
| if (bitmap == null) { |
| fail("Failed to get scaled bitmap"); |
| } |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_320x120" + ".jpg"); |
| } |
| |
| if (bitmap.getWidth() != 160 /* width */) { |
| fail("Bitmap width is " + bitmap.getWidth() + "Expect: 160"); |
| } |
| if (bitmap.getHeight() != 120 /* height */) { |
| fail("Bitmap height is " + bitmap.getHeight() + "Expect: 120"); |
| } |
| |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| |
| // Test scaled up bitmap to 160 x 240. Return should be 160 x 120 |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 160 /*width*/, 240 /*height*/); |
| if (bitmap == null) { |
| fail("Failed to get scaled bitmap"); |
| } |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_160x240" + ".jpg"); |
| } |
| |
| if (bitmap.getWidth() != 160 /* width */) { |
| fail("Bitmap width is " + bitmap.getWidth() + "Expect: 160"); |
| } |
| if (bitmap.getHeight() != 120 /* height */) { |
| fail("Bitmap height is " + bitmap.getHeight() + "Expect: 120"); |
| } |
| |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| |
| // Test scaled the video with aspect ratio |
| resId = R.raw.binary_counter_320x240_720x240_30fps_600frames; |
| afd = resources.openRawResourceFd(resId); |
| |
| retriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| try { |
| afd.close(); |
| } catch (IOException e) { |
| fail("Unable to close file"); |
| } |
| try { |
| Bitmap bitmap = retriever.getScaledFrameAtTime( |
| 2066666 /*timeUs */, OPTION_CLOSEST, 330 /*width*/, 240 /*height*/); |
| if (bitmap == null) { |
| fail("Failed to get scaled bitmap"); |
| } |
| if (SAVE_BITMAP_OUTPUT) { |
| CodecUtils.saveBitmapToFile(bitmap, "test_330x240" + ".jpg"); |
| } |
| |
| if (bitmap.getWidth() != 330 /* width */) { |
| fail("Bitmap width is " + bitmap.getWidth() + "Expect: 330"); |
| } |
| if (bitmap.getHeight() != 110 /* height */) { |
| fail("Bitmap height is " + bitmap.getHeight() + "Expect: 110"); |
| } |
| |
| } catch (Exception e) { |
| fail("Exception getting bitmap: " + e); |
| } |
| } |
| |
| public void testGetImageAtIndex() throws Exception { |
| if (!MediaUtils.hasDecoder(MediaFormat.MIMETYPE_VIDEO_HEVC)) { |
| MediaUtils.skipTest("no video decoders for resource"); |
| return; |
| } |
| |
| testGetImage(R.raw.heifwriter_input, 1920, 1080, 0 /*rotation*/, |
| 4 /*imageCount*/, 3 /*primary*/, true /*useGrid*/, true /*checkColor*/); |
| } |
| |
| /** |
| * Determines if two color values are approximately equal. |
| */ |
| private static boolean approxEquals(Color expected, Color actual) { |
| final float MAX_DELTA = 0.025f; |
| return (Math.abs(expected.red() - actual.red()) <= MAX_DELTA) |
| && (Math.abs(expected.green() - actual.green()) <= MAX_DELTA) |
| && (Math.abs(expected.blue() - actual.blue()) <= MAX_DELTA); |
| } |
| |
| private static Rect getColorBarRect(int index, int width, int height) { |
| int barWidth = (width - BORDER_WIDTH * 2) / COLOR_BARS.length; |
| return new Rect(BORDER_WIDTH + barWidth * index, BORDER_WIDTH, |
| BORDER_WIDTH + barWidth * (index + 1), height - BORDER_WIDTH); |
| } |
| |
| private static Rect getColorBlockRect(int index, int width, int height) { |
| int blockCenterX = (width / 5) * (index % 4 + 1); |
| return new Rect(blockCenterX - width / 10, height / 6, |
| blockCenterX + width / 10, height / 3); |
| } |
| |
| private void testGetImage( |
| int resId, int width, int height, int rotation, |
| int imageCount, int primary, boolean useGrid, boolean checkColor) |
| throws Exception { |
| MediaMetadataRetriever retriever = null; |
| MediaExtractor extractor = null; |
| AssetFileDescriptor afd = null; |
| InputStream inputStream = null; |
| |
| try { |
| retriever = new MediaMetadataRetriever(); |
| |
| Resources resources = getContext().getResources(); |
| afd = resources.openRawResourceFd(resId); |
| |
| retriever.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| |
| // Verify image related meta keys. |
| String hasImage = retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_HAS_IMAGE); |
| assertTrue("No images found in resId " + resId, "yes".equals(hasImage)); |
| assertEquals("Wrong width", width, |
| Integer.parseInt(retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_IMAGE_WIDTH))); |
| assertEquals("Wrong height", height, |
| Integer.parseInt(retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_IMAGE_HEIGHT))); |
| assertEquals("Wrong rotation", rotation, |
| Integer.parseInt(retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_IMAGE_ROTATION))); |
| assertEquals("Wrong image count", imageCount, |
| Integer.parseInt(retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_IMAGE_COUNT))); |
| assertEquals("Wrong primary index", primary, |
| Integer.parseInt(retriever.extractMetadata( |
| MediaMetadataRetriever.METADATA_KEY_IMAGE_PRIMARY))); |
| |
| if (checkColor) { |
| Bitmap bitmap = null; |
| // For each image in the image collection, check the 7 color bars' color. |
| // Also check the position of the color block, which should move left-to-right |
| // with the index. |
| for (int imageIndex = 0; imageIndex < imageCount; imageIndex++) { |
| bitmap = retriever.getImageAtIndex(imageIndex); |
| |
| for (int barIndex = 0; barIndex < COLOR_BARS.length; barIndex++) { |
| Rect r = getColorBarRect(barIndex, width, height); |
| assertTrue("Color bar " + barIndex + |
| " for image " + imageIndex + " doesn't match", |
| approxEquals(COLOR_BARS[barIndex], Color.valueOf( |
| bitmap.getPixel(r.centerX(), r.centerY())))); |
| } |
| |
| Rect r = getColorBlockRect(imageIndex, width, height); |
| assertTrue("Color block for image " + imageIndex + " doesn't match", |
| approxEquals(COLOR_BLOCK, Color.valueOf( |
| bitmap.getPixel(r.centerX(), height - r.centerY())))); |
| bitmap.recycle(); |
| } |
| |
| // Check the color block position on the primary image. |
| Rect r = getColorBlockRect(primary, width, height); |
| bitmap = retriever.getPrimaryImage(); |
| assertTrue("Color block for primary image doesn't match", |
| approxEquals(COLOR_BLOCK, Color.valueOf( |
| bitmap.getPixel(r.centerX(), height - r.centerY())))); |
| bitmap.recycle(); |
| |
| // Check the color block position on the bitmap decoded by BitmapFactory. |
| // This should match the primary image as well. |
| inputStream = getContext().getResources().openRawResource(resId); |
| bitmap = BitmapFactory.decodeStream(inputStream); |
| assertTrue("Color block for bitmap decoding doesn't match", |
| approxEquals(COLOR_BLOCK, Color.valueOf( |
| bitmap.getPixel(r.centerX(), height - r.centerY())))); |
| bitmap.recycle(); |
| } |
| |
| // Check the grid configuration related keys. |
| if (useGrid) { |
| extractor = new MediaExtractor(); |
| extractor.setDataSource( |
| afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength()); |
| MediaFormat format = extractor.getTrackFormat(0); |
| int tileWidth = format.getInteger(MediaFormat.KEY_TILE_WIDTH); |
| int tileHeight = format.getInteger(MediaFormat.KEY_TILE_HEIGHT); |
| int gridRows = format.getInteger(MediaFormat.KEY_GRID_ROWS); |
| int gridCols = format.getInteger(MediaFormat.KEY_GRID_COLUMNS); |
| assertTrue("Wrong tile width or grid cols", |
| ((width + tileWidth - 1) / tileWidth) == gridCols); |
| assertTrue("Wrong tile height or grid rows", |
| ((height + tileHeight - 1) / tileHeight) == gridRows); |
| } |
| } catch (IOException e) { |
| fail("Unable to open file"); |
| } finally { |
| if (retriever != null) { |
| retriever.release(); |
| } |
| if (extractor != null) { |
| extractor.release(); |
| } |
| if (afd != null) { |
| afd.close(); |
| } |
| if (inputStream != null) { |
| inputStream.close(); |
| } |
| } |
| } |
| } |
