// 時間が増加する分には速く取れるように作れそう。
val bitmap1 = getVideoFrameBitmap(ms = 1_000)
val bitmap2 = getVideoFrameBitmap(ms = 1_100)
val bitmap3 = getVideoFrameBitmap(ms = 1_200)
val bitmap4 = getVideoFrameBitmap(ms = 1_300)
val bitmap5 = getVideoFrameBitmap(ms = 1_400)

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun MainScreen() {
 
    val context = LocalContext.current
    val bitmap = remember { mutableStateOf<ImageBitmap?>(null) }
 
    val videoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { uri ->
            // MediaMetadataRetriever は File からも作れます
            uri ?: return@rememberLauncherForActivityResult
            val mediaMetadataRetriever = MediaMetadataRetriever().apply {
                setDataSource(context, uri)
            }
            // Bitmap を取り出す
            // 引数の単位は Ms ではなく Us です
            bitmap.value = mediaMetadataRetriever.getFrameAtTime(13_000_000, MediaMetadataRetriever.OPTION_CLOSEST)?.asImageBitmap()
            // もう使わないなら
            mediaMetadataRetriever.release()
        }
    )
 
    Scaffold(
        topBar = {
            TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) })
        }
    ) { paddingValues ->
        Column(
            modifier = Modifier
                .padding(paddingValues)
                .fillMaxSize(),
            verticalArrangement = Arrangement.spacedBy(10.dp)
        ) {
 
            if (bitmap.value != null) {
                Image(
                    modifier = Modifier.fillMaxWidth(),
                    bitmap = bitmap.value!!,
                    contentDescription = null
                )
            }
 
            Button(onClick = { videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly)) }) {
                Text(text = "取り出す")
            }
 
        }
    }
}

// 時間が巻き戻らなければ速くフレーム返して欲しい
// これだけでも 1 秒くらいはかかっちゃう
mediaMetadataRetriever.getFrameAtTime(1_000_000L, MediaMetadataRetriever.OPTION_CLOSEST)
mediaMetadataRetriever.getFrameAtTime(1_100_000L, MediaMetadataRetriever.OPTION_CLOSEST)
mediaMetadataRetriever.getFrameAtTime(1_200_000L, MediaMetadataRetriever.OPTION_CLOSEST)

// 3枚取り出す
val time = measureTimeMillis {
    repeat(3) {
        val timeUs = it * 1_000_000L
        val mediaMetadataRetriever = MediaMetadataRetriever().apply {
            setDataSource(context, uri)
        }
        // Bitmap を取り出す
        // 引数の単位は Ms ではなく Us です
        mediaMetadataRetriever.getFrameAtTime(timeUs, MediaMetadataRetriever.OPTION_CLOSEST)?.asImageBitmap()
        // もう使わないなら
        mediaMetadataRetriever.release()
    }
}
println("time = $time")

scope.launch {
    // 3枚取り出す
    val time = measureTimeMillis {
        (0 until 3).map {
            launch {
                val timeUs = it * 1_000_000L
                val mediaMetadataRetriever = MediaMetadataRetriever().apply {
                    setDataSource(context, uri)
                }
                // Bitmap を取り出す
                // 引数の単位は Ms ではなく Us です
                mediaMetadataRetriever.getFrameAtTime(timeUs, MediaMetadataRetriever.OPTION_CLOSEST)?.asImageBitmap()
                // もう使わないなら
                mediaMetadataRetriever.release()
            }
        }.joinAll()
    }
    println("time = $time ms")
}

// TODO 動くかわからない。多分動かない
val imageReader = ImageReader.newInstance(videoWidth, videoHeight, ImageFormat.YUV_420_888, 2)
imageReader.setOnImageAvailableListener({
    // 毎フレームごとに呼ばれるんじゃないかな
    // 連続して取り出す分には出来そう
    val currentPosition = mediaPlayer.currentPosition
    val image = imageReader.acquireLatestImage()
    val bitmap = image.toBitmap() // toBitmap は自分で書いて...
}, null)
 
val mediaPlayer = MediaPlayer().apply {
    setSurface(imageReader.surface)
    setDataSource(videoFile.path)
    prepare()
    seekTo(1_000)
    start() // 再生
}

