beamcoder-roundtrip.ts

import beamcoder from 'beamcoder';
import { Readable, Writable } from 'stream';

async function * transform(demuxer: beamcoder.Demuxer) {
  const vdec = beamcoder.decoder({ name: 'h264' });
  const adec = beamcoder.decoder({ name: 'aac' });

  const venc = beamcoder.encoder({ name: 'h264' });
  const aenc = beamcoder.encoder({ name: 'aac' });

  let frames: beamcoder.Frame[];
  let packets: beamcoder.Packet[];
  for (;;) {
    const packet = await demuxer.read();
    if (!packet) break;
    
    const type = demuxer.streams[packet.stream_index].codecpar.codec_type;
    switch(type) {
      case 'video': {
        ({ frames } = await vdec.decode(packet));
        ({ packets } = await venc.encode(frames));
        yield * packets;
        break;
      }
      case 'audio': {
        ({ frames } = await adec.decode(packet));
        ({ packets } = await aenc.encode(frames));
        yield * packets;
        break;
      }
    }
  }

  console.log("Flushing");
  ({ frames } = await vdec.flush());
  ({ packets } = await venc.encode(frames));
  yield * packets;

  ({ frames } = await adec.flush());
  ({ packets } = await aenc.encode(frames));
  yield * packets;

  ({ packets } = await venc.flush());
  yield * packets;

  ({ packets } = await aenc.flush());
  yield * packets;
}

export async function clip(is: Readable, os: Writable) {
  const dmxstream = beamcoder.demuxerStream({ highwaterMark: 1024 });
  is.pipe(dmxstream);
  const demuxer = await dmxstream.demuxer({ });

  const rmxstream = beamcoder.muxerStream({ highwaterMark: 1024 });
  rmxstream.pipe(os);
  const remuxer = rmxstream.muxer({ format_name: 'mpegts' });

  for (const s of demuxer.streams)
    remuxer.newStream(s);

  await remuxer.openIO();
  console.log(await remuxer.initOutput());
  console.log(await remuxer.writeHeader());

  for await (const packet of transform(demuxer))
    remuxer.writeFrame(packet);

  return remuxer.writeTrailer();
}