mediamuxer+MediaExtratoc+MediaCodec剪视频

要剪切视频，我们需要使用MediaExtractor和MediaMuxer来提取和合成视频数据，同时使用MediaCodec来对视频数据进行编解码操作。

具体步骤如下：

1. 使用MediaExtractor从源视频文件中获取视频轨道和音频轨道的信息。

2. 创建包含需要剪切的时间段的新视频文件，并使用MediaMuxer将视频轨道和音频轨道添加到新文件中。

3. 使用MediaCodec对源视频文件中的视频轨道进行编解码操作，并将解码后的数据写入新文件中。

4. 根据需要剪切的时间段，使用MediaExtractor定位到指定时间戳的数据位置，并使用MediaCodec对该时间段的视频数据进行编解码操作，并将解码后的数据写入新文件中。

5. 将新文件中的音视频数据封装为一个完整的多媒体文件。

以上是大致的剪视频流程，具体实现细节还需要根据具体场景进行调整。

相关问题

MediaCodec和MediaMuxer API剪切视频demo

以下是一个简单的示例代码，演示如何使用MediaCodec和MediaMuxer API剪切视频。请注意，这只是一个基本示例，实际上需要更多的代码来完成这个任务，例如处理不同的视频格式和编解码器参数等。

import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.media.MediaMuxer;
import android.os.Environment;
import android.util.Log;

import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;

public class VideoClipper {
    private static final String TAG = "VideoClipper";
    private static final String SAMPLE_PREFIX = "video_clip_";
    private static final String SAMPLE_EXTENSION = ".mp4";
    private static final int TIMEOUT_US = 10000;