// 毎フレーム、巻き戻ししなければ速く取得できる処理が作れるのではないか。
getVideoFrameBitmap(ms = 16)
getVideoFrameBitmap(ms = 33)
getVideoFrameBitmap(ms = 66)
getVideoFrameBitmap(ms = 99)

/**
 * [MediaCodec]と[MediaExtractor]、[ImageReader]を使って高速に動画からフレームを取り出す
 */
class VideoFrameBitmapExtractor {
 
    /** MediaCodec デコーダー */
    private var decodeMediaCodec: MediaCodec? = null
 
    /** Extractor */
    private var mediaExtractor: MediaExtractor? = null
 
    /** 映像デコーダーから Bitmap として取り出すための ImageReader */
    private var imageReader: ImageReader? = null
 
    /** 最後の[getVideoFrameBitmap]で取得したフレームの位置 */
    private var latestDecodePositionMs = 0L
 
    /** 前回のシーク位置 */
    private var prevSeekToMs = -1L
 
    /** 前回[getImageReaderBitmap]で作成した Bitmap */
    private var prevBitmap: Bitmap? = null
 
    /**
     * デコーダーを初期化する
     *
     * @param uri 動画ファイル
     */
    suspend fun prepareDecoder(
        context: Context,
        uri: Uri,
    ) = withContext(Dispatchers.IO) {
        // todo
    }
 
    /**
     * 指定位置の動画のフレームを取得して、[Bitmap]で返す
     *
     * @param seekToMs シーク位置
     * @return Bitmap
     */
    suspend fun getVideoFrameBitmap(
        seekToMs: Long
    ): Bitmap = withContext(Dispatchers.Default) {
        // TODO
    }
 
    /** 破棄する */
    fun destroy() {
        decodeMediaCodec?.release()
        mediaExtractor?.release()
        imageReader?.close()
        inputSurface?.release()
    }
 
    companion object {
        /** MediaCodec タイムアウト */
        private const val TIMEOUT_US = 10_000L
 
        /** OpenGL 用に用意した描画用スレッド。Kotlin coroutines では Dispatcher を切り替えて使う */
        @OptIn(DelicateCoroutinesApi::class)
        private val openGlRenderDispatcher = newSingleThreadContext("openGlRenderDispatcher")
    }
}

/**
 * デコーダーを初期化する
 *
 * @param uri 動画ファイル
 */
suspend fun prepareDecoder(
    context: Context,
    uri: Uri,
) = withContext(Dispatchers.IO) {
    // コンテナからメタデータを取り出す
    val mediaExtractor = MediaExtractor().apply {
        context.contentResolver.openFileDescriptor(uri, "r")?.use {
            setDataSource(it.fileDescriptor)
        }
    }
    this@VideoFrameBitmapExtractor.mediaExtractor = mediaExtractor
 
    // 映像トラックを探して指定する。音声と映像で2️個入ってるので
    val trackIndex = (0 until mediaExtractor.trackCount)
        .map { index -> mediaExtractor.getTrackFormat(index) }
        .indexOfFirst { mediaFormat -> mediaFormat.getString(MediaFormat.KEY_MIME)?.startsWith("video/") == true }
    mediaExtractor.selectTrack(trackIndex)
 
    // デコーダーの用意
    val mediaFormat = mediaExtractor.getTrackFormat(trackIndex)
    val codecName = mediaFormat.getString(MediaFormat.KEY_MIME)!!
    val videoHeight = mediaFormat.getInteger(MediaFormat.KEY_HEIGHT)
    val videoWidth = mediaFormat.getInteger(MediaFormat.KEY_WIDTH)
 
    // Surface 経由で Bitmap が取れる ImageReader つくる
    imageReader = ImageReader.newInstance(videoWidth, videoHeight, PixelFormat.RGBA_8888, 2)
 
    // 描画用スレッドに切り替える
    withContext(openGlRenderDispatcher) {
        // MediaCodec と ImageReader の間に OpenGL を経由させる
        // 経由させないと、Google Pixel 以外（Snapdragon 端末とか）で動かなかった
        this@VideoFrameBitmapExtractor.inputSurface = InputSurface(
            surface = imageReader!!.surface,
            textureRenderer = TextureRenderer()
        )
        inputSurface!!.makeCurrent()
        inputSurface!!.createRender()
    }
 
    // 映像デコーダー起動
    // デコード結果を ImageReader に流す
    decodeMediaCodec = MediaCodec.createDecoderByType(codecName).apply {
        configure(mediaFormat, inputSurface!!.drawSurface, null, 0)
    }
    decodeMediaCodec!!.start()
}

