/**
 * HDR かどうか判定する
 *
 * @param context [Context]
 * @param uri フォトピッカー等で選んで
 * @return true で HDR（HLG / HDR10 / HDR10+）
 */
private fun isHdrVideo(context: Context, uri: Uri): Boolean {
    return MediaMetadataRetriever().use { mediaMetadataRetriever ->
        // Uri を MediaMetadataRetriever に渡す
        context.contentResolver.openFileDescriptor(uri, "r")?.use {
            mediaMetadataRetriever.setDataSource(it.fileDescriptor)
        }
        // 色空間、ガンマカーブを取得する
        val colorSpace = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_STANDARD)?.toInt()
        val colorTransfer = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_TRANSFER)?.toInt()
        // HDR なら色空間が BT.2020、ガンマカーブが HLG か PQ であるはず
        colorSpace == MediaFormat.COLOR_STANDARD_BT2020 && (colorTransfer == MediaFormat.COLOR_TRANSFER_HLG || colorTransfer == MediaFormat.COLOR_TRANSFER_ST2084)
    }
}
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun MainScreen() {
    val isHdr = remember { mutableStateOf(false) }
    val context = LocalContext.current
 
    val videoPicker = rememberLauncherForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
        uri ?: return@rememberLauncherForActivityResult
        isHdr.value = isHdrVideo(context, uri)
    }
 
    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text(text = "HDR 判定くん") }
            )
        }
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
            Button(onClick = { videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly)) }) {
                Text(text = "動画を選ぶ")
            }
            Text(text = if (isHdr.value) "HDR 動画です" else "HDR 動画ではありません")
        }
    }
}

/** SDR かどうか判定する */
private fun isSdrVideo(context: Context, uri: Uri): Boolean {
    return MediaMetadataRetriever().use { mediaMetadataRetriever ->
        // Uri を MediaMetadataRetriever に渡す
        context.contentResolver.openFileDescriptor(uri, "r")?.use {
            mediaMetadataRetriever.setDataSource(it.fileDescriptor)
        }
        // 色空間を取得する
        val colorSpace = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_STANDARD)?.toInt()
        // SDR なら BT.709 のはず
        colorSpace == MediaFormat.COLOR_STANDARD_BT709
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
 
        val cameraManager = getSystemService(Context.CAMERA_SERVICE) as CameraManager
        // バックカメラ
        val backCameraId = cameraManager.cameraIdList.first { cameraId ->
            cameraManager.getCameraCharacteristics(cameraId).get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_BACK
        }
        val characteristic = cameraManager.getCameraCharacteristics(backCameraId)
        val capabilities = characteristic[CameraCharacteristics.REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES]?.supportedProfiles ?: emptySet()
        val isHlg = DynamicRangeProfiles.HLG10 in capabilities
        val isHdr10 = DynamicRangeProfiles.HDR10 in capabilities
        val isHdr10plus = DynamicRangeProfiles.HDR10_PLUS in capabilities
        println("isHlg = $isHlg / isHdr10 = $isHdr10 / isHdr10plus = $isHdr10plus")
    }
}

isHlg = true / isHdr10 = false / isHdr10plus = false

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            val context = LocalContext.current
            val isPermissionGranted = remember {
                mutableStateOf(REQUIRED_PERMISSION.all { permission -> ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED })
            }
 
            AndroidCamera2HdrTheme {
                // 権限があればカメラ画面へ
                if (isPermissionGranted.value) {
                    MainScreen()
                } else {
                    PermissionScreen(onGranted = { isPermissionGranted.value = true })
                }
            }
        }
    }
}
 
/** 必要な権限 */
private val REQUIRED_PERMISSION = listOf(android.Manifest.permission.CAMERA, android.Manifest.permission.RECORD_AUDIO)
 
/** 権限ください画面 */
@Composable
private fun PermissionScreen(onGranted: () -> Unit) {
    val permissionRequest = rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { it ->
        if (it.all { it.value /* == true */ }) {
            onGranted()
        }
    }
 
    Scaffold {
        Column(Modifier.padding(it)) {
            Button(onClick = { permissionRequest.launch(REQUIRED_PERMISSION.toTypedArray()) }) {
                Text(text = "権限を付与してください")
            }
        }
    }
}
 
/** カメラ画面 */
@Composable
private fun MainScreen() {
    // このあとすぐ
}

@SuppressLint("MissingPermission")
class CameraController(private val context: Context) {
    // このあとすぐ
}

class CameraController(private val context: Context) {
    private val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
    private val cameraExecutor = Executors.newSingleThreadExecutor()
    private val scope = CoroutineScope(Dispatchers.Default + Job())
 
    private val _isRecording = MutableStateFlow(false)
    private var mediaRecorder: MediaRecorder? = null
    private var saveVideoFile: File? = null
 
    /** 今の処理キャンセル用 */
    private var currentJob: Job? = null
 
    /** Surface の生成を通知する Flow */
    private val _surfaceFlow = MutableStateFlow<Surface?>(null)
 
    /** カメラを開いて、状態を通知する Flow */
    private val backCameraDeviceFlow = callbackFlow {
        var _device: CameraDevice? = null
        // openCamera は複数回コールバック関数を呼び出すので flow にする必要がある
        cameraManager.openCamera(getBackCameraId(), cameraExecutor, object : StateCallback() {
            override fun onOpened(camera: CameraDevice) {
                _device = camera
                trySend(camera)
            }
 
            override fun onDisconnected(camera: CameraDevice) {
                // TODO エラー処理
                _device?.close()
                _device = null
                trySend(null)
            }
 
            override fun onError(camera: CameraDevice, error: Int) {
                // TODO エラー処理
                _device?.close()
                _device = null
                trySend(null)
            }
        })
        // キャンセル時
        awaitClose { _device?.close() }
    }.stateIn(
        scope = scope,
        started = SharingStarted.Eagerly,
        initialValue = null
    )
 
    /** 初回時、録画終了後に呼び出す */
    fun prepare() {
        scope.launch {
            currentJob?.cancelAndJoin()
 
            // MediaRecorder を作る
            initMediaRecorder()
 
            currentJob = launch {
                // SurfaceView の生存に合わせる
                // アプリ切り替えで SurfaceView は再生成されるので、常に監視する必要がある
                _surfaceFlow.collectLatest { previewSurface ->
                    previewSurface ?: return@collectLatest
 
                    // 外カメラが開かれるのを待つ
                    val cameraDevice = backCameraDeviceFlow.filterNotNull().first()
 
                    // カメラ出力先。プレビューと MediaRecorder
                    val outputSurfaceList = listOfNotNull(previewSurface, mediaRecorder?.surface)
 
                    // CaptureRequest をつくる
                    val captureRequest = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
                        // HDR はここじゃない
                        outputSurfaceList.forEach { surface -> addTarget(surface) }
                        // FPS とかズームとか設定するなら
                        // set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(VIDEO_FPS, VIDEO_FPS))
                    }
 
                    // CaptureSession をつくる
                    val captureSession = cameraDevice.awaitCameraSessionConfiguration(outputSurfaceList = outputSurfaceList) ?: return@collectLatest
 
                    // プレビュー開始
                    captureSession.setRepeatingRequest(captureRequest.build(), null, null)
                }
            }
        }
    }
 
    /** Surface の生成コールバックで呼び出す */
    fun createSurface(surface: Surface) {
        _surfaceFlow.value = surface
    }
 
    /** Surface の破棄コールバックで呼び出す */
    fun destroySurface() {
        _surfaceFlow.value = null
    }
 
    /** MediaRecorder と仮のファイルを作る */
    private fun initMediaRecorder() {
        // 一時的に getExternalFilesDir に保存する
        saveVideoFile = context.getExternalFilesDir(null)!!.resolve("${System.currentTimeMillis()}.mp4")
        mediaRecorder = MediaRecorder(context).apply {
            setAudioSource(MediaRecorder.AudioSource.MIC)
            setVideoSource(MediaRecorder.VideoSource.SURFACE)
            setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
            setVideoEncoder(MediaRecorder.VideoEncoder.HEVC) // 10 ビット HDR 動画の場合は HEVC にする
            setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
            setAudioChannels(2)
            setVideoEncodingBitRate(20_000_000)
            setVideoFrameRate(60)
            setVideoSize(VIDEO_WIDTH, VIDEO_HEIGHT)
            setAudioEncodingBitRate(192_000)
            setAudioSamplingRate(48_000)
            setOutputFile(saveVideoFile)
            prepare()
        }
    }
 
    /** CameraDevice#createCaptureSession をサスペンド関数にしたもの */
    private suspend fun CameraDevice.awaitCameraSessionConfiguration(outputSurfaceList: List<Surface>): CameraCaptureSession? = suspendCoroutine { continuation ->
        // OutputConfiguration を作る
        val outputConfigurationList = outputSurfaceList
            .map { surface -> OutputConfiguration(surface) }
            .onEach { outputConfig ->
                // 10 ビット HDR 動画撮影を有効にする
                // HDR 動画撮影に対応している場合、少なくとも HLG 形式の HDR に対応していることが保証されているので HLG
                if (isSupportedTenBitHdr()) {
                    outputConfig.dynamicRangeProfile = DynamicRangeProfiles.HLG10
                }
            }
        val sessionConfiguration = SessionConfiguration(SessionConfiguration.SESSION_REGULAR, outputConfigurationList, cameraExecutor, object : CameraCaptureSession.StateCallback() {
            override fun onConfigured(captureSession: CameraCaptureSession) {
                continuation.resume(captureSession)
            }
 
            override fun onConfigureFailed(p0: CameraCaptureSession) {
                // TODO エラー処理
                continuation.resume(null)
            }
        })
        createCaptureSession(sessionConfiguration)
    }
 
    /** 10 ビット HDR 動画撮影に対応している場合は true */
    private fun isSupportedTenBitHdr(): Boolean {
        val characteristic = cameraManager.getCameraCharacteristics(getBackCameraId())
        val capabilities = characteristic[CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES]
        return capabilities?.contains(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT) == true
    }
 
    /** バックカメラの ID を返す */
    private fun getBackCameraId(): String = cameraManager
        .cameraIdList
        .first { cameraId -> cameraManager.getCameraCharacteristics(cameraId).get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_BACK }
 
    companion object {
 
        // フル HD
        const val VIDEO_WIDTH = 1920
        const val VIDEO_HEIGHT = 1080
        const val VIDEO_FPS = 60
 
    }
}

