First release

node_modules/mux.js/cjs/flv/transmuxer.js

@@ -0,0 +1,425 @@
+/**
+ * mux.js
+ *
+ * Copyright (c) Brightcove
+ * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+ */
+'use strict';
+
+var Stream = require('../utils/stream.js');
+
+var FlvTag = require('./flv-tag.js');
+
+var m2ts = require('../m2ts/m2ts.js');
+
+var AdtsStream = require('../codecs/adts.js');
+
+var H264Stream = require('../codecs/h264').H264Stream;
+
+var CoalesceStream = require('./coalesce-stream.js');
+
+var TagList = require('./tag-list.js');
+
+var _Transmuxer, _VideoSegmentStream, _AudioSegmentStream, collectTimelineInfo, metaDataTag, extraDataTag;
+/**
+ * Store information about the start and end of the tracka and the
+ * duration for each frame/sample we process in order to calculate
+ * the baseMediaDecodeTime
+ */
+
+
+collectTimelineInfo = function collectTimelineInfo(track, data) {
+  if (typeof data.pts === 'number') {
+    if (track.timelineStartInfo.pts === undefined) {
+      track.timelineStartInfo.pts = data.pts;
+    } else {
+      track.timelineStartInfo.pts = Math.min(track.timelineStartInfo.pts, data.pts);
+    }
+  }
+
+  if (typeof data.dts === 'number') {
+    if (track.timelineStartInfo.dts === undefined) {
+      track.timelineStartInfo.dts = data.dts;
+    } else {
+      track.timelineStartInfo.dts = Math.min(track.timelineStartInfo.dts, data.dts);
+    }
+  }
+};
+
+metaDataTag = function metaDataTag(track, pts) {
+  var tag = new FlvTag(FlvTag.METADATA_TAG); // :FlvTag
+
+  tag.dts = pts;
+  tag.pts = pts;
+  tag.writeMetaDataDouble('videocodecid', 7);
+  tag.writeMetaDataDouble('width', track.width);
+  tag.writeMetaDataDouble('height', track.height);
+  return tag;
+};
+
+extraDataTag = function extraDataTag(track, pts) {
+  var i,
+      tag = new FlvTag(FlvTag.VIDEO_TAG, true);
+  tag.dts = pts;
+  tag.pts = pts;
+  tag.writeByte(0x01); // version
+
+  tag.writeByte(track.profileIdc); // profile
+
+  tag.writeByte(track.profileCompatibility); // compatibility
+
+  tag.writeByte(track.levelIdc); // level
+
+  tag.writeByte(0xFC | 0x03); // reserved (6 bits), NULA length size - 1 (2 bits)
+
+  tag.writeByte(0xE0 | 0x01); // reserved (3 bits), num of SPS (5 bits)
+
+  tag.writeShort(track.sps[0].length); // data of SPS
+
+  tag.writeBytes(track.sps[0]); // SPS
+
+  tag.writeByte(track.pps.length); // num of PPS (will there ever be more that 1 PPS?)
+
+  for (i = 0; i < track.pps.length; ++i) {
+    tag.writeShort(track.pps[i].length); // 2 bytes for length of PPS
+
+    tag.writeBytes(track.pps[i]); // data of PPS
+  }
+
+  return tag;
+};
+/**
+ * Constructs a single-track, media segment from AAC data
+ * events. The output of this stream can be fed to flash.
+ */
+
+
+_AudioSegmentStream = function AudioSegmentStream(track) {
+  var adtsFrames = [],
+      videoKeyFrames = [],
+      oldExtraData;
+
+  _AudioSegmentStream.prototype.init.call(this);
+
+  this.push = function (data) {
+    collectTimelineInfo(track, data);
+
+    if (track) {
+      track.audioobjecttype = data.audioobjecttype;
+      track.channelcount = data.channelcount;
+      track.samplerate = data.samplerate;
+      track.samplingfrequencyindex = data.samplingfrequencyindex;
+      track.samplesize = data.samplesize;
+      track.extraData = track.audioobjecttype << 11 | track.samplingfrequencyindex << 7 | track.channelcount << 3;
+    }
+
+    data.pts = Math.round(data.pts / 90);
+    data.dts = Math.round(data.dts / 90); // buffer audio data until end() is called
+
+    adtsFrames.push(data);
+  };
+
+  this.flush = function () {
+    var currentFrame,
+        adtsFrame,
+        lastMetaPts,
+        tags = new TagList(); // return early if no audio data has been observed
+
+    if (adtsFrames.length === 0) {
+      this.trigger('done', 'AudioSegmentStream');
+      return;
+    }
+
+    lastMetaPts = -Infinity;
+
+    while (adtsFrames.length) {
+      currentFrame = adtsFrames.shift(); // write out a metadata frame at every video key frame
+
+      if (videoKeyFrames.length && currentFrame.pts >= videoKeyFrames[0]) {
+        lastMetaPts = videoKeyFrames.shift();
+        this.writeMetaDataTags(tags, lastMetaPts);
+      } // also write out metadata tags every 1 second so that the decoder
+      // is re-initialized quickly after seeking into a different
+      // audio configuration.
+
+
+      if (track.extraData !== oldExtraData || currentFrame.pts - lastMetaPts >= 1000) {
+        this.writeMetaDataTags(tags, currentFrame.pts);
+        oldExtraData = track.extraData;
+        lastMetaPts = currentFrame.pts;
+      }
+
+      adtsFrame = new FlvTag(FlvTag.AUDIO_TAG);
+      adtsFrame.pts = currentFrame.pts;
+      adtsFrame.dts = currentFrame.dts;
+      adtsFrame.writeBytes(currentFrame.data);
+      tags.push(adtsFrame.finalize());
+    }
+
+    videoKeyFrames.length = 0;
+    oldExtraData = null;
+    this.trigger('data', {
+      track: track,
+      tags: tags.list
+    });
+    this.trigger('done', 'AudioSegmentStream');
+  };
+
+  this.writeMetaDataTags = function (tags, pts) {
+    var adtsFrame;
+    adtsFrame = new FlvTag(FlvTag.METADATA_TAG); // For audio, DTS is always the same as PTS. We want to set the DTS
+    // however so we can compare with video DTS to determine approximate
+    // packet order
+
+    adtsFrame.pts = pts;
+    adtsFrame.dts = pts; // AAC is always 10
+
+    adtsFrame.writeMetaDataDouble('audiocodecid', 10);
+    adtsFrame.writeMetaDataBoolean('stereo', track.channelcount === 2);
+    adtsFrame.writeMetaDataDouble('audiosamplerate', track.samplerate); // Is AAC always 16 bit?
+
+    adtsFrame.writeMetaDataDouble('audiosamplesize', 16);
+    tags.push(adtsFrame.finalize());
+    adtsFrame = new FlvTag(FlvTag.AUDIO_TAG, true); // For audio, DTS is always the same as PTS. We want to set the DTS
+    // however so we can compare with video DTS to determine approximate
+    // packet order
+
+    adtsFrame.pts = pts;
+    adtsFrame.dts = pts;
+    adtsFrame.view.setUint16(adtsFrame.position, track.extraData);
+    adtsFrame.position += 2;
+    adtsFrame.length = Math.max(adtsFrame.length, adtsFrame.position);
+    tags.push(adtsFrame.finalize());
+  };
+
+  this.onVideoKeyFrame = function (pts) {
+    videoKeyFrames.push(pts);
+  };
+};
+
+_AudioSegmentStream.prototype = new Stream();
+/**
+ * Store FlvTags for the h264 stream
+ * @param track {object} track metadata configuration
+ */
+
+_VideoSegmentStream = function VideoSegmentStream(track) {
+  var nalUnits = [],
+      config,
+      h264Frame;
+
+  _VideoSegmentStream.prototype.init.call(this);
+
+  this.finishFrame = function (tags, frame) {
+    if (!frame) {
+      return;
+    } // Check if keyframe and the length of tags.
+    // This makes sure we write metadata on the first frame of a segment.
+
+
+    if (config && track && track.newMetadata && (frame.keyFrame || tags.length === 0)) {
+      // Push extra data on every IDR frame in case we did a stream change + seek
+      var metaTag = metaDataTag(config, frame.dts).finalize();
+      var extraTag = extraDataTag(track, frame.dts).finalize();
+      metaTag.metaDataTag = extraTag.metaDataTag = true;
+      tags.push(metaTag);
+      tags.push(extraTag);
+      track.newMetadata = false;
+      this.trigger('keyframe', frame.dts);
+    }
+
+    frame.endNalUnit();
+    tags.push(frame.finalize());
+    h264Frame = null;
+  };
+
+  this.push = function (data) {
+    collectTimelineInfo(track, data);
+    data.pts = Math.round(data.pts / 90);
+    data.dts = Math.round(data.dts / 90); // buffer video until flush() is called
+
+    nalUnits.push(data);
+  };
+
+  this.flush = function () {
+    var currentNal,
+        tags = new TagList(); // Throw away nalUnits at the start of the byte stream until we find
+    // the first AUD
+
+    while (nalUnits.length) {
+      if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
+        break;
+      }
+
+      nalUnits.shift();
+    } // return early if no video data has been observed
+
+
+    if (nalUnits.length === 0) {
+      this.trigger('done', 'VideoSegmentStream');
+      return;
+    }
+
+    while (nalUnits.length) {
+      currentNal = nalUnits.shift(); // record the track config
+
+      if (currentNal.nalUnitType === 'seq_parameter_set_rbsp') {
+        track.newMetadata = true;
+        config = currentNal.config;
+        track.width = config.width;
+        track.height = config.height;
+        track.sps = [currentNal.data];
+        track.profileIdc = config.profileIdc;
+        track.levelIdc = config.levelIdc;
+        track.profileCompatibility = config.profileCompatibility;
+        h264Frame.endNalUnit();
+      } else if (currentNal.nalUnitType === 'pic_parameter_set_rbsp') {
+        track.newMetadata = true;
+        track.pps = [currentNal.data];
+        h264Frame.endNalUnit();
+      } else if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
+        if (h264Frame) {
+          this.finishFrame(tags, h264Frame);
+        }
+
+        h264Frame = new FlvTag(FlvTag.VIDEO_TAG);
+        h264Frame.pts = currentNal.pts;
+        h264Frame.dts = currentNal.dts;
+      } else {
+        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
+          // the current sample is a key frame
+          h264Frame.keyFrame = true;
+        }
+
+        h264Frame.endNalUnit();
+      }
+
+      h264Frame.startNalUnit();
+      h264Frame.writeBytes(currentNal.data);
+    }
+
+    if (h264Frame) {
+      this.finishFrame(tags, h264Frame);
+    }
+
+    this.trigger('data', {
+      track: track,
+      tags: tags.list
+    }); // Continue with the flush process now
+
+    this.trigger('done', 'VideoSegmentStream');
+  };
+};
+
+_VideoSegmentStream.prototype = new Stream();
+/**
+ * An object that incrementally transmuxes MPEG2 Trasport Stream
+ * chunks into an FLV.
+ */
+
+_Transmuxer = function Transmuxer(options) {
+  var self = this,
+      packetStream,
+      parseStream,
+      elementaryStream,
+      videoTimestampRolloverStream,
+      audioTimestampRolloverStream,
+      timedMetadataTimestampRolloverStream,
+      adtsStream,
+      h264Stream,
+      videoSegmentStream,
+      audioSegmentStream,
+      captionStream,
+      coalesceStream;
+
+  _Transmuxer.prototype.init.call(this);
+
+  options = options || {}; // expose the metadata stream
+
+  this.metadataStream = new m2ts.MetadataStream();
+  options.metadataStream = this.metadataStream; // set up the parsing pipeline
+
+  packetStream = new m2ts.TransportPacketStream();
+  parseStream = new m2ts.TransportParseStream();
+  elementaryStream = new m2ts.ElementaryStream();
+  videoTimestampRolloverStream = new m2ts.TimestampRolloverStream('video');
+  audioTimestampRolloverStream = new m2ts.TimestampRolloverStream('audio');
+  timedMetadataTimestampRolloverStream = new m2ts.TimestampRolloverStream('timed-metadata');
+  adtsStream = new AdtsStream();
+  h264Stream = new H264Stream();
+  coalesceStream = new CoalesceStream(options); // disassemble MPEG2-TS packets into elementary streams
+
+  packetStream.pipe(parseStream).pipe(elementaryStream); // !!THIS ORDER IS IMPORTANT!!
+  // demux the streams
+
+  elementaryStream.pipe(videoTimestampRolloverStream).pipe(h264Stream);
+  elementaryStream.pipe(audioTimestampRolloverStream).pipe(adtsStream);
+  elementaryStream.pipe(timedMetadataTimestampRolloverStream).pipe(this.metadataStream).pipe(coalesceStream); // if CEA-708 parsing is available, hook up a caption stream
+
+  captionStream = new m2ts.CaptionStream(options);
+  h264Stream.pipe(captionStream).pipe(coalesceStream); // hook up the segment streams once track metadata is delivered
+
+  elementaryStream.on('data', function (data) {
+    var i, videoTrack, audioTrack;
+
+    if (data.type === 'metadata') {
+      i = data.tracks.length; // scan the tracks listed in the metadata
+
+      while (i--) {
+        if (data.tracks[i].type === 'video') {
+          videoTrack = data.tracks[i];
+        } else if (data.tracks[i].type === 'audio') {
+          audioTrack = data.tracks[i];
+        }
+      } // hook up the video segment stream to the first track with h264 data
+
+
+      if (videoTrack && !videoSegmentStream) {
+        coalesceStream.numberOfTracks++;
+        videoSegmentStream = new _VideoSegmentStream(videoTrack); // Set up the final part of the video pipeline
+
+        h264Stream.pipe(videoSegmentStream).pipe(coalesceStream);
+      }
+
+      if (audioTrack && !audioSegmentStream) {
+        // hook up the audio segment stream to the first track with aac data
+        coalesceStream.numberOfTracks++;
+        audioSegmentStream = new _AudioSegmentStream(audioTrack); // Set up the final part of the audio pipeline
+
+        adtsStream.pipe(audioSegmentStream).pipe(coalesceStream);
+
+        if (videoSegmentStream) {
+          videoSegmentStream.on('keyframe', audioSegmentStream.onVideoKeyFrame);
+        }
+      }
+    }
+  }); // feed incoming data to the front of the parsing pipeline
+
+  this.push = function (data) {
+    packetStream.push(data);
+  }; // flush any buffered data
+
+
+  this.flush = function () {
+    // Start at the top of the pipeline and flush all pending work
+    packetStream.flush();
+  }; // Caption data has to be reset when seeking outside buffered range
+
+
+  this.resetCaptions = function () {
+    captionStream.reset();
+  }; // Re-emit any data coming from the coalesce stream to the outside world
+
+
+  coalesceStream.on('data', function (event) {
+    self.trigger('data', event);
+  }); // Let the consumer know we have finished flushing the entire pipeline
+
+  coalesceStream.on('done', function () {
+    self.trigger('done');
+  });
+};
+
+_Transmuxer.prototype = new Stream(); // forward compatibility
+
+module.exports = _Transmuxer;