|-------◯----|
   ↑

/**
 * 今の再生位置よりも前の位置にシークして、指定した時間のフレームまでデコードする。
 * 指定した時間のフレームがキーフレームじゃない場合は、キーフレームまでさらに巻き戻すので、ちょっと時間がかかります。
 *
 * @param seekToMs シーク位置
 */
private suspend fun awaitSeekToPrevDecode(
    seekToMs: Long
) = withContext(Dispatchers.Default) {
    val decodeMediaCodec = decodeMediaCodec!!
    val mediaExtractor = mediaExtractor!!
    val inputSurface = inputSurface!!
 
    // シークする。SEEK_TO_PREVIOUS_SYNC なので、シーク位置にキーフレームがない場合はキーフレームがある場所まで戻る
    mediaExtractor.seekTo(seekToMs * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
    // エンコードサれたデータを順番通りに送るわけではない（隣接したデータじゃない）ので flush する
    decodeMediaCodec.flush()
 
    // デコーダーに渡す
    var isRunning = true
    val bufferInfo = MediaCodec.BufferInfo()
    while (isRunning) {
        // キャンセル時
        if (!isActive) break
 
        // コンテナフォーマットからサンプルを取り出し、デコーダーに渡す
        // while で繰り返しているのは、シーク位置がキーフレームのため戻った場合に、狙った時間のフレームが表示されるまで繰り返しデコーダーに渡すため
        val inputBufferIndex = decodeMediaCodec.dequeueInputBuffer(TIMEOUT_US)
        if (inputBufferIndex >= 0) {
            val inputBuffer = decodeMediaCodec.getInputBuffer(inputBufferIndex)!!
            // デコーダーへ流す
            val size = mediaExtractor.readSampleData(inputBuffer, 0)
            decodeMediaCodec.queueInputBuffer(inputBufferIndex, 0, size, mediaExtractor.sampleTime, 0)
            // 狙ったフレームになるまでデータを進める
            mediaExtractor.advance()
        }
 
        // デコーダーから映像を受け取る部分
        var isDecoderOutputAvailable = true
        while (isDecoderOutputAvailable) {
            // デコード結果が来ているか
            val outputBufferIndex = decodeMediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US)
            when {
                outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER -> {
                    // もう無い時
                    isDecoderOutputAvailable = false
                }
 
                outputBufferIndex >= 0 -> {
                    // ImageReader ( Surface ) に描画する
                    val doRender = bufferInfo.size != 0
                    decodeMediaCodec.releaseOutputBuffer(outputBufferIndex, doRender)
                    // OpenGL で描画して、ImageReader で撮影する
                    // OpenGL 描画用スレッドに切り替えてから、swapBuffers とかやる
                    withContext(openGlRenderDispatcher) {
                        if (doRender) {
                            var errorWait = false
                            try {
                                inputSurface.awaitNewImage()
                            } catch (e: Exception) {
                                errorWait = true
                            }
                            if (!errorWait) {
                                inputSurface.drawImage()
                                inputSurface.setPresentationTime(bufferInfo.presentationTimeUs * 1000)
                                inputSurface.swapBuffers()
                            }
                        }
                    }
                    // 欲しいフレームの時間に到達した場合、ループを抜ける
                    val presentationTimeMs = bufferInfo.presentationTimeUs / 1000
                    if (seekToMs <= presentationTimeMs) {
                        isRunning = false
                        latestDecodePositionMs = presentationTimeMs
                    }
                }
            }
        }
    }
}

|-------◯----|
              ↑

