media: Clean up MediaCodecBridge and remove subclasses

media/base/android/java/src/org/chromium/media/MediaCodecBridge.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.media.AudioFormat;
 import android.media.MediaCodec;
 import android.media.MediaCodec.CryptoInfo;
@@ skipping 10 matching lines @@
 import org.chromium.media.MediaCodecUtil.BitrateAdjustmentTypes;
 import org.chromium.media.MediaCodecUtil.MimeTypes;
 
 import java.nio.ByteBuffer;
 
 /**
  * A MediaCodec wrapper for adapting the API and catching exceptions.
  */
 @JNINamespace("media")
 class MediaCodecBridge {
-    private static final String TAG = "cr_MediaCodecBridge";
-
-    // Status codes. Keep these in sync with MediaCodecStatus in media_codec_bridge.h.
-    private static final int MEDIA_CODEC_OK = 0;
-    private static final int MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER = 1;
-    private static final int MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER = 2;
-    private static final int MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED = 3;
-    private static final int MEDIA_CODEC_OUTPUT_FORMAT_CHANGED = 4;
-    private static final int MEDIA_CODEC_NO_KEY = 5;
-    private static final int MEDIA_CODEC_ERROR = 6;
+    private static final String TAG = "cr.MediaCodecBridge";
 
     // After a flush(), dequeueOutputBuffer() can often produce empty presentation timestamps
     // for several frames. As a result, the player may find that the time does not increase
     // after decoding a frame. To detect this, we check whether the presentation timestamp from
     // dequeueOutputBuffer() is larger than input_timestamp - MAX_PRESENTATION_TIMESTAMP_SHIFT_US
     // after a flush. And we set the presentation timestamp from dequeueOutputBuffer() to be
     // non-decreasing for the remaining frames.
     private static final long MAX_PRESENTATION_TIMESTAMP_SHIFT_US = 100000;
 
     // We use only one output audio format (PCM16) that has 2 bytes per sample
     private static final int PCM16_BYTES_PER_SAMPLE = 2;
 
-    // The following values should be kept in sync with the media::EncryptionScheme::CipherMode
-    // enum in media/base/encryption_scheme.h
-    private static final int MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_UNENCRYPTED = 0;
-    private static final int MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_AES_CTR = 1;
-    private static final int MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_AES_CBC = 2;
-
     private static final int MEDIA_CODEC_UNKNOWN_CIPHER_MODE = -1;
 
     // TODO(qinmin): Use MediaFormat constants when part of the public API.
     private static final String KEY_CROP_LEFT = "crop-left";
     private static final String KEY_CROP_RIGHT = "crop-right";
     private static final String KEY_CROP_BOTTOM = "crop-bottom";
     private static final String KEY_CROP_TOP = "crop-top";
 
     private static final int BITRATE_ADJUSTMENT_FPS = 30;
     private static final int MAXIMUM_INITIAL_FPS = 30;
@@ skipping 77 matching lines @@
         @CalledByNative("DequeueOutputResult")
         private int numBytes() {
             return mNumBytes;
         }
     }
 
     /** A wrapper around a MediaFormat. */
     @MainDex
     private static class GetOutputFormatResult {
         private final int mStatus;
-        // May be null if mStatus is not MEDIA_CODEC_OK.
+        // May be null if mStatus is not MediaCodecStatus.OK.
         private final MediaFormat mFormat;
 
         private GetOutputFormatResult(int status, MediaFormat format) {
             mStatus = status;
             mFormat = format;
         }
 
         private boolean formatHasCropValues() {
             return mFormat.containsKey(KEY_CROP_RIGHT) && mFormat.containsKey(KEY_CROP_LEFT)
                     && mFormat.containsKey(KEY_CROP_BOTTOM) && mFormat.containsKey(KEY_CROP_TOP);
@@ skipping 38 matching lines @@
         mFlushed = true;
         mAdaptivePlaybackSupported = adaptivePlaybackSupported;
         mBitrateAdjustmentType = bitrateAdjustmentType;
     }
 
     @CalledByNative
     private static MediaCodecBridge create(
             String mime, boolean isSecure, int direction, boolean requireSoftwareCodec) {
         MediaCodecUtil.CodecCreationInfo info = new MediaCodecUtil.CodecCreationInfo();
         try {
-            if (direction == MediaCodecUtil.MEDIA_CODEC_ENCODER) {
+            if (direction == MediaCodecDirection.ENCODER) {
                 info = MediaCodecUtil.createEncoder(mime);
             } else {
                 // |isSecure| only applies to video decoders.
                 info = MediaCodecUtil.createDecoder(mime, isSecure, requireSoftwareCodec);
             }
         } catch (Exception e) {
             Log.e(TAG, "Failed to create MediaCodec: %s, isSecure: %s, direction: %d",
                     mime, isSecure, direction, e);
         }
 
@@ skipping 36 matching lines @@
             return false;
         } catch (IllegalArgumentException e) {
             Log.e(TAG, "Cannot start the media codec", e);
             return false;
         }
         return true;
     }
 
     @CalledByNative
     private DequeueInputResult dequeueInputBuffer(long timeoutUs) {
-        int status = MEDIA_CODEC_ERROR;
+        int status = MediaCodecStatus.ERROR;
         int index = -1;
         try {
             int indexOrStatus = mMediaCodec.dequeueInputBuffer(timeoutUs);
             if (indexOrStatus >= 0) { // index!
-                status = MEDIA_CODEC_OK;
+                status = MediaCodecStatus.OK;
                 index = indexOrStatus;
             } else if (indexOrStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
-                status = MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER;
+                status = MediaCodecStatus.TRY_AGAIN_LATER;
             } else {
                 Log.e(TAG, "Unexpected index_or_status: " + indexOrStatus);
                 assert false;
             }
         } catch (Exception e) {
             Log.e(TAG, "Failed to dequeue input buffer", e);
         }
         return new DequeueInputResult(status, index);
     }
 
     @CalledByNative
     private int flush() {
         try {
             mFlushed = true;
             mMediaCodec.flush();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to flush MediaCodec", e);
-            return MEDIA_CODEC_ERROR;
+            return MediaCodecStatus.ERROR;
         }
-        return MEDIA_CODEC_OK;
+        return MediaCodecStatus.OK;
     }
 
     @CalledByNative
     private void stop() {
         try {
             mMediaCodec.stop();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to stop MediaCodec", e);
         }
     }
 
     @TargetApi(Build.VERSION_CODES.KITKAT)
     @CalledByNative
     private String getName() {
         String codecName = "unknown";
         try {
             codecName = mMediaCodec.getName();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Cannot get codec name", e);
         }
         return codecName;
     }
 
     @CalledByNative
     private GetOutputFormatResult getOutputFormat() {
         MediaFormat format = null;
-        int status = MEDIA_CODEC_OK;
+        int status = MediaCodecStatus.OK;
         try {
             format = mMediaCodec.getOutputFormat();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to get output format", e);
-            status = MEDIA_CODEC_ERROR;
+            status = MediaCodecStatus.ERROR;
         }
         return new GetOutputFormatResult(status, format);
     }
 
     /** Returns null if MediaCodec throws IllegalStateException. */
     @CalledByNative
     private ByteBuffer getInputBuffer(int index) {
         if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
             try {
                 return mMediaCodec.getInputBuffer(index);
@@ skipping 20 matching lines @@
     }
 
     @CalledByNative
     private int queueInputBuffer(
             int index, int offset, int size, long presentationTimeUs, int flags) {
         resetLastPresentationTimeIfNeeded(presentationTimeUs);
         try {
             mMediaCodec.queueInputBuffer(index, offset, size, presentationTimeUs, flags);
         } catch (Exception e) {
             Log.e(TAG, "Failed to queue input buffer", e);
-            return MEDIA_CODEC_ERROR;
+            return MediaCodecStatus.ERROR;
         }
-        return MEDIA_CODEC_OK;
+        return MediaCodecStatus.OK;
     }
 
     @TargetApi(Build.VERSION_CODES.KITKAT)
     @CalledByNative
     private void setVideoBitrate(int bps, int frameRate) {
         int targetBps = bps;
         if (mBitrateAdjustmentType == BitrateAdjustmentTypes.FRAMERATE_ADJUSTMENT
                 && frameRate > 0) {
             targetBps = BITRATE_ADJUSTMENT_FPS * bps / frameRate;
         }
@@ skipping 19 matching lines @@
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to set MediaCodec parameters", e);
         }
     }
 
     // Incoming |native| values are as defined in media/base/encryption_scheme.h. Translated values
     // are from MediaCodec. At present, these values are in sync. Returns
     // MEDIA_CODEC_UNKNOWN_CIPHER_MODE in the case of unknown incoming value.
     private int translateCipherModeValue(int nativeValue) {
         switch (nativeValue) {
-            case MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_UNENCRYPTED:
+            case CipherMode.UNENCRYPTED:
                 return MediaCodec.CRYPTO_MODE_UNENCRYPTED;
-            case MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_AES_CTR:
+            case CipherMode.AES_CTR:
                 return MediaCodec.CRYPTO_MODE_AES_CTR;
-            case MEDIA_ENCRYPTION_SCHEME_CIPHER_MODE_AES_CBC:
+            case CipherMode.AES_CBC:
                 return MediaCodec.CRYPTO_MODE_AES_CBC;
             default:
                 Log.e(TAG, "Unsupported cipher mode: " + nativeValue);
                 return MEDIA_CODEC_UNKNOWN_CIPHER_MODE;
         }
     }
 
     @CalledByNative
     private int queueSecureInputBuffer(int index, int offset, byte[] iv, byte[] keyId,
             int[] numBytesOfClearData, int[] numBytesOfEncryptedData, int numSubSamples,
             int cipherMode, int patternEncrypt, int patternSkip, long presentationTimeUs) {
         resetLastPresentationTimeIfNeeded(presentationTimeUs);
         try {
             cipherMode = translateCipherModeValue(cipherMode);
             if (cipherMode == MEDIA_CODEC_UNKNOWN_CIPHER_MODE) {
-                return MEDIA_CODEC_ERROR;
+                return MediaCodecStatus.ERROR;
             }
             boolean usesCbcs = cipherMode == MediaCodec.CRYPTO_MODE_AES_CBC;
             if (usesCbcs && !MediaCodecUtil.platformSupportsCbcsEncryption()) {
                 Log.e(TAG, "Encryption scheme 'cbcs' not supported on this platform.");
-                return MEDIA_CODEC_ERROR;
+                return MediaCodecStatus.ERROR;
             }
             CryptoInfo cryptoInfo = new CryptoInfo();
             cryptoInfo.set(numSubSamples, numBytesOfClearData, numBytesOfEncryptedData, keyId, iv,
                     cipherMode);
             if (patternEncrypt != 0 && patternSkip != 0) {
                 if (usesCbcs) {
                     // Above platform check ensured that setting the pattern is indeed supported.
                     MediaCodecUtil.setPatternIfSupported(cryptoInfo, patternEncrypt, patternSkip);
                 } else {
                     Log.e(TAG, "Pattern encryption only supported for 'cbcs' scheme (CBC mode).");
-                    return MEDIA_CODEC_ERROR;
+                    return MediaCodecStatus.ERROR;
                 }
             }
             mMediaCodec.queueSecureInputBuffer(index, offset, cryptoInfo, presentationTimeUs, 0);
         } catch (MediaCodec.CryptoException e) {
             if (e.getErrorCode() == MediaCodec.CryptoException.ERROR_NO_KEY) {
                 Log.d(TAG, "Failed to queue secure input buffer: CryptoException.ERROR_NO_KEY");
-                return MEDIA_CODEC_NO_KEY;
+                return MediaCodecStatus.NO_KEY;
             }
             Log.e(TAG, "Failed to queue secure input buffer, CryptoException with error code "
                             + e.getErrorCode());
-            return MEDIA_CODEC_ERROR;
+            return MediaCodecStatus.ERROR;
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to queue secure input buffer, IllegalStateException " + e);
-            return MEDIA_CODEC_ERROR;
+            return MediaCodecStatus.ERROR;
         }
-        return MEDIA_CODEC_OK;
+        return MediaCodecStatus.OK;
     }
 
     @CalledByNative
     private void releaseOutputBuffer(int index, boolean render) {
         try {
             mMediaCodec.releaseOutputBuffer(index, render);
         } catch (IllegalStateException e) {
             // TODO(qinmin): May need to report the error to the caller. crbug.com/356498.
             Log.e(TAG, "Failed to release output buffer", e);
         }
     }
 
     @SuppressWarnings("deprecation")
     @CalledByNative
     private DequeueOutputResult dequeueOutputBuffer(long timeoutUs) {
         MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
-        int status = MEDIA_CODEC_ERROR;
+        int status = MediaCodecStatus.ERROR;
         int index = -1;
         try {
             int indexOrStatus = mMediaCodec.dequeueOutputBuffer(info, timeoutUs);
             if (info.presentationTimeUs < mLastPresentationTimeUs) {
                 // TODO(qinmin): return a special code through DequeueOutputResult
                 // to notify the native code the the frame has a wrong presentation
                 // timestamp and should be skipped.
                 info.presentationTimeUs = mLastPresentationTimeUs;
             }
             mLastPresentationTimeUs = info.presentationTimeUs;
 
             if (indexOrStatus >= 0) { // index!
-                status = MEDIA_CODEC_OK;
+                status = MediaCodecStatus.OK;
                 index = indexOrStatus;
             } else if (indexOrStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                 mOutputBuffers = mMediaCodec.getOutputBuffers();
-                status = MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED;
+                status = MediaCodecStatus.OUTPUT_BUFFERS_CHANGED;
             } else if (indexOrStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
-                status = MEDIA_CODEC_OUTPUT_FORMAT_CHANGED;
+                status = MediaCodecStatus.OUTPUT_FORMAT_CHANGED;
                 MediaFormat newFormat = mMediaCodec.getOutputFormat();
             } else if (indexOrStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
-                status = MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER;
+                status = MediaCodecStatus.TRY_AGAIN_LATER;
             } else {
                 Log.e(TAG, "Unexpected index_or_status: " + indexOrStatus);
                 assert false;
             }
         } catch (IllegalStateException e) {
-            status = MEDIA_CODEC_ERROR;
+            status = MediaCodecStatus.ERROR;
             Log.e(TAG, "Failed to dequeue output buffer", e);
         }
 
         return new DequeueOutputResult(
                 status, index, info.flags, info.offset, info.presentationTimeUs, info.size);
     }
 
     @CalledByNative
     private boolean configureVideo(MediaFormat format, Surface surface, MediaCrypto crypto,
             int flags, boolean allowAdaptivePlayback) {
@@ skipping 99 matching lines @@
         MediaFormat format = MediaFormat.createVideoFormat(mime, width, height);
         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
         format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
         format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
         Log.d(TAG, "video encoder format: " + format);
         return format;
     }
 
     @CalledByNative
-    private boolean isAdaptivePlaybackSupported(int width, int height) {
+    private boolean isAdaptivePlaybackSupported() {
         // If media codec has adaptive playback supported, then the max sizes
         // used during creation are only hints.
         return mAdaptivePlaybackSupported;
     }
 
     @CalledByNative
     private static void setCodecSpecificData(MediaFormat format, int index, byte[] bytes) {
         // Codec Specific Data is set in the MediaFormat as ByteBuffer entries with keys csd-0,
         // csd-1, and so on. See: http://developer.android.com/reference/android/media/MediaCodec.html
         // for details.
@@ skipping 74 matching lines @@
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                     return AudioFormat.CHANNEL_OUT_7POINT1_SURROUND;
                 } else {
                     return AudioFormat.CHANNEL_OUT_7POINT1;
                 }
             default:
                 return AudioFormat.CHANNEL_OUT_DEFAULT;
         }
     }
 }