dependencies {
    // Image Segmentation
    // MediaPipe
    implementation("com.google.mediapipe:tasks-vision:0.10.14")

    // 以下省略...

/** MediaPipe で ImageSegmentation する */
class MediaPipeImageSegmentation(context: Context) {

    private val imageSegmenter = ImageSegmenter.createFromOptions(
        context,
        ImageSegmenter.ImageSegmenterOptions.builder().apply {
            setBaseOptions(BaseOptions.builder().apply {
                // DeepLabV3
                // assets に置いたモデル
                setModelAssetPath("deeplab_v3.tflite")
            }.build())
            setRunningMode(RunningMode.IMAGE)
            setOutputCategoryMask(true)
            setOutputConfidenceMasks(false)
        }.build()
    )

    /** 推論して分類する。処理が終わるまで止まります。 */
    suspend fun segmentation(bitmap: Bitmap) = withContext(Dispatchers.Default) {
        val mpImage = BitmapImageBuilder(bitmap).build()
        val segmenterResult = imageSegmenter.segment(mpImage)
        val segmentedBitmap = convertBitmapFromMPImage(segmenterResult.categoryMask().get())
        return@withContext segmentedBitmap
    }

    /** [MPImage]から[Bitmap]を作る */
    private fun convertBitmapFromMPImage(mpImage: MPImage): Bitmap {
        val byteBuffer = ByteBufferExtractor.extract(mpImage)
        val pixels = IntArray(byteBuffer.capacity())

        for (i in pixels.indices) {
            // Using unsigned int here because selfie segmentation returns 0 or 255U (-1 signed)
            // with 0 being the found person, 255U for no label.
            // Deeplab uses 0 for background and other labels are 1-19,
            // so only providing 20 colors from ImageSegmenterHelper -> labelColors

            // 使ったモデル（DeepLab-v3）は、0 が背景。それ以外の 1 から 19 までが定義されているラベルになる
            // 今回は背景を青。それ以外は透過するようにしてみる。
            val index = byteBuffer.get(i).toUInt() % 20U
            val color = if (index.toInt() == 0) Color.BLUE else Color.TRANSPARENT
            pixels[i] = color
        }
        return Bitmap.createBitmap(
            pixels,
            mpImage.width,
            mpImage.height,
            Bitmap.Config.ARGB_8888
        )
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            AndroidMediaPipeImageSegmentationTheme {
                ImageSegmentationScreen()
            }
        }
    }
}

@Composable
private fun ImageSegmentationScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    val mediaPipeImageSegmentation = remember { MediaPipeImageSegmentation(context) }

    val inputBitmap = remember { mutableStateOf<ImageBitmap?>(null) }
    val segmentedBitmap = remember { mutableStateOf<ImageBitmap?>(null) }

    val photoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { uri ->
            uri ?: return@rememberLauncherForActivityResult
            // 推論はコルーチンでやる
            scope.launch {
                // Bitmap を取得。Glide や Coil が使えるならそっちで取得したほうが良いです
                val bitmap = context.contentResolver.openInputStream(uri)
                    .use { BitmapFactory.decodeStream(it) }
                // 推論
                val resultBitmap = mediaPipeImageSegmentation.segmentation(bitmap)
                // UI に表示
                inputBitmap.value = bitmap.asImageBitmap()
                segmentedBitmap.value = resultBitmap.asImageBitmap()
            }
        }
    )

    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {

            Button(onClick = {
                photoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly))
            }) { Text(text = "写真を選ぶ") }

            if (inputBitmap.value != null) {
                Image(
                    bitmap = inputBitmap.value!!,
                    contentDescription = null
                )
            }
            if (segmentedBitmap.value != null) {
                Image(
                    bitmap = segmentedBitmap.value!!,
                    contentDescription = null
                )
            }
        }
    }
}