/**
 * 今の再生位置よりも後の位置にシークして、指定した時間のフレームまでデコードする。
 *
 * また高速化のため、まず[seekToMs]へシークするのではなく、次のキーフレームまでデータをデコーダーへ渡します。
 * この間に[seekToMs]のフレームがあればシークしません。
 * これにより、キーフレームまで戻る必要がなくなり、連続してフレームを取得する場合は高速に取得できます。
 *
 * @param seekToMs シーク位置
 */
private suspend fun awaitSeekToNextDecode(
    seekToMs: Long
) = withContext(Dispatchers.Default) {
    val decodeMediaCodec = decodeMediaCodec!!
    val mediaExtractor = mediaExtractor!!
    val inputSurface = inputSurface!!
 
    var isRunning = isActive
    val bufferInfo = MediaCodec.BufferInfo()
    while (isRunning) {
        // キャンセル時
        if (!isActive) break
 
        // コンテナフォーマットからサンプルを取り出し、デコーダーに渡す
        // シークしないことで、連続してフレームを取得する場合にキーフレームまで戻る必要がなくなり、早くなる
        val inputBufferIndex = decodeMediaCodec.dequeueInputBuffer(TIMEOUT_US)
        if (inputBufferIndex >= 0) {
            // デコーダーへ流す
            val inputBuffer = decodeMediaCodec.getInputBuffer(inputBufferIndex)!!
            val size = mediaExtractor.readSampleData(inputBuffer, 0)
            decodeMediaCodec.queueInputBuffer(inputBufferIndex, 0, size, mediaExtractor.sampleTime, 0)
        }
 
        // デコーダーから映像を受け取る部分
        var isDecoderOutputAvailable = true
        while (isDecoderOutputAvailable) {
            // デコード結果が来ているか
            val outputBufferIndex = decodeMediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US)
            when {
                outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER -> {
                    // もう無い時
                    isDecoderOutputAvailable = false
                }
 
                outputBufferIndex >= 0 -> {
                    // ImageReader ( Surface ) に描画する
                    val doRender = bufferInfo.size != 0
                    decodeMediaCodec.releaseOutputBuffer(outputBufferIndex, doRender)
                    // OpenGL で描画して、ImageReader で撮影する
                    // OpenGL 描画用スレッドに切り替えてから、swapBuffers とかやる
                    withContext(openGlRenderDispatcher) {
                        if (doRender) {
                            var errorWait = false
                            try {
                                inputSurface.awaitNewImage()
                            } catch (e: Exception) {
                                errorWait = true
                            }
                            if (!errorWait) {
                                inputSurface.drawImage()
                                inputSurface.setPresentationTime(bufferInfo.presentationTimeUs * 1000)
                                inputSurface.swapBuffers()
                            }
                        }
                    }
                    // 欲しいフレームの時間に到達した場合、ループを抜ける
                    val presentationTimeMs = bufferInfo.presentationTimeUs / 1000
                    if (seekToMs <= presentationTimeMs) {
                        isRunning = false
                        latestDecodePositionMs = presentationTimeMs
                    }
                }
            }
        }
 
        // 次に進める
        mediaExtractor.advance()
 
        // 欲しいフレームが前回の呼び出しと連続していないときの処理
        // 例えば、前回の取得位置よりもさらに数秒以上先にシークした場合、指定位置になるまで待ってたら遅くなるので、数秒先にあるキーフレームまでシークする
        // で、このシークが必要かどうかの判定がこれ。数秒先をリクエストした結果、欲しいフレームが来るよりも先にキーフレームが来てしまった
        // この場合は一気にシーク位置に一番近いキーフレームまで進める
        // ただし、キーフレームが来ているサンプルの時間を比べて、欲しいフレームの位置の方が大きくなっていることを確認してから。
        // デコーダーの時間 presentationTimeUs と、MediaExtractor の sampleTime は同じじゃない？らしく、sampleTime の方がデコーダーの時間より早くなるので注意
        val isKeyFrame = mediaExtractor.sampleFlags and MediaExtractor.SAMPLE_FLAG_SYNC != 0
        val currentSampleTimeMs = mediaExtractor.sampleTime / 1000
        if (isKeyFrame && currentSampleTimeMs < seekToMs) {
            mediaExtractor.seekTo(seekToMs * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
        }
    }
}

     suspend fun getVideoFrameBitmap(
         seekToMs: Long
-    ): Bitmap = withContext(Dispatchers.Default) {
+    ): Bitmap? = withContext(Dispatchers.Default) {

             else -> {
                 // 巻き戻しでも無く、フレームを取り出す必要がある
                 awaitSeekToNextDecode(seekToMs)
-                getImageReaderBitmap()
+                // 巻き戻しでも無く、フレームを取り出す必要がある
+                val hasData = awaitSeekToNextDecode(seekToMs)
+                if (hasData) getImageReaderBitmap() else null
             }

     private suspend fun awaitSeekToNextDecode(
         seekToMs: Long
-    ) = withContext(Dispatchers.Default) {
+    ): Boolean = withContext(Dispatchers.Default) {

         val decodeMediaCodec = decodeMediaCodec!!
         val mediaExtractor = mediaExtractor!!
         val inputSurface = inputSurface!!
 
+        // advance() で false を返したことがある場合、もうデータがない。getSampleTime も -1 になる。
+        if (mediaExtractor.sampleTime == -1L) {
+            return@withContext false
+        }
+
         var isRunning = isActive
         val bufferInfo = MediaCodec.BufferInfo()

 
-            // 次に進める
-            mediaExtractor.advance()
+            // 次に進める。advance() が false の場合はもうデータがないので、break する。
+            val isEndOfFile = !mediaExtractor.advance()
+            if (isEndOfFile) {
+                break
+            }

-                bitmap.value = videoFrameBitmapExtractor.getVideoFrameBitmap(currentPositionMs.value).asImageBitmap()
+                bitmap.value = videoFrameBitmapExtractor.getVideoFrameBitmap(currentPositionMs.value)?.asImageBitmap()

/** [imageReader]から[Bitmap]を取り出す */
private suspend fun getImageReaderBitmap(): Bitmap = withContext(Dispatchers.Default) {
    val image = imageReader!!.acquireLatestImage()
    val width = image.width
    val height = image.height
    val buffer = image.planes.first().buffer
    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
    bitmap.copyPixelsFromBuffer(buffer)
    prevBitmap = bitmap
    // Image を close する
    image.close()
    return@withContext bitmap
}

/**
 * 指定位置の動画のフレームを取得して、[Bitmap]で返す
 *
 * @param seekToMs シーク位置
 * @return Bitmap
 */
suspend fun getVideoFrameBitmap(
    seekToMs: Long
): Bitmap = withContext(Dispatchers.Default) {
    val videoFrameBitmap = when {
        // 現在の再生位置よりも戻る方向に（巻き戻し）した場合
        seekToMs < prevSeekToMs -> {
            awaitSeekToPrevDecode(seekToMs)
            getImageReaderBitmap()
        }
 
        // シーク不要
        // 例えば 30fps なら 33ms 毎なら新しい Bitmap を返す必要があるが、 16ms 毎に要求されたら Bitmap 変化しないので
        // つまり映像のフレームレートよりも高頻度で Bitmap が要求されたら、前回取得した Bitmap がそのまま使い回せる
        seekToMs < latestDecodePositionMs && prevBitmap != null -> {
            prevBitmap!!
        }
 
        else -> {
            // 巻き戻しでも無く、フレームを取り出す必要がある
            awaitSeekToNextDecode(seekToMs)
            getImageReaderBitmap()
        }
    }
    prevSeekToMs = seekToMs
    return@withContext videoFrameBitmap
}

fun VideoFrameBitmapExtractorScreen() {
    val scope = rememberCoroutineScope()
    val context = LocalContext.current
    val bitmap = remember { mutableStateOf<ImageBitmap?>(null) }
 
    // フレームを取り出すやつと取り出した位置
    val currentPositionMs = remember { mutableStateOf(0L) }
    val videoFrameBitmapExtractor = remember { VideoFrameBitmapExtractor() }
 
    val videoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { uri ->
            uri ?: return@rememberLauncherForActivityResult
            scope.launch {
                videoFrameBitmapExtractor.prepareDecoder(context, uri)
                currentPositionMs.value = 1000
                bitmap.value = videoFrameBitmapExtractor.getVideoFrameBitmap(currentPositionMs.value).asImageBitmap()
            }
        }
    )
 
    // 破棄時
    DisposableEffect(key1 = Unit) {
        onDispose { videoFrameBitmapExtractor.destroy() }
    }
 
    Scaffold(
        topBar = {
            TopAppBar(title = { Text(text = "VideoFrameBitmapExtractorScreen") })
        }
    ) { paddingValues ->
        Column(
            modifier = Modifier
                .padding(paddingValues)
                .fillMaxSize(),
            verticalArrangement = Arrangement.spacedBy(10.dp)
        ) {
 
            if (bitmap.value != null) {
                Image(
                    modifier = Modifier.fillMaxWidth(),
                    bitmap = bitmap.value!!,
                    contentDescription = null
                )
            }
 
            Text(text = "currentPositionMs = ${currentPositionMs.value}")
 
            Button(onClick = {
                videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly))
            }) { Text(text = "取り出す") }
 
            Button(onClick = {
                scope.launch {
                    currentPositionMs.value += 16
                    bitmap.value = videoFrameBitmapExtractor.getVideoFrameBitmap(currentPositionMs.value).asImageBitmap()
                }
            }) { Text(text = "16ms 進める") }
 
        }
    }
 
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        setContent {
            AndroidVideoFrameFastNextExtractorTheme {
                VideoFrameBitmapExtractorScreen()
            }
        }
    }
}

