further poking at fmod

app/src/main/java/org/fmod/MediaCodec.kt

@@ -1,103 +1,105 @@
 package org.fmod
 
 import android.media.MediaCodec
-import android.media.MediaCrypto
 import android.media.MediaDataSource
 import android.media.MediaExtractor
 import android.media.MediaCodec.BufferInfo
+import android.media.MediaFormat
+import android.os.Build
 import android.util.Log
-import android.view.Surface
 import java.io.IOException
 import java.nio.ByteBuffer
 
 class MediaCodec {
     private var channelCount = 0
 
-    var mCodecPtr: Long = 0
+    var mCodecPtr = 0L
     private var mCurrentOutputBufferIndex = -1
     private var mDecoder: MediaCodec? = null
     private var mExtractor: MediaExtractor? = null
     private var mInputBuffers: Array<ByteBuffer>? = null
     private var mInputFinished = false
-    private var length: Long = 0
+    private var length = 0L
     private var mOutputBuffers: Array<ByteBuffer>? = null
     private var mOutputFinished = false
     private var sampleRate = 0
 
-    fun init(j: Long): Boolean {
+    fun init(codecPtr: Long): Boolean {
-        mCodecPtr = j
+        mCodecPtr = codecPtr
-        var i = 0
 
         try {
             val mediaExtractor = MediaExtractor()
             mExtractor = mediaExtractor
             mediaExtractor.setDataSource(object : MediaDataSource() {
                 override fun close() {}
-                override fun readAt(j: Long, bArr: ByteArray, i: Int, i2: Int): Int {
+                override fun readAt(position: Long, buffer: ByteArray, offset: Int, size: Int): Int {
-                    return fmodReadAt(mCodecPtr, j, bArr, i, i2)
+                    return fmodReadAt(mCodecPtr, position, buffer, offset, size)
                 }
 
                 override fun getSize(): Long {
                     return fmodGetSize(mCodecPtr)
                 }
             })
-        } catch (e5: IOException) {
+        } catch (e: IOException) {
-            Log.w("fmod", "MediaCodec::init : $e5")
+            Log.w("fmod", "MediaCodec::init : $e")
             return false
         }
 
-        val trackCount = mExtractor!!.trackCount
+        val extractor = mExtractor!!
-        var i2 = 0
+
-        while (i2 < trackCount) {
+        val trackCount = extractor.trackCount
-            val trackFormat = mExtractor!!.getTrackFormat(i2)
+        var track = 0
-            val string = trackFormat.getString("mime")
+
+        while (track < trackCount) {
+            val trackFormat = extractor.getTrackFormat(track)
+            val string = trackFormat.getString(MediaFormat.KEY_MIME)
             Log.d(
                 "fmod",
-                "MediaCodec::init : Format $i2 / $trackCount -- $trackFormat"
+                "MediaCodec::init : Format $track / $trackCount -- $trackFormat"
             )
-            if (string == "audio/mp4a-latm") {
+            if (string == MediaFormat.MIMETYPE_AUDIO_AAC) {
                 return try {
-                    mDecoder = MediaCodec.createDecoderByType(string)
+                    val decoder = MediaCodec.createDecoderByType(string)
-                    mExtractor!!.selectTrack(i2)
+                    extractor.selectTrack(track)
-                    mDecoder!!.configure(trackFormat, null as Surface?, null as MediaCrypto?, 0)
+                    decoder.configure(trackFormat, null, null, 0)
-                    mDecoder!!.start()
+                    decoder.start()
-                    mInputBuffers = mDecoder!!.inputBuffers
+                    mInputBuffers = decoder.inputBuffers
-                    mOutputBuffers = mDecoder!!.outputBuffers
+                    mOutputBuffers = decoder.outputBuffers
-                    val integer =
+                    mDecoder = decoder
-                        if (trackFormat.containsKey("encoder-delay")) trackFormat.getInteger("encoder-delay") else 0
+
-                    if (trackFormat.containsKey("encoder-padding")) {
+                    val encoderDelay =
-                        i = trackFormat.getInteger("encoder-padding")
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && trackFormat.containsKey(MediaFormat.KEY_ENCODER_DELAY))
-                    }
+                            trackFormat.getInteger(MediaFormat.KEY_ENCODER_DELAY) else 0
-                    val j2 = trackFormat.getLong("durationUs")
+
-                    channelCount = trackFormat.getInteger("channel-count")
+                    val encoderPadding = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && trackFormat.containsKey(MediaFormat.KEY_ENCODER_PADDING))
-                    val integer2 = trackFormat.getInteger("sample-rate")
+                        trackFormat.getInteger(MediaFormat.KEY_ENCODER_PADDING) else 0
-                    sampleRate = integer2
+
+                    val trackDuration = trackFormat.getLong(MediaFormat.KEY_DURATION)
+                    channelCount = trackFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+                    val trackSampleRate = trackFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+                    sampleRate = trackSampleRate
                     length =
-                        (((j2 * integer2.toLong() + 999999) / 1000000).toInt() - integer - i).toLong()
+                        (((trackDuration * trackSampleRate.toLong() + 999999) / 1000000).toInt() - encoderDelay - encoderPadding).toLong()
+
                     true
-                } catch (e6: IOException) {
+                } catch (e: IOException) {
-                    Log.e("fmod", "MediaCodec::init : $e6")
+                    Log.e("fmod", "MediaCodec::init : $e")
                     false
                 }
             } else {
-                i2++
+                track++
             }
         }
         return false
     }
 
     fun release() {
-        val mediaCodec = mDecoder
+        mDecoder?.stop()
-        if (mediaCodec != null) {
+        mDecoder?.release()
-            mediaCodec.stop()
+        mDecoder = null
-            mDecoder?.release()
+
-            mDecoder = null
+        mExtractor?.release()
-        }
+        mExtractor = null
-        val mediaExtractor = mExtractor
-        if (mediaExtractor != null) {
-            mediaExtractor.release()
-            mExtractor = null
-        }
     }
 
     fun read(bArr: ByteArray, i: Int): Int {
@@ -194,9 +196,9 @@ class MediaCodec {
 
     companion object {
         @JvmStatic
-        external fun fmodGetSize(j: Long): Long
+        external fun fmodGetSize(codecPtr: Long): Long
 
         @JvmStatic
-        external fun fmodReadAt(j: Long, j2: Long, bArr: ByteArray?, i: Int, i2: Int): Int
+        external fun fmodReadAt(codecPtr: Long, position: Long, buffer: ByteArray?, offset: Int, size: Int): Int
     }
 }