// 推論はコルーチンでやる
scope.launch {
    // Bitmap を取得。Glide や Coil が使えるならそっちで取得したほうが良いです
    val bitmap = context.contentResolver.openInputStream(uri)
        .use { BitmapFactory.decodeStream(it) }

    // 推論
    val resultBitmap: Bitmap
    val time = measureTimeMillis {
        resultBitmap = mediaPipeImageSegmentation.segmentation(bitmap)
    }
    println("time = $time")

    // UI に表示
    inputBitmap.value = bitmap.asImageBitmap()
    segmentedBitmap.value = resultBitmap.asImageBitmap()
}

class MediaPipeImageSegmentation(context: Context) {

    private val imageSegmenter = ImageSegmenter.createFromOptions(
        context,
        ImageSegmenter.ImageSegmenterOptions.builder().apply {
            setBaseOptions(BaseOptions.builder().apply {
                // DeepLabV3
                // assets に置いたモデル
                setModelAssetPath("deeplab_v3.tflite")
            }.build())
            setRunningMode(RunningMode.VIDEO) // 動画モード
            setOutputCategoryMask(true)
            setOutputConfidenceMasks(false)
        }.build()
    )

    /** 推論して分類する。処理が終わるまで止まります。 */
    suspend fun segmentation(bitmap: Bitmap, framePositionMs: Long) = withContext(Dispatchers.Default) {
        // framePositionMs を引数にとって、segmentForVideo を呼び出すようにする
        val mpImage = BitmapImageBuilder(bitmap).build()
        val segmenterResult = imageSegmenter.segmentForVideo(mpImage, framePositionMs)
        val segmentedBitmap = convertBitmapFromMPImage(segmenterResult.categoryMask().get())
        return@withContext segmentedBitmap
    }

dependencies {
    // Image Segmentation
    // MediaPipe
    implementation("com.google.mediapipe:tasks-vision:0.10.14")

    // ↓これを足す
    // 動画を編集すると言うか、MediaCodec を代わりに叩いてくれる
    implementation("io.github.takusan23:akaricore:4.0.0")

    // 以下省略

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            AndroidVideoBackgroundTransparentEditorTheme {
                ImageSegmentationScreen()
            }
        }
    }
}

@Composable
private fun ImageSegmentationScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    val mediaPipeImageSegmentation = remember { MediaPipeImageSegmentation(context) }

    // エンコード済み時間と処理中かどうか
    val encodedPositionMs = remember { mutableLongStateOf(0) }
    val isRunning = remember { mutableStateOf(false) }

    val videoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { uri ->
            // 選んでもらったら処理開始
            uri ?: return@rememberLauncherForActivityResult
            scope.launch {
                isRunning.value = true

                // 動画サイズが欲しい
                val metadataRetriever = MediaMetadataRetriever().apply {
                    context.contentResolver.openFileDescriptor(uri, "r")
                        ?.use { setDataSource(it.fileDescriptor) }
                }
                val videoWidth = metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
                val videoHeight = metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()

                // 一枚一枚取り出すやつ。MetadataRetriever より速い
                val videoFrameBitmapExtractor = VideoFrameBitmapExtractor()
                videoFrameBitmapExtractor.prepareDecoder(uri.toAkariCoreInputOutputData(context))

                // BB 素材保存先
                val resultVideoMetadata = contentValuesOf(
                    MediaStore.Video.VideoColumns.DISPLAY_NAME to "${System.currentTimeMillis()}.mp4",
                    MediaStore.Video.VideoColumns.MIME_TYPE to "video/mp4",
                    MediaStore.MediaColumns.RELATIVE_PATH to "${Environment.DIRECTORY_MOVIES}/AndroidVideoBackgroundBlueBackEditor"
                )
                val resultVideoFileUri = context.contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, resultVideoMetadata)!!

                // Canvas から動画を作るやつ
                val paint = Paint()
                CanvasVideoProcessor.start(
                    output = resultVideoFileUri.toAkariCoreInputOutputData(context),
                    outputVideoWidth = videoWidth,
                    outputVideoHeight = videoHeight,
                    onCanvasDrawRequest = { positionMs ->
                        // 一枚一枚取り出す
                        val videoFrameBitmap = videoFrameBitmapExtractor.getVideoFrameBitmap(positionMs)
                        if (videoFrameBitmap != null) {
                            // 推論する
                            val segmentedBitmap = mediaPipeImageSegmentation.segmentation(videoFrameBitmap, positionMs)

                            // Canvas に書き込む
                            // 背景を青にした推論結果を上に重ねて描画することで、BB 素材っぽく
                            drawBitmap(videoFrameBitmap, 0f, 0f, paint)
                            drawBitmap(segmentedBitmap, 0f, 0f, paint)
                        }

                        // 進捗を UI に
                        encodedPositionMs.longValue = positionMs
                        // とりあえず 60 秒まで動画を作る
                        positionMs <= 60_000
                    }
                )

                isRunning.value = false
            }
        }
    )

    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {

            Button(onClick = {
                videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly))
            }) { Text(text = "動画を選ぶ") }

            if (isRunning.value) {
                CircularProgressIndicator()
                Text(text = "処理済みの時間 : ${encodedPositionMs.longValue} ミリ秒")
            }
        }
    }
}