val availableProfiles = characteristic[CameraCharacteristics.REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES]?.supportedProfiles
val isHdr10Support = availableProfiles?.contains(DynamicRangeProfiles.HDR10) == true

/** 録画中か */
val isRecording = _isRecording.asStateFlow()
 
/** 撮影開始 */
fun startRecord() {
    mediaRecorder?.start()
    _isRecording.value = true
}
 
/** 撮影終了 */
fun stopRecord() {
    scope.launch {
        // 処理を止める
        currentJob?.cancelAndJoin()
        // 録画停止
        mediaRecorder?.stop()
        mediaRecorder?.release()
        _isRecording.value = false
 
        // 動画データを動画フォルダへ移動
        val contentResolver = context.contentResolver
        val contentValues = contentValuesOf(
            MediaStore.Images.Media.DISPLAY_NAME to saveVideoFile!!.name,
            MediaStore.Images.Media.RELATIVE_PATH to "${Environment.DIRECTORY_MOVIES}/AndroidCamera2HdrVideo"
        )
        val uri = contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)!!
        saveVideoFile!!.inputStream().use { inputStream ->
            contentResolver.openOutputStream(uri)?.use { outputStream ->
                inputStream.copyTo(outputStream)
            }
        }
        saveVideoFile?.delete()
 
        // MediaRecorder は使い捨てなので、準備からやり直す
        prepare()
    }
}
 
/** 終了時に呼ぶ */
fun destroy() {
    scope.cancel()
    cameraExecutor.shutdown()
}

/** カメラ画面 */
@Composable
private fun MainScreen() {
    val context = LocalContext.current
    val cameraController = remember { CameraController(context) }
    val isRecording = cameraController.isRecording.collectAsState()
 
    DisposableEffect(key1 = Unit) {
        // プレビュー開始
        cameraController.prepare()
        // 使わなくなったら破棄
        onDispose { cameraController.destroy() }
    }
 
    // TODO 横画面しか対応できていない
    Box(modifier = Modifier.fillMaxSize()) {
        AndroidView(
            modifier = Modifier
                .align(Alignment.Center)
                .aspectRatio(CameraController.VIDEO_WIDTH / CameraController.VIDEO_HEIGHT.toFloat()),
            factory = {
                SurfaceView(context).apply {
                    holder.addCallback(object : SurfaceHolder.Callback {
                        override fun surfaceCreated(holder: SurfaceHolder) {
                            // 解像度を合わせておく
                            holder.setFixedSize(CameraController.VIDEO_WIDTH, CameraController.VIDEO_HEIGHT)
                            cameraController.createSurface(holder.surface)
                        }
 
                        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
                            // do nothing
                        }
 
                        override fun surfaceDestroyed(holder: SurfaceHolder) {
                            cameraController.destroySurface()
                        }
                    })
                }
            }
        )
 
        Box(
            modifier = Modifier
                .padding(bottom = 30.dp)
                .align(Alignment.BottomCenter)
                .clip(CircleShape)
                .size(80.dp)
                // 録画中は色を変える
                .background(if (isRecording.value) Color.Red else Color.Gray)
                .clickable { if (isRecording.value) cameraController.stopRecord() else cameraController.startRecord() }
        )
    }
}

/**
 * [OpenGlRenderer] で描画する際に OpenGL ES の設定が必要で、引数の Surface に対して、EGL 周りの設定をしてくれるやつ。
 * HDR 有効時は EGL 1.4 、GLES 3.0 でセットアップする。[OpenGlRenderer] は GL スレッドから呼び出すこと。
 *
 * @param outputSurface 出力先 [Surface]
 * @param isEnableTenBitHdr 10-bit HDR を利用する場合は true
 */
class InputSurface(
    private val outputSurface: Surface,
    private val isEnableTenBitHdr: Boolean
) {
    private var mEGLDisplay = EGL14.EGL_NO_DISPLAY
    private var mEGLContext = EGL14.EGL_NO_CONTEXT
    private var mEGLSurface = EGL14.EGL_NO_SURFACE
 
    init {
        // 10-bit HDR のためには HLG の表示が必要。
        // それには OpenGL ES 3.0 でセットアップし、10Bit に設定する必要がある。
        if (isEnableTenBitHdr) {
            eglSetupForTenBitHdr()
        } else {
            eglSetupForSdr()
        }
    }
 
    /** 10-bit HDR version. Prepares EGL. We want a GLES 3.0 context and a surface that supports recording. */
    private fun eglSetupForTenBitHdr() {
        mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
        if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
            throw RuntimeException("unable to get EGL14 display")
        }
        val version = IntArray(2)
        if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
            throw RuntimeException("unable to initialize EGL14")
        }
        // Configure EGL for recording and OpenGL ES 3.0.
        val attribList = intArrayOf(
            EGL14.EGL_RENDERABLE_TYPE, EGLExt.EGL_OPENGL_ES3_BIT_KHR,
            EGL14.EGL_RED_SIZE, 10,
            EGL14.EGL_GREEN_SIZE, 10,
            EGL14.EGL_BLUE_SIZE, 10,
            EGL14.EGL_ALPHA_SIZE, 2,
            EGL14.EGL_SURFACE_TYPE, (EGL14.EGL_WINDOW_BIT or EGL14.EGL_PBUFFER_BIT),
            // EGL_RECORDABLE_ANDROID, 1, // RGBA1010102 だと使えないし多分いらない
            EGL14.EGL_NONE
        )
        val configs = arrayOfNulls<EGLConfig>(1)
        val numConfigs = IntArray(1)
        EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.size, numConfigs, 0)
        checkEglError("eglCreateContext RGBA1010102 ES3")
 
        // Configure context for OpenGL ES 3.0.
        val attrib_list = intArrayOf(
            EGL14.EGL_CONTEXT_CLIENT_VERSION, 3,
            EGL14.EGL_NONE
        )
        mEGLContext = EGL14.eglCreateContext(
            mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT,
            attrib_list, 0
        )
        checkEglError("eglCreateContext")
 
        // Create a window surface, and attach it to the Surface we received.
        // EGL_GL_COLORSPACE_BT2020_HLG_EXT を使うことで OpenGL ES で HDR 表示が可能になる（HLG 形式）
        // TODO 10-bit HDR（BT2020 / HLG）に対応していない端末で有効にした場合にエラーになる。とりあえず対応していない場合は何もしない
        val surfaceAttribs = if (isAvailableExtension("EGL_EXT_gl_colorspace_bt2020_hlg")) {
            intArrayOf(
                EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_BT2020_HLG_EXT,
                EGL14.EGL_NONE
            )
        } else {
            intArrayOf(
                EGL14.EGL_NONE
            )
        }
        mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], outputSurface, surfaceAttribs, 0)
        checkEglError("eglCreateWindowSurface")
    }
 
    /** Prepares EGL. We want a GLES 3.0 context and a surface that supports recording. */
    private fun eglSetupForSdr() {
        mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
        if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
            throw RuntimeException("unable to get EGL14 display")
        }
        val version = IntArray(2)
        if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
            throw RuntimeException("unable to initialize EGL14")
        }
        // Configure EGL for recording and OpenGL ES 3.0.
        val attribList = intArrayOf(
            EGL14.EGL_RED_SIZE, 8,
            EGL14.EGL_GREEN_SIZE, 8,
            EGL14.EGL_BLUE_SIZE, 8,
            EGL14.EGL_ALPHA_SIZE, 8,
            EGL14.EGL_RENDERABLE_TYPE, EGLExt.EGL_OPENGL_ES3_BIT_KHR,
            EGL_RECORDABLE_ANDROID, 1,
            EGL14.EGL_NONE
        )
        val configs = arrayOfNulls<EGLConfig>(1)
        val numConfigs = IntArray(1)
        EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.size, numConfigs, 0)
        checkEglError("eglCreateContext RGB888 ES3")
 
        // Configure context for OpenGL ES 3.0.
        val attrib_list = intArrayOf(
            EGL14.EGL_CONTEXT_CLIENT_VERSION, 3,
            EGL14.EGL_NONE
        )
        mEGLContext = EGL14.eglCreateContext(
            mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT,
            attrib_list, 0
        )
        checkEglError("eglCreateContext")
 
        // Create a window surface, and attach it to the Surface we received.
        val surfaceAttribs = intArrayOf(
            EGL14.EGL_NONE
        )
        mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], outputSurface, surfaceAttribs, 0)
        checkEglError("eglCreateWindowSurface")
    }
 
    /** Discards all resources held by this class, notably the EGL context. */
    fun destroy() {
        if (mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
            EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT)
            EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface)
            EGL14.eglDestroyContext(mEGLDisplay, mEGLContext)
            EGL14.eglReleaseThread()
            EGL14.eglTerminate(mEGLDisplay)
        }
        mEGLDisplay = EGL14.EGL_NO_DISPLAY
        mEGLContext = EGL14.EGL_NO_CONTEXT
        mEGLSurface = EGL14.EGL_NO_SURFACE
    }
 
    /**
     * Makes our EGL context and surface current.
     */
    fun makeCurrent() {
        EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)
        checkEglError("eglMakeCurrent")
    }
 
    /**
     * Calls eglSwapBuffers.  Use this to "publish" the current frame.
     */
    fun swapBuffers(): Boolean {
        val result = EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface)
        checkEglError("eglSwapBuffers")
        return result
    }
 
    /**
     * Sends the presentation time stamp to EGL.  Time is expressed in nanoseconds.
     */
    fun setPresentationTime(nsecs: Long) {
        EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurface, nsecs)
        checkEglError("eglPresentationTimeANDROID")
    }
 
    /**
     * Checks for EGL errors.  Throws an exception if one is found.
     */
    private fun checkEglError(msg: String) {
        val error = EGL14.eglGetError()
        if (error != EGL14.EGL_SUCCESS) {
            throw RuntimeException("$msg: EGL error: 0x${Integer.toHexString(error)}")
        }
    }
 
    /**
     * OpenGL ES の拡張機能をサポートしているか。
     * 例えば 10-bit HDR を描画する機能は新し目の Android にしか無いため
     *
     * @param extensionName "EGL_EXT_gl_colorspace_bt2020_hlg" など
     * @return 拡張機能をサポートしている場合は true
     */
    private fun isAvailableExtension(extensionName: String): Boolean {
        val display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
        val eglExtensions = EGL14.eglQueryString(display, EGL10.EGL_EXTENSIONS)
        return eglExtensions != null && eglExtensions.contains(extensionName)
    }
 
    companion object {
        private const val EGL_RECORDABLE_ANDROID = 0x3142
 
        // HDR 表示に必要
        private const val EGL_GL_COLORSPACE_KHR = 0x309D
        private const val EGL_GL_COLORSPACE_BT2020_HLG_EXT = 0x3540
    }
}

