Эффективная отрисовка YUV с доступом к кадрам на Android

class OptimizedRTSPPlayerView : TextureView, TextureView.SurfaceTextureListener {
    private var mediaCodec: MediaCodec? = null
    private var surfaceTexture: SurfaceTexture? = null
    private var renderer: YuvGLRenderer? = null
    private var frameProcessingEnabled = false
    
    fun enableFrameProcessing(enable: Boolean) {
        frameProcessingEnabled = enable
        // Переключение между прямой отрисовкой и обработкой кадров
        updateRenderingMode()
    }
    
    private fun updateRenderingMode() {
        mediaCodec?.let { decoder ->
            val surface = if (frameProcessingEnabled) {
                // Использование SurfaceTexture для доступа к кадрам
                surfaceTexture?.let { Surface(it) }
            } else {
                // Использование прямого Surface для аппаратной отрисовки
                Surface(surfaceTexture)
            }
            decoder.setOutputSurface(surface)
        }
    }
}

class AsyncFrameProcessor {
    private val processingQueue = ConcurrentLinkedQueue<FrameData>()
    private val processingThread = HandlerThread("FrameProcessor").apply { start() }
    private val processingHandler = Handler(processingThread.looper)
    
    fun submitFrame(frame: FrameData) {
        if (shouldProcessFrame(frame)) {
            processingQueue.offer(frame)
            processingHandler.post { processNextFrame() }
        }
    }
    
    private fun processNextFrame() {
        val frame = processingQueue.poll() ?: return
        // Обработка кадра в асинхронном режиме
        processFrameInBackground(frame)
    }
    
    private fun shouldProcessFrame(frame: FrameData): Boolean {
        // Реализация логики определения, какие кадры нуждаются в обработке
        return frame.timestamp % frameSkipInterval == 0L
    }
}

class HybridMediaDecoder {
    private val mainCodec: MediaCodec
    private val processingCodec: MediaCodec?
    private val mainSurface: Surface
    private val processingSurface: Surface?
    
    init {
        // Основной декодер для отображения
        mainCodec = MediaCodec.createDecoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
        val format = createVideoFormat()
        mainCodec.configure(format, createDisplaySurface(), null, 0)
        mainCodec.start()
        
        // Опциональный второй декодер для доступа к кадрам
        if (needFrameAccess) {
            processingCodec = MediaCodec.createDecoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
            processingCodec.configure(format, createProcessingSurface(), null, 0)
            processingCodec.start()
        } else {
            processingCodec = null
            processingSurface = null
        }
    }
    
    private fun createDisplaySurface(): Surface {
        return Surface(textureView.surfaceTexture)
    }
    
    private fun createProcessingSurface(): Surface {
        val surfaceTexture = SurfaceTexture(textureId).apply {
            setDefaultBufferSize(videoWidth, videoHeight)
        }
        return Surface(surfaceTexture)
    }
    
    fun requestFrameAccess(): Boolean {
        return synchronized(this) {
            if (processingCodec != null) {
                processingCodec.requestKeyFrame()
                true
            } else {
                false
            }
        }
    }
}

// Вертексный шейдер
attribute vec4 aPosition;
attribute vec2 aTexCoord;
varying vec2 vTexCoord;

void main() {
    gl_Position = aPosition;
    vTexCoord = aTexCoord;
}

// Фрагментный шейдер для прямой отрисовки YUV
precision mediump float;
varying vec2 vTexCoord;
uniform sampler2D yTexture;
uniform sampler2D uvTexture;

void main() {
    vec3 yuv;
    yuv.x = texture2D(yTexture, vTexCoord).r;
    yuv.yz = texture2D(uvTexture, vTexCoord).rg - vec2(0.5, 0.5);
    
    // Преобразование YUV в RGB с использованием оптимизированной матрицы
    vec3 rgb = mat3(
        1.0, 1.0, 1.0,
        0.0, -0.39465, 2.03211,
        1.13983, -0.58060, 0.0
    ) * yuv;
    
    gl_FragColor = vec4(rgb, 1.0);
}

