我正在开发一个基于webrtc的视频聊天应用程序，当前正在进行视频通话，但是我想使用VideoFileRenderer录制来自远程视频流的视频，该接口有很多实现，例如：{{3} } 这是我正在使用的实现。它将视频保存到文件中没有问题，但是使用编解码器后我只能在桌面上播放它，因为文件是.y4m而不是.mp4，并且当我尝试使用VideoView播放它时说它无法播放视频，即使我尝试使用android随附的videoPlayer播放视频也无法播放，也只能使用MXPlayer，VLC或桌面上具有编解码器的任何其他应用程序播放。
为简化问题：
How can I play video.y4m on native android VideoView?
我将进一步简化它，假设我不理解记录文件的格式，这是我用来记录文件的代码：
开始录制时：
remoteVideoFileRenderer = new VideoFileRenderer(
fileToRecordTo.getAbsolutePath(),
640,
480,
rootEglBase.getEglBaseContext());
remoteVideoTrack.addSink(remoteVideoFileRenderer);
完成录制后：
remoteVideoFileRenderer.release();
再次提出问题：我有一个“ fileToRecordTo”，该视频文件可以在GOM（windows），VLC（windows，mac和Android），MXPlayer（Android）上播放，但我既不能使用内置于Android中的播放器（如果可以的话，我会在我的应用中使用过该播放器），也不能在Android本机videoView中使用。
任何帮助。
答案 0 :(得分：3)
我的项目中也有类似的案例。最初，我尝试使用WebRTC的默认VideoFileRenderer，但是视频大小太大，因为未应用压缩。 我找到了这个仓库。对我而言，这确实有所帮助。 https://github.com/cloudwebrtc/flutter-webrtc
这里是逐步指南。我也做了一些调整。
将此类添加到您的项目中。它有很多选项可以配置最终的视频格式。
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaFormat;
import android.media.MediaMuxer;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.view.Surface;
import org.webrtc.EglBase;
import org.webrtc.GlRectDrawer;
import org.webrtc.VideoFrame;
import org.webrtc.VideoFrameDrawer;
import org.webrtc.VideoSink;
import java.io.IOException;
import java.nio.ByteBuffer;
class FileEncoder implements VideoSink {
private static final String TAG = "FileRenderer";
private final HandlerThread renderThread;
private final Handler renderThreadHandler;
private int outputFileWidth = -1;
private int outputFileHeight = -1;
private ByteBuffer[] encoderOutputBuffers;
private EglBase eglBase;
private EglBase.Context sharedContext;
private VideoFrameDrawer frameDrawer;
private static final String MIME_TYPE = "video/avc"; // H.264 Advanced Video Coding
private static final int FRAME_RATE = 30; // 30fps
private static final int IFRAME_INTERVAL = 5; // 5 seconds between I-frames
private MediaMuxer mediaMuxer;
private MediaCodec encoder;
private MediaCodec.BufferInfo bufferInfo;
private int trackIndex = -1;
private boolean isRunning = true;
private GlRectDrawer drawer;
private Surface surface;
FileEncoder(String outputFile, final EglBase.Context sharedContext) throws IOException {
renderThread = new HandlerThread(TAG + "RenderThread");
renderThread.start();
renderThreadHandler = new Handler(renderThread.getLooper());
bufferInfo = new MediaCodec.BufferInfo();
this.sharedContext = sharedContext;
mediaMuxer = new MediaMuxer(outputFile,
MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
}
private void initVideoEncoder() {
MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, 1280, 720);
format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
format.setInteger(MediaFormat.KEY_BIT_RATE, 6000000);
format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);
try {
encoder = MediaCodec.createEncoderByType(MIME_TYPE);
encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
renderThreadHandler.post(() -> {
eglBase = EglBase.create(sharedContext, EglBase.CONFIG_RECORDABLE);
surface = encoder.createInputSurface();
eglBase.createSurface(surface);
eglBase.makeCurrent();
drawer = new GlRectDrawer();
});
} catch (Exception e) {
Log.wtf(TAG, e);
}
}
@Override
public void onFrame(VideoFrame frame) {
frame.retain();
if (outputFileWidth == -1) {
outputFileWidth = frame.getRotatedWidth();
outputFileHeight = frame.getRotatedHeight();
initVideoEncoder();
}
renderThreadHandler.post(() -> renderFrameOnRenderThread(frame));
}
private void renderFrameOnRenderThread(VideoFrame frame) {
if (frameDrawer == null) {
frameDrawer = new VideoFrameDrawer();
}
frameDrawer.drawFrame(frame, drawer, null, 0, 0, outputFileWidth, outputFileHeight);
frame.release();
drainEncoder();
eglBase.swapBuffers();
}
/**
* Release all resources. All already posted frames will be rendered first.
*/
void release() {
isRunning = false;
renderThreadHandler.post(() -> {
if (encoder != null) {
encoder.stop();
encoder.release();
}
eglBase.release();
mediaMuxer.stop();
mediaMuxer.release();
renderThread.quit();
});
}
private boolean encoderStarted = false;
private volatile boolean muxerStarted = false;
private long videoFrameStart = 0;
private void drainEncoder() {
if (!encoderStarted) {
encoder.start();
encoderOutputBuffers = encoder.getOutputBuffers();
encoderStarted = true;
return;
}
while (true) {
int encoderStatus = encoder.dequeueOutputBuffer(bufferInfo, 10000);
if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
break;
} else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
// not expected for an encoder
encoderOutputBuffers = encoder.getOutputBuffers();
Log.e(TAG, "encoder output buffers changed");
} else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
// not expected for an encoder
MediaFormat newFormat = encoder.getOutputFormat();
Log.e(TAG, "encoder output format changed: " + newFormat);
trackIndex = mediaMuxer.addTrack(newFormat);
if (!muxerStarted) {
mediaMuxer.start();
muxerStarted = true;
}
if (!muxerStarted)
break;
} else if (encoderStatus < 0) {
Log.e(TAG, "unexpected result fr om encoder.dequeueOutputBuffer: " + encoderStatus);
} else { // encoderStatus >= 0
try {
ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
if (encodedData == null) {
Log.e(TAG, "encoderOutputBuffer " + encoderStatus + " was null");
break;
}
// It's usually necessary to adjust the ByteBuffer values to match BufferInfo.
encodedData.position(bufferInfo.offset);
encodedData.limit(bufferInfo.offset + bufferInfo.size);
if (videoFrameStart == 0 && bufferInfo.presentationTimeUs != 0) {
videoFrameStart = bufferInfo.presentationTimeUs;
}
bufferInfo.presentationTimeUs -= videoFrameStart;
if (muxerStarted)
mediaMuxer.writeSampleData(trackIndex, encodedData, bufferInfo);
isRunning = isRunning && (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) == 0;
encoder.releaseOutputBuffer(encoderStatus, false);
if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
break;
}
} catch (Exception e) {
Log.wtf(TAG, e);
break;
}
}
}
}
private long presTime = 0L;
}
现在在您的Activity / Fragment类上
声明上述类的变量
FileEncoder recording;
收到要录制的流（远程或本地）时，可以初始化录制。
FileEncoder recording = new FileEncoder("path/to/video", rootEglBase.eglBaseContext)
remoteVideoTrack.addSink(recording)
通话结束后，您需要停止并释放录音。
remoteVideoTrack.removeSink(recording)
recording.release()
这足以录制视频但不录制音频。
对于本地对等方，应将“音频源”设置为MIC，对于远程对等方，应将“音频源”设置为VOICE_CALL。
mediaRecorder = new MediaRecorder()
mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC)
mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP)
mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB)
mediaRecorder.setOutputFile("path/to/audio")
mediaRecorder.prepare()
mediaRecorder.start()
关于挂断发布资源
mediaRecorder.stop()
mediaRecorder.reset()
mediaRecorder.release()
添加此依赖项
implementation 'com.googlecode.mp4parser:isoparser:1.1.22'
然后在通话结束时将此片段添加到您的代码中。确保视频和音频录制已停止并正确释放。
try {
Movie video;
video = MovieCreator.build("path/to/recorded/video");
Movie audio;
audio = MovieCreator.build("path/to/recorded/audio");
Track audioTrack = audio.getTracks().get(0)
video.addTrack(audioTrack);
Container out = new DefaultMp4Builder().build(video);
FileChannel fc = new FileOutputStream(new File("path/to/final/output")).getChannel();
out.writeContainer(fc);
fc.close();
} catch (IOException e) {
e.printStackTrace();
}
我知道这不是在Android WebRTC视频通话中录制音频和视频的最佳解决方案。如果有人知道如何使用WebRTC提取音频，请添加注释。