val totalTimeVideoFrameBitmapExtractor = remember { mutableStateOf(0L) }
val totalTimeMetadataRetriever = remember { mutableStateOf(0L) }
 
fun startVideoFrameBitmapExtractorBenchMark(uri: Uri?) {
    uri ?: return
    scope.launch(Dispatchers.Default) {
        totalTimeVideoFrameBitmapExtractor.value = 0
        totalTimeVideoFrameBitmapExtractor.value = measureTimeMillis {
            VideoFrameBitmapExtractor().apply {
                prepareDecoder(context, uri)
                getVideoFrameBitmap(1_000)
                getVideoFrameBitmap(1_100)
                getVideoFrameBitmap(1_200)
            }
        }
    }
}
 
fun startMediaMetadataRetrieverBenchMark(uri: Uri?) {
    uri ?: return
    scope.launch(Dispatchers.Default) {
        totalTimeMetadataRetriever.value = 0
        totalTimeMetadataRetriever.value = measureTimeMillis {
            MediaMetadataRetriever().apply {
                setDataSource(context, uri)
                getFrameAtTime(1_000_000, MediaMetadataRetriever.OPTION_CLOSEST)
                getFrameAtTime(1_100_000, MediaMetadataRetriever.OPTION_CLOSEST)
                getFrameAtTime(1_200_000, MediaMetadataRetriever.OPTION_CLOSEST)
            }
        }
    }
}

