@lumen5/beamcoder 0.0.1

package/test/packetSpec.js

@@ -0,0 +1,122 @@
+/*
+  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.
+*/
+
+const test = require('tape');
+const beamcoder = require('../index.js');
+
+test('Create a packet', t => {
+  let pkt = beamcoder.packet();
+  t.ok(pkt, 'is truthy.');
+  t.equal(typeof pkt._packet, 'object', 'external value present.');
+  t.deepEqual(pkt, { type: 'Packet',
+    pts: null,
+    dts: null,
+    data: null,
+    size: 0,
+    stream_index: 0,
+    flags:
+     { KEY: false,
+       CORRUPT: false,
+       DISCARD: false,
+       TRUSTED: false,
+       DISPOSABLE: false },
+    side_data: null,
+    duration: 0,
+    pos: -1 }, 'has expected minimal value.');
+  t.end();
+});
+
+test('Minimal JSON serialization', t => {
+  let pkt = beamcoder.packet();
+  t.equal(typeof pkt.toJSON, 'function', 'has hidden toJSON function.');
+  let ps = JSON.stringify(pkt);
+  t.equal(typeof ps, 'string', 'stringify created a string.');
+  let pps = JSON.parse(ps);
+  t.deepEqual(pps, { type: 'Packet', stream_index: 0 }, 'made minimal value.');
+  let rpkt = beamcoder.packet(ps);
+  t.ok(rpkt, 'roundtrip packet is truthy.');
+  t.deepEqual(rpkt, { type: 'Packet',
+    pts: null,
+    dts: null,
+    data: null,
+    size: 0,
+    stream_index: 0,
+    flags:
+     { KEY: false,
+       CORRUPT: false,
+       DISCARD: false,
+       TRUSTED: false,
+       DISPOSABLE: false },
+    side_data: null,
+    duration: 0,
+    pos: -1 }, 'has expected minimal value.');
+  t.end();
+});
+
+test('Maximal JSON serialization', t => {
+  let pkt = beamcoder.packet({ type: 'Packet',
+    pts: 42,
+    dts: 43,
+    data: Buffer.from('wibble'),
+    stream_index: 7,
+    flags:
+     { KEY: true,
+       CORRUPT: false,
+       DISCARD: false,
+       TRUSTED: true,
+       DISPOSABLE: false },
+    side_data: { replaygain: Buffer.from('wobble') },
+    duration: 44,
+    pos: 45 });
+  let ps = JSON.stringify(pkt);
+  t.equal(typeof ps, 'string', 'stringify created a string.');
+  let rpkt = beamcoder.packet(ps);
+  t.ok(rpkt, 'roundtrip packet is truthy.');
+  t.deepEqual(rpkt, { type: 'Packet',
+    pts: 42,
+    dts: 43,
+    data: null,
+    size: 0,
+    stream_index: 7,
+    flags:
+     { KEY: true,
+       CORRUPT: false,
+       DISCARD: false,
+       TRUSTED: true,
+       DISPOSABLE: false },
+    side_data:
+     { type: 'PacketSideData',
+       replaygain: Buffer.from([0x77, 0x6f, 0x62, 0x62, 0x6c, 0x65]) },
+    duration: 44,
+    pos: 45 }, 'roundtrips expected values.');
+  t.end();
+});
+
+test('Reset packet data', t => {
+  let p = beamcoder.packet({ pts: 42, size: 4321, data: Buffer.alloc(4321 + beamcoder.AV_INPUT_BUFFER_PADDING_SIZE) });
+  t.ok(Buffer.isBuffer(p.data), 'data is a buffer.');
+  t.notEqual(p.data.length, p.size, 'data length is greater than the packet size.');
+  t.equal(p.data.length, 4321 + beamcoder.AV_INPUT_BUFFER_PADDING_SIZE, 'length is as expected.');
+  p.data = null;
+  t.equal(p.data, null, 'after reset, packet data is set to null.');
+  t.equal(p.size, 4321, 'after reset, size remains at original value.');
+  t.end();
+});

package/types/Beamstreams.d.ts