// 時間測って println してくれるやつ
inline fun <T> printTime(task: () -> T): T {
    val taskResult: T
    val time = measureTimeMillis {
        taskResult = task()
    }
    println("PrintTime $time")
    return taskResult
}

sSegmentedTextureHandle = GLES20.glGetUniformLocation(mProgram, "sSegmentedTexture")
checkGlError("glGetUniformLocation sSegmentedTexture")
if (sSegmentedTextureHandle == -1) {
    throw RuntimeException("Could not get attrib location for sSegmentedTexture")
}

// テクスチャ ID を払い出してもらう
// 前面カメラの映像、背面カメラの映像で2個
// イメージセグメンテーション用にもう1個
val textures = IntArray(3)
GLES20.glGenTextures(3, textures, 0)

// 以下省略...

// 3個目はイメージセグメンテーションの結果
segmentedTextureId = textures[2]
GLES20.glActiveTexture(GLES20.GL_TEXTURE2)
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, segmentedTextureId)
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR)
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR)
checkGlError("glTexParameteri")

/**
 * イメージセグメンテーションの結果を渡す
 *
 * @param segmentedBitmap MediaPipe から出てきたやつ
 */
fun updateSegmentedBitmap(segmentedBitmap: Bitmap) {
    // texImage2D、引数違いがいるので注意
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, segmentedTextureId)
    GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, segmentedBitmap, 0)
    checkGlError("GLUtils.texImage2D")
}

// テクスチャの ID をわたす
GLES20.glUniform1i(sFrontCameraTextureHandle, 0) // GLES20.GL_TEXTURE0 なので 0
GLES20.glUniform1i(sBackCameraTextureHandle, 1) // GLES20.GL_TEXTURE1 なので 1
GLES20.glUniform1i(sSegmentedTextureHandle, 2) // GLES20.GL_TEXTURE2 なので 2
checkGlError("glUniform1i sFrontCameraTextureHandle sBackCameraTextureHandle")

#extension GL_OES_EGL_image_external : require
precision mediump float;

varying vec2 vTextureCoord;
uniform samplerExternalOES sFrontCameraTexture;
uniform samplerExternalOES sBackCameraTexture;
uniform sampler2D sSegmentedTexture;

// sFrontCameraTexture を描画する場合は 1。
// sBackCameraTexture は 0。
uniform int iDrawFrontCameraTexture;