/**
 * [SurfaceTexture]をラップしたもの、ちょっと使いにくいので
 *
 * @param initTexName [OpenGlRenderer.generateTextureId]
 */
class TextureRendererSurfaceTexture(private val initTexName: Int) {
 
    private val surfaceTexture = SurfaceTexture(initTexName)
    private val _isAvailableFrameFlow = MutableStateFlow(false)
 
    /** [SurfaceTexture.detachFromGLContext]したら false */
    private var isAttach = true
 
    /** [SurfaceTexture]へ映像を渡す[Surface] */
    val surface = Surface(surfaceTexture) // Surface に SurfaceTexture を渡すというよくわからない API 設計
 
    init {
        surfaceTexture.setOnFrameAvailableListener {
            // StateFlow はスレッドセーフが約束されているので
            _isAvailableFrameFlow.value = true
        }
    }
 
    /**
     * [SurfaceTexture.setDefaultBufferSize] を呼び出す
     * Camera2 API の解像度、SurfaceTexture の場合はここで決定する
     */
    fun setTextureSize(width: Int, height: Int) {
        surfaceTexture.setDefaultBufferSize(width, height)
    }
 
    /**
     * GL コンテキストを切り替え、テクスチャ ID の変更を行う。GL スレッドから呼び出すこと。
     * [OpenGlRenderer]を作り直しする場合など。
     *
     * @param texName テクスチャ
     */
    fun attachGl(texName: Int) {
        // 余計に呼び出さないようにする
        if (!isAttach) {
            surfaceTexture.attachToGLContext(texName)
            isAttach = true
        }
    }
 
    /**
     * GL コンテキストから切り離す。GL スレッドから呼び出すこと。
     * [OpenGlRenderer]を作り直しする場合など。
     */
    fun detachGl() {
        if (isAttach) {
            surfaceTexture.detachFromGLContext()
            isAttach = false
        }
    }
 
    /** テクスチャが更新されていれば、[SurfaceTexture.updateTexImage]を呼び出す */
    fun checkAndUpdateTexImage() {
        val isAvailable = _isAvailableFrameFlow.value
        if (isAvailable) {
            _isAvailableFrameFlow.value = false
            surfaceTexture.updateTexImage()
        }
    }
 
    /** [SurfaceTexture.getTransformMatrix]を呼ぶ */
    fun getTransformMatrix(mtx: FloatArray) {
        surfaceTexture.getTransformMatrix(mtx)
    }
 
    /**
     * 破棄する
     * GL スレッドから呼び出すこと（テクスチャを破棄したい）
     * TODO テクスチャを明示的に破棄すべきか
     */
    fun destroy() {
        val textures = intArrayOf(initTexName)
        GLES20.glDeleteTextures(1, textures, 0)
        surface.release()
        surfaceTexture.release()
    }
}

/**
 * [OpenGlRenderer]から実際の描画処理を持ってきたもの。OpenGL ES のセットアップは[InputSurface]でやる。
 * カメラ映像や動画デコーダーの映像を描画したり、Canvas で書いたものを OpenGL ES へ転写したりする。
 *
 * @param width 映像の幅
 * @param height 映像の高さ
 * @param isEnableTenBitHdr 10-bit HDR を利用する場合は true
 */