    public static void clipVideo(String inputVideoPath, long startMs, long endMs) throws IOException {
        File inputFile = new File(inputVideoPath);
        MediaExtractor extractor = new MediaExtractor();
        extractor.setDataSource(inputFile.toString());

        int trackCount = extractor.getTrackCount();
        int videoTrackIndex = -1;
        MediaFormat videoFormat = null;

        // Find the first video track index and its format
        for (int i = 0; i < trackCount; i++) {
            MediaFormat format = extractor.getTrackFormat(i);
            String mime = format.getString(MediaFormat.KEY_MIME);
            if (mime.startsWith("video/")) {
                videoTrackIndex = i;
                videoFormat = format;
                break;
            }
        }

        if (videoTrackIndex == -1) {
            throw new RuntimeException("No video track found in " + inputVideoPath);
        }

        // Configure the video codec
        MediaCodec videoDecoder = MediaCodec.createDecoderByType(videoFormat.getString(MediaFormat.KEY_MIME));
        videoDecoder.configure(videoFormat, null, null, 0);
        videoDecoder.start();

        // Configure the video muxer
        String outputVideoPath = new File(Environment.getExternalStorageDirectory(),
                SAMPLE_PREFIX + System.currentTimeMillis() + SAMPLE_EXTENSION).getAbsolutePath();
        MediaMuxer muxer = new MediaMuxer(outputVideoPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);

        // Copy the video header
        ByteBuffer header = ByteBuffer.allocate(1024);
        videoDecoder.getOutputFormat().getByteBuffer("csd-0").rewind();
        header.put(videoDecoder.getOutputFormat().getByteBuffer("csd-0"));
        header.put(videoDecoder.getOutputFormat().getByteBuffer("csd-1"));
        header.flip();
        int videoTrackIndexOut = muxer.addTrack(videoDecoder.getOutputFormat());

        muxer.start();

        // Extract video frames and write to muxer
        extractor.selectTrack(videoTrackIndex);
        ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
        boolean inputDone = false;
        boolean outputDone = false;
        boolean videoDone = false;
        long videoStartTimeMs = -1;
        long videoEndTimeMs = -1;
        while (!outputDone) {
            if (!inputDone) {
                int inputIndex = videoDecoder.dequeueInputBuffer(TIMEOUT_US);
                if (inputIndex >= 0) {
                    ByteBuffer inputBuffer = videoDecoder.getInputBuffer(inputIndex);
                    int sampleSize = extractor.readSampleData(inputBuffer, 0);
                    if (sampleSize < 0) {
                        videoDecoder.queueInputBuffer(inputIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                        inputDone = true;
                    } else {
                        long presentationTimeUs = extractor.getSampleTime();
                        if (videoStartTimeMs == -1) {
                            videoStartTimeMs = presentationTimeUs / 1000;
                        }
                        if (videoEndTimeMs == -1 || presentationTimeUs / 1000 < videoEndTimeMs) {
                            videoDecoder.queueInputBuffer(inputIndex, 0, sampleSize, presentationTimeUs, 0);
                            extractor.advance();
                        } else {
                            inputDone = true;
                        }
                    }
                }
            }

            if (!videoDone) {
                MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
                int outputIndex = videoDecoder.dequeueOutputBuffer(bufferInfo, TIMEOUT_US);
                if (outputIndex >= 0) {
                    if (bufferInfo.flags == MediaCodec.BUFFER_FLAG_END_OF_STREAM) {
                        outputDone = true;
                    } else {
                        ByteBuffer outputBuffer = videoDecoder.getOutputBuffer(outputIndex);
                        buffer.clear();
                        buffer.put(header);
                        buffer.put(outputBuffer);
                        buffer.flip();
                        muxer.writeSampleData(videoTrackIndexOut, buffer, bufferInfo);
                        videoDecoder.releaseOutputBuffer(outputIndex, false);
                        if (videoEndTimeMs == -1 && bufferInfo.presentationTimeUs / 1000 >= endMs) {
                            videoEndTimeMs = bufferInfo.presentationTimeUs / 1000;
                            videoDone = true;
                        }
                    }
                }
            }

            if (inputDone && videoDone) {
                outputDone = true;
            }
        }

        // Release resources
        extractor.release();
        if (videoDecoder != null) {
            videoDecoder.stop();
            videoDecoder.release();
        }
        if (muxer != null) {
            muxer.stop();
            muxer.release();
        }

        Log.i(TAG, "Video clipped and saved to " + outputVideoPath);
    }
}

要使用这个示例代码，只需调用`clipVideo`方法并传入要剪切的视频文件路径、开始时间和结束时间。例如：

try {
    VideoClipper.clipVideo("/sdcard/input.mp4", 10000, 20000);
} catch (IOException e) {
    e.printStackTrace();
}

这将在SD卡根目录下创建一个名为“video_clip_*.mp4”的新视频文件，其中*是当前时间的毫秒级时间戳。这个新文件将是原始视频文件从10秒到20秒的剪辑版本。

android glsurfaceview +camera+mediaCodec编码，在不影响预览的情况下，如何自定义编码帧率(0-30帧)

在android glsurfaceview +camera+mediaCodec编码中，可以通过设置MediaCodec的参数来自定义编码帧率，具体步骤如下：

1. 创建MediaCodec编码器

MediaCodec mediaCodec = MediaCodec.createEncoderByType(mimeType);

2. 配置MediaCodec参数

MediaFormat mediaFormat = MediaFormat.createVideoFormat(mimeType, width, height);
mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate); // 设置帧率
mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

其中，frameRate参数即为要设置的帧率值，可以在0-30之间自定义。

3. 启动MediaCodec编码器

mediaCodec.start();

4. 循环获取相机预览数据并进行编码

while (mIsRecording) {
    // 获取相机预览数据
    byte[] input = getCameraData();
    // 将获取到的数据传入MediaCodec进行编码
    int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);
    if (inputBufferIndex >= 0) {
        ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
        inputBuffer.clear();
        inputBuffer.put(input);
        mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, System.nanoTime() / 1000, 0);
    }
    // 获取编码后的数据
    int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US);
    if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
        // 获取到编码后的格式信息，可进行相关初始化操作
        MediaFormat newFormat = mediaCodec.getOutputFormat();
        // ...
    } else if (outputBufferIndex >= 0) {
        ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
        byte[] output = new byte[bufferInfo.size];
        outputBuffer.get(output);
        // 处理编码后的数据
        // ...
        mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    }
}

通过以上步骤，即可在不影响预览的情况下自定义编码帧率。需要注意的是，帧率的设置只是建议值，并不一定能够达到。