Codificación H. 264 de la cámara con Android MediaCodec

Estoy tratando de conseguir que esto funcione en Android 4.1 (utilizando una tableta Asus Transformer actualizada). Gracias a la respuesta de Alex a mi pregunta anterior, ya pude escribir algunos datos H. 264 sin procesar en un archivo, pero este archivo solo se puede reproducir con ffplay -f h264, y parece que ha perdido toda la información sobre la velocidad de fotogramas (reproducción extremadamente rápida). También el espacio de color parece incorrecto (atm usando el valor predeterminado de la cámara en el lado del codificador).

public class AvcEncoder {

private MediaCodec mediaCodec;
private BufferedOutputStream outputStream;

public AvcEncoder() { 
    File f = new File(Environment.getExternalStorageDirectory(), "Download/video_encoded.264");
    touch (f);
    try {
        outputStream = new BufferedOutputStream(new FileOutputStream(f));
        Log.i("AvcEncoder", "outputStream initialized");
    } catch (Exception e){ 
        e.printStackTrace();
    }

    mediaCodec = MediaCodec.createEncoderByType("video/avc");
    MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", 320, 240);
    mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 125000);
    mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 15);
    mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar);
    mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 5);
    mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    mediaCodec.start();
}

public void close() {
    try {
        mediaCodec.stop();
        mediaCodec.release();
        outputStream.flush();
        outputStream.close();
    } catch (Exception e){ 
        e.printStackTrace();
    }
}

// called from Camera.setPreviewCallbackWithBuffer(...) in other class
public void offerEncoder(byte[] input) {
    try {
        ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();
        ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();
        int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);
        if (inputBufferIndex >= 0) {
            ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
            inputBuffer.clear();
            inputBuffer.put(input);
            mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, 0, 0);
        }

        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo,0);
        while (outputBufferIndex >= 0) {
            ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
            byte[] outData = new byte[bufferInfo.size];
            outputBuffer.get(outData);
            outputStream.write(outData, 0, outData.length);
            Log.i("AvcEncoder", outData.length + " bytes written");

            mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
            outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, 0);

        }
    } catch (Throwable t) {
        t.printStackTrace();
    }

}

Cambiar el tipo de codificador a "video / mp4" aparentemente resuelve el problema de la velocidad de fotogramas, pero como el objetivo principal es hacer un servicio de transmisión, esta no es una buena solución.

Soy consciente de que se me cayó parte del código de Alex teniendo en cuenta el SPS y PPS NALU, pero esperaba que esto no fuera necesario ya que esa información también venía de outData y asumí que el codificador formatearía esto correctamente. Si este no es el caso, ¿cómo debo organizar los diferentes tipos de NALU en mi archivo/flujo?

Entonces, ¿qué soy falta aquí para hacer una corriente H. 264 válida y funcional? ¿Y qué ajustes debo usar para hacer una coincidencia entre el espacio de color de la cámara y el espacio de color del codificador?

Tengo la sensación de que esta es más una pregunta relacionada con H. 264 que un tema de Android/MediaCodec. ¿O sigo sin utilizar correctamente la API de MediaCodec?

Gracias de antemano.