class TextureRenderer(
    private val width: Int,
    private val height: Int,
    private val isEnableTenBitHdr: Boolean
) {
 
    private val mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.size * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer()
    private val mMVPMatrix = FloatArray(16)
    private val mSTMatrix = FloatArray(16)
    private var mProgram = 0
    private var muMVPMatrixHandle = 0
    private var muSTMatrixHandle = 0
    private var maPositionHandle = 0
    private var maTextureHandle = 0
 
    // Uniform 変数のハンドル
    private var sSurfaceTextureHandle = 0
    private var sCanvasTextureHandle = 0
    private var iDrawModeHandle = 0
 
    // テクスチャ ID
    private var surfaceTextureTextureId = 0
    private var canvasTextureTextureId = 0
 
    // Canvas 描画のため Bitmap
    private val canvasBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
    private val canvas = Canvas(canvasBitmap)
 
    init {
        mTriangleVertices.put(mTriangleVerticesData).position(0)
    }
 
    /**
     * Canvas に書く。
     * GL スレッドから呼び出すこと。
     */
    fun drawCanvas(draw: Canvas.() -> Unit) {
        // 前回のを消す
        canvas.drawColor(0, PorterDuff.Mode.CLEAR)
        // 書く
        draw(canvas)
 
        // 多分いる
        GLES20.glActiveTexture(GLES20.GL_TEXTURE1)
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, canvasTextureTextureId)
 
        // テクスチャを転送
        // texImage2D、引数違いがいるので注意
        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, canvasBitmap, 0)
        checkGlError("GLUtils.texImage2D")
 
        // glError 1282 の原因とかになる
        GLES20.glUseProgram(mProgram)
        checkGlError("glUseProgram")
 
        // テクスチャの ID をわたす
        GLES20.glUniform1i(sSurfaceTextureHandle, 0) // GLES20.GL_TEXTURE0
        GLES20.glUniform1i(sCanvasTextureHandle, 1) // GLES20.GL_TEXTURE1
        // モード切替
        GLES20.glUniform1i(iDrawModeHandle, FRAGMENT_SHADER_DRAW_MODE_CANVAS_BITMAP)
        checkGlError("glUniform1i sSurfaceTextureHandle sCanvasTextureHandle iDrawModeHandle")
 
        // そのほかの値を渡す
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET)
        GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maPosition")
        GLES20.glEnableVertexAttribArray(maPositionHandle)
        checkGlError("glEnableVertexAttribArray maPositionHandle")
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET)
        GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maTextureHandle")
        GLES20.glEnableVertexAttribArray(maTextureHandle)
        checkGlError("glEnableVertexAttribArray maTextureHandle")
 
        // 行列を戻す
        Matrix.setIdentityM(mSTMatrix, 0)
        Matrix.setIdentityM(mMVPMatrix, 0)
 
        // 描画する
        GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0)
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0)
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
        checkGlError("glDrawArrays")
        GLES20.glFinish()
    }
 
    /**
     * SurfaceTexture を描画する。
     * GL スレッドから呼び出すこと。
     *
     * @param surfaceTexture 描画する[SurfaceTexture]
     * @param onTransform 位置や回転を適用するための行列を作るための関数
     */
    fun drawSurfaceTexture(
        surfaceTexture: TextureRendererSurfaceTexture,
        onTransform: ((mvpMatrix: FloatArray) -> Unit)? = null
    ) {
        // attachGlContext の前に呼ぶ必要あり。多分
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, surfaceTextureTextureId)
 
        // 映像を OpenGL ES で使う準備
        surfaceTexture.detachGl()
        surfaceTexture.attachGl(surfaceTextureTextureId)
        // 映像が来ていればテクスチャ更新
        surfaceTexture.checkAndUpdateTexImage()
        surfaceTexture.getTransformMatrix(mSTMatrix)
 
        // glError 1282 の原因とかになる
        GLES20.glUseProgram(mProgram)
        checkGlError("glUseProgram")
 
        // テクスチャの ID をわたす
        GLES20.glUniform1i(sSurfaceTextureHandle, 0) // GLES20.GL_TEXTURE0
        GLES20.glUniform1i(sCanvasTextureHandle, 1) // GLES20.GL_TEXTURE1
        // モード切替
        GLES20.glUniform1i(iDrawModeHandle, FRAGMENT_SHADER_DRAW_MODE_SURFACE_TEXTURE)
        checkGlError("glUniform1i sSurfaceTextureHandle sCanvasTextureHandle iDrawModeHandle")
 
        // そのほかの値を渡す
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET)
        GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maPosition")
        GLES20.glEnableVertexAttribArray(maPositionHandle)
        checkGlError("glEnableVertexAttribArray maPositionHandle")
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET)
        GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maTextureHandle")
        GLES20.glEnableVertexAttribArray(maTextureHandle)
        checkGlError("glEnableVertexAttribArray maTextureHandle")
 
        // 行列を適用したい場合
        Matrix.setIdentityM(mMVPMatrix, 0)
        if (onTransform != null) {
            onTransform(mMVPMatrix)
        }
 
        // 描画する
        GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0)
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0)
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
        checkGlError("glDrawArrays")
        GLES20.glFinish()
    }
 
    /**
     * バーテックスシェーダ、フラグメントシェーダーをコンパイルする。
     * GL スレッドから呼び出すこと。
     */
    fun prepareShader() {
        mProgram = createProgram(
            vertexSource = VERTEX_SHADER,
            // TODO HLG だろうと samplerExternalOES から HDR のフレームが取れてそう
            fragmentSource = if (isEnableTenBitHdr) FRAGMENT_SHADER_10BIT_HDR else FRAGMENT_SHADER
        )
        if (mProgram == 0) {
            throw RuntimeException("failed creating program")
        }
        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition")
        checkGlError("glGetAttribLocation aPosition")
        if (maPositionHandle == -1) {
            throw RuntimeException("Could not get attrib location for aPosition")
        }
        maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord")
        checkGlError("glGetAttribLocation aTextureCoord")
        if (maTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for aTextureCoord")
        }
        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix")
        checkGlError("glGetUniformLocation uMVPMatrix")
        if (muMVPMatrixHandle == -1) {
            throw RuntimeException("Could not get attrib location for uMVPMatrix")
        }
        muSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix")
        checkGlError("glGetUniformLocation uSTMatrix")
        if (muSTMatrixHandle == -1) {
            throw RuntimeException("Could not get attrib location for uSTMatrix")
        }
        sSurfaceTextureHandle = GLES20.glGetUniformLocation(mProgram, "sSurfaceTexture")
        checkGlError("glGetUniformLocation sSurfaceTexture")
        if (sSurfaceTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for sSurfaceTexture")
        }
        sCanvasTextureHandle = GLES20.glGetUniformLocation(mProgram, "sCanvasTexture")
        checkGlError("glGetUniformLocation sCanvasTexture")
        if (sCanvasTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for sCanvasTexture")
        }
        iDrawModeHandle = GLES20.glGetUniformLocation(mProgram, "iDrawMode")
        checkGlError("glGetUniformLocation iDrawMode")
        if (iDrawModeHandle == -1) {
            throw RuntimeException("Could not get attrib location for iDrawMode")
        }
 
        // テクスチャ ID を払い出してもらう
        // SurfaceTexture / Canvas Bitmap 用
        val textures = IntArray(2)
        GLES20.glGenTextures(2, textures, 0)
 
        surfaceTextureTextureId = textures[0]
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, surfaceTextureTextureId)
        checkGlError("glBindTexture cameraTextureId")
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST.toFloat())
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR.toFloat())
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
        checkGlError("glTexParameter")
 
        canvasTextureTextureId = textures[1]
        GLES20.glActiveTexture(GLES20.GL_TEXTURE1)
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, canvasTextureTextureId)
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST.toFloat())
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR.toFloat())
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
        checkGlError("glTexParameter")
 
        // アルファブレンディング
        // Canvas で書いた際に、透明な部分は透明になるように
        GLES20.glEnable(GLES20.GL_BLEND)
        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA)
        checkGlError("glEnable GLES20.GL_BLEND")
    }
 
    /** テクスチャ ID を払い出す。[SurfaceTexture]を作成するのに必要なので。 */
    fun generateTextureId(): Int {
        val textures = IntArray(1)
        GLES20.glGenTextures(1, textures, 0)
        return textures.first()
    }
 
    /**
     * 描画前に呼び出す。
     * GL スレッドから呼び出すこと。
     */
    fun prepareDraw() {
        // クリア？多分必要
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT or GLES20.GL_COLOR_BUFFER_BIT)
 
        // drawCanvas / drawSurfaceTexture どっちも呼び出さない場合 glUseProgram 誰もしないので
        GLES20.glUseProgram(mProgram)
        checkGlError("glUseProgram")
    }
 
    private fun checkGlError(op: String) {
        val error = GLES20.glGetError()
        if (error != GLES20.GL_NO_ERROR) {
            throw RuntimeException("$op: glError $error")
        }
    }
 
    /**
     * GLSL（フラグメントシェーダー・バーテックスシェーダー）をコンパイルして、OpenGL ES とリンクする
     *
     * @throws RuntimeException 構文エラーの場合に投げる
     * @throws RuntimeException それ以外
     * @return 0 以外で成功
     */
    private fun createProgram(vertexSource: String, fragmentSource: String): Int {
        val vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource)
        if (vertexShader == 0) {
            return 0
        }
        val pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource)
        if (pixelShader == 0) {
            return 0
        }
        var program = GLES20.glCreateProgram()
        checkGlError("glCreateProgram")
        if (program == 0) {
            return 0
        }
        GLES20.glAttachShader(program, vertexShader)
        checkGlError("glAttachShader")
        GLES20.glAttachShader(program, pixelShader)
        checkGlError("glAttachShader")
        GLES20.glLinkProgram(program)
        val linkStatus = IntArray(1)
        GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0)
        if (linkStatus[0] != GLES20.GL_TRUE) {
            GLES20.glDeleteProgram(program)
            program = 0
        }
        return program
    }
 
    /**
     * GLSL（フラグメントシェーダー・バーテックスシェーダー）のコンパイルをする
     *
     * @throws RuntimeException 構文エラーの場合に投げる
     * @throws RuntimeException それ以外
     * @return 0 以外で成功
     */
    private fun loadShader(shaderType: Int, source: String): Int {
        val shader = GLES20.glCreateShader(shaderType)
        checkGlError("glCreateShader type=$shaderType")
        GLES20.glShaderSource(shader, source)
        GLES20.glCompileShader(shader)
        val compiled = IntArray(1)
        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0)
        if (compiled[0] == 0) {
            // 失敗したら例外を投げる。その際に構文エラーのメッセージを取得する
            val syntaxErrorMessage = GLES20.glGetShaderInfoLog(shader)
            GLES20.glDeleteShader(shader)
            throw RuntimeException(syntaxErrorMessage)
            // ここで return 0 しても例外を投げるので意味がない
            // shader = 0
        }
        return shader
    }
 
    companion object {
        private const val FLOAT_SIZE_BYTES = 4
        private const val TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES
        private const val TRIANGLE_VERTICES_DATA_POS_OFFSET = 0
        private const val TRIANGLE_VERTICES_DATA_UV_OFFSET = 3
 
        private val mTriangleVerticesData = floatArrayOf(
            -1.0f, -1.0f, 0f, 0f, 0f,
            1.0f, -1.0f, 0f, 1f, 0f,
            -1.0f, 1.0f, 0f, 0f, 1f,
            1.0f, 1.0f, 0f, 1f, 1f
        )
 
        private const val VERTEX_SHADER = """#version 300 es
in vec4 aPosition;
in vec4 aTextureCoord;
 
uniform mat4 uMVPMatrix;
uniform mat4 uSTMatrix;
 
out vec2 vTextureCoord;
 
void main() {
  gl_Position = uMVPMatrix * aPosition;
  vTextureCoord = (uSTMatrix * aTextureCoord).xy;
}
"""
 
        // iDrawMode に渡す定数
        private const val FRAGMENT_SHADER_DRAW_MODE_SURFACE_TEXTURE = 1
        private const val FRAGMENT_SHADER_DRAW_MODE_CANVAS_BITMAP = 2
 
        /** 10-bit HDR の時に使うフラグメントシェーダー */
        private const val FRAGMENT_SHADER_10BIT_HDR = """#version 300 es
#extension GL_EXT_YUV_target : require
precision mediump float;
 
in vec2 vTextureCoord;
uniform sampler2D sCanvasTexture;
uniform __samplerExternal2DY2YEXT sSurfaceTexture;
 
// 何を描画するか
// 1 SurfaceTexture（カメラや動画のデコード映像）
// 2 Bitmap（テキストや画像を描画した Canvas）
uniform int iDrawMode;
 
// 出力色
out vec4 FragColor;
 
// https://github.com/android/camera-samples/blob/a07d5f1667b1c022dac2538d1f553df20016d89c/Camera2Video/app/src/main/java/com/example/android/camera2/video/HardwarePipeline.kt#L107
vec3 yuvToRgb(vec3 yuv) {
  const vec3 yuvOffset = vec3(0.0625, 0.5, 0.5);
  const mat3 yuvToRgbColorTransform = mat3(
    1.1689f, 1.1689f, 1.1689f,
    0.0000f, -0.1881f, 2.1502f,
    1.6853f, -0.6530f, 0.0000f
  );
  return clamp(yuvToRgbColorTransform * (yuv - yuvOffset), 0.0, 1.0);
}
 
void main() {   
  vec4 outColor = vec4(0.0, 0.0, 0.0, 1.0);
 
  if (iDrawMode == 1) {
    outColor.rgb = yuvToRgb(texture(sSurfaceTexture, vTextureCoord).rgb);
  } else if (iDrawMode == 2) {
    // テクスチャ座標なので Y を反転
    outColor = texture(sCanvasTexture, vec2(vTextureCoord.x, 1.0 - vTextureCoord.y));
  }
 
  FragColor = outColor;
}
"""
 
        /** SDR のときに使うフラグメントシェーダー */
        private const val FRAGMENT_SHADER = """#version 300 es
#extension GL_OES_EGL_image_external_essl3 : require
precision mediump float;
 
in vec2 vTextureCoord;
uniform sampler2D sCanvasTexture;
uniform samplerExternalOES sSurfaceTexture;
 
// 何を描画するか
// 1 SurfaceTexture（カメラや動画のデコード映像）
// 2 Bitmap（テキストや画像を描画した Canvas）
uniform int iDrawMode;
 
// 出力色
out vec4 FragColor;
 
void main() {   
  vec4 outColor = vec4(0.0, 0.0, 0.0, 1.0);
 
  if (iDrawMode == 1) {
    outColor = texture(sSurfaceTexture, vTextureCoord);
  } else if (iDrawMode == 2) {
    // テクスチャ座標なので Y を反転
    outColor = texture(sCanvasTexture, vec2(vTextureCoord.x, 1.0 - vTextureCoord.y));
  }
 
  FragColor = outColor;
}
"""
    }
}