void main() { 
  // 出力色
  vec4 outColor = vec4(0., 0., 0., 1.);

  // どっちを描画するのか
  if (bool(iDrawFrontCameraTexture)) {
    // フロントカメラ（自撮り）
    vec4 cameraColor = texture2D(sFrontCameraTexture, vTextureCoord); 
    // 推論結果の被写体の色
    vec4 targetColor = vec4(0., 0., 1., 1.);
    // 推論結果
    vec4 segmentedColor = texture2D(sSegmentedTexture, vTextureCoord);
    // 青色だったら discard。そうじゃなければフロントカメラの色を
    // length でどれくらい似ているかが取れる（雑な説明）
    if (.3 < length(targetColor - segmentedColor)) {
      outColor = cameraColor;
    } else {
      // outColor = segmentedColor; // ブルーバックを出す
      discard;
    }
  } else {
    // バックカメラ（外側）
    vec4 cameraColor = texture2D(sBackCameraTexture, vTextureCoord);
    outColor = cameraColor;
  }

  // 出力
  gl_FragColor = outColor;
}

/**
 * イメージセグメンテーション用に Bitmap を提供しなくてはいけない、そのための[ImageReader]。
 * maxImages が多いが、多めに取らないと、プレビューが遅くなる。https://stackoverflow.com/questions/42688188/
 *
 * width / height を半分以下にしているのはメモリ使用量を減らす目的と、
 * どうせ解析にクソデカい画像を入れても遅くなるだけなので、この段階で小さくしてしまう。
 */
private val analyzeImageReader = ImageReader.newInstance(CAMERA_RESOLUTION_WIDTH / 4, CAMERA_RESOLUTION_HEIGHT / 4, ImageFormat.JPEG, 30)

// フロントカメラの設定
// 出力先
val frontCameraOutputList = listOfNotNull(
    previewOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
    recordOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
    analyzeImageReader.surface // これ
)
val frontCameraCaptureRequest = frontCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
    frontCameraOutputList.forEach { surface -> addTarget(surface) }
}.build()
val frontCameraCaptureSession = frontCamera.awaitCameraSessionConfiguration(frontCameraOutputList)
frontCameraCaptureSession?.setRepeatingRequest(frontCameraCaptureRequest, null, null)

private val createInstanceTime = System.currentTimeMillis()
private val _segmentedBitmapFlow = MutableStateFlow<Bitmap?>(null)

private val imageSegmenter = ImageSegmenter.createFromOptions(
    context,
    ImageSegmenter.ImageSegmenterOptions.builder().apply {
        setBaseOptions(BaseOptions.builder().apply {
            // DeepLabV3
            // assets に置いたモデル
            setModelAssetPath("deeplab_v3.tflite")
        }.build())
        setRunningMode(RunningMode.LIVE_STREAM) // ライブモード、カメラ映像を流すため
        setOutputCategoryMask(true)
        setOutputConfidenceMasks(false)
        setResultListener { result, _ -> // コールバックを使う必要がある
            // Flow で通知
            _segmentedBitmapFlow.value = convertBitmapFromMPImage(result.categoryMask().get())
        }
    }.build()
)

/** 推論結果を流す Flow */
val segmentedBitmapFlow = _segmentedBitmapFlow.asStateFlow()

/** 推論して分類する。 */
fun segmentation(bitmap: Bitmap) {
    val mpImage = BitmapImageBuilder(bitmap).build()
    imageSegmenter.segmentAsync(mpImage, System.currentTimeMillis() - createInstanceTime) // segmentAsync を使う、フレームの時間を渡す必要がある
}

/** 破棄する */
fun destroy() {
    imageSegmenter.close()
}

