How to use FileDescriptor in MediaMuxer

Question

I want to save my MediaMuxer data in memory. Anybody can help me what is the actual procedure to do that.

I used filedescriptor but got IllegalStateException when starting the muxer. I used the solution from Create an in-memory FileDescriptor

Here is my code

public void onStartButtonClick(View view) throws IOException {
    int FRAME_RATE = 30;
    int IFRAME_INTERVAL = 5;

    try {

        String name = context
                .getFileStreamPath("socket-" + UUID.randomUUID())
                .getAbsolutePath();
        LocalSocketAddress address = new LocalSocketAddress(name,  LocalSocketAddress.Namespace.FILESYSTEM);

        // Bind a server to the socket.
        LocalSocket server = new LocalSocket(LocalSocket.SOCKET_STREAM);
        server.bind(address);
        LocalServerSocket serverWrapper;
        try {
            serverWrapper = new LocalServerSocket(server.getFileDescriptor());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // Connect a client to the socket.
        LocalSocket client = new LocalSocket(LocalSocket.SOCKET_STREAM);
        client.connect(address);

        // Start a thread to read from the server socket.
        Thread x = new Thread(new Runnable() {
            @Override
            public void run() {
                LocalSocket socket;
                try {
                    socket = serverWrapper.accept();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                try {
                    InputStream input = socket.getInputStream();
                    byte[] buffer = new byte[100000];
                    input.read(buffer);
                    input.close();
                    Log.d("MainActivity", " data" + new String(buffer));

                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
         
            }
        });
        x.start();

       
        FileDescriptor fd = client.getFileDescriptor();

        String text = "MemoryFile Text";

        MediaMuxer mediaMuxer = new MediaMuxer(fd, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);

        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 640, 480);

        // Configure media format
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 2000000);
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);

        // Create the encoder and input surface
        MediaCodec mediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
        mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        Surface inputSurface = mediaCodec.createInputSurface();
        mediaCodec.start();

        // Render text frames onto the input surface
        Canvas canvas = inputSurface.lockCanvas(null);
        Paint paint = new Paint();
        paint.setColor(Color.WHITE);
        paint.setTextSize(40);
        canvas.drawColor(Color.BLACK);
        canvas.drawText(text, 100, 240, paint);
        inputSurface.unlockCanvasAndPost(canvas);

        // Encode and mux frames
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();
        boolean muxing = true;

        while (muxing) {
            int encoderStatus = mediaCodec.dequeueOutputBuffer(bufferInfo, -1);
            if (encoderStatus >= 0) {
                ByteBuffer encodedData = outputBuffers[encoderStatus];

                if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    bufferInfo.size = 0;
                }

                if (bufferInfo.size != 0) {
                    encodedData.position(bufferInfo.offset);
                    encodedData.limit(bufferInfo.offset + bufferInfo.size);
                    mediaMuxer.writeSampleData(0, encodedData, bufferInfo);
                }

                mediaCodec.releaseOutputBuffer(encoderStatus, false);

                if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    break;
                }
            } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                // Configure the media format for the muxer
                MediaFormat outputFormat = mediaCodec.getOutputFormat();
                mediaMuxer.addTrack(outputFormat);
                mediaMuxer.start();
            }
        }

        mediaMuxer.stop();
        mediaMuxer.release();
        mediaCodec.stop();
        mediaCodec.release();
        serverWrapper.close();
        server.close();
        client.close();
    } catch (Exception e) {
        e.printStackTrace();
        Log.e("MainActivity", e.toString());

    }

}