// 0 から 3 秒まで、33 ずつ増やした数字の配列（30fps = 33ms なので）
val BenchMarkFramePositionMsList = (0 until 3_000L step 33)
 
val totalTimeVideoFrameBitmapExtractor = remember { mutableStateOf(0L) }
val totalTimeMetadataRetriever = remember { mutableStateOf(0L) }
 
fun startVideoFrameBitmapExtractorBenchMark(uri: Uri?) {
    uri ?: return
    scope.launch(Dispatchers.Default) {
        totalTimeVideoFrameBitmapExtractor.value = 0
        totalTimeVideoFrameBitmapExtractor.value = measureTimeMillis {
            VideoFrameBitmapExtractor().apply {
                prepareDecoder(context, uri)
                BenchMarkFramePositionMsList.forEach { framePositionMs ->
                    println("framePositionMs = $framePositionMs")
                    getVideoFrameBitmap(framePositionMs)
                }
            }
        }
    }
}
 
fun startMediaMetadataRetrieverBenchMark(uri: Uri?) {
    uri ?: return
    scope.launch(Dispatchers.Default) {
        totalTimeMetadataRetriever.value = 0
        totalTimeMetadataRetriever.value = measureTimeMillis {
            MediaMetadataRetriever().apply {
                setDataSource(context, uri)
                BenchMarkFramePositionMsList.forEach { framePositionMs ->
                    println("framePositionMs = $framePositionMs")
                    getFrameAtTime(framePositionMs * 1000, MediaMetadataRetriever.OPTION_CLOSEST)
                }
            }
        }
    }
}