/** 用意をする */
fun prepare() {
    scope.launch {
        // モードに応じて初期化を分岐
        when (mode) {
            CaptureMode.PICTURE -> initPictureMode()
            CaptureMode.VIDEO -> initVideoMode()
        }

        // プレビュー Surface で OpenGL ES の描画と破棄を行う。OpenGL ES の用意は map { } でやっている。
        // 新しい値が来たら、既存の OpenGlDrawPair は破棄するので、collectLatest でキャンセルを投げてもらうようにする。
        // また、録画用（静止画撮影、動画撮影）も別のところで描画
        launch {
            previewOpenGlDrawPairFlow.collectLatest { previewOpenGlDrawPair ->
                previewOpenGlDrawPair ?: return@collectLatest

                try {
                    // OpenGL ES の描画のためのメインループ
                    withContext(previewGlThreadDispatcher) {
                        while (isActive) {
                            renderOpenGl(previewOpenGlDrawPair)
                        }
                    }
                } finally {
                    // 終了時は OpenGL ES の破棄
                    withContext(NonCancellable + previewGlThreadDispatcher) {
                        previewOpenGlDrawPair.textureRenderer.destroy()
                        previewOpenGlDrawPair.inputSurface.destroy()
                    }
                }
            }
        }

        // MediaPipe のイメージセグメンテーションを行う
        // まず前面カメラのカメラ映像を ImageReader で受け取り、Bitmap にする
        // そのあと、イメージセグメンテーションの推論をして、結果を OpenGL ES へ渡す
        // OpenGL ES 側で描画する処理は、他のプレビューとかの描画ループ中に入れてもらうことにする。
        launch { prepareAndStartImageSegmentation() }

        // プレビューを開始する
        startPreview()
    }
}

/** イメージセグメンテーションの開始 */
private suspend fun startImageSegmentation() = coroutineScope {
    // MediaPipe
    val mediaPipeImageSegmentation = MediaPipeImageSegmentation(context)

    try {
        listOf(
            launch {
                // カメラ映像を受け取って解析に投げる部分
                while (isActive) {
                    val bitmap = analyzeImageReader.acquireLatestImage()?.toJpegBitmap()
                    if (bitmap != null) {
                        mediaPipeImageSegmentation.segmentation(bitmap)
                    }
                }
            },
            launch {
                // 解析結果を受け取って、OpenGL ES へテクスチャとして提供する
                mediaPipeImageSegmentation
                    .segmentedBitmapFlow
                    .filterNotNull()
                    .collect { segmentedBitmap ->
                        withContext(previewGlThreadDispatcher) {
                            previewOpenGlDrawPairFlow.value?.textureRenderer?.updateSegmentedBitmap(segmentedBitmap)
                        }
                        withContext(recordGlThreadDispatcher) {
                            recordOpenGlDrawPair?.textureRenderer?.updateSegmentedBitmap(segmentedBitmap)
                        }
                    }
            }
        ).joinAll()
    } finally {
        mediaPipeImageSegmentation.destroy()
    }
}

private suspend fun Image.toJpegBitmap() = withContext(Dispatchers.IO) {
    val imageBuf: ByteBuffer = planes[0].buffer
    val imageBytes = ByteArray(imageBuf.remaining())
    imageBuf[imageBytes]
    close()
    BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
}

        private const val VERTEX_SHADER = """
uniform mat4 uMVPMatrix;
uniform mat4 uSTMatrix;
attribute vec4 aPosition;
attribute vec4 aTextureCoord;
varying vec2 vTextureCoord;
varying vec2 vSegmentTextureCoord;

// Matrix.setIdentityM()
const mat4 uTextureSTMatrix = mat4(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);

void main() {
  gl_Position = uMVPMatrix * aPosition;
  vTextureCoord = (uSTMatrix * aTextureCoord).xy;
  
  // vTextureCoord は SurfaceTexture 用なので、普通のテクスチャ描画用の vTextureCoord を作る
  // またテクスチャ座標は反転しているので戻す
  vSegmentTextureCoord = (uTextureSTMatrix * aTextureCoord).xy;
  vSegmentTextureCoord = vec2(vSegmentTextureCoord.x, 1.-vSegmentTextureCoord.y);
}
"""

        private const val FRAGMENT_SHADER = """
#extension GL_OES_EGL_image_external : require
precision mediump float;

varying vec2 vTextureCoord;
uniform samplerExternalOES sFrontCameraTexture;
uniform samplerExternalOES sBackCameraTexture;

varying vec2 vSegmentTextureCoord;
uniform sampler2D sSegmentedTexture;

// sFrontCameraTexture を描画する場合は 1。
// sBackCameraTexture は 0。
uniform int iDrawFrontCameraTexture;

void main() { 
  // 出力色
  vec4 outColor = vec4(0., 0., 0., 1.);

  // どっちを描画するのか
  if (bool(iDrawFrontCameraTexture)) {
    // フロントカメラ（自撮り）
    vec4 cameraColor = texture2D(sFrontCameraTexture, vTextureCoord); 
    // 推論結果の被写体の色
    vec4 targetColor = vec4(0., 0., 1., 1.);
    // 推論結果
    vec4 segmentedColor = texture2D(sSegmentedTexture, vSegmentTextureCoord);
    // 青色だったら discard。そうじゃなければフロントカメラの色を
    // length でどれくらい似ているかが取れる（雑な説明）
    if (.3 < length(targetColor - segmentedColor)) {
      outColor = cameraColor;
    } else {
      // outColor = segmentedColor; // ブルーバックを出す
      discard;
    }
  } else {
    // バックカメラ（外側）
    vec4 cameraColor = texture2D(sBackCameraTexture, vTextureCoord);
    outColor = cameraColor;
  }

  // 出力
  gl_FragColor = outColor;
}
"""