#version 300 es
#extension GL_EXT_YUV_target : require
precision mediump float;
 
in vec2 vTextureCoord;
uniform sampler2D sCanvasTexture;
uniform __samplerExternal2DY2YEXT sSurfaceTexture;
 
// 何を描画するか
// 1 SurfaceTexture（カメラや動画のデコード映像）
// 2 Bitmap（テキストや画像を描画した Canvas）
uniform int iDrawMode;
 
// 出力色
out vec4 FragColor;
 
// https://github.com/android/camera-samples/blob/a07d5f1667b1c022dac2538d1f553df20016d89c/Camera2Video/app/src/main/java/com/example/android/camera2/video/HardwarePipeline.kt#L107
vec3 yuvToRgb(vec3 yuv) {
  const vec3 yuvOffset = vec3(0.0625, 0.5, 0.5);
  const mat3 yuvToRgbColorTransform = mat3(
    1.1689f, 1.1689f, 1.1689f,
    0.0000f, -0.1881f, 2.1502f,
    1.6853f, -0.6530f, 0.0000f
  );
  return clamp(yuvToRgbColorTransform * (yuv - yuvOffset), 0.0, 1.0);
}
 
void main() {   
  vec4 outColor = vec4(0.0, 0.0, 0.0, 1.0);
 
  if (iDrawMode == 1) {
    outColor.rgb = yuvToRgb(texture(sSurfaceTexture, vTextureCoord).rgb);
  } else if (iDrawMode == 2) {
    // テクスチャ座標なので Y を反転
    outColor = texture(sCanvasTexture, vec2(vTextureCoord.x, 1.0 - vTextureCoord.y));
  }
 
  FragColor = outColor;
}

/**
 * OpenGL ES を利用して[TextureRendererSurfaceTexture]や Canvas の中身を描画するクラス。
 * カメラ映像に Canvas で書いた文字を重ねたり出来ます。
 *
 * @param outputSurface 描画した内容の出力先 Surface。SurfaceView、MediaRecorder、MediaCodec など
 * @param width 幅
 * @param height 高さ
 * @param isEnableTenBitHdr 10-bit HDR を有効にする場合は true
 */
class OpenGlRenderer(
    outputSurface: Surface,
    width: Int,
    height: Int,
    isEnableTenBitHdr: Boolean
) {
 
    /** OpenGL 描画用スレッドの Kotlin Coroutine Dispatcher */
    @OptIn(ExperimentalCoroutinesApi::class, DelicateCoroutinesApi::class)
    private val openGlRelatedThreadDispatcher = newSingleThreadContext("openGlRelatedThreadDispatcher")
 
    private val inputSurface = InputSurface(outputSurface, isEnableTenBitHdr)
    private val textureRenderer = TextureRenderer(width, height, isEnableTenBitHdr)
 
    /** OpenGL ES の用意をし、フラグメントシェーダー等をコンパイルする */
    suspend fun prepare() {
        withContext(openGlRelatedThreadDispatcher) {
            inputSurface.makeCurrent()
            textureRenderer.prepareShader()
        }
    }
 
    /** テクスチャ ID を払い出す。SurfaceTexture 作成に使うので */
    suspend fun generateTextureId(): Int {
        return withContext(openGlRelatedThreadDispatcher) {
            textureRenderer.generateTextureId()
        }
    }
 
    /** 描画する */
    suspend fun drawLoop(drawTexture: suspend TextureRenderer.() -> DrawContinuesData) {
        withContext(openGlRelatedThreadDispatcher) {
            while (true) {
                yield()
 
                // 描画する
                textureRenderer.prepareDraw()
                val continuesData = drawTexture(textureRenderer)
 
                // presentationTime が多分必要。swapBuffers して Surface に流す
                inputSurface.setPresentationTime(continuesData.currentTimeNanoSeconds)
                inputSurface.swapBuffers()
 
                // 続行するか
                if (!continuesData.isAvailableNext) break
            }
        }
    }
 
    /** 破棄する */
    suspend fun destroy() {
        // try-finally で呼び出されるため NonCancellable 必須
        withContext(openGlRelatedThreadDispatcher + NonCancellable) {
            inputSurface.destroy()
        }
        openGlRelatedThreadDispatcher.close()
    }
 
    /**
     * 描画を続行するかのデータ
     *
     * @param isAvailableNext 次も描画できる場合は true
     * @param currentTimeNanoSeconds プレビューのときは使われてない（？）、MediaRecorder の場合は[System.nanoTime]、MediaCodec の場合は今のフレームの時間を入れてください。
     */
    data class DrawContinuesData(
        var isAvailableNext: Boolean,
        var currentTimeNanoSeconds: Long = System.nanoTime()
    )
}

/** 初回時、録画終了後に呼び出す */
fun prepare() {
    scope.launch {
        currentJob?.cancelAndJoin()
 
        // MediaRecorder を作る
        initMediaRecorder()
        // MediaRecorder 用 OpenGlRenderer と SurfaceTexture を作る
        val (recordOpenGlRenderer, recordSurfaceTexture) = createOpenGlRendererAndSurfaceTexture(mediaRecorder!!.surface)
 
        currentJob = launch {
            // SurfaceView の生存に合わせる
            // アプリ切り替えで SurfaceView は再生成されるので、常に監視する必要がある
            _surfaceFlow.collectLatest { previewSurface ->
                previewSurface ?: return@collectLatest
 
                // プレビュー 用 OpenGlRenderer と SurfaceTexture を作る
                val (previewOpenGlRenderer, previewSurfaceTexture) = createOpenGlRendererAndSurfaceTexture(previewSurface)
 
                // 外カメラが開かれるのを待つ
                val cameraDevice = backCameraDeviceFlow.filterNotNull().first()
 
                // カメラ出力先。それぞれの SurfaceTexture
                val outputSurfaceList = listOfNotNull(previewSurfaceTexture.surface, recordSurfaceTexture.surface)
 
                // CaptureRequest をつくる
                val captureRequest = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
                    // HDR はここじゃない
                    outputSurfaceList.forEach { surface -> addTarget(surface) }
                    // FPS とかズームとか設定するなら
                    set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(VIDEO_FPS, VIDEO_FPS))
                }
 
                // CaptureSession をつくる
                val captureSession = cameraDevice.awaitCameraSessionConfiguration(outputSurfaceList = outputSurfaceList) ?: return@collectLatest
 
                // カメラ映像を流し始める
                captureSession.setRepeatingRequest(captureRequest.build(), null, null)
 
                coroutineScope {
                    // プレビューを描画する
                    launch {
                        try {
                            // メインループ
                            val drawContinuesData = OpenGlRenderer.DrawContinuesData(true, 0)
                            previewOpenGlRenderer.drawLoop {
                                drawFrame(previewSurfaceTexture)
                                drawContinuesData
                            }
                        } finally {
                            // コルーチンキャンセル時
                            previewSurfaceTexture.destroy()
                            previewOpenGlRenderer.destroy()
                        }
                    }
                    // MediaRecorder のを描画する
                    launch {
                        try {
                            // メインループ
                            val drawContinuesData = OpenGlRenderer.DrawContinuesData(true, 0)
                            recordOpenGlRenderer.drawLoop {
                                drawFrame(recordSurfaceTexture)
                                // MediaRecorder は setPresentationTime の指定が必要（そう）
                                drawContinuesData.currentTimeNanoSeconds = System.nanoTime()
                                drawContinuesData
                            }
                        } finally {
                            // コルーチンキャンセル時
                            recordSurfaceTexture.destroy()
                            recordOpenGlRenderer.destroy()
                        }
                    }
                }
            }
        }
    }
}
 