@@ -0,0 +1,98 @@
+import { Demuxer, DemuxerCreateOptions } from "./Demuxer"
+import { Muxer, MuxerCreateOptions } from "./Muxer"
+import { InputFormat } from "./FormatContext"
+
+/**
+ * A [Node.js Writable stream](https://nodejs.org/docs/latest-v12.x/api/stream.html#stream_writable_streams)
+ * allowing source data to be streamed to the demuxer from a file or other stream source such as a network connection
+ */
+export interface WritableDemuxerStream extends NodeJS.WritableStream {
+	/**
+	 * Create a demuxer for this source
+	 * @param options a DemuxerCreateOptions object
+   * @returns a promise that resolves to a Demuxer when it has determined sufficient 
+	 * format details by consuming data from the source. The promise will wait indefinitely 
+	 * until sufficient source data has been read.
+	 */
+	demuxer(options: DemuxerCreateOptions): Promise<Demuxer>
+}
+/**
+ * Create a WritableDemuxerStream to allow streaming to a Demuxer
+ * @param options.highwaterMark Buffer level when `stream.write()` starts returng false.
+ * @returns A WritableDemuxerStream that can be streamed to.
+ */
+export function demuxerStream(options: { highwaterMark?: number }): WritableDemuxerStream
+
+/**
+ * A [Node.js Readable stream](https://nodejs.org/docs/latest-v12.x/api/stream.html#stream_readable_streams)
+ * allowing data to be streamed from the muxer to a file or other stream destination such as a network connection
+ */
+export interface ReadableMuxerStream extends NodeJS.ReadableStream {
+	/**
+	 * Create a muxer for this source
+	 * @param options a MuxerCreateOptions object
+   * @returns A Muxer object
+	 */
+	muxer(options: MuxerCreateOptions): Muxer
+}
+/**
+ * Create a ReadableMuxerStream to allow streaming from a Muxer
+ * @param options.highwaterMark The maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource.
+ * @returns A ReadableMuxerStream that can be streamed from.
+ */
+export function muxerStream(options: { highwaterMark?: number }): ReadableMuxerStream
+
+/** Create object for AVIOContext based buffered I/O */
+export function governor(options: { highWaterMark: number }): {
+  read(len: number): Promise<Buffer>
+  write(data: Buffer): Promise<null>
+  finish(): undefined
+}
+
+/** Source definition for a beamstream channel, from either a file or NodeJS ReadableStream */
+export interface BeamstreamSource {
+	url?: string
+	input_stream?: NodeJS.ReadableStream
+	ms?: { start: number, end: number }
+	streamIndex?: number
+	iformat?: InputFormat
+  options?: { [key: string]: any }
+}
+/** Codec definition for the destination channel */
+export interface BeamstreamStream {
+	name: string
+	time_base: Array<number>
+	codecpar: { [key: string]: any }
+}
+/** Definition for a channel of beamstream processing */
+export interface BeamstreamChannel {
+	sources: Array<BeamstreamSource>
+	filterSpec: string
+	streams: Array<BeamstreamStream>
+}
+/**
+ * Definition for a beamstream process consisting of a number of audio and video sources
+ * that are to be processed and multiplexed into an output file or stream
+ */
+export interface BeamstreamParams {
+	video?: Array<BeamstreamChannel>
+	audio?: Array<BeamstreamChannel>
+  /** Destination definition for the beamstream process, to either a file or NodeJS WritableStream */
+  out: {
+		formatName: string
+		url?: string
+		output_stream?: NodeJS.WritableStream
+	}
+}
+/**
+ * Initialise the sources for the beamstream process.
+ * Note - the params object is updated by the function.
+ */
+export function makeSources(params: BeamstreamParams): Promise<null>
+/**
+ * Initialise the output streams for the beamstream process.
+ * Note - the params object is updated by the function.
+ * @returns Promise which resolves to an object with a run function that starts the processing
+ */
+export function makeStreams(params: BeamstreamParams): Promise<{ run(): Promise<null>} >
+

package/types/Codec.d.ts