class DirectYuvRenderer {
    private val programId: Int
    private val yTextureId: Int
    private val uvTextureId: Int
    
    init {
        programId = createShaderProgram(yuvVertexShader, yuvFragmentShader)
        yTextureId = createTexture()
        uvTextureId = createTexture()
    }
    
    fun renderFrame(yTexture: Int, uvTexture: Int, width: Int, height: Int) {
        glUseProgram(programId)
        
        // Привязка Y текстуры
        glActiveTexture(GL_TEXTURE0)
        glBindTexture(GL_TEXTURE_2D, yTexture)
        glUniform1i(glGetUniformLocation(programId, "yTexture"), 0)
        
        // Привязка UV текстуры
        glActiveTexture(GL_TEXTURE1)
        glBindTexture(GL_TEXTURE_2D, uvTexture)
        glUniform1i(glGetUniformLocation(programId, "uvTexture"), 1)
        
        // Отрисовка квадрата
        drawQuad()
    }
}

class OptimizedBufferManager {
    private val availableBuffers = ConcurrentLinkedQueue<Int>()
    private val inUseBuffers = ConcurrentHashMap<Int, Long>()
    private val bufferRecycleTime = 1000L // 1 секунда
    
    fun acquireBuffer(): Int? {
        return availableBuffers.poll() ?: allocateNewBuffer()
    }
    
    fun releaseBuffer(bufferId: Int) {
        synchronized(inUseBuffers) {
            inUseBuffers.remove(bufferId)?.let { timestamp ->
                if (System.currentTimeMillis() - timestamp < bufferRecycleTime) {
                    availableBuffers.offer(bufferId)
                } else {
                    // Буфер слишком старый, освобождаем
                    deleteBuffer(bufferId)
                }
            }
        }
    }
    
    fun markBufferInUse(bufferId: Int) {
        inUseBuffers[bufferId] = System.currentTimeMillis()
    }
    
    private fun allocateNewBuffer(): Int? {
        return try {
            val buffer = IntArray(1)
            glGenBuffers(1, buffer, 0)
            buffer[0]
        } catch (e: Exception) {
            null
        }
    }
}

class SmartFrameProcessor {
    private var lastProcessedFrame = 0L
    private val processInterval = 3 // Обрабатывать каждый 3-й кадр
    
    fun shouldProcessFrame(frameNumber: Long): Boolean {
        return frameNumber % processInterval == 0L
    }
}

class GpuFrameSaver {
    private val fboId: Int
    private var textureId: Int
    
    init {
        fboId = createFrameBuffer()
        textureId = createTexture()
    }
    
    fun saveFrameToDisk(texture: Int, width: Int, height: Int, path: String) {
        glBindFramebuffer(GL_FRAMEBUFFER, fboId)
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0)
        
        val pixels = ByteBuffer.allocateDirect(width * height * 4)
        glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels)
        
        // Сохранение на диск в фоновом потоке
        Thread {
            saveBitmap(pixels, width, height, path)
        }.start()
    }
}

class FrameBufferPool {
    private val pool = ConcurrentHashMap<Int, FrameBuffer>()
    private val maxSize = 10
    
    fun acquireBuffer(width: Int, height: Int): FrameBuffer? {
        synchronized(pool) {
            return pool.values.find { it.width == width && it.height == height && !it.inUse }
                ?.also { it.inUse = true }
                ?: createNewBuffer(width, height)
        }
    }
    
    fun releaseBuffer(buffer: FrameBuffer) {
        synchronized(pool) {
            buffer.inUse = false
            if (pool.size < maxSize) {
                pool[buffer.id] = buffer
            }
        }
    }
}

class DeviceCapabilitiesChecker {
    fun getOptimalOutputFormat(codec: MediaCodec): String {
        val capabilities = codec.codecInfo.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_AVC)
        
        // Предпочтение форматам с аппаратным ускорением
        val supportedFormats = capabilities.colorFormats
        return when {
            supportedFormats.contains(MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar) -> 
                MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar
            supportedFormats.contains(MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar) -> 
                MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar
            else -> MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
        }
    }
}