private val textPaint = Paint().apply {
    color = Color.WHITE
    textSize = 50f
    isAntiAlias = true
}
 
/** プレビューと録画の描画を共通化するための関数 */
private fun TextureRenderer.drawFrame(surfaceTexture: TextureRendererSurfaceTexture) {
    drawSurfaceTexture(surfaceTexture) { mvpMatrix ->
        // 回転する
        // TODO 常に横画面で使う想定のため、条件分岐がありません。縦持ちでも使いたい場合は if (isLandscape) { } をやってください
        Matrix.rotateM(mvpMatrix, 0, 90f, 0f, 0f, 1f)
    }
    drawCanvas {
        drawText("撮影:${Build.MODEL} コーデック:HEVC ダイナミックレンジ:HDR(BT.2020, HLG)", 100f, 1000f, textPaint)
    }
}
 
/** [OpenGlRenderer]と[TextureRendererSurfaceTexture]を作る */
@SuppressLint("Recycle")
private suspend fun createOpenGlRendererAndSurfaceTexture(surface: Surface): Pair<OpenGlRenderer, TextureRendererSurfaceTexture> {
    // OpenGL ES で描画する OpenGlRenderer を作る
    val openGlRenderer = OpenGlRenderer(surface, VIDEO_WIDTH, VIDEO_HEIGHT, isSupportedTenBitHdr())
    openGlRenderer.prepare()
    // カメラ映像を OpenGL ES へ渡す SurfaceTexture を作る
    val surfaceTexture = TextureRendererSurfaceTexture(openGlRenderer.generateTextureId())
    // カメラ映像の解像度を設定
    surfaceTexture.setTextureSize(VIDEO_WIDTH, VIDEO_HEIGHT)
    return openGlRenderer to surfaceTexture
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    enableEdgeToEdge()
 
 
    println("HEVC = ${getSupportedHdrEncodingByHevc()}")
    println("VP9 = ${getSupportedHdrEncodingByVp9()}")
    println("AV1 = ${getSupportedHdrEncodingByAv1()}")
}
 
/** HEVC エンコーダーが対応している HDR の種類を返す */
private fun getSupportedHdrEncodingByHevc(): SupportHdrEncoding {
    val hevcEncoderList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
        .codecInfos
        .filter { !it.isAlias }
        .filter { it.isEncoder && MediaFormat.MIMETYPE_VIDEO_HEVC in it.supportedTypes }
    // ハードウェアエンコーダーで、ない場合はソフトウェア
    val hevcEncoder = hevcEncoderList.firstOrNull { it.isHardwareAccelerated } ?: hevcEncoderList.first()
    // 対応しているか見る
    val profileList = hevcEncoder.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_HEVC).profileLevels.map { it.profile }
    return SupportHdrEncoding(
        hlg = MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10 in profileList,
        hdr10 = MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10 in profileList,
        hdr10plus = MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10Plus in profileList
    )
}
 
/** AV1 エンコーダーが対応している HDR の種類を返す */
private fun getSupportedHdrEncodingByAv1(): SupportHdrEncoding {
    val hevcEncoderList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
        .codecInfos
        .filter { !it.isAlias }
        .filter { it.isEncoder && MediaFormat.MIMETYPE_VIDEO_AV1 in it.supportedTypes }
    // ハードウェアエンコーダーで、ない場合はソフトウェア
    val hevcEncoder = hevcEncoderList.firstOrNull { it.isHardwareAccelerated } ?: hevcEncoderList.first()
    // 対応しているか見る
    val profileList = hevcEncoder.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_AV1).profileLevels.map { it.profile }
    return SupportHdrEncoding(
        hlg = MediaCodecInfo.CodecProfileLevel.AV1ProfileMain10 in profileList,
        hdr10 = MediaCodecInfo.CodecProfileLevel.AV1ProfileMain10HDR10 in profileList,
        hdr10plus = MediaCodecInfo.CodecProfileLevel.AV1ProfileMain10HDR10Plus in profileList
    )
}
 
/** VP9 エンコーダーが対応している HDR の種類を返す */
private fun getSupportedHdrEncodingByVp9(): SupportHdrEncoding {
    val hevcEncoderList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
        .codecInfos
        .filter { !it.isAlias }
        .filter { it.isEncoder && MediaFormat.MIMETYPE_VIDEO_VP9 in it.supportedTypes }
    // ハードウェアエンコーダーで、ない場合はソフトウェア
    val hevcEncoder = hevcEncoderList.firstOrNull { it.isHardwareAccelerated } ?: hevcEncoderList.first()
    // 対応しているか見る
    val profileList = hevcEncoder.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_VP9).profileLevels.map { it.profile }
    // HLG / PQ 兼用らしい
    val isHlgOrPqAvailable = MediaCodecInfo.CodecProfileLevel.VP9Profile2HDR in profileList || MediaCodecInfo.CodecProfileLevel.VP9Profile3HDR in profileList
    val isHdr10plus = MediaCodecInfo.CodecProfileLevel.VP9Profile2HDR10Plus in profileList || MediaCodecInfo.CodecProfileLevel.VP9Profile3HDR10Plus in profileList
    return SupportHdrEncoding(
        hlg = isHlgOrPqAvailable,
        hdr10 = isHlgOrPqAvailable,
        hdr10plus = isHdr10plus
    )
}
 
data class SupportHdrEncoding(
    val hlg: Boolean,
    val hdr10: Boolean,
    val hdr10plus: Boolean
)

HEVC = SupportHdrEncoding(hlg=true, hdr10=true, hdr10plus=true)
VP9 = SupportHdrEncoding(hlg=true, hdr10=true, hdr10plus=true)
AV1 = SupportHdrEncoding(hlg=true, hdr10=true, hdr10plus=true)

HEVC = SupportHdrEncoding(hlg=true, hdr10=true, hdr10plus=true)
VP9 = SupportHdrEncoding(hlg=false, hdr10=false, hdr10plus=false)
AV1 = SupportHdrEncoding(hlg=true, hdr10=false, hdr10plus=false)

/** MediaCodec を使って動画をデコードする */
class VideoDecoder {
 
    private var decodeMediaCodec: MediaCodec? = null
    private var mediaExtractor: MediaExtractor? = null
 
    /**
     * デコードの準備をする
     *
     * @param context [Context]
     * @param uri PhotoPicker 等で選んだやつ
     * @param outputSurface デコードした映像の出力先
     */
    fun prepare(context: Context, uri: Uri, outputSurface: Surface) {
        val mediaExtractor = MediaExtractor().apply {
            context.contentResolver.openFileDescriptor(uri, "r")?.use {
                setDataSource(it.fileDescriptor)
            }
        }
        this.mediaExtractor = mediaExtractor
 
        // 動画トラックを探す
        val (trackIndex, mediaFormat) = (0 until mediaExtractor.trackCount)
            .map { mediaExtractor.getTrackFormat(it) }
            .withIndex()
            .first { it.value.getString(MediaFormat.KEY_MIME)?.startsWith("video/") == true }
        mediaExtractor.selectTrack(trackIndex)
 
        // MediaCodec を作る
        val codecName = mediaFormat.getString(MediaFormat.KEY_MIME)!!
        decodeMediaCodec = MediaCodec.createDecoderByType(codecName).apply {
            configure(mediaFormat, outputSurface, null, 0)
        }
        decodeMediaCodec?.start()
    }
 
    /** 破棄する */
    fun destroy() {
        decodeMediaCodec?.stop()
        decodeMediaCodec?.release()
        mediaExtractor?.release()
    }
 
