Saving the audio recording is easy, but what about video?

[Charles92011]

In the audio sink I simply write the audio data out to a binary file and I can post process it to just any format with ffmpeg.
But the video sink doesn't seem to provide an easily writeable buffer the way that audio sink does.

[Charles92011]

	//Audio Sink
	@Override
	public void onData(byte[] data, int bitsPerSample, int sampleRate, int channels, int frames) {
		
		try (FileOutputStream fos = new FileOutputStream(file, true)) {
			
			fos.write(data);
				
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}

	//Video Sink		
	@Override
	public void onVideoFrame(VideoFrame frame) {

		try (FileOutputStream fos = new FileOutputStream(file, true)) {

			// What the heck do I do here?
			
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

[Charles92011]

I found examples of android applications that write the video to a file, but none of them demonstrated the formatting of the output buffer, so I just experimented until I was able to figure it out.

	@Override
	public void onVideoFrame(VideoFrame frame) {

		if (!infoWritten)				
			writeInfo("");

		try {
			videoFileRenderer.queue(frame);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

public class VideoFileRenderer implements Runnable {

	private final Queue<VideoFrame> frameQueue = new ConcurrentLinkedQueue<VideoFrame>();
	private final File file;
	private Thread thread = null;
	
	private int outputFileWidth;
	private int outputFileHeight;
	private int outputFrameSize;
 
	private FileOutputStream fileOutputStream;
	
	private AtomicBoolean headerWritten = new AtomicBoolean(false);
	
	public VideoFileRenderer(File file) {
		
		this.file = file;
	}
	
	public synchronized void queue(VideoFrame videoFrame) throws IOException {
		
		if (headerWritten.getAndSet(true) == false) {
			
			// first time in, set some things up
			
			final VideoFrameBuffer videoFrameBuffer = videoFrame.buffer; 
			
			outputFileWidth = videoFrameBuffer.getWidth();
			outputFileHeight = videoFrameBuffer.getHeight();
			outputFrameSize = outputFileWidth * outputFileHeight * 3 / 2;

			final String fileHeader = String.format("YUV4MPEG2 C420 W%d H%d Ip F30:1 A1:1\n", outputFileWidth, outputFileHeight);
			Log.lo("Video file: %s\n%s", file.getName(), fileHeader);
			
			fileOutputStream = new FileOutputStream(file);
			fileOutputStream.write(fileHeader.getBytes(Charset.forName("US-ASCII")));
			
		}
		
		videoFrame.retain();
		frameQueue.add(videoFrame);
		
		if (thread != null) {
			
			if (thread.isAlive()) return;
		}

		Thread thread = new Thread(this);
		thread.run();
	}
	
	@Override
	public void run() {

		VideoFrame currentFrame;
		
		while ((currentFrame = frameQueue.poll()) != null) {
			
			renderCurrentFrame(currentFrame);
			
		}
	}
	
	private void renderCurrentFrame(VideoFrame currentFrame) {
		
	    final VideoFrameBuffer videoFrameBuffer = currentFrame.buffer;
	    videoFrameBuffer.retain();

	    final I420Buffer i420Buffer = videoFrameBuffer.toI420();
	    i420Buffer.retain();
	    
	    final ByteBuffer outputFrameBuffer = ByteBuffer.allocate(i420Buffer.getDataY().capacity() + 4 + i420Buffer.getDataU().capacity() + 4 + i420Buffer.getDataV().capacity() + 4);

	    outputFrameBuffer.put(i420Buffer.getDataY());
	    outputFrameBuffer.putInt(i420Buffer.getStrideY());
	    
	    outputFrameBuffer.put(i420Buffer.getDataU());
	    outputFrameBuffer.putInt(i420Buffer.getStrideU());
	    
	    outputFrameBuffer.put(i420Buffer.getDataV());
	    outputFrameBuffer.putInt(i420Buffer.getStrideV());

	    i420Buffer.release();
	    videoFrameBuffer.release();
	    currentFrame.release();
	    
	    try {
		    
	    	fileOutputStream.write("FRAME\n".getBytes(Charset.forName("US-ASCII")));
	    	fileOutputStream.write(
	            outputFrameBuffer.array(), outputFrameBuffer.arrayOffset(), outputFrameSize);
	    	
	    } catch (IOException e) {
	    	throw new RuntimeException("Error writing video to disk", e);
	    }

	}
}