@@ -0,0 +1,123 @@
+import { PrivClass } from "./PrivClass"
+
+export interface Codec {
+	/** Object name. */
+	readonly type: 'Codec'
+	/**
+	 * Name of the codec implementation.
+   * The name is globally unique among encoders and among decoders (but an
+   * encoder and a decoder can share the same name).
+   * This is the primary way to find a codec from the user perspective.
+	 */
+	readonly name: string
+  /** Descriptive name for the codec, meant to be more human readable than name. */
+	readonly long_name: string
+  /** String describing the media type */
+	readonly codec_type: 'unknown' | 'video' | 'audio' | 'data' | 'subtitle' | 'attachment' | 'nb'
+  /** Number that identifies the syntax and semantics of the bitstream. */
+	readonly id: number
+  /** true if codec is an decoder */
+	readonly decoder: boolean
+  /** true if codec is an encoder */
+	readonly encoder: boolean
+  /** Codec capabilities - see AV_CODEC_CAP_* */
+	readonly capabilities: {
+		/** Decoder can use draw_horiz_band callback. */
+		DRAW_HORIZ_BAND: boolean
+		/** Codec uses get_buffer() for allocating buffers and supports custom allocators. */
+		DR1: boolean
+		TRUNCATED: boolean
+		/**
+		 * Decoder requires flushing with NULL input at the end in order to
+     * give the complete and correct output.
+
+		 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
+		 * with NULL data. The user can still send NULL data to the decode function,
+		 * but it will not be passed along to the codec unless this flag is set.
+		 * 
+		 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
+		 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
+		 * returns frames.
+		 */
+		DELAY: boolean
+    /** Codec can be fed a final frame with a smaller size. This can be used to prevent truncation of the last audio samples. */
+		SMALL_LAST_FRAME: boolean
+		/**
+		 * Codec can output multiple frames per APacket
+		 * Normally demuxers return one frame at a time, demuxers which do not do
+		 * are connected to a parser to split what they return into proper frames.
+		 * This flag is reserved to the very rare category of codecs which have a
+		 * bitstream that cannot be split into frames without timeconsuming
+		 * operations like full decoding. Demuxers carrying such bitstreams thus
+		 * may return multiple frames in a packet. This has many disadvantages like
+		 * prohibiting stream copy in many cases thus it should only be considered
+		 * as a last resort.
+ 		 */
+		SUBFRAMES: boolean
+    /** Codec is experimental and is thus avoided in favor of non experimental codecs */
+		EXPERIMENTAL: boolean
+    /** Codec should fill in channel configuration and samplerate instead of container */
+		CHANNEL_CONF: boolean
+		/** Codec supports frame-level multithreading. */
+		FRAME_THREADS: boolean
+		/** Codec supports slice-based (or partition-based) multithreading. */
+		SLICE_THREADS: boolean
+		/** Codec supports changed parameters at any point. */
+		PARAM_CHANGE: boolean
+		/** Codec supports avctx->thread_count == 0 (auto). */
+		AUTO_THREADS: boolean
+		/** Audio encoder supports receiving a different number of samples in each call. */
+		VARIABLE_FRAME_SIZE: boolean
+    /**
+		 * Decoder is not a preferred choice for probing.
+		 * This indicates that the decoder is not a good choice for probing.
+		 * It could for example be an expensive to spin up hardware decoder,
+		 * or it could simply not provide a lot of useful information about
+		 * the stream.
+		 * A decoder marked with this flag should only be used as last resort
+		 * choice for probing.
+		 */
+		AVOID_PROBING: boolean
+    /** Codec is intra only. */
+		INTRA_ONLY: boolean
+		/** Codec is lossless. */
+		LOSSLESS: boolean
+		/** Codec is backed by a hardware implementation. Typically used to identify a non-hwaccel hardware decoder. */
+		HARDWARE: boolean
+		/**
+		 * Codec is potentially backed by a hardware implementation, but not necessarily.
+		 * This is used instead of the HARDWARE flag if the implementation provides some sort of internal fallback.
+		 */
+		HYBRID: boolean
+	}
+  /** Array of supported framerates (as a rational [num, den]), or null if unknown. */
+	readonly supported_framerates: ReadonlyArray<ReadonlyArray<number>> | null
+  /** Array of supported pixel formats, or null if unknown. */
+	readonly pix_fmts: ReadonlyArray<string> | null
+  /** Array of supported audio samplerates, or null if unknown */
+	readonly supported_samplerates: ReadonlyArray<number> | null
+  /** Array of supported sample formats, or NULL if unknown, */
+	readonly sample_fmts: ReadonlyArray<string>
+  /** */
+	readonly channel_layouts: ReadonlyArray<string>
+  /** */
+	readonly max_lowres: number
+	/** Class for private context */
+	readonly priv_class: PrivClass
+  /** */
+	readonly profiles: ReadonlyArray<string> | null
+  /** */
+	readonly wrapper_name?: string
+  /** */
+	readonly descriptor: {
+	  INTRA_ONLY: boolean
+	  LOSSY: boolean
+  	LOSSLESS: boolean
+  	REORDER: boolean
+  	BITMAP_SUB: boolean
+		TEXT_SUB: boolean
+	}
+}
+
+/** List the available codecs */
+export function codecs(): { [key: string]: { encoder?: Codec, decoder?: Codec }}