    /**
     * 次の時間のフレームを取得する
     *
     * @param seekToMs 欲しいフレームの時間
     * @return 次のフレームがない場合は null。そうじゃない場合は動画フレームの時間
     */
    suspend fun seekNextFrame(seekToMs: Long): Long? {
        val decodeMediaCodec = decodeMediaCodec!!
        val mediaExtractor = mediaExtractor!!
 
        // advance() で false を返したことがある場合、もうデータがない。getSampleTime も -1 になる。
        if (mediaExtractor.sampleTime == -1L) {
            return null
        }
 
        var isRunning = true
        val bufferInfo = MediaCodec.BufferInfo()
        var returnValue: Long? = null
        while (isRunning) {
 
            // キャンセル時
            yield()
 
            // コンテナフォーマットからサンプルを取り出し、デコーダーに渡す
            // シークしないことで、連続してフレームを取得する場合にキーフレームまで戻る必要がなくなり、早くなる
            val inputBufferIndex = decodeMediaCodec.dequeueInputBuffer(TIMEOUT_US)
            if (0 <= inputBufferIndex) {
                // デコーダーへ流す
                val inputBuffer = decodeMediaCodec.getInputBuffer(inputBufferIndex)!!
                val size = mediaExtractor.readSampleData(inputBuffer, 0)
                decodeMediaCodec.queueInputBuffer(inputBufferIndex, 0, size, mediaExtractor.sampleTime, 0)
            }
 
            // デコーダーから映像を受け取る部分
            var isDecoderOutputAvailable = true
            while (isDecoderOutputAvailable) {
 
                // キャンセル時
                yield()
 
                // デコード結果が来ているか
                val outputBufferIndex = decodeMediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US)
                when {
                    outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER -> {
                        // リトライが必要
                        isDecoderOutputAvailable = false
                    }
 
                    0 <= outputBufferIndex -> {
                        // ImageReader ( Surface ) に描画する
                        val doRender = bufferInfo.size != 0
                        decodeMediaCodec.releaseOutputBuffer(outputBufferIndex, doRender)
                        if (doRender) {
                            // 欲しいフレームの時間に到達した場合、ループを抜ける
                            val presentationTimeMs = bufferInfo.presentationTimeUs / 1000
                            if (seekToMs <= presentationTimeMs) {
                                isRunning = false
                                isDecoderOutputAvailable = false
                                returnValue = presentationTimeMs
                            }
                        }
                    }
                }
            }
 
            // 次に進める。デコーダーにデータを入れた事を確認してから。
            // advance() が false の場合はもうデータがないので、break
            if (0 <= inputBufferIndex) {
                val isEndOfFile = !mediaExtractor.advance()
                if (isEndOfFile) {
                    // return で false（フレームが取得できない旨）を返す
                    returnValue = null
                    break
                }
            }
        }
 
        return returnValue
    }
 
    companion object {
        /** MediaCodec タイムアウト */
        private const val TIMEOUT_US = 0L
    }
}

/** MediaCodec を使って動画をエンコードする */
class VideoEncoder {
    private var encodeMediaCodec: MediaCodec? = null
    private var mediaMuxer: MediaMuxer? = null
 
    /**
     * MediaCodec エンコーダーの準備をする
     *
     * @param videoFilePath 保存先
     * @param codecName コーデック名
     * @param bitRate ビットレート
     * @param frameRate フレームレート
     * @param keyframeInterval キーフレームの間隔
     * @param outputVideoWidth 動画の高さ
     * @param outputVideoHeight 動画の幅
     * @param tenBitHdrParametersOrNullSdr SDR 動画の場合は null。HDR でエンコードする場合は[TenBitHdrParameters]を埋めてください
     */
    fun prepare(
        videoFilePath: String,
        outputVideoWidth: Int = 1280,
        outputVideoHeight: Int = 720,
        frameRate: Int = 30,
        bitRate: Int = 1_000_000,
        keyframeInterval: Int = 1,
        codecName: String = MediaFormat.MIMETYPE_VIDEO_HEVC,
        tenBitHdrParametersOrNullSdr: TenBitHdrParameters? = null
    ) {
        // エンコーダーにセットするMediaFormat
        // コーデックが指定されていればそっちを使う
        val videoMediaFormat = MediaFormat.createVideoFormat(codecName, outputVideoWidth, outputVideoHeight).apply {
            setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
            setInteger(MediaFormat.KEY_FRAME_RATE, frameRate)
            setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, keyframeInterval)
            setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
 
            // 10-bit HDR のパラメーターをセット
            if (tenBitHdrParametersOrNullSdr != null) {
                setInteger(MediaFormat.KEY_PROFILE, tenBitHdrParametersOrNullSdr.codecProfile)
                setInteger(MediaFormat.KEY_COLOR_STANDARD, tenBitHdrParametersOrNullSdr.colorStandard)
                setInteger(MediaFormat.KEY_COLOR_TRANSFER, tenBitHdrParametersOrNullSdr.colorTransfer)
                setFeatureEnabled(MediaCodecInfo.CodecCapabilities.FEATURE_HdrEditing, true)
            }
        }
 
        // マルチプレクサ
        mediaMuxer = MediaMuxer(videoFilePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
 
        encodeMediaCodec = MediaCodec.createEncoderByType(codecName).apply {
            configure(videoMediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
        }
    }
 
    /** エンコーダーの入力になる[Surface]を取得する */
    fun getInputSurface(): Surface = encodeMediaCodec!!.createInputSurface()
 
    /** エンコーダーを開始する */
    suspend fun start() {
        val encodeMediaCodec = encodeMediaCodec ?: return
        val mediaMuxer = mediaMuxer ?: return
 
        var videoTrackIndex = -1
        val bufferInfo = MediaCodec.BufferInfo()
        encodeMediaCodec.start()
 
        try {
            while (true) {
                // yield() で 占有しないよう
                yield()
 
                // Surface経由でデータを貰って保存する
                val encoderStatus = encodeMediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US)
                if (0 <= encoderStatus) {
                    if (bufferInfo.size > 0) {
                        if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG == 0) {
                            val encodedData = encodeMediaCodec.getOutputBuffer(encoderStatus)!!
                            mediaMuxer.writeSampleData(videoTrackIndex, encodedData, bufferInfo)
                        }
                    }
                    encodeMediaCodec.releaseOutputBuffer(encoderStatus, false)
                } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                    // MediaMuxerへ映像トラックを追加するのはこのタイミングで行う
                    // このタイミングでやると固有のパラメーターがセットされたMediaFormatが手に入る(csd-0 とか)
                    // 映像がぶっ壊れている場合（緑で塗りつぶされてるとか）は多分このあたりが怪しい
                    val newFormat = encodeMediaCodec.outputFormat
                    videoTrackIndex = mediaMuxer.addTrack(newFormat)
                    mediaMuxer.start()
                }
                if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) {
                    continue
                }
            }
        } finally {
            // エンコーダー終了
            encodeMediaCodec.signalEndOfInputStream()
            encodeMediaCodec.stop()
            encodeMediaCodec.release()
            // コンテナフォーマットに書き込む処理も終了
            mediaMuxer.stop()
            mediaMuxer.release()
        }
    }
 
    /**
     * 10-bit HDR の動画を作成するためのパラメーター。
     * 色空間とガンマカーブを指定してください。
     *
     * HLG 形式の HDR の場合は[MediaFormat.COLOR_STANDARD_BT2020]と[MediaFormat.COLOR_TRANSFER_HLG]と[MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10]。
     * デフォルト引数は HLG。
     *
     * 定数自体は Android 7 からありますが、10-bit HDR の動画編集が（MediaCodec が？） 13 以上なので。
     *
     * @param colorStandard 色空間
     * @param colorTransfer ガンマカーブ
     * @param codecProfile コーデックのプロファイル
     */
    data class TenBitHdrParameters(
        val colorStandard: Int = MediaFormat.COLOR_STANDARD_BT2020,
        val colorTransfer: Int = MediaFormat.COLOR_TRANSFER_HLG,
        val codecProfile: Int = MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10
    )
 
    companion object {
        /** タイムアウト */
        private const val TIMEOUT_US = 0L
    }
}

object MediaMuxerTool {
 