/** 解析用 [OpenGlDrawPair] */
private data class AnalyzeOpenGlDrawPair(
    val inputSurface: InputSurface,
    val textureRenderer: TextureCopyTextureRenderer
)

/**
 * イメージセグメンテーション用に Bitmap を提供しなくてはいけない、そのための[ImageReader]。
 *
 * width / height を半分以下にしているのはメモリ使用量を減らす目的と、
 * どうせ解析にクソデカい画像を入れても遅くなるだけなので、この段階で小さくしてしまう。
 */
private val analyzeImageReader = ImageReader.newInstance(
    CAMERA_RESOLUTION_WIDTH / ANALYZE_DIV_SCALE,
    CAMERA_RESOLUTION_HEIGHT / ANALYZE_DIV_SCALE,
    PixelFormat.RGBA_8888,
    2
)

/** [analyzeImageReader]用 GL スレッド */
private val analyzeGlThreadDispatcher = newSingleThreadContext("AnalyzeGlThread")

/** [analyzeImageReader]用[OpenGlDrawPair] */
private var analyzeOpenGlDrawPair: AnalyzeOpenGlDrawPair? = null

companion object {
    const val CAMERA_RESOLUTION_WIDTH = 720
    const val CAMERA_RESOLUTION_HEIGHT = 1280
    private const val ANALYZE_DIV_SCALE = 4 // イメージセグメンテーションに元の解像度はいらないので 1/4 する
}

fun prepare() {
    scope.launch {
        // 省略...

        // MediaPipe のイメージセグメンテーションを行う
        // まず前面カメラのカメラ映像を ImageReader で受け取り、Bitmap にする
        // そのあと、イメージセグメンテーションの推論をして、結果を OpenGL ES へ渡す
        // OpenGL ES 側で描画する処理は、他のプレビューとかの描画ループ中に入れてもらうことにする。
        analyzeOpenGlDrawPair = withContext(analyzeGlThreadDispatcher) {
            // また、本当は ImageReader を Camera2 API に渡せばいいはずだが、プレビューが重たくなってしまった。
            // OpenGL ES を経由すると改善したのでとりあえずそれで（謎）
            val inputSurface = InputSurface(analyzeImageReader.surface)
            val textureRenderer = TextureCopyTextureRenderer()
            inputSurface.makeCurrent()
            textureRenderer.createShader()
            textureRenderer.setSurfaceTextureSize(CAMERA_RESOLUTION_WIDTH / ANALYZE_DIV_SCALE, CAMERA_RESOLUTION_HEIGHT / ANALYZE_DIV_SCALE)
            AnalyzeOpenGlDrawPair(inputSurface, textureRenderer)
        }
        launch { startImageSegmentation() }

        // プレビューを開始する
        startPreview()
    }
}