// Surface 経由で Bitmap が取れる ImageReader つくる
imageReader = ImageReader.newInstance(videoWidth, videoHeight, ImageFormat.YUV_420_888, 2)
// 映像デコーダー起動
// デコード結果を ImageReader に流す
decodeMediaCodec = MediaCodec.createDecoderByType(codecName).apply {
    configure(mediaFormat, imageReader!!.surface, null, 0)
}
decodeMediaCodec!!.start()

java_vm_ext.cc:591] JNI DETECTED ERROR IN APPLICATION: non-zero capacity for nullptr pointer: 1
java_vm_ext.cc:591]     in call to NewDirectByteBuffer
java_vm_ext.cc:591]     from android.media.ImageReader$SurfaceImage$SurfacePlane[] android.media.ImageReader$SurfaceImage.nativeCreatePlanes(int, int, long)
runtime.cc:691] Runtime aborting...
runtime.cc:691] Dumping all threads without mutator lock held
runtime.cc:691] All threads:
runtime.cc:691] DALVIK THREADS (26):
runtime.cc:691] "main" prio=10 tid=1 Native

// Surface 経由で Bitmap が取れる ImageReader つくる
imageReader = ImageReader.newInstance(videoWidth, videoHeight, ImageFormat.YUV_420_888, 2)
 
// 映像デコーダー起動
// デコード結果を ImageReader に流す
decodeMediaCodec = MediaCodec.createDecoderByType(codecName).apply {
    // Google Pixel 以外（Snapdragon 搭載機？）でおちるので
    mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible)
    configure(mediaFormat, imageReader!!.surface, null, 0)
}
decodeMediaCodec!!.start()

// しかし、一部の縦動画（画面録画）を入れるとどうしても乱れてしまう。
// Google Pixel の場合は、縦と横にを 16 で割り切れる数字にすることで修正できたが、Snapdragon は直らなかった。
// ・・・・
// Snapdragon がどうやっても直んないので、別の方法を取る。
// 色々いじってみた結果、Snapdragon も 320 / 480 / 720 / 1280 / 1920 / 2560 / 3840 とかのキリがいい数字は何故か動くので、もうこの値を縦と横に適用する。
// その後元あった Bitmap のサイズに戻す。もう何もわからない。なんだよこれ・・
val originWidth = videoWidth
val originHeight = videoHeight
val maxSize = maxOf(videoWidth, videoHeight)
val imageReaderSize = when {
    maxSize < 320 -> 320
    maxSize < 480 -> 480
    maxSize < 720 -> 720
    maxSize < 1280 -> 1280
    maxSize < 1920 -> 1920
    maxSize < 2560 -> 2560
    maxSize < 3840 -> 3840
    else -> 1920 // 何もなければ適当に Full HD
}
imageReader = ImageReader.newInstance(imageReaderSize, imageReaderSize, PixelFormat.RGBA_8888, 2)

val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
bitmap.copyPixelsFromBuffer(buffer)
// アスペクト比を戻す
val resultBitmap = bitmap.scale(originWidth, originHeight)

     companion object {
         /** MediaCodec タイムアウト */
-        private const val TIMEOUT_US = 10_000L
+        private const val TIMEOUT_US = 0L

-            // 次に進める。advance() が false の場合はもうデータがないので、break する。
-            val isEndOfFile = !mediaExtractor.advance()
-            if (isEndOfFile) {
-                break
+            // 次に進める。デコーダーにデータを入れた事を確認してから。
+            // advance() が false の場合はもうデータがないので、break する。
+            if (0 <= inputBufferIndex) {
+                val isEndOfFile = !mediaExtractor.advance()
+                if (isEndOfFile) {
+                    break
+                }
             }

                         val presentationTimeMs = bufferInfo.presentationTimeUs / 1000
                         if (seekToMs <= presentationTimeMs) {
                             isRunning = false
+                            isDecoderOutputAvailable = false
                             latestDecodePositionMs = presentationTimeMs
                         }
                     }