    /** それぞれ音声トラック、映像トラックを取り出して、2つのトラックを一つの mp4 にする */
    @SuppressLint("WrongConstant")
    suspend fun mixAvTrack(
        context: Context,
        audioTrackUri: Uri,
        videoTrackFilePath: String,
        resultFilePath: String
    ) {
        // 出力先
        val mediaMuxer = MediaMuxer(resultFilePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
 
        // 音声は元の動画データから
        // 映像は作った仮ファイルから
        val (audioExtractor, audioFormat) = createMediaExtractor(context, audioTrackUri, "audio/")
        val (videoExtractor, videoFormat) = createMediaExtractor(videoTrackFilePath, "video/")
 
        // MediaMuxer に追加して開始
        val audioTrackIndex = mediaMuxer.addTrack(audioFormat)
        val videoTrackIndex = mediaMuxer.addTrack(videoFormat)
        mediaMuxer.start()
 
        // MediaExtractor からトラックを取り出して、MediaMuxer に入れ直す処理
        listOf(
            audioExtractor to audioTrackIndex,
            videoExtractor to videoTrackIndex
        ).forEach { (extractor, trackIndex) ->
            val byteBuffer = ByteBuffer.allocate(1024 * 4096)
            val bufferInfo = MediaCodec.BufferInfo()
            // データが無くなるまで回す
            while (true) {
                yield()
                // データを読み出す
                val offset = byteBuffer.arrayOffset()
                bufferInfo.size = extractor.readSampleData(byteBuffer, offset)
                // もう無い場合
                if (bufferInfo.size < 0) break
                // 書き込む
                bufferInfo.presentationTimeUs = extractor.sampleTime
                bufferInfo.flags = extractor.sampleFlags // Lintがキレるけど黙らせる
                mediaMuxer.writeSampleData(trackIndex, byteBuffer, bufferInfo)
                // 次のデータに進める
                extractor.advance()
            }
            // あとしまつ
            extractor.release()
        }
        // 後始末
        mediaMuxer.stop()
        mediaMuxer.release()
    }
 
    /** [Uri]から[MediaExtractor]を作る */
    private fun createMediaExtractor(context: Context, uri: Uri, mimeType: String): Pair<MediaExtractor, MediaFormat> {
        val mediaExtractor = MediaExtractor().apply {
            context.contentResolver.openFileDescriptor(uri, "r")?.use {
                setDataSource(it.fileDescriptor)
            }
        }
        val (trackIndex, mediaFormat) = (0 until mediaExtractor.trackCount)
            .map { index -> mediaExtractor.getTrackFormat(index) }
            .withIndex()
            .first { it.value.getString(MediaFormat.KEY_MIME)?.startsWith(mimeType) == true }
        mediaExtractor.selectTrack(trackIndex)
        return mediaExtractor to mediaFormat
    }
 
    /** [filePath]から[MediaExtractor]を作る */
    private fun createMediaExtractor(filePath: String, mimeType: String): Pair<MediaExtractor, MediaFormat> {
        val mediaExtractor = MediaExtractor().apply {
            setDataSource(filePath)
        }
        val (trackIndex, mediaFormat) = (0 until mediaExtractor.trackCount)
            .map { index -> mediaExtractor.getTrackFormat(index) }
            .withIndex()
            .first { it.value.getString(MediaFormat.KEY_MIME)?.startsWith(mimeType) == true }
        mediaExtractor.selectTrack(trackIndex)
        return mediaExtractor to mediaFormat
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            AndroidMediaCodecHdrVideoCanvasOverlayTheme {
                HomeScreen()
            }
        }
    }
}
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun HomeScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
 
    val videoUri = remember { mutableStateOf<Uri?>(null) }
    val overlayText = remember { mutableStateOf("10 ビット HDR 動画の編集テスト") }
    val videoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { videoUri.value = it }
    )
 
    fun start() {
        scope.launch {
            // このあとすぐ
        }
    }
 
    Scaffold(
        topBar = { TopAppBar(title = { Text(text = stringResource(R.string.app_name)) }) },
        modifier = Modifier.fillMaxSize()
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
 
            Button(onClick = { videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly)) }) {
                Text(text = "動画を選ぶ")
            }
 
            OutlinedTextField(
                value = overlayText.value,
                onValueChange = { overlayText.value = it },
                label = { Text(text = "映像の上に重ねる文字") }
            )
 
            if (videoUri.value != null) {
                Button(onClick = { start() }) {
                    Text(text = "動画編集を始める")
                }
            }
        }
    }
}

fun start() {
    scope.launch(Dispatchers.Default) {
        val inputUri = videoUri.value ?: return@launch
        val tempVideoTrackFile = context.getExternalFilesDir(null)?.resolve("temp_video.mp4") ?: return@launch
 
        // 動画のメタデータを取得
        val videoWidth: Int
        val videoHeight: Int
        val fps: Int
        val colorStandard: Int
        val colorTransfer: Int
        MediaMetadataRetriever().use { mediaMetadataRetriever ->
            context.contentResolver.openFileDescriptor(inputUri, "r")?.use {
                mediaMetadataRetriever.setDataSource(it.fileDescriptor)
            }
            // FPS / 色空間 / ガンマカーブ
            fps = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)?.toIntOrNull() ?: 30
            colorStandard = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_STANDARD)?.toIntOrNull() ?: MediaFormat.COLOR_STANDARD_BT2020
            colorTransfer = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_TRANSFER)?.toIntOrNull() ?: MediaFormat.COLOR_TRANSFER_HLG
            // 動画の縦横サイズは ROTATION を見る必要あり
            val __videoWidth = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toIntOrNull() ?: 1280
            val __videoHeight = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull() ?: 720
            val rotation = mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull() ?: 0
            // 縦動画の場合、縦横が入れ替わるので
            val (_videoWidth, _videoHeight) = when (rotation) {
                90, 270 -> __videoHeight to __videoWidth
                else -> __videoWidth to __videoHeight
            }
            videoWidth = _videoWidth
            videoHeight = _videoHeight
        }
 
        // 動画のエンコーダー
        val videoEncoder = VideoEncoder().apply {
            prepare(
                videoFilePath = tempVideoTrackFile.path,
                outputVideoWidth = videoWidth,
                outputVideoHeight = videoHeight,
                frameRate = fps,
                bitRate = 20_000_000,
                keyframeInterval = 1,
                codecName = MediaFormat.MIMETYPE_VIDEO_HEVC,
                tenBitHdrParametersOrNullSdr = VideoEncoder.TenBitHdrParameters(
                    colorStandard = colorStandard,
                    colorTransfer = colorTransfer,
                    codecProfile = when (colorTransfer) {
                        MediaFormat.COLOR_TRANSFER_HLG -> MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10
                        MediaFormat.COLOR_TRANSFER_ST2084 -> MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10
                        else -> -1 // ココには来ないはず
                    }
                )
            )
        }
 
        // OpenGL で描画するクラス
        val openGlRenderer = OpenGlRenderer(
            outputSurface = videoEncoder.getInputSurface(),
            width = videoWidth,
            height = videoHeight,
            // BT.2020 でかつ、HLG か ST2084
            isEnableTenBitHdr = (colorStandard == MediaFormat.COLOR_STANDARD_BT2020 && (colorTransfer == MediaFormat.COLOR_TRANSFER_HLG || colorTransfer == MediaFormat.COLOR_TRANSFER_ST2084))
        ).apply { prepare() }
 
        // 映像を流す SurfaceTexture を作る
        val surfaceTexture = TextureRendererSurfaceTexture(openGlRenderer.generateTextureId())
 
        // 動画のデコーダーを作る
        val videoDecoder = VideoDecoder().apply {
            prepare(
                context = context,
                uri = inputUri,
                outputSurface = surfaceTexture.surface
            )
        }
 
        try {
            coroutineScope {
                // エンコーダー
                val encoderJob = launch { videoEncoder.start() }
 
                // OpenGL のメインループ
                val openGlJob = launch {
                    val continuesData = OpenGlRenderer.DrawContinuesData(true, 0)
                    val frameMs = 1_000 / fps
                    val textPaint = Paint().apply {
                        color = Color.WHITE
                        textSize = 100f
                        isAntiAlias = true
                    }
                    var currentPositionMs = 0L
 
                    // isAvailableNext が false までループする
                    openGlRenderer.drawLoop {
                        // フレームを取得。次のフレームがない場合は null
                        val hasNextFrame = videoDecoder.seekNextFrame(currentPositionMs) != null
                        currentPositionMs += frameMs
 
                        // 描画する
                        drawSurfaceTexture(surfaceTexture)
                        drawCanvas { drawText(overlayText.value, 100f, 200f, textPaint) }
 
                        // ループ続行情報
                        continuesData.isAvailableNext = hasNextFrame
                        continuesData.currentTimeNanoSeconds = currentPositionMs * 1_000_000L // nanoseconds に変換する
                        continuesData
                    }
                }
 
                // 終わったらエンコーダーも終わり
                openGlJob.join()
                encoderJob.cancelAndJoin()
            }
        } finally {
            surfaceTexture.destroy()
            openGlRenderer.destroy()
            videoDecoder.destroy()
        }
 
        // 音声トラックがないので（音がないので）、元の動画データから入れ直す
        val resultFile = context.getExternalFilesDir(null)?.resolve("result_${System.currentTimeMillis()}.mp4")!!
        MediaMuxerTool.mixAvTrack(
            context = context,
            audioTrackUri = inputUri,
            videoTrackFilePath = tempVideoTrackFile.path,
            resultFilePath = resultFile.path
        )
 
        // 端末の動画フォルダに入れる
        val contentResolver = context.contentResolver
        val contentValues = contentValuesOf(
            MediaStore.Images.Media.DISPLAY_NAME to resultFile.name,
            MediaStore.Images.Media.RELATIVE_PATH to "${Environment.DIRECTORY_MOVIES}/AndroidMediaCodecHdrVideoCanvasOverlay"
        )
        val uri = contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)!!
        resultFile.inputStream().use { inputStream ->
            contentResolver.openOutputStream(uri)?.use { outputStream ->
                inputStream.copyTo(outputStream)
            }
        }
 
        // コピーしたので消す
        tempVideoTrackFile.delete()
        resultFile.delete()
 
        // おわり
        withContext(Dispatchers.Main) {
            Toast.makeText(context, "おわり", Toast.LENGTH_SHORT).show()
        }
    }
}