/** イメージセグメンテーションの開始 */
private suspend fun startImageSegmentation() = coroutineScope {
    // MediaPipe
    val mediaPipeImageSegmentation = MediaPipeImageSegmentation(context)

    try {
        listOf(
            launch {
                // カメラ映像を受け取って解析に投げる部分
                withContext(analyzeGlThreadDispatcher) {
                    while (isActive) {
                        if (analyzeOpenGlDrawPair?.textureRenderer?.isAvailableFrame() == true) {
                            // カメラ映像テクスチャを更新して、描画
                            analyzeOpenGlDrawPair?.textureRenderer?.updateCameraTexture()
                            analyzeOpenGlDrawPair?.textureRenderer?.draw()
                            analyzeOpenGlDrawPair?.inputSurface?.swapBuffers()
                            // ImageReader で取りだして、MediaPipe のイメージセグメンテーションに投げる
                            val bitmap = analyzeImageReader.acquireLatestImage()?.toRgbaBitmap(
                                imageReaderWidth = CAMERA_RESOLUTION_WIDTH / ANALYZE_DIV_SCALE,
                                imageReaderHeight = CAMERA_RESOLUTION_HEIGHT / ANALYZE_DIV_SCALE,
                            )
                            if (bitmap != null) {
                                mediaPipeImageSegmentation.segmentation(bitmap)
                            }
                        }
                    }
                }
            },
            launch {
                // 解析結果を受け取って、プレビュー、録画用 OpenGL ES へテクスチャとして提供する
                mediaPipeImageSegmentation
                    .segmentedBitmapFlow
                    .filterNotNull()
                    .collect { segmentedBitmap ->
                        withContext(previewGlThreadDispatcher) {
                            previewOpenGlDrawPairFlow.value?.textureRenderer?.updateSegmentedBitmap(segmentedBitmap)
                        }
                        withContext(recordGlThreadDispatcher) {
                            recordOpenGlDrawPair?.textureRenderer?.updateSegmentedBitmap(segmentedBitmap)
                        }
                    }
            }
        ).joinAll()
    } finally {
        mediaPipeImageSegmentation.destroy()
    }
}

/** [Image]から[Bitmap]を作る */
private suspend fun Image.toRgbaBitmap(imageReaderWidth: Int, imageReaderHeight: Int) = withContext(Dispatchers.IO) {
    val image = this@toRgbaBitmap
    val width = image.width
    val height = image.height
    val planes = image.planes
    val buffer = planes[0].buffer
    // なぜか ImageReader のサイズに加えて、何故か Padding が入っていることを考慮する必要がある
    val pixelStride = planes[0].pixelStride
    val rowStride = planes[0].rowStride
    val rowPadding = rowStride - pixelStride * width
    // Bitmap 作成
    val readBitmap = Bitmap.createBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.ARGB_8888)
    readBitmap.copyPixelsFromBuffer(buffer)
    // 余分な Padding を消す
    val editBitmap = Bitmap.createBitmap(readBitmap, 0, 0, imageReaderWidth, imageReaderHeight)
    readBitmap.recycle()
    image.close()
    return@withContext editBitmap
}

// フロントカメラの設定
// 出力先
val frontCameraOutputList = listOfNotNull(
    previewOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
    recordOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
    analyzeOpenGlDrawPair?.textureRenderer?.inputSurface // こ↑こ↓
)
val frontCameraCaptureRequest = frontCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
    frontCameraOutputList.forEach { surface -> addTarget(surface) }
}.build()
val frontCameraCaptureSession = frontCamera.awaitCameraSessionConfiguration(frontCameraOutputList)
frontCameraCaptureSession?.setRepeatingRequest(frontCameraCaptureRequest, null, null)