video-data-encode-test.js

/*
  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
  Copyright (C) 2019  Streampunk Media Ltd.

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.

  https://www.streampunk.media/ mailto:furnace@streampunk.media
  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
*/

/* Generate a 200 frame test pattern and encode it as a raw H.264 file.

  Usage: node encode_h264.js <filename.h264>

  Output can be viewed in VLC. Make sure "All Files" is selected to see the file.
*/

const beamcoder = require('beamcoder'); // Use require('beamcoder') externally

async function run() {

	let start = process.hrtime();
	let encParams = {
		name: 'libx264',
		width: 1920,
		height: 1080,
		bit_rate: 2000000,
		time_base: [1, 25],
		framerate: [25, 1],
		gop_size: 10,
		max_b_frames: 1,
		pix_fmt: 'yuv420p',
		priv_data: { preset: 'slow' }
	};

	let encoder = await beamcoder.encoder(encParams);
	console.log('Encoder', encoder);

	const mux = beamcoder.muxer({ filename: 'test.ts' });
	let vstr = mux.newStream({
		name: 'h264',
		time_base: [1, 90000],
		interleaved: true }); // Set to false for manual interleaving, true for automatic
	Object.assign(vstr.codecpar, {
		width: 1920,
		height: 1080,
		format: 'yuv420p'
	});
	console.log(vstr);

	let dataStream;
	dataStream = mux.newStream({
		name:        'text',
		time_base:   [1, 90000],
		interleaved: true
	});
	console.log(dataStream);

	await mux.openIO();
	await mux.writeHeader();

	for ( let i = 0 ; i < 50 ; i++ ) {
		let frame = beamcoder.frame({
			width: encParams.width,
			height: encParams.height,
			format: encParams.pix_fmt
		}).alloc();

		let linesize = frame.linesize;
		let [ ydata, bdata, cdata ] = frame.data;
		frame.pts = i+100;

		for ( let y = 0 ; y < frame.height ; y++ ) {
			for ( let x = 0 ; x < linesize[0] ; x++ ) {
				ydata[y * linesize[0] + x] =  x + y + i * 3;
			}
		}

		for ( let y = 0 ; y < frame.height / 2 ; y++) {
			for ( let x = 0; x < linesize[1] ; x++) {
				bdata[y * linesize[1] + x] = 128 + y + i * 2;
				cdata[y * linesize[1] + x] = 64 + x + i * 5;
			}
		}

		let packets = await encoder.encode(frame);
		if ( i % 10 === 0) console.log('Encoding frame', i);
		for (const pkt of packets.packets) {
			pkt.duration = 1;
			pkt.stream_index = vstr.index;
			pkt.pts = pkt.pts * 90000/25;
			pkt.dts = pkt.dts * 90000/25;
			await mux.writeFrame(pkt);
		}

		if(dataStream) {
			const dataBuf = Buffer.from("Hello, world!");
			const dataPacket = beamcoder.packet({
				pts:  frame.pts, // frame is the video frame above
				data: dataBuf,
				size: dataBuf.byteLength,
			});

			console.log(` Writing data pts ${dataPacket.pts * 90000/25} with ${dataBuf.byteLength} bytes`);

			for (const pkt of [ dataPacket ]) {
				pkt.duration = 1;
				pkt.stream_index = dataStream.index;
				pkt.pts = pkt.pts * 90000/25;
				pkt.dts = pkt.dts * 90000/25;
				await mux.writeFrame(pkt);
			}
		}
	}

	let p2 = await encoder.flush();
	console.log('Flushing', p2.packets.length, 'frames.');
	for (const pkt of p2.packets) {
		pkt.duration = 1;
		pkt.stream_index = vstr.index;
		pkt.pts = pkt.pts * 90000/25;
		pkt.dts = pkt.dts * 90000/25;
		await mux.writeFrame(pkt);
	}
	await mux.writeTrailer();

	console.log('Total time ', process.hrtime(start));

	// Try to read data back from the file we created above
	const testFile = 'test.ts';
	const demuxer = await beamcoder.demuxer('file:' + testFile);

	let dataStreamInput = demuxer.streams.find(x => x.codecpar.codec_type === 'data');
	// console.log("Found data stream from input:", dataStreamInput);

	let packet = {};
	while(packet != null) {
		packet = await demuxer.read(); // Read next frame. Note: returns null for EOF
		if (packet && packet.stream_index === dataStreamInput.index) {
			const dataBuf = packet.data.subarray(0, packet.size);
			console.log(`Data: ${packet.pts} [${dataBuf.byteLength} bytes]: ${dataBuf.toString()}`)
		}
	}

	console.log("Done testing");
}

run();