external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-15 04:42:04 +00:00
Code Issues Releases Wiki Activity
srs/trunk/research/players/srs_player/src/Hls.as

4744 lines
195 KiB
ActionScript
Raw Normal View History

support play hls
2016-03-19 08:35:13 +00:00
package
{
import flash.events.Event;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.utils.ByteArray;
/**
* the hls main class.
*/
public class Hls
{
private var m3u8:M3u8;
private var avc:SrsRawH264Stream;
private var h264_sps:ByteArray;
private var h264_pps:ByteArray;
private var aac:SrsRawAacStream;
private var aac_specific_config:ByteArray;
private var width:int;
private var height:int;
private var video_sh_tag:ByteArray;
private var audio_sh_tag:ByteArray;
private var owner:M3u8Player;
private var _log:ILogger = new TraceLogger("HLS");
public static const SRS_TS_PACKET_SIZE:int = 188;
public function Hls(o:M3u8Player)
{
owner = o;
m3u8 = new M3u8(this);
reset();
}
/**
* parse the m3u8.
* @param url, the m3u8 url, for m3u8 to generate the ts url.
* @param v, the m3u8 string.
*/
public function parse(url:String, v:String):void
{
// TODO: FIXME: reset the hls when parse.
m3u8.parse(url, v);
}
/**
* get the total count of ts in m3u8.
*/
public function get tsCount():Number
{
return m3u8.tsCount;
}
/**
* get the total duration in seconds of m3u8.
*/
public function get duration():Number
{
return m3u8.duration;
}
/**
* get the sequence number, the id of first ts.
*/
public function get seq_no():Number
{
return m3u8.seq_no;
}
/**
* whether the m3u8 contains variant m3u8.
*/
public function get variant():Boolean
{
return m3u8.variant;
}
/**
* dumps the metadata, for example, set the width and height,
* which is decoded from sps.
*/
public function dumpMetaData(metadata:Object):void
{
if (width > 0) {
metadata.width = width;
}
if (height > 0) {
metadata.height = height;
}
}
/**
* get the ts url by piece id, which is actually the piece index.
*/
public function getTsUrl(pieceId:Number):String
{
return m3u8.getTsUrl(pieceId);
}
/**
* reset the HLS when parse m3u8.
*/
public function reset():void
{
avc = new SrsRawH264Stream();
h264_sps = new ByteArray();
h264_pps = new ByteArray();
aac = new SrsRawAacStream();
aac_specific_config = new ByteArray();
width = 0;
height = 0;
video_sh_tag = new ByteArray();
audio_sh_tag = new ByteArray();
}
/**
* parse the piece in hls format,
* set the piece.skip if error.
* @param onParsed, a function(piece:FlvPiece, body:ByteArray):void callback.
*/
public function parseBodyAsync(piece:FlvPiece, data:ByteArray, body:ByteArray, onParsed:Function):void
{
var handler:SrsTsHanlder = new SrsTsHanlder(
avc, aac,
h264_sps, h264_pps,
aac_specific_config,
video_sh_tag, audio_sh_tag,
this, body,
_on_size_changed, _on_sequence_changed
);
// the context used to parse the whole ts file.
var context:SrsTsContext = new SrsTsContext(this);
// we assumpt to parse the piece in 10 times.
// the total parse time is 10*AlgP2P.HlsAsyncParseTimeout
var ts_packets:uint = data.length / SRS_TS_PACKET_SIZE;
var each_parse:uint = ts_packets / 10;
var nb_parsed:uint = 0;
var aysncParse:Function = function():void {
try {
// do the parse.
doParseBody(piece, data, body, handler, context, each_parse);
// check whether parsed.
nb_parsed += each_parse;
if (nb_parsed < ts_packets) {
refine srs player to play hls.
2016-03-19 11:11:31 +00:00
flash.utils.setTimeout(aysncParse, Consts.TsParseAsyncInterval);
support play hls
2016-03-19 08:35:13 +00:00
return;
}
// flush the messages in queue.
handler.flush_message_queue(body);
__report(body);
_log.info("hls async parsed to flv, piece={0}, hls={1}B, flv={2}B", piece.pieceId, data.length, body.length);
} catch (e:Error) {
piece.skip = true;
_log.error("hls async parse piece={0}, exception={1}, stack={2}",
piece.pieceId, e.message, e.getStackTrace());
}
onParsed(piece, body);
};
aysncParse();
}
/**
* parse the piece in hls format,
* set the piece.skip if error.
*/
public function parseBody(piece:FlvPiece, data:ByteArray, body:ByteArray):void
{
try {
var handler:SrsTsHanlder = new SrsTsHanlder(
avc, aac,
h264_sps, h264_pps,
aac_specific_config,
video_sh_tag, audio_sh_tag,
this, body,
_on_size_changed, _on_sequence_changed
);
// the context used to parse the whole ts file.
var context:SrsTsContext = new SrsTsContext(this);
// do the parse.
doParseBody(piece, data, body, handler, context, -1);
// flush the messages in queue.
handler.flush_message_queue(body);
__report(body);
_log.info("hls sync parsed to flv, piece={0}, hls={1}B, flv={2}B", piece.pieceId, data.length, body.length);
} catch (e:Error) {
piece.skip = true;
_log.error("hls sync parse piece={0}, exception={1}, stack={2}",
piece.pieceId, e.message, e.getStackTrace());
}
}
private function _on_size_changed(w:int, h:int):void
{
width = w;
height = h;
}
private function _on_sequence_changed(
pavc:SrsRawH264Stream, paac:SrsRawAacStream,
ph264_sps:ByteArray, ph264_pps:ByteArray,
paac_specific_config:ByteArray,
pvideo_sh_tag:ByteArray, paudio_sh_tag:ByteArray,
sh:ByteArray):void
{
// when sequence header not changed, ignore.
if (SrsUtils.array_equals(h264_sps, ph264_sps)) {
if (SrsUtils.array_equals(h264_pps, ph264_pps)) {
if (SrsUtils.array_equals(aac_specific_config, paac_specific_config)) {
return;
}
}
}
avc = pavc;
h264_sps = ph264_sps;
h264_pps = ph264_pps;
aac = paac;
aac_specific_config = paac_specific_config;
video_sh_tag = pvideo_sh_tag;
audio_sh_tag = paudio_sh_tag;
_log.info("hls: got sequence header, ash={0}B, bsh={1}B", audio_sh_tag.length, video_sh_tag.length);
owner.flvHeader = sh;
owner.onSequenceHeader();
__report(sh);
}
/**
* do the parse.
* @maxTsPackets the max ts packets to parse, stop when exceed this ts packet.
* -1 to parse all packets.
*/
private function doParseBody(
piece:FlvPiece, data:ByteArray, body:ByteArray,
handler:SrsTsHanlder, context:SrsTsContext, maxTsPackets:int):void
{
for (var i:int = 0; (maxTsPackets == -1 || i < maxTsPackets) && data.bytesAvailable > 0; i++) {
var tsBytes:ByteArray = new ByteArray();
data.readBytes(tsBytes, 0, Hls.SRS_TS_PACKET_SIZE);
context.decode(tsBytes, handler);
}
}
private function __report(flv:ByteArray):void
{
// report only for debug.
return;
var url:URLRequest = new URLRequest("http://192.168.10.108:1980/api/v3/file");
url.data = flv;
url.method = URLRequestMethod.POST;
var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE, function(e:Event):void {
loader.close();
});
loader.load(url);
}
}
}
import flash.utils.ByteArray;
class SrsTsHanlder implements ISrsTsHandler
{
private var avc:SrsRawH264Stream;
private var h264_sps:ByteArray;
private var h264_pps:ByteArray;
private var h264_sps_changed:Boolean;
private var h264_pps_changed:Boolean;
private var aac:SrsRawAacStream;
private var aac_specific_config:ByteArray;
private var width:int;
private var height:int;
private var video_sh_tag:ByteArray;
private var audio_sh_tag:ByteArray;
private var queue:Array;
// hls data.
private var _hls:Hls;
private var _body:ByteArray;
private var _on_size_changed:Function;
private var _on_sequence_changed:Function;
private var _log:ILogger = new TraceLogger("HLS");
public function SrsTsHanlder(
pavc:SrsRawH264Stream, paac:SrsRawAacStream,
ph264_sps:ByteArray, ph264_pps:ByteArray,
paac_specific_config:ByteArray,
pvideo_sh_tag:ByteArray, paudio_sh_tag:ByteArray,
hls:Hls, body:ByteArray, oszc:Function, oshc:Function)
{
_hls = hls;
_body = body;
_on_size_changed = oszc;
_on_sequence_changed = oshc;
avc = pavc;
h264_sps = ph264_sps;
h264_pps = ph264_pps;
aac = paac;
aac_specific_config = paac_specific_config;
video_sh_tag = pvideo_sh_tag;
audio_sh_tag = paudio_sh_tag;
queue = new Array();
width = 0;
height = 0;
h264_sps_changed = false;
h264_pps_changed = false;
}
public function on_ts_message(msg:SrsTsMessage):void
{
do_on_ts_message(msg, _body);
}
private function do_on_ts_message(msg:SrsTsMessage, body:ByteArray):void
{
// @see SrsMpegtsOverUdp::on_ts_message
if (false) {
_log.info("got ts {4} message, dts={0}, pts={1}, size={2}/{3}",
msg.dts, msg.pts, msg.PES_packet_length, msg.payload.length,
(msg.channel.apply.equals(SrsTsPidApply.Video)? "Video":"Audio"));
} else {
_log.debug("got ts {4} message, dts={0}, pts={1}, size={2}/{3}",
msg.dts, msg.pts, msg.PES_packet_length, msg.payload.length,
(msg.channel.apply.equals(SrsTsPidApply.Video)? "Video":"Audio"));
}
// when not audio/video, or not adts/annexb format, donot support.
if (msg.stream_number() != 0) {
throw new Error("mpegts: unsupported stream format, sid=" + msg.stream_number());
}
// check supported codec
if (msg.channel.stream != SrsTsStream.VideoH264 && msg.channel.stream != SrsTsStream.AudioAAC) {
throw new Error("mpegts: unsupported stream codec=" + msg.channel.stream.toString());
}
// we must use queue to cache the msg, then parse it if possible.
queue.push(msg);
parse_message_queue(body);
}
private function parse_message_queue(body:ByteArray):void
{
if (queue.length == 0) {
return;
}
var first_ts_msg:SrsTsMessage = queue[0] as SrsTsMessage;
var context:SrsTsContext = first_ts_msg.channel.context;
var cpa:Boolean = context.is_pure_audio();
var nb_videos:uint = 0;
if (!cpa) {
for (var i:int = 0; i < queue.length; i++) {
var msg:SrsTsMessage = queue[i] as SrsTsMessage;
// publish audio or video.
if (msg.channel.stream == SrsTsStream.VideoH264) {
nb_videos++;
}
}
// always wait 2+ videos, to left one video in the queue.
// TODO: FIXME: support pure audio hls.
if (nb_videos <= 1) {
return;
}
}
// we must sort the adio and videos, for they maybe not monotonically increase.
queue.sort(function(a:SrsTsMessage, b:SrsTsMessage):int{
return a.dts - b.dts;
});
// parse messages util the last video.
while ((cpa && queue.length > 1) || nb_videos > 1) {
if (queue.length == 0) {
throw new Error("assert queue not empty.");
}
msg = queue[0] as SrsTsMessage;
if (msg.channel.stream == SrsTsStream.VideoH264) {
nb_videos--;
}
queue.splice(0, 1);
// publish audio or video.
if (msg.channel.stream == SrsTsStream.VideoH264) {
on_ts_video(msg, body);
}
if (msg.channel.stream == SrsTsStream.AudioAAC) {
on_ts_audio(msg, body);
}
}
}
public function flush_message_queue(body:ByteArray):void
{
for (var i:int = 0; i < queue.length; i++) {
var msg:SrsTsMessage = queue[i] as SrsTsMessage;
// publish audio or video.
if (msg.channel.stream == SrsTsStream.VideoH264) {
on_ts_video(msg, body);
}
if (msg.channel.stream == SrsTsStream.AudioAAC) {
on_ts_audio(msg, body);
}
}
// clear queue.
queue = new Array();
}
private function on_ts_video(msg:SrsTsMessage, body:ByteArray):void
{
// ts tbn to flv tbn.
var dts:uint = (uint)(msg.dts / 90);
var pts:uint = (uint)(msg.pts / 90);
var ibps:ByteArray = new ByteArray();
var frame_type:uint = SrsConsts.SrsCodecVideoAVCFrameInterFrame;
// each frame must prefixed by annexb format.
// first check the msg.payload outside the while cycle, to avoid throw error inside.
// if msg.payload not startwith annexb, just return.
var annexb:Object = SrsUtils.srs_avc_startswith_annexb(msg.payload);
if (!annexb.ok) {
_log.warn("msg.payload not startwith annexb, drop size={0}B, dts={1}", msg.payload.length, dts);
return;
}
// group each NALU frame to a RTMP/flv/ts message
while (msg.payload.bytesAvailable) {
var frame:ByteArray = avc.annexb_demux(msg.payload);
// 5bits, 7.3.1 NAL unit syntax,
// H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
// 7: SPS, 8: PPS, 5: I Frame, 1: P Frame
var nal_unit_type:uint = (uint)(frame[0] & 0x1f);
// for IDR frame, the frame is keyframe.
if (nal_unit_type == SrsConsts.SrsAvcNaluTypeIDR) {
frame_type = SrsConsts.SrsCodecVideoAVCFrameKeyFrame;
}
// ignore the nalu type aud(9)
if (nal_unit_type == SrsConsts.SrsAvcNaluTypeAccessUnitDelimiter) {
var aud_nalu:String = "";
for (var i:int = 0; i < frame.length; i++) {
aud_nalu += " 0x" + int(frame[i]).toString(16);
}
_log.debug("hls, aud nalu: {0}", aud_nalu);
continue;
}
// for sps
if (avc.is_sps(frame)) {
var sps:ByteArray = avc.sps_demux(frame);
if (SrsUtils.array_equals(h264_sps, sps)) {
continue;
}
h264_sps = sps;
h264_sps_changed = true;
// demux the sps, get the width x height.
avc_demux_sps(sps);
if (false) {
_log.info("hls: got sps, size={0}B", sps.length);
} else {
_log.debug("hls: got sps, size={0}B", sps.length);
}
continue;
}
// for pps
if (avc.is_pps(frame)) {
var pps:ByteArray = avc.pps_demux(frame);
if (SrsUtils.array_equals(h264_pps, pps)) {
continue;
}
h264_pps = pps;
h264_pps_changed = true;
if (false) {
_log.info("hls: got pps, size={0}B", pps.length);
} else {
_log.debug("hls: got pps, size={0}B", pps.length);
}
continue;
}
// ibp frame.
//info("mpegts: demux avc ibp frame size=%d, dts=%d", ibpframe_size, dts);
var ibp:ByteArray = avc.mux_ipb_frame(frame);
ibps.writeBytes(ibp);
}
write_h264_sps_pps(msg.channel.context, dts, pts);
write_h264_ipb_frame(ibps, frame_type, dts, pts, body);
}
private function on_ts_audio(msg:SrsTsMessage, piece:ByteArray):void
{
// ts tbn to flv tbn.
var dts:uint = msg.dts / 90;
// got the next message to calc the delta duration for each audio.
var duration:uint = 0;
if (queue.length > 0) {
var nm:SrsTsMessage = queue[0] as SrsTsMessage;
duration = (uint)(Math.max(0, nm.dts - msg.dts) / 90);
}
var min_dts:uint = dts;
var max_dts:uint = min_dts + duration;
// send each frame.
while (msg.payload.bytesAvailable) {
var ret:Object = aac.adts_demux(msg.payload);
var frame:ByteArray = ret.frame;
var codec:SrsRawAacStreamCodec = ret.codec;
// ignore invalid frame,
// * atleast 1bytes for aac to decode the data.
if (!frame.bytesAvailable) {
continue;
}
//info("mpegts: demux aac frame size=%d, dts=%d", frame_size, dts);
// generate sh.
if (!aac_specific_config.length) {
aac_specific_config = aac.mux_sequence_header(codec);
codec.aac_packet_type = 0;
if (false) {
_log.info("hls: got audio specific config, size={0}B", aac_specific_config.length);
} else {
_log.debug("hls: got audio specific config, size={0}B", aac_specific_config.length);
}
var tag_body:ByteArray = aac.mux_aac2flv(aac_specific_config, codec, dts);
audio_sh_tag = mux_flv_packet(SrsConsts.SrsCodecFlvTagAudio, dts, tag_body);
on_sequence_header(msg.channel.context);
}
// audio raw data.
codec.aac_packet_type = 1;
write_audio_raw_frame(frame, codec, dts, piece);
// calc the delta of dts, when previous frame output.
var delta:uint = duration / (msg.payload.length / frame.length);
dts = (uint)(Math.min(max_dts, dts + delta));
if (msg.payload.bytesAvailable) {
_log.debug("Audio [{0}, {1}], the A2+ is {2}", min_dts, max_dts, dts);
}
}
}
private function write_audio_raw_frame(frame:ByteArray, codec:SrsRawAacStreamCodec, dts:uint, piece:ByteArray):void
{
var tag_body:ByteArray = aac.mux_aac2flv(frame, codec, dts);
var tag:ByteArray = mux_flv_packet(SrsConsts.SrsCodecFlvTagAudio, dts, tag_body);
// append flv packet to piece.
piece.writeBytes(tag);
}
private function avc_demux_sps(sps:ByteArray):void
{
sps.position = 0;
if (false) {
var str:String = "";
for (var i:int = 0; i < sps.length; i++) {
str += " 0x" + int(sps[i]).toString(16);
}
}
var nalu_type:uint = sps.readUnsignedByte();
if ((nalu_type & 0x1f) != SrsConsts.SrsAvcNaluTypeSPS) {
_log.warn("avc: sps nalu type invalid.");
return;
}
var rbsp:ByteArray = new ByteArray();
while (sps.bytesAvailable) {
rbsp.writeByte(sps.readByte());
// XX 00 00 03 XX, the 03 byte should be drop.
var nb_rbsp:uint = rbsp.length;
if (nb_rbsp > 2) {
var p2:uint = rbsp[nb_rbsp - 3];
var p1:uint = rbsp[nb_rbsp - 2];
var p0:uint = rbsp[nb_rbsp - 1];
if (p2 == 0 && p1 == 0 && p0 == 3) {
rbsp.position = rbsp.length - 1;
// read 1 byte more.
if (!sps.bytesAvailable) {
break;
}
rbsp.writeByte(sps.readByte());
}
}
}
try {
avc_demux_sps_rbsp(rbsp);
} catch (e:Error) {
_log.warn(e.message);
}
}
private function avc_demux_sps_rbsp(rbsp:ByteArray):void
{
rbsp.position = 0;
// for SPS, 7.3.2.1.1 Sequence parameter set data syntax
// H.264-AVC-ISO_IEC_14496-10-2012.pdf, page 62.
if (rbsp.bytesAvailable < 3) {
_log.warn("avc: sps shall atleast 3bytes");
return;
}
var profile_idc:uint = rbsp.readUnsignedByte();
var flags:uint = rbsp.readUnsignedByte();
var level_idc:uint = rbsp.readUnsignedByte();
var bs:SrsBitStream = new SrsBitStream(rbsp);
var seq_parameter_set_id:uint = SrsUtils.srs_avc_nalu_read_uev(bs);
_log.debug("sps parse profile={0}, level={1}, sps_id={2}", profile_idc, level_idc, seq_parameter_set_id);
if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244
|| profile_idc == 44 || profile_idc == 83 || profile_idc == 86 || profile_idc == 118
|| profile_idc == 128
) {
var chroma_format_idc:int = SrsUtils.srs_avc_nalu_read_uev(bs);
if (chroma_format_idc == 3) {
var separate_colour_plane_flag:int = SrsUtils.srs_avc_nalu_read_bit(bs);
}
var bit_depth_luma_minus8:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var bit_depth_chroma_minus8:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var qpprime_y_zero_transform_bypass_flag:int = SrsUtils.srs_avc_nalu_read_bit(bs);
var seq_scaling_matrix_present_flag:int = SrsUtils.srs_avc_nalu_read_bit(bs);
if (seq_scaling_matrix_present_flag) {
throw new Error("sps seq_scaling_matrix_present_flag not zero.");
}
_log.debug("sps cfi={0}, bdlm={1}, bdcm={2}, qyztb={3}, ssmpf={4}",
chroma_format_idc, bit_depth_luma_minus8, bit_depth_chroma_minus8,
qpprime_y_zero_transform_bypass_flag, seq_scaling_matrix_present_flag);
}
var log2_max_frame_num_minus4:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var pic_order_cnt_type:int = SrsUtils.srs_avc_nalu_read_uev(bs);
if (pic_order_cnt_type == 0) {
var log2_max_pic_order_cnt_lsb_minus4:int = SrsUtils.srs_avc_nalu_read_uev(bs);
_log.debug("sps lmpoclm={0}", log2_max_pic_order_cnt_lsb_minus4);
} else if (pic_order_cnt_type == 1) {
var delta_pic_order_always_zero_flag:int = SrsUtils.srs_avc_nalu_read_bit(bs);
var offset_for_non_ref_pic:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var offset_for_top_to_bottom_field:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var num_ref_frames_in_pic_order_cnt_cycle:int = SrsUtils.srs_avc_nalu_read_uev(bs);
_log.debug("sps dpoazf={0}, ofnrp={1}, ofttbf={2}, nrfipocc={3}",
delta_pic_order_always_zero_flag, offset_for_non_ref_pic, offset_for_top_to_bottom_field,
num_ref_frames_in_pic_order_cnt_cycle);
}
var max_num_ref_frames:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var gaps_in_frame_num_value_allowed_flag:int = SrsUtils.srs_avc_nalu_read_bit(bs);
var pic_width_in_mbs_minus1:int = SrsUtils.srs_avc_nalu_read_uev(bs);
var pic_height_in_map_units_minus1:int = SrsUtils.srs_avc_nalu_read_uev(bs);
width = (int)(pic_width_in_mbs_minus1 + 1) * 16;
height = (int)(pic_height_in_map_units_minus1 + 1) * 16;
_log.info("sps parse profile={0}, level={1}, size={2}x{3}", profile_idc, level_idc, width, height);
_on_size_changed(width, height);
}
private function write_h264_sps_pps(context:SrsTsContext, dts:uint, pts:uint):void
{
if (!h264_sps_changed && !h264_pps_changed) {
return;
}
// when not got sps/pps, wait.
if (h264_pps.length == 0 || h264_sps.length == 0) {
return;
}
// h264 raw to h264 packet.
var sh:ByteArray = avc.mux_sequence_header(h264_sps, h264_pps, dts, pts);
// h264 packet to flv packet.
var frame_type:uint = SrsConsts.SrsCodecVideoAVCFrameKeyFrame;
var avc_packet_type:uint = SrsConsts.SrsCodecVideoAVCTypeSequenceHeader;
var tag_body:ByteArray = avc.mux_avc2flv(sh, frame_type, avc_packet_type, dts, pts);
// the timestamp in rtmp message header is dts.
video_sh_tag = mux_flv_packet(SrsConsts.SrsCodecFlvTagVideo, dts, tag_body);
on_sequence_header(context);
}
private function write_h264_ipb_frame(ibps:ByteArray, frame_type:uint, dts:uint, pts:uint, piece:ByteArray):void
{
// when sps or pps not sent, ignore the packet.
// @see https://github.com/winlinvip/simple-rtmp-server/issues/203
if (video_sh_tag.length == 0) {
return;
}
var avc_packet_type:uint = SrsConsts.SrsCodecVideoAVCTypeNALU;
var tag_body:ByteArray = avc.mux_avc2flv(ibps, frame_type, avc_packet_type, dts, pts);
// the timestamp in rtmp message header is dts.
var timestamp:uint = dts;
var tag:ByteArray = mux_flv_packet(SrsConsts.SrsCodecFlvTagVideo, timestamp, tag_body);
// append flv packet to piece.
piece.writeBytes(tag);
}
private function mux_flv_packet(type:uint, timestamp:uint, flv:ByteArray):ByteArray
{
// E.4.1 FLV Tag
var packet:ByteArray = new ByteArray();
// Reserved UB [2]
// Filter UB [1]
// TagType UB [5]
packet.writeByte(type & 0x1f);
// DataSize UI24
var size:uint = flv.length;
packet.writeByte(size >> 16);
packet.writeByte(size >> 8);
packet.writeByte(size);
// Timestamp UI24
var dts:uint = timestamp;
packet.writeByte(dts >> 16);
packet.writeByte(dts >> 8);
packet.writeByte(dts);
// TimestampExtended UI8
packet.writeByte(dts >> 24);
// StreamID, UI24, Always 0.
packet.writeByte(0x00);
packet.writeByte(0x00);
packet.writeByte(0x00);
// tag body.
packet.writeBytes(flv);
// PreviousTagSizeN, UI32, Size of last tag, including its header, in bytes.
size = packet.length;
packet.writeUnsignedInt(size);
if (false) {
_log.info("mux flv type={0}, time={1}, size={3}", type, timestamp, dts, packet.length);
} else {
_log.debug("mux flv type={0}, time={1}, size={3}", type, timestamp, dts, packet.length);
}
return packet;
}
private function on_sequence_header(context:SrsTsContext):void
{
if (!audio_sh_tag.length) {
return;
}
if (!context.is_pure_audio() && !video_sh_tag.length) {
return;
}
var sh:ByteArray = new ByteArray();
// @remark HSS without flv header.
// 9bytes header and 4bytes first previous-tag-size
// Signatures "FLV"
sh.writeByte(0x46); // 'F'
sh.writeByte(0x4c); // 'L'
sh.writeByte(0x56); // 'V'
// File version (for example, 0x01 for FLV version 1)
sh.writeByte(0x01);
// 4, audio; 1, video; 5 audio+video.
if (context.is_pure_audio()) {
sh.writeByte(0x04);
} else {
sh.writeByte(0x05);
}
// DataOffset UI32 The length of this header in bytes
sh.writeUnsignedInt(0x00000009);
// previous tag size.
sh.writeUnsignedInt(0x00000000);
// append video and audio sequence header.
if (!context.is_pure_audio()) {
sh.writeBytes(video_sh_tag);
}
sh.writeBytes(audio_sh_tag);
// reset the positions.
h264_sps.position = 0;
h264_pps.position = 0;
aac_specific_config.position = 0;
video_sh_tag.position = 0;
audio_sh_tag.position = 0;
// notice the HLS to change sh if should to.
_on_sequence_changed(
avc, aac,
h264_sps, h264_pps,
aac_specific_config,
video_sh_tag, audio_sh_tag,
sh
);
}
}
class SrsConsts
{
// E.4.3.1 VIDEODATA
// Frame Type UB [4]
// Type of video frame. The following values are defined:
// 1 = key frame (for AVC, a seekable frame)
// 2 = inter frame (for AVC, a non-seekable frame)
// 3 = disposable inter frame (H.263 only)
// 4 = generated key frame (reserved for server use only)
// 5 = video info/command frame
public static const SrsCodecVideoAVCFrameReserved:uint = 0;
public static const SrsCodecVideoAVCFrameReserved1:uint = 6;
public static const SrsCodecVideoAVCFrameKeyFrame:uint = 1;
public static const SrsCodecVideoAVCFrameInterFrame:uint = 2;
public static const SrsCodecVideoAVCFrameDisposableInterFrame:uint = 3;
public static const SrsCodecVideoAVCFrameGeneratedKeyFrame:uint = 4;
public static const SrsCodecVideoAVCFrameVideoInfoFrame:uint = 5;
// AACPacketType IF SoundFormat == 10 UI8
// The following values are defined:
// 0 = AAC sequence header
// 1 = AAC raw
public static const SrsCodecAudioTypeReserved:uint = 2;
public static const SrsCodecAudioTypeSequenceHeader:uint = 0;
public static const SrsCodecAudioTypeRawData:uint = 1;
// AVCPacketType IF CodecID == 7 UI8
// The following values are defined:
// 0 = AVC sequence header
// 1 = AVC NALU
// 2 = AVC end of sequence (lower level NALU sequence ender is
// not required or supported)
public static const SrsCodecVideoAVCTypeReserved:uint = 3;
public static const SrsCodecVideoAVCTypeSequenceHeader:uint = 0;
public static const SrsCodecVideoAVCTypeNALU:uint = 1;
public static const SrsCodecVideoAVCTypeSequenceHeaderEOF:uint = 2;
// E.4.3.1 VIDEODATA
// CodecID UB [4]
// Codec Identifier. The following values are defined:
// 2 = Sorenson H.263
// 3 = Screen video
// 4 = On2 VP6
// 5 = On2 VP6 with alpha channel
// 6 = Screen video version 2
// 7 = AVC
public static const SrsCodecVideoReserved:uint = 0;
public static const SrsCodecVideoReserved1:uint = 1;
public static const SrsCodecVideoReserved2:uint = 9;
// for user to disable video, for example, use pure audio hls.
public static const SrsCodecVideoDisabled:uint = 8;
public static const SrsCodecVideoSorensonH263:uint = 2;
public static const SrsCodecVideoScreenVideo:uint = 3;
public static const SrsCodecVideoOn2VP6:uint = 4;
public static const SrsCodecVideoOn2VP6WithAlphaChannel:uint = 5;
public static const SrsCodecVideoScreenVideoVersion2:uint = 6;
public static const SrsCodecVideoAVC:uint = 7;
// SoundFormat UB [4]
// Format of SoundData. The following values are defined:
// 0 = Linear PCM, platform endian
// 1 = ADPCM
// 2 = MP3
// 3 = Linear PCM, little endian
// 4 = Nellymoser 16 kHz mono
// 5 = Nellymoser 8 kHz mono
// 6 = Nellymoser
// 7 = G.711 A-law logarithmic PCM
// 8 = G.711 mu-law logarithmic PCM
// 9 = reserved
// 10 = AAC
// 11 = Speex
// 14 = MP3 8 kHz
// 15 = Device-specific sound
// Formats 7, 8, 14, and 15 are reserved.
// AAC is supported in Flash Player 9,0,115,0 and higher.
// Speex is supported in Flash Player 10 and higher.
public static const SrsCodecAudioReserved1:uint = 16;
public static const SrsCodecAudioLinearPCMPlatformEndian:uint = 0;
public static const SrsCodecAudioADPCM:uint = 1;
public static const SrsCodecAudioMP3:uint = 2;
public static const SrsCodecAudioLinearPCMLittleEndian:uint = 3;
public static const SrsCodecAudioNellymoser16kHzMono:uint = 4;
public static const SrsCodecAudioNellymoser8kHzMono:uint = 5;
public static const SrsCodecAudioNellymoser:uint = 6;
public static const SrsCodecAudioReservedG711AlawLogarithmicPCM:uint = 7;
public static const SrsCodecAudioReservedG711MuLawLogarithmicPCM:uint = 8;
public static const SrsCodecAudioReserved:uint = 9;
public static const SrsCodecAudioAAC:uint = 10;
public static const SrsCodecAudioSpeex:uint = 11;
public static const SrsCodecAudioReservedMP3_8kHz:uint = 14;
public static const SrsCodecAudioReservedDeviceSpecificSound:uint = 15;
/**
* the FLV/RTMP supported audio sample rate.
* Sampling rate. The following values are defined:
* 0 = 5.5 kHz = 5512 Hz
* 1 = 11 kHz = 11025 Hz
* 2 = 22 kHz = 22050 Hz
* 3 = 44 kHz = 44100 Hz
*/
public static const SrsCodecAudioSampleRateReserved:uint = 4;
public static const SrsCodecAudioSampleRate5512:uint = 0;
public static const SrsCodecAudioSampleRate11025:uint = 1;
public static const SrsCodecAudioSampleRate22050:uint = 2;
public static const SrsCodecAudioSampleRate44100:uint = 3;
/**
* E.4.1 FLV Tag, page 75
*/
public static const SrsCodecFlvTagReserved:uint = 0;
// 8 = audio
public static const SrsCodecFlvTagAudio:uint = 8;
// 9 = video
public static const SrsCodecFlvTagVideo:uint = 9;
// 18 = script data
public static const SrsCodecFlvTagScript:uint = 18;
/**
* Table 7-1 – NAL unit type codes, syntax element categories, and NAL unit type classes
* H.264-AVC-ISO_IEC_14496-10-2012.pdf, page 83.
*/
// Coded slice of a non-IDR picture slice_layer_without_partitioning_rbsp( )
public static const SrsAvcNaluTypeNonIDR:uint = 1;
// Coded slice data partition A slice_data_partition_a_layer_rbsp( )
public static const SrsAvcNaluTypeDataPartitionA:uint = 2;
// Coded slice data partition B slice_data_partition_b_layer_rbsp( )
public static const SrsAvcNaluTypeDataPartitionB:uint = 3;
// Coded slice data partition C slice_data_partition_c_layer_rbsp( )
public static const SrsAvcNaluTypeDataPartitionC:uint = 4;
// Coded slice of an IDR picture slice_layer_without_partitioning_rbsp( )
public static const SrsAvcNaluTypeIDR:uint = 5;
// Supplemental enhancement information (SEI) sei_rbsp( )
public static const SrsAvcNaluTypeSEI:uint = 6;
// Sequence parameter set seq_parameter_set_rbsp( )
public static const SrsAvcNaluTypeSPS:uint = 7;
// Picture parameter set pic_parameter_set_rbsp( )
public static const SrsAvcNaluTypePPS:uint = 8;
// Access unit delimiter access_unit_delimiter_rbsp( )
public static const SrsAvcNaluTypeAccessUnitDelimiter:uint = 9;
// End of sequence end_of_seq_rbsp( )
public static const SrsAvcNaluTypeEOSequence:uint = 10;
// End of stream end_of_stream_rbsp( )
public static const SrsAvcNaluTypeEOStream:uint = 11;
// Filler data filler_data_rbsp( )
public static const SrsAvcNaluTypeFilterData:uint = 12;
// Sequence parameter set extension seq_parameter_set_extension_rbsp( )
public static const SrsAvcNaluTypeSPSExt:uint = 13;
// Prefix NAL unit prefix_nal_unit_rbsp( )
public static const SrsAvcNaluTypePrefixNALU:uint = 14;
// Subset sequence parameter set subset_seq_parameter_set_rbsp( )
public static const SrsAvcNaluTypeSubsetSPS:uint = 15;
// Coded slice of an auxiliary coded picture without partitioning slice_layer_without_partitioning_rbsp( )
public static const SrsAvcNaluTypeLayerWithoutPartition:uint = 19;
// Coded slice extension slice_layer_extension_rbsp( )
public static const SrsAvcNaluTypeCodedSliceExt:uint = 20;
}
class SrsUtils
{
/*
* MPEG2 transport stream (aka DVB) mux
* Copyright (c) 2003 Fabrice Bellard.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
private static const crc_table:Array = [
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
];
// @see http://www.stmc.edu.hk/~vincent/ffmpeg_0.4.9-pre1/libavformat/mpegtsenc.c
private static function mpegts_crc32(bytes:ByteArray):uint
{
var crc:uint = 0xffffffff;
for (var i:int = 0; i < bytes.length; i++) {
crc = (crc << 8) ^ crc_table[((crc >> 24) ^ bytes[i]) & 0xff];
}
return crc;
}
public static function srs_crc32(bytes:ByteArray):uint
{
return mpegts_crc32(bytes);
}
/**
* parse the annexb header.
* @return an object which is:
* nb_header, an int start code, the header size.
* ok, a bool indicates whether the stream is annexb.
*/
public static function srs_avc_startswith_annexb(stream:ByteArray):Object
{
var nb_start_code:int = 0;
var is_annexb:Boolean = false;
var bytes:uint = stream.position;
var p:uint = bytes;
for (;;) {
if (stream.bytesAvailable < p - bytes + 3) {
break;
}
// not match
if (stream[p] != 0x00 || stream[p + 1] != 0x00) {
break;
}
// match N[00] 00 00 01, where N>=0
if (stream[p + 2] == 0x01) {
nb_start_code = p - bytes + 3;
is_annexb = true;
break;
}
p++;
}
return {
nb_header: nb_start_code,
ok: is_annexb
};
}
/**
* whether stream starts with the aac ADTS
* from aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 75, 1.A.2.2 ADTS.
* start code must be '1111 1111 1111'B, that is 0xFFF
*/
public static function srs_aac_startswith_adts(stream:ByteArray):Boolean
{
if (stream.bytesAvailable < 2) {
return false;
}
// matched 12bits 0xFFF,
// @remark, we must cast the 0xff to char to compare.
var p:uint = stream.position;
if (stream[p] != 0xff || (stream[p + 1] & 0xf0) != 0xf0) {
return false;
}
return true;
}
public static function array_equals(a:ByteArray, b:ByteArray):Boolean
{
if ((a && !b) || (!b && a) || a.length != b.length) {
return false;
}
for (var i:int = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
/**
* read the ue(v) of h.264 bit stream.
*/
public static function srs_avc_nalu_read_uev(stream:SrsBitStream):int
{
if (stream.empty()) {
throw new Error("avc: h.264 bit stream empty.");
}
// ue(v) in 9.1 Parsing process for Exp-Golomb codes
// H.264-AVC-ISO_IEC_14496-10-2012.pdf, page 227.
// Syntax elements coded as ue(v), me(v), or se(v) are Exp-Golomb-coded.
// leadingZeroBits = -1;
// for( b = 0; !b; leadingZeroBits++ )
// b = read_bits( 1 )
// The variable codeNum is then assigned as follows:
// codeNum = (2<<leadingZeroBits) – 1 + read_bits( leadingZeroBits )
var leadingZeroBits:int = -1;
for (var b:uint = 0; !b && !stream.empty(); leadingZeroBits++) {
b = stream.read_bit();
}
if (leadingZeroBits >= 31) {
throw new Error("avc: h.264 ue(v) overflow.");
}
var v:int = (1 << leadingZeroBits) - 1;
for (var i:int = 0; i < leadingZeroBits; i++) {
b = stream.read_bit();
v += b << (leadingZeroBits - 1);
}
return v;
}
/**
* read a bit from the h.264 avc bit stream.
*/
public static function srs_avc_nalu_read_bit(stream:SrsBitStream):int
{
if (stream.empty()) {
throw new Error("avc: h.264 bit stream empty.");
}
var v:int = stream.read_bit();
return v;
}
public static function srs_print_bytes(bytes:ByteArray, len:int):void
{
var prt_len:int;
var print:String = "";
prt_len = len == -1? (bytes.length - bytes.position): len;
prt_len = Math.min(prt_len, Math.min((bytes.length - bytes.position), 2048));
for (var i:int = 0; i < prt_len; i++)
{
print += bytes[i + bytes.position].toString(16).toUpperCase() + " ";
}
trace(print);
}
}
class SrsBitStream
{
private var stream:ByteArray;
private var cb:uint;
private var cb_left:uint;
public function SrsBitStream(s:ByteArray)
{
cb = 0;
cb_left = 0;
stream = s;
}
public function empty():Boolean
{
if (cb_left) {
return false;
}
return stream.bytesAvailable == 0;
}
public function read_bit():uint
{
if (!cb_left) {
cb = stream.readUnsignedByte();
cb_left = 8;
}
var v:uint = (cb >> (cb_left - 1)) & 0x01;
cb_left--;
return v;
}
}
/**
* the raw h.264 stream, in annexb.
*/
class SrsRawH264Stream
{
private var _log:ILogger = new TraceLogger("HLS");
public function SrsRawH264Stream()
{
}
/**
* demux the stream in annexb format.
*/
public function annexb_demux(stream:ByteArray):ByteArray
{
var frame:ByteArray = new ByteArray();
while (stream.bytesAvailable) {
// each frame must prefixed by annexb format.
// about annexb, @see H.264-AVC-ISO_IEC_14496-10.pdf, page 211.
var annexb:Object = SrsUtils.srs_avc_startswith_annexb(stream);
if (!annexb.ok) {
throw new Error("avc: not annexb format.");
}
var nb_annexb_header:uint = annexb.nb_header;
var start:uint = stream.position + annexb.nb_header;
stream.position += annexb.nb_header;
// find the last frame prefixed by annexb format.
while (stream.bytesAvailable) {
annexb = SrsUtils.srs_avc_startswith_annexb(stream);
if (annexb.ok) {
break;
}
stream.position++;
}
// demux the frame.
var pos:uint = stream.position;
var nb_frame:int = pos - start;
stream.position = start;
stream.readBytes(frame, 0, nb_frame);
stream.position = pos;
_log.debug("avc: annexb {0}B header, {1}B frame", nb_annexb_header, nb_frame);
break;
}
return frame;
}
/**
* whether the frame is sps or pps.
*/
public function is_sps(frame:ByteArray):Boolean
{
// 5bits, 7.3.1 NAL unit syntax,
// H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
// 7: SPS, 8: PPS, 5: I Frame, 1: P Frame
var nal_unit_type:uint = (frame[0] & 0x1f);
return nal_unit_type == 7;
}
public function is_pps(frame:ByteArray):Boolean
{
// 5bits, 7.3.1 NAL unit syntax,
// H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
// 7: SPS, 8: PPS, 5: I Frame, 1: P Frame
var nal_unit_type:uint = (frame[0] & 0x1f);
return nal_unit_type == 8;
}
/**
* demux the sps or pps to string.
* @param sps/pps output the sps/pps.
*/
public function sps_demux(frame:ByteArray):ByteArray
{
// atleast 1bytes for SPS to decode the type, profile, constrain and level.
if (frame.bytesAvailable < 4) {
return null;
}
return frame;
}
public function pps_demux(frame:ByteArray):ByteArray
{
if (!frame.bytesAvailable) {
return null;
}
return frame;
}
/**
* h264 raw data to h264 packet, without flv payload header.
* mux the sps/pps to flv sequence header packet.
* @param sh output the sequence header.
*/
public function mux_sequence_header(sps:ByteArray, pps:ByteArray, dts:uint, pts:uint):ByteArray
{
var sh:ByteArray = new ByteArray();
// 5bytes sps/pps header:
// configurationVersion, AVCProfileIndication, profile_compatibility,
// AVCLevelIndication, lengthSizeMinusOne
// 3bytes size of sps:
// numOfSequenceParameterSets, sequenceParameterSetLength(2B)
// Nbytes of sps.
// sequenceParameterSetNALUnit
// 3bytes size of pps:
// numOfPictureParameterSets, pictureParameterSetLength
// Nbytes of pps:
// pictureParameterSetNALUnit
// decode the SPS:
// @see: 7.3.2.1.1, H.264-AVC-ISO_IEC_14496-10-2012.pdf, page 62
if (true) {
if (sps.length < 4) {
throw new Error("sps atleast 4bytes.");
}
var frame:ByteArray = sps;
// @see: Annex A Profiles and levels, H.264-AVC-ISO_IEC_14496-10.pdf, page 205
// Baseline profile profile_idc is 66(0x42).
// Main profile profile_idc is 77(0x4d).
// Extended profile profile_idc is 88(0x58).
var profile_idc:int = (int)(frame[1]);
//u_int8_t constraint_set = frame[2];
var level_idc:int = (int)(frame[3]);
// generate the sps/pps header
// 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
// configurationVersion
sh.writeByte(0x01);
// AVCProfileIndication
sh.writeByte(profile_idc);
// profile_compatibility
sh.writeByte(0x00);
// AVCLevelIndication
sh.writeByte(level_idc);
// lengthSizeMinusOne, or NAL_unit_length, always use 4bytes size,
// so we always set it to 0x03.
sh.writeByte(0x03);
}
// sps
if (true) {
// 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
// numOfSequenceParameterSets, always 1
sh.writeByte(0x01);
// sequenceParameterSetLength
sh.writeShort(sps.length);
// sequenceParameterSetNALUnit
sh.writeBytes(sps);
}
// pps
if (true) {
// 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
// numOfPictureParameterSets, always 1
sh.writeByte(0x01);
// pictureParameterSetLength
sh.writeShort(pps.length);
// pictureParameterSetNALUnit
sh.writeBytes(pps);
}
// TODO: FIXME: for more profile.
// 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
// profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 144
return sh;
}
/**
* h264 raw data to h264 packet, without flv payload header.
* mux the ibp to flv ibp packet.
* @return ibp an ByteArray contains the bytes.
*/
public function mux_ipb_frame(frame:ByteArray):ByteArray
{
var ibp:ByteArray = new ByteArray();
// 4bytes size of nalu:
// NALUnitLength
// Nbytes of nalu.
// NALUnit
// 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16
// lengthSizeMinusOne, or NAL_unit_length, always use 4bytes size
var NAL_unit_length:uint = frame.length;
// mux the avc NALU in "ISO Base Media File Format"
// from H.264-AVC-ISO_IEC_14496-15.pdf, page 20
// NALUnitLength
ibp.writeUnsignedInt(NAL_unit_length);
// NALUnit
ibp.writeBytes(frame);
return ibp;
}
/**
* mux the avc video packet to flv video packet.
* @param frame_type, SrsCodecVideoAVCFrameKeyFrame or SrsCodecVideoAVCFrameInterFrame.
* @param avc_packet_type, SrsCodecVideoAVCTypeSequenceHeader or SrsCodecVideoAVCTypeNALU.
* @param video the h.264 raw data.
* @param flv output the muxed flv packet.
* @param nb_flv output the muxed flv size.
*/
public function mux_avc2flv(frame:ByteArray, frame_type:uint, avc_packet_type:uint, dts:uint, pts:uint):ByteArray
{
var flv:ByteArray = new ByteArray();
// for h264 in RTMP video payload, there is 5bytes header:
// 1bytes, FrameType | CodecID
// 1bytes, AVCPacketType
// 3bytes, CompositionTime, the cts.
// @see: E.4.3 Video Tags, video_file_format_spec_v10_1.pdf, page 78
// @see: E.4.3 Video Tags, video_file_format_spec_v10_1.pdf, page 78
// Frame Type, Type of video frame.
// CodecID, Codec Identifier.
// set the rtmp header
flv.writeByte((frame_type << 4) | SrsConsts.SrsCodecVideoAVC);
// AVCPacketType
flv.writeByte(avc_packet_type);
// CompositionTime
// pts = dts + cts, or
// cts = pts - dts.
// where cts is the header in rtmp video packet payload header.
var cts:uint = pts - dts;
flv.writeByte(cts >> 16);
flv.writeByte(cts >> 8);
flv.writeByte(cts);
// h.264 raw data.
flv.writeBytes(frame);
return flv;
}
};
/**
* the header of adts sample.
*/
class SrsRawAacStreamCodec
{
public var protection_absent:uint;
public var aac_object:SrsAacObjectType;
public var sampling_frequency_index:uint;
public var channel_configuration:uint;
public var frame_length:uint;
public var sound_format:uint;
public var sound_rate:uint;
public var sound_size:uint;
public var sound_type:uint;
// 0 for sh; 1 for raw data.
public var aac_packet_type:uint;
};
/**
* the raw aac stream, in adts.
*/
class SrsRawAacStream
{
private var _log:ILogger = new TraceLogger("HLS");
public function SrsRawAacStream()
{
}
/**
* demux the stream in adts format.
* @param stream the input stream bytes.
* @return an object which is:
* frame a byte array contains the demuxed aac frame.
* code a aac stream codec info.
*/
public function adts_demux(stream:ByteArray):Object
{
var frame:ByteArray = new ByteArray();
var codec:SrsRawAacStreamCodec = new SrsRawAacStreamCodec();
while (stream.bytesAvailable) {
var adts_header_start:uint = stream.position;
// decode the ADTS.
// @see aac-iso-13818-7.pdf, page 26
// 6.2 Audio Data Transport Stream, ADTS
// @see https://github.com/winlinvip/simple-rtmp-server/issues/212#issuecomment-64145885
// byte_alignment()
// adts_fixed_header:
// 12bits syncword,
// 16bits left.
// adts_variable_header:
// 28bits
// 12+16+28=56bits
// adts_error_check:
// 16bits if protection_absent
// 56+16=72bits
// if protection_absent:
// require(7bytes)=56bits
// else
// require(9bytes)=72bits
if (stream.bytesAvailable < 7) {
throw new Error("aac: adts required atleast 7bytes.");
}
// for aac, the frame must be ADTS format.
if (!SrsUtils.srs_aac_startswith_adts(stream)) {
throw new Error("aac: adts schema invalid.");
}
// syncword 12 bslbf
stream.readByte();
// 4bits left.
// adts_fixed_header(), 1.A.2.2.1 Fixed Header of ADTS
// ID 1 bslbf
// layer 2 uimsbf
// protection_absent 1 bslbf
var pav:uint = (stream.readUnsignedByte() & 0x0f);
var id:uint = (uint)((pav >> 3) & 0x01);
/*int8_t layer = (pav >> 1) & 0x03;*/
var protection_absent:uint = pav & 0x01;
/**
* ID: MPEG identifier, set to ‘1’ if the audio data in the ADTS stream are MPEG-2 AAC (See ISO/IEC 13818-7)
* and set to ‘0’ if the audio data are MPEG-4. See also ISO/IEC 11172-3, subclause 2.4.2.3.
*/
if (id != 0x01) {
//warn("adts: id must be 1(aac), actual 0(mp4a).");
// well, some system always use 0, but actually is aac format.
// for example, houjian vod ts always set the aac id to 0, actually 1.
// we just ignore it, and alwyas use 1(aac) to demux.
id = 0x01;
}
var sfiv:uint = stream.readUnsignedShort();
// profile 2 uimsbf
// sampling_frequency_index 4 uimsbf
// private_bit 1 bslbf
// channel_configuration 3 uimsbf
// original/copy 1 bslbf
// home 1 bslbf
var profile:uint = (sfiv >> 14) & 0x03;
var sampling_frequency_index:uint = (sfiv >> 10) & 0x0f;
/*int8_t private_bit = (sfiv >> 9) & 0x01;*/
var channel_configuration:uint = (sfiv >> 6) & 0x07;
/*int8_t original = (sfiv >> 5) & 0x01;*/
/*int8_t home = (sfiv >> 4) & 0x01;*/
//int8_t Emphasis; @remark, Emphasis is removed, @see https://github.com/winlinvip/simple-rtmp-server/issues/212#issuecomment-64154736
// 4bits left.
// adts_variable_header(), 1.A.2.2.2 Variable Header of ADTS
// copyright_identification_bit 1 bslbf
// copyright_identification_start 1 bslbf
/*int8_t fh_copyright_identification_bit = (fh1 >> 3) & 0x01;*/
/*int8_t fh_copyright_identification_start = (fh1 >> 2) & 0x01;*/
// frame_length 13 bslbf: Length of the frame including headers and error_check in bytes.
// use the left 2bits as the 13 and 12 bit,
// the frame_length is 13bits, so we move 13-2=11.
var frame_length:uint = (sfiv << 11) & 0x1800;
// skip -1 to read 4B for actually read 3B
stream.position -= 1;
var abfv:uint = (stream.readUnsignedInt() & 0x00ffffff);
// frame_length 13 bslbf: consume the first 13-2=11bits
// the fh2 is 24bits, so we move right 24-11=13.
frame_length |= (abfv >> 13) & 0x07ff;
// adts_buffer_fullness 11 bslbf
/*int16_t fh_adts_buffer_fullness = (abfv >> 2) & 0x7ff;*/
// number_of_raw_data_blocks_in_frame 2 uimsbf
/*int16_t number_of_raw_data_blocks_in_frame = abfv & 0x03;*/
// adts_error_check(), 1.A.2.2.3 Error detection
if (!protection_absent) {
if (stream.bytesAvailable < 2) {
throw new Error("aac: adts header corrupt.");
}
// crc_check 16 Rpchof
/*int16_t crc_check = */ stream.readUnsignedShort();
}
// TODO: check the sampling_frequency_index
// TODO: check the channel_configuration
// raw_data_blocks
var adts_header_size:uint = stream.position - adts_header_start;
var raw_data_size:uint = frame_length - adts_header_size;
if (stream.bytesAvailable < raw_data_size) {
throw new Error("aac: adts raw data corrupt.");
}
// the codec info.
codec.protection_absent = protection_absent;
codec.aac_object = SrsAacProfile.parse(profile).toRtmpObjectType();
codec.sampling_frequency_index = sampling_frequency_index;
codec.channel_configuration = channel_configuration;
codec.frame_length = frame_length;
// @see srs_audio_write_raw_frame().
codec.sound_format = 10; // AAC
// TODO: FIXME: maybe need to resample audio.
if (sampling_frequency_index <= 0x0c && sampling_frequency_index > 0x0a) {
codec.sound_rate = SrsConsts.SrsCodecAudioSampleRate5512;
} else if (sampling_frequency_index <= 0x0a && sampling_frequency_index > 0x07) {
codec.sound_rate = SrsConsts.SrsCodecAudioSampleRate11025;
} else if (sampling_frequency_index <= 0x07 && sampling_frequency_index > 0x04) {
codec.sound_rate = SrsConsts.SrsCodecAudioSampleRate22050;
} else if (sampling_frequency_index <= 0x04) {
codec.sound_rate = SrsConsts.SrsCodecAudioSampleRate44100;
} else {
codec.sound_rate = SrsConsts.SrsCodecAudioSampleRate44100;
_log.warn("adts invalid sample rate for flv, rate=%{0}", sampling_frequency_index);
}
codec.sound_type = (uint)(Math.max(0, Math.min(1, channel_configuration - 1)));
// TODO: FIXME: finger it out the sound size by adts.
codec.sound_size = 1; // 0(8bits) or 1(16bits).
// frame data.
stream.readBytes(frame, 0, raw_data_size);
break;
}
return {
frame: frame,
codec: codec
};
}
/**
* aac raw data to aac packet, without flv payload header.
* mux the aac specific config to flv sequence header packet.
* @param sh output the sequence header.
*/
public function mux_sequence_header(codec:SrsRawAacStreamCodec):ByteArray
{
var sh:ByteArray = new ByteArray();
// only support aac profile 1-4.
if (codec.aac_object == SrsAacObjectType.Reserved) {
throw new Error("aac: profile invalid.");
}
var audioObjectType:SrsAacObjectType = codec.aac_object;
var channelConfiguration:uint = codec.channel_configuration;
var samplingFrequencyIndex:uint = codec.sampling_frequency_index;
// override the aac samplerate by user specified.
// @see https://github.com/winlinvip/simple-rtmp-server/issues/212#issuecomment-64146899
switch (codec.sound_rate) {
case SrsConsts.SrsCodecAudioSampleRate11025:
samplingFrequencyIndex = 0x0a; break;
case SrsConsts.SrsCodecAudioSampleRate22050:
samplingFrequencyIndex = 0x07; break;
case SrsConsts.SrsCodecAudioSampleRate44100:
samplingFrequencyIndex = 0x04; break;
default:
break;
}
var ch:uint = 0;
// @see aac-mp4a-format-ISO_IEC_14496-3+2001.pdf
// AudioSpecificConfig (), page 33
// 1.6.2.1 AudioSpecificConfig
// audioObjectType; 5 bslbf
ch = (audioObjectType.toInt() << 3) & 0xf8;
// 3bits left.
// samplingFrequencyIndex; 4 bslbf
ch |= (samplingFrequencyIndex >> 1) & 0x07;
sh.writeByte(ch);
ch = (samplingFrequencyIndex << 7) & 0x80;
if (samplingFrequencyIndex == 0x0f) {
throw new Error("aac: sample rate invalid.");
}
// 7bits left.
// channelConfiguration; 4 bslbf
ch |= (channelConfiguration << 3) & 0x78;
// 3bits left.
// GASpecificConfig(), page 451
// 4.4.1 Decoder configuration (GASpecificConfig)
// frameLengthFlag; 1 bslbf
// dependsOnCoreCoder; 1 bslbf
// extensionFlag; 1 bslbf
sh.writeByte(ch);
return sh;
}
/**
* mux the aac audio packet to flv audio packet.
* @param frame the aac raw data.
* @param nb_frame the count of aac frame.
* @param codec the codec info of aac.
* @param flv output the muxed flv packet.
* @param nb_flv output the muxed flv size.
*/
public function mux_aac2flv(frame:ByteArray, codec:SrsRawAacStreamCodec, dts:uint):ByteArray
{
var flv:ByteArray = new ByteArray();
var sound_format:uint = codec.sound_format;
var sound_type:uint = codec.sound_type;
var sound_size:uint = codec.sound_size;
var sound_rate:uint = codec.sound_rate;
var aac_packet_type:uint = codec.aac_packet_type;
// for audio frame, there is 1 or 2 bytes header:
// 1bytes, SoundFormat|SoundRate|SoundSize|SoundType
// 1bytes, AACPacketType for SoundFormat == 10, 0 is sequence header.
var audio_header:uint = sound_type & 0x01;
audio_header |= (sound_size << 1) & 0x02;
audio_header |= (sound_rate << 2) & 0x0c;
audio_header |= (sound_format << 4) & 0xf0;
flv.writeByte(audio_header);
if (sound_format == SrsConsts.SrsCodecAudioAAC) {
flv.writeByte(aac_packet_type);
}
flv.writeBytes(frame);
return flv;
}
};
/**
* the fake enum.
*/
class SrsEnum
{
protected var value:int;
public function SrsEnum(v:int)
{
value = v;
}
public function equals(e:SrsEnum):Boolean
{
return value == e.value;
}
public function notEquals(e:SrsEnum):Boolean
{
return value != e.value;
}
public function equalsValue(v:int):Boolean
{
return value == v;
}
public function toString():String
{
return String(value);
}
public function toInt():int
{
return value;
}
}
/**
* the aac profile, for ADTS(HLS/TS)
* @see https://github.com/winlinvip/simple-rtmp-server/issues/310
*/
class SrsAacProfile extends SrsEnum
{
public function SrsAacProfile(v:int)
{
super(v);
}
public static function parse(v:int):SrsAacProfile
{
switch (v) {
case 0x00: return SrsAacProfile.Main;
case 0x01: return SrsAacProfile.LC;
case 0x02: return SrsAacProfile.SSR;
default: case 0x03: return SrsAacProfile.Reserved;
}
}
public static const Reserved:SrsAacProfile = new SrsAacProfile(0x03);
// @see 7.1 Profiles, aac-iso-13818-7.pdf, page 40
public static const Main:SrsAacProfile = new SrsAacProfile(0x00);
public static const LC:SrsAacProfile = new SrsAacProfile(0x01);
public static const SSR:SrsAacProfile = new SrsAacProfile(0x02);
// ts/hls/adts audio header profile to RTMP sequence header object type.
public function toRtmpObjectType():SrsAacObjectType
{
if (SrsAacProfile.Main.equals(this)) {
return SrsAacObjectType.AacMain;
} else if (SrsAacProfile.LC.equals(this)) {
return SrsAacObjectType.AacLC;
} else if (SrsAacProfile.SSR.equals(this)) {
return SrsAacObjectType.AacSSR;
} else {
return SrsAacObjectType.Reserved;
}
}
};
/**
* the aac object type, for RTMP sequence header
* for AudioSpecificConfig, @see aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 33
* for audioObjectType, @see aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 23
*/
class SrsAacObjectType extends SrsEnum
{
public function SrsAacObjectType(v:int)
{
super(v);
}
public static function parse(v:int):SrsAacObjectType
{
switch (v) {
case 0x01: return SrsAacObjectType.AacMain;
case 0x02: return SrsAacObjectType.AacLC;
case 0x03: return SrsAacObjectType.AacSSR;
case 0x05: return SrsAacObjectType.AacHE;
case 0x29: return SrsAacObjectType.AacHEV2;
default: case 0x00: return SrsAacObjectType.Reserved;
}
}
public static const Reserved:SrsAacObjectType = new SrsAacObjectType(0x00);
// Table 1.1 – Audio Object Type definition
// @see @see aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 23
public static const AacMain:SrsAacObjectType = new SrsAacObjectType(0x01);
public static const AacLC:SrsAacObjectType = new SrsAacObjectType(0x02);
public static const AacSSR:SrsAacObjectType = new SrsAacObjectType(0x03);
// AAC HE = LC+SBR
public static const AacHE:SrsAacObjectType = new SrsAacObjectType(0x05);
// AAC HEv2 = LC+SBR+PS
public static const AacHEV2:SrsAacObjectType = new SrsAacObjectType(0x29);
// RTMP sequence header object type to ts/hls/adts audio header profile.
public function toTsProfile():SrsAacProfile
{
if (SrsAacObjectType.AacMain.equals(this)) {
return SrsAacProfile.Main;
} else if (SrsAacObjectType.AacLC.equals(this)) {
return SrsAacProfile.LC;
} else if (SrsAacObjectType.AacHE.equals(this)) {
return SrsAacProfile.LC;
} else if (SrsAacObjectType.AacHEV2.equals(this)) {
return SrsAacProfile.LC;
} else if (SrsAacObjectType.AacSSR.equals(this)) {
return SrsAacProfile.SSR;
} else {
return SrsAacProfile.Reserved;
}
}
};
/**
* the pid of ts packet,
* Table 2-3 - PID table, hls-mpeg-ts-iso13818-1.pdf, page 37
* NOTE - The transport packets with PID values 0x0000, 0x0001, and 0x0010-0x1FFE are allowed to carry a PCR.
*/
class SrsTsPid extends SrsEnum
{
public function SrsTsPid(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsPid
{
switch (v) {
case 0x00: return SrsTsPid.PAT;
case 0x01: return SrsTsPid.CAT;
case 0x02: return SrsTsPid.TSDT;
case 0x03: return SrsTsPid.ReservedStart;
case 0x0f: return SrsTsPid.ReservedEnd;
case 0x10: return SrsTsPid.AppStart;
case 0x1ffe: return SrsTsPid.AppEnd;
case 0x01FFF: return SrsTsPid.NULL;
default: return new SrsTsPid(v);
}
}
// Program Association Table(see Table 2-25).
public static const PAT:SrsTsPid = new SrsTsPid(0x00);
// Conditional Access Table (see Table 2-27).
public static const CAT:SrsTsPid = new SrsTsPid(0x01);
// Transport Stream Description Table
public static const TSDT:SrsTsPid = new SrsTsPid(0x02);
// Reserved
public static const ReservedStart:SrsTsPid = new SrsTsPid(0x03);
public static const ReservedEnd:SrsTsPid = new SrsTsPid(0x0f);
// May be assigned as network_PID, Program_map_PID, elementary_PID, or for other purposes
public static const AppStart:SrsTsPid = new SrsTsPid(0x10);
public static const AppEnd:SrsTsPid = new SrsTsPid(0x1ffe);
// null packets (see Table 2-3)
public static const NULL:SrsTsPid = new SrsTsPid(0x01FFF);
};
/**
* the transport_scrambling_control of ts packet,
* Table 2-4 - Scrambling control values, hls-mpeg-ts-iso13818-1.pdf, page 38
*/
class SrsTsScrambled extends SrsEnum
{
public function SrsTsScrambled(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsScrambled
{
switch (v) {
case 0x01: return SrsTsScrambled.UserDefined1;
case 0x02: return SrsTsScrambled.UserDefined2;
case 0x03: return SrsTsScrambled.UserDefined3;
default: case 0x00: return SrsTsScrambled.Disabled;
}
}
// Not scrambled
public static const Disabled:SrsTsScrambled = new SrsTsScrambled(0x00);
// User-defined
public static const UserDefined1:SrsTsScrambled = new SrsTsScrambled(0x01);
// User-defined
public static const UserDefined2:SrsTsScrambled = new SrsTsScrambled(0x02);
// User-defined
public static const UserDefined3:SrsTsScrambled = new SrsTsScrambled(0x03);
};
/**
* the adaption_field_control of ts packet,
* Table 2-5 - Adaptation field control values, hls-mpeg-ts-iso13818-1.pdf, page 38
*/
class SrsTsAdaptationFieldType extends SrsEnum
{
public function SrsTsAdaptationFieldType(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsAdaptationFieldType
{
switch (v) {
case 0x01: return SrsTsAdaptationFieldType.PayloadOnly;
case 0x02: return SrsTsAdaptationFieldType.AdaptionOnly;
case 0x03: return SrsTsAdaptationFieldType.Both;
default: case 0x00: return SrsTsAdaptationFieldType.Reserved;
}
}
// Reserved for future use by ISO/IEC
public static const Reserved:SrsTsAdaptationFieldType = new SrsTsAdaptationFieldType(0x00);
// No adaptation_field, payload only
public static const PayloadOnly:SrsTsAdaptationFieldType = new SrsTsAdaptationFieldType(0x01);
// Adaptation_field only, no payload
public static const AdaptionOnly:SrsTsAdaptationFieldType = new SrsTsAdaptationFieldType(0x02);
// Adaptation_field followed by payload
public static const Both:SrsTsAdaptationFieldType = new SrsTsAdaptationFieldType(0x03);
};
/**
* the actually parsed ts pid,
* @see SrsTsPid, some pid, for example, PMT/Video/Audio is specified by PAT or other tables.
*/
class SrsTsPidApply extends SrsEnum
{
public function SrsTsPidApply(v:int)
{
super(v);
}
public static const Reserved:SrsTsPidApply = new SrsTsPidApply(0x00); // TSPidTypeReserved, nothing parsed, used reserved.
public static const PAT:SrsTsPidApply = new SrsTsPidApply(0x01); // Program associtate table
public static const PMT:SrsTsPidApply = new SrsTsPidApply(0x02); // Program map table.
public static const Video:SrsTsPidApply = new SrsTsPidApply(0x03); // for video
public static const Audio:SrsTsPidApply = new SrsTsPidApply(0x04); // vor audio
};
/**
* Table 2-29 - Stream type assignments
*/
class SrsTsStream extends SrsEnum
{
public function SrsTsStream(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsStream
{
switch (v) {
case 0x8a: return SrsTsStream.AudioDTS;
case 0x80: return SrsTsStream.AudioAC3;
case 0x1b: return SrsTsStream.VideoH264;
case 0x11: return SrsTsStream.AudioMpeg4;
case 0x10: return SrsTsStream.VideoMpeg4;
case 0x0f: return SrsTsStream.AudioAAC;
case 0x04: return SrsTsStream.AudioMp3;
default: case 0x00: return SrsTsStream.Reserved;
}
}
// ITU-T | ISO/IEC Reserved
public static const Reserved:SrsTsStream = new SrsTsStream(0x00);
// ISO/IEC 11172 Video
// ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream
// ISO/IEC 11172 Audio
// ISO/IEC 13818-3 Audio
public static const AudioMp3:SrsTsStream = new SrsTsStream(0x04);
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 private_sections
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 PES packets containing private data
// ISO/IEC 13522 MHEG
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Annex A DSM-CC
// ITU-T Rec. H.222.1
// ISO/IEC 13818-6 type A
// ISO/IEC 13818-6 type B
// ISO/IEC 13818-6 type C
// ISO/IEC 13818-6 type D
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 auxiliary
// ISO/IEC 13818-7 Audio with ADTS transport syntax
public static const AudioAAC:SrsTsStream = new SrsTsStream(0x0f);
// ISO/IEC 14496-2 Visual
public static const VideoMpeg4:SrsTsStream = new SrsTsStream(0x10);
// ISO/IEC 14496-3 Audio with the LATM transport syntax as defined in ISO/IEC 14496-3 / AMD 1
public static const AudioMpeg4:SrsTsStream = new SrsTsStream(0x11);
// ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in PES packets
// ISO/IEC 14496-1 SL-packetized stream or FlexMux stream carried in ISO/IEC14496_sections.
// ISO/IEC 13818-6 Synchronized Download Protocol
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Reserved
// 0x15-0x7F
public static const VideoH264:SrsTsStream = new SrsTsStream(0x1b);
// User Private
// 0x80-0xFF
public static const AudioAC3:SrsTsStream = new SrsTsStream(0x80);
public static const AudioDTS:SrsTsStream = new SrsTsStream(0x8a);
};
/**
* the ts channel.
*/
class SrsTsChannel
{
public var pid:int;
public var apply:SrsTsPidApply;
public var stream:SrsTsStream;
public var msg:SrsTsMessage;
public var context:SrsTsContext;
public function SrsTsChannel()
{
pid = 0;
apply = SrsTsPidApply.Reserved;
stream = SrsTsStream.Reserved;
msg = null;
context = null;
}
};
/**
* the stream_id of PES payload of ts packet.
* Table 2-18 – Stream_id assignments, hls-mpeg-ts-iso13818-1.pdf, page 52.
*/
class SrsTsPESStreamId extends SrsEnum
{
public function SrsTsPESStreamId(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsPESStreamId
{
switch (v) {
case 0xbc: return SrsTsPESStreamId.ProgramStreamMap;
case 0xbd: return SrsTsPESStreamId.PrivateStream1;
case 0xbe: return SrsTsPESStreamId.PaddingStream;
case 0xbf: return SrsTsPESStreamId.PrivateStream2;
case 0x06: return SrsTsPESStreamId.AudioChecker;
case 0xc0: return SrsTsPESStreamId.AudioCommon;
case 0x0e: return SrsTsPESStreamId.VideoChecker;
case 0xe0: return SrsTsPESStreamId.VideoCommon;
case 0xf0: return SrsTsPESStreamId.EcmStream;
case 0xf1: return SrsTsPESStreamId.EmmStream;
case 0xf2: return SrsTsPESStreamId.DsmccStream;
case 0xf3: return SrsTsPESStreamId._13522Stream;
case 0xf4: return SrsTsPESStreamId.H2221TypeA;
case 0xf5: return SrsTsPESStreamId.H2221TypeB;
case 0xf6: return SrsTsPESStreamId.H2221TypeC;
case 0xf7: return SrsTsPESStreamId.H2221TypeD;
case 0xf8: return SrsTsPESStreamId.H2221TypeE;
case 0xf9: return SrsTsPESStreamId.AncillaryStream;
case 0xfa: return SrsTsPESStreamId.SlPacketizedStream;
case 0xfb: return SrsTsPESStreamId.FlexMuxStream;
case 0xff: return SrsTsPESStreamId.ProgramStreamDirectory;
default: case 0x00: return SrsTsPESStreamId.Reserved;
}
}
// reserved
public static const Reserved:SrsTsPESStreamId = new SrsTsPESStreamId(0x00);
// program_stream_map
public static const ProgramStreamMap:SrsTsPESStreamId = new SrsTsPESStreamId(0xbc);
// private_stream_1
public static const PrivateStream1:SrsTsPESStreamId = new SrsTsPESStreamId(0xbd);
// padding_stream
public static const PaddingStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xbe);
// private_stream_2
public static const PrivateStream2:SrsTsPESStreamId = new SrsTsPESStreamId(0xbf);
// 110x xxxx
// ISO/IEC 13818-3 or ISO/IEC 11172-3 or ISO/IEC 13818-7 or ISO/IEC
// 14496-3 audio stream number x xxxx
// ((sid >> 5) & 0x07) == SrsTsPESStreamIdAudio
// @remark, use SrsTsPESStreamIdAudioCommon as actually audio, SrsTsPESStreamIdAudio to check whether audio.
public static const AudioChecker:SrsTsPESStreamId = new SrsTsPESStreamId(0x06);
public static const AudioCommon:SrsTsPESStreamId = new SrsTsPESStreamId(0xc0);
// 1110 xxxx
// ITU-T Rec. H.262 | ISO/IEC 13818-2 or ISO/IEC 11172-2 or ISO/IEC
// 14496-2 video stream number xxxx
// ((stream_id >> 4) & 0x0f) == SrsTsPESStreamIdVideo
// @remark, use SrsTsPESStreamIdVideoCommon as actually video, SrsTsPESStreamIdVideo to check whether video.
public static const VideoChecker:SrsTsPESStreamId = new SrsTsPESStreamId(0x0e);
public static const VideoCommon:SrsTsPESStreamId = new SrsTsPESStreamId(0xe0);
// ECM_stream
public static const EcmStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xf0);
// EMM_stream
public static const EmmStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xf1);
// DSMCC_stream
public static const DsmccStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xf2);
// 13522_stream
public static const _13522Stream:SrsTsPESStreamId = new SrsTsPESStreamId(0xf3);
// H_222_1_type_A
public static const H2221TypeA:SrsTsPESStreamId = new SrsTsPESStreamId(0xf4);
// H_222_1_type_B
public static const H2221TypeB:SrsTsPESStreamId = new SrsTsPESStreamId(0xf5);
// H_222_1_type_C
public static const H2221TypeC:SrsTsPESStreamId = new SrsTsPESStreamId(0xf6);
// H_222_1_type_D
public static const H2221TypeD:SrsTsPESStreamId = new SrsTsPESStreamId(0xf7);
// H_222_1_type_E
public static const H2221TypeE:SrsTsPESStreamId = new SrsTsPESStreamId(0xf8);
// ancillary_stream
public static const AncillaryStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xf9);
// SL_packetized_stream
public static const SlPacketizedStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xfa);
// FlexMux_stream
public static const FlexMuxStream:SrsTsPESStreamId = new SrsTsPESStreamId(0xfb);
// reserved data stream
// 1111 1100 … 1111 1110
// program_stream_directory
public static const ProgramStreamDirectory:SrsTsPESStreamId = new SrsTsPESStreamId(0xff);
};
/**
* the media audio/video message parsed from PES packet.
*/
class SrsTsMessage
{
// decoder only,
// the ts messgae does not use them,
// for user to get the channel and packet.
public var channel:SrsTsChannel;
public var packet:SrsTsPacket;
// the audio cache buffer start pts, to flush audio if full.
// @remark the pts is not the adjust one, it's the orignal pts.
public var start_pts:Number;
// whether this message with pcr info,
// generally, the video IDR(I frame, the keyframe of h.264) carray the pcr info.
public var write_pcr:Boolean;
// whether got discontinuity ts, for example, sequence header changed.
public var discontinuity:Boolean;
// the timestamp in 90khz
public var dts:Number;
public var pts:Number;
// the id of pes stream to indicates the payload codec.
// @remark use is_audio() and is_video() to check it, and stream_number() to finger it out.
public var sid:SrsTsPESStreamId;
// the size of payload, 0 indicates the length() of payload.
public var PES_packet_length:uint;
// the chunk id.
public var continuity_counter:uint;
// the payload bytes.
public var payload:ByteArray;
public function SrsTsMessage(c:SrsTsChannel, p:SrsTsPacket)
{
channel = c;
packet = p;
dts = pts = 0;
sid = SrsTsPESStreamId.Reserved;
continuity_counter = 0;
PES_packet_length = 0;
payload = new ByteArray();
start_pts = 0;
write_pcr = false;
}
// decoder
/**
* dumps all bytes in stream to ts message.
*/
public function dump(stream:ByteArray):int
{
if (!stream.bytesAvailable) {
return 0;
}
// xB
var nb_bytes:int = stream.length - stream.position;
if (PES_packet_length > 0) {
nb_bytes = (int)(Math.min(nb_bytes, PES_packet_length - payload.length));
}
if (nb_bytes > 0) {
if (stream.bytesAvailable < nb_bytes) {
throw new Error("ts: dump PSE bytes failed, requires=" + nb_bytes + " bytes");
}
stream.readBytes(payload, payload.length, nb_bytes);
}
return nb_bytes;
}
/**
* whether ts message is completed to reap.
* @param payload_unit_start_indicator whether new ts message start.
* PES_packet_length is 0, the payload_unit_start_indicator=1 to reap ts message.
* PES_packet_length > 0, the payload.length() == PES_packet_length to reap ts message.
* @remark when PES_packet_length>0, the payload_unit_start_indicator should never be 1 when not completed.
* @remark when fresh, the payload_unit_start_indicator should be 1.
*/
public function completed(payload_unit_start_indicator:Number):Boolean
{
if (PES_packet_length == 0) {
return payload_unit_start_indicator != 0;
}
return payload.length >= PES_packet_length;
}
/**
* whether the message is fresh.
*/
public function fresh():Boolean
{
return payload.length == 0;
}
/**
* whether the sid indicates the elementary stream audio.
*/
public function is_audio():Boolean
{
var sidValue:int = (sid.toInt() >> 5) & 0x07;
return SrsTsPESStreamId.AudioChecker.equalsValue(sidValue);
}
/**
* whether the sid indicates the elementary stream video.
*/
public function is_video():Boolean
{
var sidValue:int = (sid.toInt() >> 4) & 0x0f;
return SrsTsPESStreamId.VideoChecker.equalsValue(sidValue);
}
/**
* when audio or video, get the stream number which specifies the format of stream.
* @return the stream number for audio/video; otherwise, -1.
*/
public function stream_number():Number
{
if (is_audio()) {
return sid.toInt() & 0x1f;
} else if (is_video()) {
return sid.toInt() & 0x0f;
}
return -1;
}
};
/**
* the ts message handler.
*/
interface ISrsTsHandler
{
/**
* when ts context got message, use handler to process it.
* @param msg the ts msg, user should never free it.
* @return an int error code.
*/
function on_ts_message(msg:SrsTsMessage):void;
};
/**
* the context of ts, to decode the ts stream.
*/
class SrsTsContext
{
private var _hls:Hls;
// codec
// key, a Number indicates the pid,
// value, the SrsTsChannel object.
private var _pids:Dict;
// whether hls pure audio stream.
private var _pure_audio:Boolean;
public function SrsTsContext(hls:Hls)
{
_hls = hls;
_pure_audio = false;
_pids = new Dict();
}
/**
* whether the hls stream is pure audio stream.
*/
public function is_pure_audio():Boolean
{
return _pure_audio;
}
/**
* when PMT table parsed, we know some info about stream.
*/
public function on_pmt_parsed():void
{
_pure_audio = true;
var keys:Array = _pids.keys();
for (var i:int = 0; i < keys.length; i++) {
var channel:SrsTsChannel = _pids.get(keys[i]) as SrsTsChannel;
if (channel.apply == SrsTsPidApply.Video) {
_pure_audio = false;
}
}
}
// codec
/**
* get the pid apply, the parsed pid.
* @return the apply channel; NULL for invalid.
*/
public function getChannel(pid:Number):SrsTsChannel
{
if (!_pids.has(pid)) {
return null;
}
return _pids.get(pid) as SrsTsChannel;
}
/**
* set the pid apply, the parsed pid.
*/
public function setChannel(pid:Number, apply_pid:SrsTsPidApply, stream:SrsTsStream):void
{
var channel:SrsTsChannel = null;
if (!_pids.get(pid)) {
channel = new SrsTsChannel();
channel.context = this;
_pids.set(pid, channel);
} else {
channel = _pids.get(pid) as SrsTsChannel;
}
channel.pid = pid;
channel.apply = apply_pid;
channel.stream = stream;
}
// decode methods
/**
* the stream contains only one ts packet.
* @param handler the ts message handler to process the msg.
* @remark we will consume all bytes in stream.
*/
public function decode(stream:ByteArray, handler:ISrsTsHandler):void
{
// parse util EOF of stream.
// for example, parse multiple times for the PES_packet_length(0) packet.
while (stream.bytesAvailable) {
var packet:SrsTsPacket = new SrsTsPacket(this);
var msg:SrsTsMessage = packet.decode(stream);
if (!msg) {
continue;
}
handler.on_ts_message(msg);
}
}
};
/**
* the packet in ts stream,
* 2.4.3.2 Transport Stream packet layer, hls-mpeg-ts-iso13818-1.pdf, page 36
* Transport Stream packets shall be 188 bytes long.
*/
class SrsTsPacket
{
// 1B
/**
* The sync_byte is a fixed 8-bit field whose value is '0100 0111' (0x47) or '0111 0100' (0x74). Sync_byte emulation in the choice of
* values for other regularly occurring fields, such as PID, should be avoided.
*/
public var sync_byte:int; //8bits
// 2B
/**
* The transport_error_indicator is a 1-bit flag. When set to '1' it indicates that at least
* 1 uncorrectable bit error exists in the associated Transport Stream packet. This bit may be set to '1' by entities external to
* the transport layer. When set to '1' this bit shall not be reset to '0' unless the bit value(s) in error have been corrected.
*/
public var transport_error_indicator:int; //1bit
/**
* The payload_unit_start_indicator is a 1-bit flag which has normative meaning for
* Transport Stream packets that carry PES packets (refer to 2.4.3.6) or PSI data (refer to 2.4.4).
*
* When the payload of the Transport Stream packet contains PES packet data, the payload_unit_start_indicator has the
* following significance: a '1' indicates that the payload of this Transport Stream packet will commence(start) with the first byte
* of a PES packet and a '0' indicates no PES packet shall start in this Transport Stream packet. If the
* payload_unit_start_indicator is set to '1', then one and only one PES packet starts in this Transport Stream packet. This
* also applies to private streams of stream_type 6 (refer to Table 2-29).
*
* When the payload of the Transport Stream packet contains PSI data, the payload_unit_start_indicator has the following
* significance: if the Transport Stream packet carries the first byte of a PSI section, the payload_unit_start_indicator value
* shall be '1', indicating that the first byte of the payload of this Transport Stream packet carries the pointer_field. If the
* Transport Stream packet does not carry the first byte of a PSI section, the payload_unit_start_indicator value shall be '0',
* indicating that there is no pointer_field in the payload. Refer to 2.4.4.1 and 2.4.4.2. This also applies to private streams of
* stream_type 5 (refer to Table 2-29).
*
* For null packets the payload_unit_start_indicator shall be set to '0'.
*
* The meaning of this bit for Transport Stream packets carrying only private data is not defined in this Specification.
*/
public var payload_unit_start_indicator:int; //1bit
/**
* The transport_priority is a 1-bit indicator. When set to '1' it indicates that the associated packet is
* of greater priority than other packets having the same PID which do not have the bit set to '1'. The transport mechanism
* can use this to prioritize its data within an elementary stream. Depending on the application the transport_priority field
* may be coded regardless of the PID or within one PID only. This field may be changed by channel specific encoders or
* decoders.
*/
public var transport_priority:int; //1bit
/**
* The PID is a 13-bit field, indicating the type of the data stored in the packet payload. PID value 0x0000 is
* reserved for the Program Association Table (see Table 2-25). PID value 0x0001 is reserved for the Conditional Access
* Table (see Table 2-27). PID values 0x0002 - 0x000F are reserved. PID value 0x1FFF is reserved for null packets (see
* Table 2-3).
*/
public var pid:int; //13bits
// 1B
/**
* This 2-bit field indicates the scrambling mode of the Transport Stream packet payload.
* The Transport Stream packet header, and the adaptation field when present, shall not be scrambled. In the case of a null
* packet the value of the transport_scrambling_control field shall be set to '00' (see Table 2-4).
*/
public var transport_scrambling_control:SrsTsScrambled; //2bits
/**
* This 2-bit field indicates whether this Transport Stream packet header is followed by an
* adaptation field and/or payload (see Table 2-5).
*
* ITU-T Rec. H.222.0 | ISO/IEC 13818-1 decoders shall discard Transport Stream packets with the
* adaptation_field_control field set to a value of '00'. In the case of a null packet the value of the adaptation_field_control
* shall be set to '01'.
*/
public var adaption_field_control:SrsTsAdaptationFieldType; //2bits
/**
* The continuity_counter is a 4-bit field incrementing with each Transport Stream packet with the
* same PID. The continuity_counter wraps around to 0 after its maximum value. The continuity_counter shall not be
* incremented when the adaptation_field_control of the packet equals '00'(reseverd) or '10'(adaptation field only).
*
* In Transport Streams, duplicate packets may be sent as two, and only two, consecutive Transport Stream packets of the
* same PID. The duplicate packets shall have the same continuity_counter value as the original packet and the
* adaptation_field_control field shall be equal to '01'(payload only) or '11'(both). In duplicate packets each byte of the original packet shall be
* duplicated, with the exception that in the program clock reference fields, if present, a valid value shall be encoded.
*
* The continuity_counter in a particular Transport Stream packet is continuous when it differs by a positive value of one
* from the continuity_counter value in the previous Transport Stream packet of the same PID, or when either of the nonincrementing
* conditions (adaptation_field_control set to '00' or '10', or duplicate packets as described above) are met.
* The continuity counter may be discontinuous when the discontinuity_indicator is set to '1' (refer to 2.4.3.4). In the case of
* a null packet the value of the continuity_counter is undefined.
*/
public var continuity_counter:int; //4bits
private var adaptation_field:SrsTsAdaptationField;
private var payload:SrsTsPayload;
public var context:SrsTsContext;
public function SrsTsPacket(c:SrsTsContext)
{
context = c;
}
public function decode(stream:ByteArray):SrsTsMessage
{
var pos:uint = stream.position;
// 4B ts packet header.
if (stream.bytesAvailable < 4) {
throw new Error("ts: demux header failed");
}
sync_byte = stream.readUnsignedByte();
// drm algorithms for ts packet:
// 1: "tiger", sync_byte is 0x74
if (sync_byte != 0x47 && sync_byte != 0x74) {
throw new Error("ts: sync_bytes must be 0x47 or 0x74, actual=" + sync_byte);
}
var pidv:int = stream.readUnsignedShort();
transport_error_indicator = (pidv >> 15) & 0x01;
payload_unit_start_indicator = (pidv >> 14) & 0x01;
transport_priority = (pidv >> 13) & 0x01;
pid = pidv & 0x1FFF;
var ccv:int = stream.readUnsignedByte();
transport_scrambling_control = SrsTsScrambled.parse((ccv >> 6) & 0x03);
adaption_field_control = SrsTsAdaptationFieldType.parse((ccv >> 4) & 0x03);
continuity_counter = ccv & 0x0F;
// TODO: FIXME: create pids map when got new pid.
// optional: adaptation field
if (adaption_field_control == SrsTsAdaptationFieldType.AdaptionOnly
|| adaption_field_control == SrsTsAdaptationFieldType.Both
) {
adaptation_field = new SrsTsAdaptationField(this);
adaptation_field.decode(stream);
}
// calc the user defined data size for payload.
var nb_payload:int = Hls.SRS_TS_PACKET_SIZE - (stream.position - pos);
// optional: payload.
if (adaption_field_control == SrsTsAdaptationFieldType.PayloadOnly
|| adaption_field_control == SrsTsAdaptationFieldType.Both
) {
if (SrsTsPid.PAT.equalsValue(pid)) {
// 2.4.4.3 Program association Table
payload = new SrsTsPayloadPAT(this);
} else {
var channel:SrsTsChannel = context.getChannel(pid);
if (channel && channel.apply == SrsTsPidApply.PMT) {
// 2.4.4.8 Program Map Table
payload = new SrsTsPayloadPMT(this);
} else if (channel && (channel.apply == SrsTsPidApply.Video || channel.apply == SrsTsPidApply.Audio)) {
// 2.4.3.6 PES packet
payload = new SrsTsPayloadPES(this);
} else {
// left bytes as reserved.
stream.position += nb_payload;
}
}
if (payload) {
return payload.decode(stream);
}
}
return null;
}
public function size():int
{
return 0;
}
public static function create_pat(context:SrsTsContext, pmt_number:int, pmt_pid:int):SrsTsPacket
{
return null;
}
public static function create_pmt(context:SrsTsContext,
pmt_number:int, pmt_pid:int, vpid:int, vs:SrsTsStream, apid:int, ts:SrsTsStream):SrsTsPacket
{
return null;
}
public static function create_pes_first(context:SrsTsContext,
pid:int, sid:SrsTsPESStreamId, continuity_counter:uint, discontinuity:Boolean,
pcr:Number, dts:Number, pts:Number, size:int):SrsTsPacket
{
return null;
}
public static function create_pes_continue(context:SrsTsContext,
pid:int, sid:SrsTsPESStreamId, continuity_counter:int
):SrsTsPacket
{
return null;
}
};
/**
* the adaption field of ts packet.
* 2.4.3.5 Semantic definition of fields in adaptation field, hls-mpeg-ts-iso13818-1.pdf, page 39
* Table 2-6 - Transport Stream adaptation field, hls-mpeg-ts-iso13818-1.pdf, page 40
*/
class SrsTsAdaptationField
{
// 1B
/**
* The adaptation_field_length is an 8-bit field specifying the number of bytes in the
* adaptation_field immediately following the adaptation_field_length. The value 0 is for inserting a single stuffing byte in
* a Transport Stream packet. When the adaptation_field_control value is '11', the value of the adaptation_field_length shall
* be in the range 0 to 182. When the adaptation_field_control value is '10', the value of the adaptation_field_length shall
* be 183. For Transport Stream packets carrying PES packets, stuffing is needed when there is insufficient PES packet data
* to completely fill the Transport Stream packet payload bytes. Stuffing is accomplished by defining an adaptation field
* longer than the sum of the lengths of the data elements in it, so that the payload bytes remaining after the adaptation field
* exactly accommodates the available PES packet data. The extra space in the adaptation field is filled with stuffing bytes.
*
* This is the only method of stuffing allowed for Transport Stream packets carrying PES packets. For Transport Stream
* packets carrying PSI, an alternative stuffing method is described in 2.4.4.
*/
public var adaption_field_length:int; //8bits
// 1B
/**
* This is a 1-bit field which when set to '1' indicates that the discontinuity state is true for the
* current Transport Stream packet. When the discontinuity_indicator is set to '0' or is not present, the discontinuity state is
* false. The discontinuity indicator is used to indicate two types of discontinuities, system time-base discontinuities and
* continuity_counter discontinuities.
*
* A system time-base discontinuity is indicated by the use of the discontinuity_indicator in Transport Stream packets of a
* PID designated as a PCR_PID (refer to 2.4.4.9). When the discontinuity state is true for a Transport Stream packet of a
* PID designated as a PCR_PID, the next PCR in a Transport Stream packet with that same PID represents a sample of a
* new system time clock for the associated program. The system time-base discontinuity point is defined to be the instant
* in time when the first byte of a packet containing a PCR of a new system time-base arrives at the input of the T-STD.
* The discontinuity_indicator shall be set to '1' in the packet in which the system time-base discontinuity occurs. The
* discontinuity_indicator bit may also be set to '1' in Transport Stream packets of the same PCR_PID prior to the packet
* which contains the new system time-base PCR. In this case, once the discontinuity_indicator has been set to '1', it shall
* continue to be set to '1' in all Transport Stream packets of the same PCR_PID up to and including the Transport Stream
* packet which contains the first PCR of the new system time-base. After the occurrence of a system time-base
* discontinuity, no fewer than two PCRs for the new system time-base shall be received before another system time-base
* discontinuity can occur. Further, except when trick mode status is true, data from no more than two system time-bases
* shall be present in the set of T-STD buffers for one program at any time.
*
* Prior to the occurrence of a system time-base discontinuity, the first byte of a Transport Stream packet which contains a
* PTS or DTS which refers to the new system time-base shall not arrive at the input of the T-STD. After the occurrence of
* a system time-base discontinuity, the first byte of a Transport Stream packet which contains a PTS or DTS which refers
* to the previous system time-base shall not arrive at the input of the T-STD.
*
* A continuity_counter discontinuity is indicated by the use of the discontinuity_indicator in any Transport Stream packet.
* When the discontinuity state is true in any Transport Stream packet of a PID not designated as a PCR_PID, the
* continuity_counter in that packet may be discontinuous with respect to the previous Transport Stream packet of the same
* PID. When the discontinuity state is true in a Transport Stream packet of a PID that is designated as a PCR_PID, the
* continuity_counter may only be discontinuous in the packet in which a system time-base discontinuity occurs. A
* continuity counter discontinuity point occurs when the discontinuity state is true in a Transport Stream packet and the
* continuity_counter in the same packet is discontinuous with respect to the previous Transport Stream packet of the same
* PID. A continuity counter discontinuity point shall occur at most one time from the initiation of the discontinuity state
* until the conclusion of the discontinuity state. Furthermore, for all PIDs that are not designated as PCR_PIDs, when the
* discontinuity_indicator is set to '1' in a packet of a specific PID, the discontinuity_indicator may be set to '1' in the next
* Transport Stream packet of that same PID, but shall not be set to '1' in three consecutive Transport Stream packet of that
* same PID.
*
* For the purpose of this clause, an elementary stream access point is defined as follows:
* Video - The first byte of a video sequence header.
* Audio - The first byte of an audio frame.
*
* After a continuity counter discontinuity in a Transport packet which is designated as containing elementary stream data,
* the first byte of elementary stream data in a Transport Stream packet of the same PID shall be the first byte of an
* elementary stream access point or in the case of video, the first byte of an elementary stream access point or a
* sequence_end_code followed by an access point. Each Transport Stream packet which contains elementary stream data
* with a PID not designated as a PCR_PID, and in which a continuity counter discontinuity point occurs, and in which a
* PTS or DTS occurs, shall arrive at the input of the T-STD after the system time-base discontinuity for the associated
* program occurs. In the case where the discontinuity state is true, if two consecutive Transport Stream packets of the same
* PID occur which have the same continuity_counter value and have adaptation_field_control values set to '01' or '11', the
* second packet may be discarded. A Transport Stream shall not be constructed in such a way that discarding such a packet
* will cause the loss of PES packet payload data or PSI data.
*
* After the occurrence of a discontinuity_indicator set to '1' in a Transport Stream packet which contains PSI information,
* a single discontinuity in the version_number of PSI sections may occur. At the occurrence of such a discontinuity, a
* version of the TS_program_map_sections of the appropriate program shall be sent with section_length = = 13 and the
* current_next_indicator = = 1, such that there are no program_descriptors and no elementary streams described. This shall
* then be followed by a version of the TS_program_map_section for each affected program with the version_number
* incremented by one and the current_next_indicator = = 1, containing a complete program definition. This indicates a
* version change in PSI data.
*/
public var discontinuity_indicator:int; //1bit
/**
* The random_access_indicator is a 1-bit field that indicates that the current Transport
* Stream packet, and possibly subsequent Transport Stream packets with the same PID, contain some information to aid
* random access at this point. Specifically, when the bit is set to '1', the next PES packet to start in the payload of Transport
* Stream packets with the current PID shall contain the first byte of a video sequence header if the PES stream type (refer
* to Table 2-29) is 1 or 2, or shall contain the first byte of an audio frame if the PES stream type is 3 or 4. In addition, in
* the case of video, a presentation timestamp shall be present in the PES packet containing the first picture following the
* sequence header. In the case of audio, the presentation timestamp shall be present in the PES packet containing the first
* byte of the audio frame. In the PCR_PID the random_access_indicator may only be set to '1' in Transport Stream packet
* containing the PCR fields.
*/
public var random_access_indicator:int; //1bit
/**
* The elementary_stream_priority_indicator is a 1-bit field. It indicates, among
* packets with the same PID, the priority of the elementary stream data carried within the payload of this Transport Stream
* packet. A '1' indicates that the payload has a higher priority than the payloads of other Transport Stream packets. In the
* case of video, this field may be set to '1' only if the payload contains one or more bytes from an intra-coded slice. A
* value of '0' indicates that the payload has the same priority as all other packets which do not have this bit set to '1'.
*/
public var elementary_stream_priority_indicator:int; //1bit
/**
* The PCR_flag is a 1-bit flag. A value of '1' indicates that the adaptation_field contains a PCR field coded in
* two parts. A value of '0' indicates that the adaptation field does not contain any PCR field.
*/
public var PCR_flag:int; //1bit
/**
* The OPCR_flag is a 1-bit flag. A value of '1' indicates that the adaptation_field contains an OPCR field
* coded in two parts. A value of '0' indicates that the adaptation field does not contain any OPCR field.
*/
public var OPCR_flag:int; //1bit
/**
* The splicing_point_flag is a 1-bit flag. When set to '1', it indicates that a splice_countdown field
* shall be present in the associated adaptation field, specifying the occurrence of a splicing point. A value of '0' indicates
* that a splice_countdown field is not present in the adaptation field.
*/
public var splicing_point_flag:int; //1bit
/**
* The transport_private_data_flag is a 1-bit flag. A value of '1' indicates that the
* adaptation field contains one or more private_data bytes. A value of '0' indicates the adaptation field does not contain any
* private_data bytes.
*/
public var transport_private_data_flag:int; //1bit
/**
* The adaptation_field_extension_flag is a 1-bit field which when set to '1' indicates
* the presence of an adaptation field extension. A value of '0' indicates that an adaptation field extension is not present in
* the adaptation field.
*/
public var adaptation_field_extension_flag:int; //1bit
// if PCR_flag, 6B
/**
* The program_clock_reference (PCR) is a
* 42-bit field coded in two parts. The first part, program_clock_reference_base, is a 33-bit field whose value is given by
* PCR_base(i), as given in equation 2-2. The second part, program_clock_reference_extension, is a 9-bit field whose value
* is given by PCR_ext(i), as given in equation 2-3. The PCR indicates the intended time of arrival of the byte containing
* the last bit of the program_clock_reference_base at the input of the system target decoder.
*/
public var program_clock_reference_base:Number; //33bits
/**
* 6bits reserved, must be '1'
*/
public var const1_value0:int; // 6bits
public var program_clock_reference_extension:int; //9bits
// if OPCR_flag, 6B
/**
* The optional original
* program reference (OPCR) is a 42-bit field coded in two parts. These two parts, the base and the extension, are coded
* identically to the two corresponding parts of the PCR field. The presence of the OPCR is indicated by the OPCR_flag.
* The OPCR field shall be coded only in Transport Stream packets in which the PCR field is present. OPCRs are permitted
* in both single program and multiple program Transport Streams.
*
* OPCR assists in the reconstruction of a single program Transport Stream from another Transport Stream. When
* reconstructing the original single program Transport Stream, the OPCR may be copied to the PCR field. The resulting
* PCR value is valid only if the original single program Transport Stream is reconstructed exactly in its entirety. This
* would include at least any PSI and private data packets which were present in the original Transport Stream and would
* possibly require other private arrangements. It also means that the OPCR must be an identical copy of its associated PCR
* in the original single program Transport Stream.
*/
public var original_program_clock_reference_base:Number; //33bits
/**
* 6bits reserved, must be '1'
*/
public var const1_value2:int; // 6bits
public var original_program_clock_reference_extension:int; //9bits
// if splicing_point_flag, 1B
/**
* The splice_countdown is an 8-bit field, representing a value which may be positive or negative. A
* positive value specifies the remaining number of Transport Stream packets, of the same PID, following the associated
* Transport Stream packet until a splicing point is reached. Duplicate Transport Stream packets and Transport Stream
* packets which only contain adaptation fields are excluded. The splicing point is located immediately after the last byte of
* the Transport Stream packet in which the associated splice_countdown field reaches zero. In the Transport Stream packet
* where the splice_countdown reaches zero, the last data byte of the Transport Stream packet payload shall be the last byte
* of a coded audio frame or a coded picture. In the case of video, the corresponding access unit may or may not be
* terminated by a sequence_end_code. Transport Stream packets with the same PID, which follow, may contain data from
* a different elementary stream of the same type.
*
* The payload of the next Transport Stream packet of the same PID (duplicate packets and packets without payload being
* excluded) shall commence with the first byte of a PES packet.In the case of audio, the PES packet payload shall
* commence with an access point. In the case of video, the PES packet payload shall commence with an access point, or
* with a sequence_end_code, followed by an access point. Thus, the previous coded audio frame or coded picture aligns
* with the packet boundary, or is padded to make this so. Subsequent to the splicing point, the countdown field may also
* be present. When the splice_countdown is a negative number whose value is minus n(-n), it indicates that the associated
* Transport Stream packet is the n-th packet following the splicing point (duplicate packets and packets without payload
* being excluded).
*
* For the purposes of this subclause, an access point is defined as follows:
* Video - The first byte of a video_sequence_header.
* Audio - The first byte of an audio frame.
*/
public var splice_countdown:int; //8bits
// if transport_private_data_flag, 1+p[0] B
/**
* The transport_private_data_length is an 8-bit field specifying the number of
* private_data bytes immediately following the transport private_data_length field. The number of private_data bytes shall
* not be such that private data extends beyond the adaptation field.
*/
public var transport_private_data_length:int; //8bits
public var transport_private_data:ByteArray; //[transport_private_data_length]bytes
// if adaptation_field_extension_flag, 2+x B
/**
* The adaptation_field_extension_length is an 8-bit field. It indicates the number of
* bytes of the extended adaptation field data immediately following this field, including reserved bytes if present.
*/
public var adaptation_field_extension_length:int; //8bits
/**
* This is a 1-bit field which when set to '1' indicates the presence of the ltw_offset
* field.
*/
public var ltw_flag:int; //1bit
/**
* This is a 1-bit field which when set to '1' indicates the presence of the piecewise_rate field.
*/
public var piecewise_rate_flag:int; //1bit
/**
* This is a 1-bit flag which when set to '1' indicates that the splice_type and DTS_next_AU fields
* are present. A value of '0' indicates that neither splice_type nor DTS_next_AU fields are present. This field shall not be
* set to '1' in Transport Stream packets in which the splicing_point_flag is not set to '1'. Once it is set to '1' in a Transport
* Stream packet in which the splice_countdown is positive, it shall be set to '1' in all the subsequent Transport Stream
* packets of the same PID that have the splicing_point_flag set to '1', until the packet in which the splice_countdown
* reaches zero (including this packet). When this flag is set, if the elementary stream carried in this PID is an audio stream,
* the splice_type field shall be set to '0000'. If the elementary stream carried in this PID is a video stream, it shall fulfil the
* constraints indicated by the splice_type value.
*/
public var seamless_splice_flag:int; //1bit
/**
* reserved 5bits, must be '1'
*/
public var const1_value1:int; //5bits
// if ltw_flag, 2B
/**
* (legal time window_valid_flag) - This is a 1-bit field which when set to '1' indicates that the value of the
* ltw_offset shall be valid. A value of '0' indicates that the value in the ltw_offset field is undefined.
*/
public var ltw_valid_flag:int; //1bit
/**
* (legal time window offset) - This is a 15-bit field, the value of which is defined only if the ltw_valid flag has
* a value of '1'. When defined, the legal time window offset is in units of (300/fs) seconds, where fs is the system clock
* frequency of the program that this PID belongs to, and fulfils:
* offset = t1(i) - t(i)
* ltw_offset = offset//1
* where i is the index of the first byte of this Transport Stream packet, offset is the value encoded in this field, t(i) is the
* arrival time of byte i in the T-STD, and t1(i) is the upper bound in time of a time interval called the Legal Time Window
* which is associated with this Transport Stream packet.
*/
public var ltw_offset:int; //15bits
// if piecewise_rate_flag, 3B
//2bits reserved
/**
* The meaning of this 22-bit field is only defined when both the ltw_flag and the ltw_valid_flag are set
* to '1'. When defined, it is a positive integer specifying a hypothetical bitrate R which is used to define the end times of
* the Legal Time Windows of Transport Stream packets of the same PID that follow this packet but do not include the
* legal_time_window_offset field.
*/
public var piecewise_rate:int; //22bits
// if seamless_splice_flag, 5B
/**
* This is a 4-bit field. From the first occurrence of this field onwards, it shall have the same value in all the
* subsequent Transport Stream packets of the same PID in which it is present, until the packet in which the
* splice_countdown reaches zero (including this packet). If the elementary stream carried in that PID is an audio stream,
* this field shall have the value '0000'. If the elementary stream carried in that PID is a video stream, this field indicates the
* conditions that shall be respected by this elementary stream for splicing purposes. These conditions are defined as a
* function of profile, level and splice_type in Table 2-7 through Table 2-16.
*/
public var splice_type:int; //4bits
/**
* (decoding time stamp next access unit) - This is a 33-bit field, coded in three parts. In the case of
* continuous and periodic decoding through this splicing point it indicates the decoding time of the first access unit
* following the splicing point. This decoding time is expressed in the time base which is valid in the Transport Stream
* packet in which the splice_countdown reaches zero. From the first occurrence of this field onwards, it shall have the
* same value in all the subsequent Transport Stream packets of the same PID in which it is present, until the packet in
* which the splice_countdown reaches zero (including this packet).
*/
public var DTS_next_AU0:int; //3bits
public var marker_bit0:int; //1bit
public var DTS_next_AU1:int; //15bits
public var marker_bit1:int; //1bit
public var DTS_next_AU2:int; //15bits
public var marker_bit2:int; //1bit
// left bytes.
/**
* This is a fixed 8-bit value equal to '1111 1111' that can be inserted by the encoder. It is discarded by the
* decoder.
*/
public var nb_af_ext_reserved:int;
// left bytes.
/**
* This is a fixed 8-bit value equal to '1111 1111' that can be inserted by the encoder. It is discarded by the
* decoder.
*/
public var nb_af_reserved:int;
private var packet:SrsTsPacket;
public function SrsTsAdaptationField(pkt:SrsTsPacket)
{
packet = pkt;
adaption_field_length = 0;
discontinuity_indicator = 0;
random_access_indicator = 0;
elementary_stream_priority_indicator = 0;
PCR_flag = 0;
OPCR_flag = 0;
splicing_point_flag = 0;
transport_private_data_flag = 0;
adaptation_field_extension_flag = 0;
program_clock_reference_base = 0;
program_clock_reference_extension = 0;
original_program_clock_reference_base = 0;
original_program_clock_reference_extension = 0;
splice_countdown = 0;
transport_private_data_length = 0;
transport_private_data = null;
adaptation_field_extension_length = 0;
ltw_flag = 0;
piecewise_rate_flag = 0;
seamless_splice_flag = 0;
ltw_valid_flag = 0;
ltw_offset = 0;
piecewise_rate = 0;
splice_type = 0;
DTS_next_AU0 = 0;
marker_bit0 = 0;
DTS_next_AU1 = 0;
marker_bit1 = 0;
DTS_next_AU2 = 0;
marker_bit2 = 0;
nb_af_ext_reserved = 0;
nb_af_reserved = 0;
const1_value0 = 0x3F;
const1_value1 = 0x1F;
const1_value2 = 0x3F;
}
public function decode(stream:ByteArray):void
{
if (stream.bytesAvailable < 2) {
throw new Error("ts: demux af failed.");
}
adaption_field_length = stream.readUnsignedByte();
// When the adaptation_field_control value is '11', the value of the adaptation_field_length shall
// be in the range 0 to 182.
if (packet.adaption_field_control == SrsTsAdaptationFieldType.Both && adaption_field_length > 182) {
throw new Error("ts: demux af length failed, must in [0, 182], actual=" + adaption_field_length);
}
// When the adaptation_field_control value is '10', the value of the adaptation_field_length shall
// be 183.
if (packet.adaption_field_control == SrsTsAdaptationFieldType.AdaptionOnly && adaption_field_length != 183) {
throw new Error("ts: demux af length failed, must be 183, actual=" + adaption_field_length);
}
// no adaptation field.
if (adaption_field_length == 0) {
//info("ts: demux af empty.");
return;
}
// the adaptation field start at here.
var pos_af:uint = stream.position;
var tmpv:int = stream.readUnsignedByte();
discontinuity_indicator = (tmpv >> 7) & 0x01;
random_access_indicator = (tmpv >> 6) & 0x01;
elementary_stream_priority_indicator = (tmpv >> 5) & 0x01;
PCR_flag = (tmpv >> 4) & 0x01;
OPCR_flag = (tmpv >> 3) & 0x01;
splicing_point_flag = (tmpv >> 2) & 0x01;
transport_private_data_flag = (tmpv >> 1) & 0x01;
adaptation_field_extension_flag = tmpv & 0x01;
if (PCR_flag) {
if (stream.bytesAvailable < 6) {
throw new Error("ts: demux af PCR_flag failed.");
}
// @remark, for as, should never shift the Number object.
// @remark, use pcr base and ignore the extension
// @see https://github.com/winlinvip/simple-rtmp-server/issues/250#issuecomment-71349370
// first 33bits is pcr base.
program_clock_reference_base = (stream.readUnsignedInt() << 1) & 0x1fffffe;
var ch:uint = stream.readUnsignedByte();
program_clock_reference_base += (ch >> 7) & 0x01;
// next 6bits is the const values
const1_value0 = (ch >> 1) & 0x3f;
// last 9bits is the pcr ext.
program_clock_reference_extension = (ch << 8) & 0x1ff;
program_clock_reference_extension |= stream.readUnsignedByte();
}
if (OPCR_flag) {
if (stream.bytesAvailable < 6) {
throw new Error("ts: demux af OPCR_flag failed.");
}
// @remark, for as, should never shift the Number object.
// @remark, use pcr base and ignore the extension
// @see https://github.com/winlinvip/simple-rtmp-server/issues/250#issuecomment-71349370
// first 33bits is pcr base.
original_program_clock_reference_base = (stream.readUnsignedInt() << 1) & 0x1fffffe;
ch = stream.readUnsignedByte();
original_program_clock_reference_base += (ch >> 7) & 0x01;
// next 6bits is the const values
const1_value2 = (ch >> 1) & 0x3f;
// last 9bits is the pcr ext.
original_program_clock_reference_extension = (ch << 8) & 0x1ff;
original_program_clock_reference_extension |= stream.readUnsignedByte();
}
if (splicing_point_flag) {
if (stream.bytesAvailable < 1) {
throw new Error("ts: demux af splicing_point_flag failed.");
}
splice_countdown = stream.readUnsignedByte();
}
if (transport_private_data_flag) {
if (stream.bytesAvailable < 1) {
throw new Error("ts: demux af transport_private_data_flag failed.");
}
transport_private_data_length = stream.readUnsignedByte();
if (transport_private_data_length> 0) {
if (stream.bytesAvailable < transport_private_data_length) {
throw new Error("ts: demux af transport_private_data_flag failed.");
}
transport_private_data = new ByteArray();
stream.readBytes(transport_private_data, 0, transport_private_data_length);
}
}
if (adaptation_field_extension_flag) {
var pos_af_ext:uint = stream.position;
if (stream.bytesAvailable < 2) {
throw new Error("ts: demux af adaptation_field_extension_flag failed.");
}
adaptation_field_extension_length = stream.readUnsignedByte();
var ltwfv:int = stream.readUnsignedByte();
piecewise_rate_flag = (ltwfv >> 6) & 0x01;
seamless_splice_flag = (ltwfv >> 5) & 0x01;
ltw_flag = (ltwfv >> 7) & 0x01;
const1_value1 = ltwfv & 0x1F;
if (ltw_flag) {
if (stream.bytesAvailable < 2) {
throw new Error("ts: demux af ltw_flag failed.");
}
ltw_offset = stream.readUnsignedShort();
ltw_valid_flag = (ltw_offset >> 15) &0x01;
ltw_offset &= 0x7FFF;
}
if (piecewise_rate_flag) {
if (stream.bytesAvailable < 3) {
throw new Error("ts: demux af piecewise_rate_flag failed.");
}
// skip -1 to read 4B for 3B actually
stream.position -= 1;
piecewise_rate = (stream.readUnsignedInt() & 0x00ffffff);
piecewise_rate &= 0x3FFFFF;
}
if (seamless_splice_flag) {
if (stream.bytesAvailable < 5) {
throw new Error("ts: demux af seamless_splice_flag failed");
}
marker_bit0 = stream.readUnsignedByte();
DTS_next_AU1 = stream.readUnsignedShort();
DTS_next_AU2 = stream.readUnsignedShort();
splice_type = (marker_bit0 >> 4) & 0x0F;
DTS_next_AU0 = (marker_bit0 >> 1) & 0x07;
marker_bit0 &= 0x01;
marker_bit1 = DTS_next_AU1 & 0x01;
DTS_next_AU1 = (DTS_next_AU1 >> 1) & 0x7FFF;
marker_bit2 = DTS_next_AU2 & 0x01;
DTS_next_AU2 = (DTS_next_AU2 >> 1) & 0x7FFF;
}
nb_af_ext_reserved = adaptation_field_extension_length - (stream.position - pos_af_ext);
stream.position += nb_af_ext_reserved;
}
nb_af_reserved = adaption_field_length - (stream.position - pos_af);
stream.position += nb_af_reserved;
}
};
/**
* 2.4.4.4 Table_id assignments, hls-mpeg-ts-iso13818-1.pdf, page 62
* The table_id field identifies the contents of a Transport Stream PSI section as shown in Table 2-26.
*/
class SrsTsPsiId extends SrsEnum
{
public function SrsTsPsiId(v:int)
{
super(v);
}
public static function parse(v:int):SrsTsPsiId
{
switch (v) {
case 0x00: return SrsTsPsiId.Pas;
case 0x01: return SrsTsPsiId.Cas;
case 0x02: return SrsTsPsiId.Pms;
case 0x03: return SrsTsPsiId.Ds;
case 0x04: return SrsTsPsiId.Sds;
case 0x05: return SrsTsPsiId.Ods;
case 0x06: return SrsTsPsiId.Iso138181Start;
case 0x37: return SrsTsPsiId.Iso138181End;
case 0x38: return SrsTsPsiId.Iso138186Start;
case 0x3F: return SrsTsPsiId.Iso138186End;
case 0x40: return SrsTsPsiId.UserStart;
case 0xFE: return SrsTsPsiId.UserEnd;
case 0xFF: return SrsTsPsiId.Forbidden;
default: case 0x00: return SrsTsPsiId.Forbidden;
}
}
// program_association_section
public static const Pas:SrsTsPsiId = new SrsTsPsiId(0x00);
// conditional_access_section (CA_section)
public static const Cas:SrsTsPsiId = new SrsTsPsiId(0x01);
// TS_program_map_section
public static const Pms:SrsTsPsiId = new SrsTsPsiId(0x02);
// TS_description_section
public static const Ds:SrsTsPsiId = new SrsTsPsiId(0x03);
// ISO_IEC_14496_scene_description_section
public static const Sds:SrsTsPsiId = new SrsTsPsiId(0x04);
// ISO_IEC_14496_object_descriptor_section
public static const Ods:SrsTsPsiId = new SrsTsPsiId(0x05);
// ITU-T Rec. H.222.0 | ISO/IEC 13818-1 reserved
public static const Iso138181Start:SrsTsPsiId = new SrsTsPsiId(0x06);
public static const Iso138181End:SrsTsPsiId = new SrsTsPsiId(0x37);
// Defined in ISO/IEC 13818-6
public static const Iso138186Start:SrsTsPsiId = new SrsTsPsiId(0x38);
public static const Iso138186End:SrsTsPsiId = new SrsTsPsiId(0x3F);
// User private
public static const UserStart:SrsTsPsiId = new SrsTsPsiId(0x40);
public static const UserEnd:SrsTsPsiId = new SrsTsPsiId(0xFE);
// forbidden
public static const Forbidden:SrsTsPsiId = new SrsTsPsiId(0xFF);
};
/**
* the payload of ts packet, can be PES or PSI payload.
*/
class SrsTsPayload
{
protected var packet:SrsTsPacket;
public function SrsTsPayload(p:SrsTsPacket)
{
packet = p;
}
public function decode(stream:ByteArray):SrsTsMessage
{
throw new Error("not implements");
}
};
/**
* the PES payload of ts packet.
* 2.4.3.6 PES packet, hls-mpeg-ts-iso13818-1.pdf, page 49
*/
class SrsTsPayloadPES extends SrsTsPayload
{
// 3B
/**
* The packet_start_code_prefix is a 24-bit code. Together with the stream_id that follows it
* constitutes a packet start code that identifies the beginning of a packet. The packet_start_code_prefix is the bit string
* '0000 0000 0000 0000 0000 0001' (0x000001).
*/
public var packet_start_code_prefix:int; //24bits
// 1B
/**
* In Program Streams, the stream_id specifies the type and number of the elementary stream as defined by the
* stream_id Table 2-18. In Transport Streams, the stream_id may be set to any valid value which correctly describes the
* elementary stream type as defined in Table 2-18. In Transport Streams, the elementary stream type is specified in the
* Program Specific Information as specified in 2.4.4.
*/
// @see SrsTsPESStreamId, value can be SrsTsPESStreamIdAudioCommon or SrsTsPESStreamIdVideoCommon.
public var stream_id:int; //8bits
// 2B
/**
* A 16-bit field specifying the number of bytes in the PES packet following the last byte of the
* field. A value of 0 indicates that the PES packet length is neither specified nor bounded and is allowed only in
* PES packets whose payload consists of bytes from a video elementary stream contained in Transport Stream packets.
*/
public var PES_packet_length:int; //16bits
// 1B
/**
* 2bits const '10'
*/
public var const2bits:int; //2bits
/**
* The 2-bit PES_scrambling_control field indicates the scrambling mode of the PES packet
* payload. When scrambling is performed at the PES level, the PES packet header, including the optional fields when
* present, shall not be scrambled (see Table 2-19).
*/
public var PES_scrambling_control:int; //2bits
/**
* This is a 1-bit field indicating the priority of the payload in this PES packet. A '1' indicates a higher
* priority of the payload of the PES packet payload than a PES packet payload with this field set to '0'. A multiplexor can
* use the PES_priority bit to prioritize its data within an elementary stream. This field shall not be changed by the transport
* mechanism.
*/
public var PES_priority:int; //1bit
/**
* This is a 1-bit flag. When set to a value of '1' it indicates that the PES packet header is
* immediately followed by the video start code or audio syncword indicated in the data_stream_alignment_descriptor
* in 2.6.10 if this descriptor is present. If set to a value of '1' and the descriptor is not present, alignment as indicated in
* alignment_type '01' in Table 2-47 and Table 2-48 is required. When set to a value of '0' it is not defined whether any such
* alignment occurs or not.
*/
public var data_alignment_indicator:int; //1bit
/**
* This is a 1-bit field. When set to '1' it indicates that the material of the associated PES packet payload is
* protected by copyright. When set to '0' it is not defined whether the material is protected by copyright. A copyright
* descriptor described in 2.6.24 is associated with the elementary stream which contains this PES packet and the copyright
* flag is set to '1' if the descriptor applies to the material contained in this PES packet
*/
public var copyright:int; //1bit
/**
* This is a 1-bit field. When set to '1' the contents of the associated PES packet payload is an original.
* When set to '0' it indicates that the contents of the associated PES packet payload is a copy.
*/
public var original_or_copy:int; //1bit
// 1B
/**
* This is a 2-bit field. When the PTS_DTS_flags field is set to '10', the PTS fields shall be present in
* the PES packet header. When the PTS_DTS_flags field is set to '11', both the PTS fields and DTS fields shall be present
* in the PES packet header. When the PTS_DTS_flags field is set to '00' no PTS or DTS fields shall be present in the PES
* packet header. The value '01' is forbidden.
*/
public var PTS_DTS_flags:int; //2bits
/**
* A 1-bit flag, which when set to '1' indicates that ESCR base and extension fields are present in the PES
* packet header. When set to '0' it indicates that no ESCR fields are present.
*/
public var ESCR_flag:int; //1bit
/**
* A 1-bit flag, which when set to '1' indicates that the ES_rate field is present in the PES packet header.
* When set to '0' it indicates that no ES_rate field is present.
*/
public var ES_rate_flag:int; //1bit
/**
* A 1-bit flag, which when set to '1' it indicates the presence of an 8-bit trick mode field. When
* set to '0' it indicates that this field is not present.
*/
public var DSM_trick_mode_flag:int; //1bit
/**
* A 1-bit flag, which when set to '1' indicates the presence of the additional_copy_info field.
* When set to '0' it indicates that this field is not present.
*/
public var additional_copy_info_flag:int; //1bit
/**
* A 1-bit flag, which when set to '1' indicates that a CRC field is present in the PES packet. When set to
* '0' it indicates that this field is not present.
*/
public var PES_CRC_flag:int; //1bit
/**
* A 1-bit flag, which when set to '1' indicates that an extension field exists in this PES packet
* header. When set to '0' it indicates that this field is not present.
*/
public var PES_extension_flag:int; //1bit
// 1B
/**
* An 8-bit field specifying the total number of bytes occupied by the optional fields and any
* stuffing bytes contained in this PES packet header. The presence of optional fields is indicated in the byte that precedes
* the PES_header_data_length field.
*/
public var PES_header_data_length:int; //8bits
// 5B
/**
* Presentation times shall be related to decoding times as follows: The PTS is a 33-bit
* number coded in three separate fields. It indicates the time of presentation, tp n (k), in the system target decoder of a
* presentation unit k of elementary stream n. The value of PTS is specified in units of the period of the system clock
* frequency divided by 300 (yielding 90 kHz). The presentation time is derived from the PTS according to equation 2-11
* below. Refer to 2.7.4 for constraints on the frequency of coding presentation timestamps.
*/
// ===========1B
// 4bits const
// 3bits PTS [32..30]
// 1bit const '1'
// ===========2B
// 15bits PTS [29..15]
// 1bit const '1'
// ===========2B
// 15bits PTS [14..0]
// 1bit const '1'
public var pts:Number; // 33bits
// 5B
/**
* The DTS is a 33-bit number coded in three separate fields. It indicates the decoding time,
* td n (j), in the system target decoder of an access unit j of elementary stream n. The value of DTS is specified in units of
* the period of the system clock frequency divided by 300 (yielding 90 kHz).
*/
// ===========1B
// 4bits const
// 3bits DTS [32..30]
// 1bit const '1'
// ===========2B
// 15bits DTS [29..15]
// 1bit const '1'
// ===========2B
// 15bits DTS [14..0]
// 1bit const '1'
public var dts:Number; // 33bits
// 6B
/**
* The elementary stream clock reference is a 42-bit field coded in two parts. The first
* part, ESCR_base, is a 33-bit field whose value is given by ESCR_base(i), as given in equation 2-14. The second part,
* ESCR_ext, is a 9-bit field whose value is given by ESCR_ext(i), as given in equation 2-15. The ESCR field indicates the
* intended time of arrival of the byte containing the last bit of the ESCR_base at the input of the PES-STD for PES streams
* (refer to 2.5.2.4).
*/
// 2bits reserved
// 3bits ESCR_base[32..30]
// 1bit const '1'
// 15bits ESCR_base[29..15]
// 1bit const '1'
// 15bits ESCR_base[14..0]
// 1bit const '1'
// 9bits ESCR_extension
// 1bit const '1'
public var ESCR_base:Number; //33bits
public var ESCR_extension:int; //9bits
// 3B
/**
* The ES_rate field is a 22-bit unsigned integer specifying the rate at which the
* system target decoder receives bytes of the PES packet in the case of a PES stream. The ES_rate is valid in the PES
* packet in which it is included and in subsequent PES packets of the same PES stream until a new ES_rate field is
* encountered. The value of the ES_rate is measured in units of 50 bytes/second. The value 0 is forbidden. The value of the
* ES_rate is used to define the time of arrival of bytes at the input of a P-STD for PES streams defined in 2.5.2.4. The
* value encoded in the ES_rate field may vary from PES_packet to PES_packet.
*/
// 1bit const '1'
// 22bits ES_rate
// 1bit const '1'
public var ES_rate:int; //22bits
// 1B
/**
* A 3-bit field that indicates which trick mode is applied to the associated video stream. In cases of
* other types of elementary streams, the meanings of this field and those defined by the following five bits are undefined.
* For the definition of trick_mode status, refer to the trick mode section of 2.4.2.3.
*/
public var trick_mode_control:int; //3bits
public var trick_mode_value:int; //5bits
// 1B
// 1bit const '1'
/**
* This 7-bit field contains private data relating to copyright information.
*/
public var additional_copy_info:int; //7bits
// 2B
/**
* The previous_PES_packet_CRC is a 16-bit field that contains the CRC value that yields
* a zero output of the 16 registers in the decoder similar to the one defined in Annex A,
*/
public var previous_PES_packet_CRC:int; //16bits
// 1B
/**
* A 1-bit flag which when set to '1' indicates that the PES packet header contains private data.
* When set to a value of '0' it indicates that private data is not present in the PES header.
*/
public var PES_private_data_flag:int; //1bit
/**
* A 1-bit flag which when set to '1' indicates that an ISO/IEC 11172-1 pack header or a
* Program Stream pack header is stored in this PES packet header. If this field is in a PES packet that is contained in a
* Program Stream, then this field shall be set to '0'. In a Transport Stream, when set to the value '0' it indicates that no pack
* header is present in the PES header.
*/
public var pack_header_field_flag:int; //1bit
/**
* A 1-bit flag which when set to '1' indicates that the
* program_packet_sequence_counter, MPEG1_MPEG2_identifier, and original_stuff_length fields are present in this
* PES packet. When set to a value of '0' it indicates that these fields are not present in the PES header.
*/
public var program_packet_sequence_counter_flag:int; //1bit
/**
* A 1-bit flag which when set to '1' indicates that the P-STD_buffer_scale and P-STD_buffer_size
* are present in the PES packet header. When set to a value of '0' it indicates that these fields are not present in the
* PES header.
*/
public var P_STD_buffer_flag:int; //1bit
/**
* reverved value, must be '1'
*/
public var const1_value0:int; //3bits
/**
* A 1-bit field which when set to '1' indicates the presence of the PES_extension_field_length
* field and associated fields. When set to a value of '0' this indicates that the PES_extension_field_length field and any
* associated fields are not present.
*/
public var PES_extension_flag_2:int; //1bit
// 16B
/**
* This is a 16-byte field which contains private data. This data, combined with the fields before and
* after, shall not emulate the packet_start_code_prefix (0x000001).
*/
public var PES_private_data:ByteArray; //128bits
// (1+x)B
/**
* This is an 8-bit field which indicates the length, in bytes, of the pack_header_field().
*/
public var pack_field_length:int; //8bits
public var pack_field:ByteArray; //[pack_field_length] bytes
// 2B
// 1bit const '1'
/**
* The program_packet_sequence_counter field is a 7-bit field. It is an optional
* counter that increments with each successive PES packet from a Program Stream or from an ISO/IEC 11172-1 Stream or
* the PES packets associated with a single program definition in a Transport Stream, providing functionality similar to a
* continuity counter (refer to 2.4.3.2). This allows an application to retrieve the original PES packet sequence of a Program
* Stream or the original packet sequence of the original ISO/IEC 11172-1 stream. The counter will wrap around to 0 after
* its maximum value. Repetition of PES packets shall not occur. Consequently, no two consecutive PES packets in the
* program multiplex shall have identical program_packet_sequence_counter values.
*/
public var program_packet_sequence_counter:int; //7bits
// 1bit const '1'
/**
* A 1-bit flag which when set to '1' indicates that this PES packet carries information from
* an ISO/IEC 11172-1 stream. When set to '0' it indicates that this PES packet carries information from a Program Stream.
*/
public var MPEG1_MPEG2_identifier:int; //1bit
/**
* This 6-bit field specifies the number of stuffing bytes used in the original ITU-T
* Rec. H.222.0 | ISO/IEC 13818-1 PES packet header or in the original ISO/IEC 11172-1 packet header.
*/
public var original_stuff_length:int; //6bits
// 2B
// 2bits const '01'
/**
* The P-STD_buffer_scale is a 1-bit field, the meaning of which is only defined if this PES packet
* is contained in a Program Stream. It indicates the scaling factor used to interpret the subsequent P-STD_buffer_size field.
* If the preceding stream_id indicates an audio stream, P-STD_buffer_scale shall have the value '0'. If the preceding
* stream_id indicates a video stream, P-STD_buffer_scale shall have the value '1'. For all other stream types, the value
* may be either '1' or '0'.
*/
public var P_STD_buffer_scale:int; //1bit
/**
* The P-STD_buffer_size is a 13-bit unsigned integer, the meaning of which is only defined if this
* PES packet is contained in a Program Stream. It defines the size of the input buffer, BS n , in the P-STD. If
* P-STD_buffer_scale has the value '0', then the P-STD_buffer_size measures the buffer size in units of 128 bytes. If
* P-STD_buffer_scale has the value '1', then the P-STD_buffer_size measures the buffer size in units of 1024 bytes.
*/
public var P_STD_buffer_size:int; //13bits
// (1+x)B
// 1bit const '1'
/**
* This is a 7-bit field which specifies the length, in bytes, of the data following this field in
* the PES extension field up to and including any reserved bytes.
*/
public var PES_extension_field_length:int; //7bits
public var PES_extension_field:ByteArray; //[PES_extension_field_length] bytes
// NB
/**
* This is a fixed 8-bit value equal to '1111 1111' that can be inserted by the encoder, for example to meet
* the requirements of the channel. It is discarded by the decoder. No more than 32 stuffing bytes shall be present in one
* PES packet header.
*/
public var nb_stuffings:int;
// NB
/**
* PES_packet_data_bytes shall be contiguous bytes of data from the elementary stream
* indicated by the packet’s stream_id or PID. When the elementary stream data conforms to ITU-T
* Rec. H.262 | ISO/IEC 13818-2 or ISO/IEC 13818-3, the PES_packet_data_bytes shall be byte aligned to the bytes of this
* Recommendation | International Standard. The byte-order of the elementary stream shall be preserved. The number of
* PES_packet_data_bytes, N, is specified by the PES_packet_length field. N shall be equal to the value indicated in the
* PES_packet_length minus the number of bytes between the last byte of the PES_packet_length field and the first
* PES_packet_data_byte.
*
* In the case of a private_stream_1, private_stream_2, ECM_stream, or EMM_stream, the contents of the
* PES_packet_data_byte field are user definable and will not be specified by ITU-T | ISO/IEC in the future.
*/
public var nb_bytes:int;
// NB
/**
* This is a fixed 8-bit value equal to '1111 1111'. It is discarded by the decoder.
*/
public var nb_paddings:int;
private var _log:ILogger = new TraceLogger("HLS");
public function SrsTsPayloadPES(p:SrsTsPacket)
{
super(p);
PES_private_data = null;
pack_field = null;
PES_extension_field = null;
nb_stuffings = 0;
nb_bytes = 0;
nb_paddings = 0;
const2bits = 0x02;
const1_value0 = 0x07;
}
override public function decode(stream:ByteArray):SrsTsMessage
{
// find the channel from chunk.
var channel:SrsTsChannel = packet.context.getChannel(packet.pid);
if (!channel) {
throw new Error("ts: demux PES no channel, pid=" + packet.pid);
}
// init msg.
var msg:SrsTsMessage = channel.msg;
if (!msg) {
msg = new SrsTsMessage(channel, packet);
channel.msg = msg;
}
// we must cache the fresh state of msg,
// for the PES_packet_length is 0, the first payload_unit_start_indicator always 1,
// so should check for the fresh and not completed it.
var is_fresh_msg:Boolean = msg.fresh();
// check when fresh, the payload_unit_start_indicator
// should be 1 for the fresh msg.
if (is_fresh_msg && !packet.payload_unit_start_indicator) {
_log.error("ts: PES fresh packet length={0}, us={1}, cc={2}",
msg.PES_packet_length, packet.payload_unit_start_indicator, packet.continuity_counter);
throw new Error("ts: PES fresh packet invalid.");
}
// check when not fresh and PES_packet_length>0,
// the payload_unit_start_indicator should never be 1 when not completed.
if (!is_fresh_msg && msg.PES_packet_length > 0
&& !msg.completed(packet.payload_unit_start_indicator)
&& packet.payload_unit_start_indicator
) {
_log.error("ts: PES packet length={0}, us={1}, cc={2}",
msg.PES_packet_length, packet.payload_unit_start_indicator, packet.continuity_counter);
throw new Error("ts: PES packet length invalid.");
// reparse current msg.
stream.position = 0;
channel.msg = null;
return null;
}
// check the continuity counter
if (!is_fresh_msg) {
// late-incoming or duplicated continuity, drop message.
// @remark check overflow, the counter plus 1 should greater when invalid.
if (msg.continuity_counter >= packet.continuity_counter
&& ((msg.continuity_counter + 1) & 0x0f) > packet.continuity_counter
) {
_log.warn("ts: drop PES {0}B for duplicated cc={1}",
stream.length, msg.continuity_counter);
stream.position = 0;
return null;
}
// when got partially message, the continous count must be continuous, or drop it.
if (((msg.continuity_counter + 1) & 0x0f) != packet.continuity_counter) {
_log.error("ts: continuity must be continous, msg={0}, packet={1}",
msg.continuity_counter, packet.continuity_counter);
throw new Error("ts: continuity must be continous.");
// reparse current msg.
stream.position = 0;
channel.msg = null;
return null;
}
}
msg.continuity_counter = packet.continuity_counter;
// for the PES_packet_length(0), reap when completed.
if (!is_fresh_msg && msg.completed(packet.payload_unit_start_indicator)) {
// reap previous PES packet.
channel.msg = null;
// reparse current msg.
stream.position = 0;
return msg;
}
// contious packet, append bytes for unit start is 0
if (!packet.payload_unit_start_indicator) {
nb_bytes = msg.dump(stream);
}
// when unit start, parse the fresh msg.
if (packet.payload_unit_start_indicator) {
// 6B fixed header.
if (stream.bytesAvailable < 6) {
throw new Error("ts: demux PSE failed.");
}
// 3B
stream.position -= 1;
packet_start_code_prefix = (stream.readUnsignedInt()) & 0x00ffffff;
// 1B
stream_id = stream.readUnsignedByte();
// 2B
PES_packet_length = stream.readUnsignedShort();
// check the packet start prefix.
packet_start_code_prefix &= 0xFFFFFF;
if (packet_start_code_prefix != 0x01) {
_log.error("ts: demux PES start code failed, expect=0x01, actual={0}",
packet_start_code_prefix);
throw new Error("ts: demux PES start code failed.");
}
var pos_packet:uint = stream.position;
// @remark the sid indicates the elementary stream format.
// the SrsTsPESStreamIdAudio and SrsTsPESStreamIdVideo is start by 0b110 or 0b1110
var sid:SrsTsPESStreamId = SrsTsPESStreamId.parse(stream_id);
msg.sid = sid;
if (sid.notEquals(SrsTsPESStreamId.ProgramStreamMap)
&& sid.notEquals(SrsTsPESStreamId.PaddingStream)
&& sid.notEquals(SrsTsPESStreamId.PrivateStream2)
&& sid.notEquals(SrsTsPESStreamId.EcmStream)
&& sid.notEquals(SrsTsPESStreamId.EmmStream)
&& sid.notEquals(SrsTsPESStreamId.ProgramStreamDirectory)
&& sid.notEquals(SrsTsPESStreamId.DsmccStream)
&& sid.notEquals(SrsTsPESStreamId.H2221TypeE)
) {
// 3B flags.
if (stream.bytesAvailable < 3) {
throw new Error("ts: demux PSE flags failed.");
}
// 1B
var oocv:int = stream.readUnsignedByte();
// 1B
var pefv:int = stream.readUnsignedByte();
// 1B
PES_header_data_length = stream.readUnsignedByte();
// position of header start.
var pos_header:uint = stream.position;
const2bits = (oocv >> 6) & 0x03;
PES_scrambling_control = (oocv >> 4) & 0x03;
PES_priority = (oocv >> 3) & 0x01;
data_alignment_indicator = (oocv >> 2) & 0x01;
copyright = (oocv >> 1) & 0x01;
original_or_copy = oocv & 0x01;
PTS_DTS_flags = (pefv >> 6) & 0x03;
ESCR_flag = (pefv >> 5) & 0x01;
ES_rate_flag = (pefv >> 4) & 0x01;
DSM_trick_mode_flag = (pefv >> 3) & 0x01;
additional_copy_info_flag = (pefv >> 2) & 0x01;
PES_CRC_flag = (pefv >> 1) & 0x01;
PES_extension_flag = pefv & 0x01;
// check required together.
var nb_required:int = 0;
nb_required += (PTS_DTS_flags == 0x2)? 5:0;
nb_required += (PTS_DTS_flags == 0x3)? 10:0;
nb_required += ESCR_flag? 6:0;
nb_required += ES_rate_flag? 3:0;
nb_required += DSM_trick_mode_flag? 1:0;
nb_required += additional_copy_info_flag? 1:0;
nb_required += PES_CRC_flag? 2:0;
nb_required += PES_extension_flag? 1:0;
if (stream.bytesAvailable < nb_required) {
throw new Error("ts: demux PSE payload failed.");
}
// 5B
if (PTS_DTS_flags == 0x2) {
pts = decode_33bits_dts_pts(stream);
dts = pts;
// update the dts and pts of message.
msg.dts = dts;
msg.pts = pts;
}
// 10B
if (PTS_DTS_flags == 0x3) {
pts = decode_33bits_dts_pts(stream);
dts = decode_33bits_dts_pts(stream);
// check sync, the diff of dts and pts should never greater than 1s.
if (dts - pts > 90000 || pts - dts > 90000) {
_log.warn("ts: sync dts={0}, pts={1}", dts, pts);
}
// update the dts and pts of message.
msg.dts = dts;
msg.pts = pts;
}
// 6B
if (ESCR_flag) {
ESCR_extension = 0;
ESCR_base = 0;
stream.position += 6;
_log.warn("ts: demux PES, ignore the escr.");
}
// 3B
if (ES_rate_flag) {
// skip -1 to read 4bytes for the ES_rate is 3B.
stream.position -= 1;
ES_rate = (stream.readUnsignedInt() & 0x00ffffff);
ES_rate = ES_rate >> 1;
ES_rate &= 0x3FFFFF;
}
// 1B
if (DSM_trick_mode_flag) {
trick_mode_control = stream.readUnsignedByte();
trick_mode_value = trick_mode_control & 0x1f;
trick_mode_control = (trick_mode_control >> 5) & 0x03;
}
// 1B
if (additional_copy_info_flag) {
additional_copy_info = stream.readUnsignedByte();
additional_copy_info &= 0x7f;
}
// 2B
if (PES_CRC_flag) {
previous_PES_packet_CRC = stream.readUnsignedShort();
}
// 1B
if (PES_extension_flag) {
var efv:int = stream.readUnsignedByte();
PES_private_data_flag = (efv >> 7) & 0x01;
pack_header_field_flag = (efv >> 6) & 0x01;
program_packet_sequence_counter_flag = (efv >> 5) & 0x01;
P_STD_buffer_flag = (efv >> 4) & 0x01;
const1_value0 = (efv >> 1) & 0x07;
PES_extension_flag_2 = efv & 0x01;
nb_required = 0;
nb_required += PES_private_data_flag? 16:0;
nb_required += pack_header_field_flag? 1:0; // 1+x bytes.
nb_required += program_packet_sequence_counter_flag? 2:0;
nb_required += P_STD_buffer_flag? 2:0;
nb_required += PES_extension_flag_2? 1:0; // 1+x bytes.
if (stream.bytesAvailable < nb_required) {
throw new Error("ts: demux PSE ext payload failed.");
}
// 16B
if (PES_private_data_flag) {
PES_private_data = new ByteArray();
stream.readBytes(PES_private_data, 0, 16);
}
// (1+x)B
if (pack_header_field_flag) {
pack_field_length = stream.readUnsignedByte();
if (pack_field_length > 0) {
// the adjust required bytes.
nb_required = nb_required - 16 - 1 + pack_field_length;
if (stream.bytesAvailable < nb_required) {
throw new Error("ts: demux PSE ext pack failed.");
}
pack_field = new ByteArray();
stream.readBytes(pack_field, 0, pack_field_length);
}
}
// 2B
if (program_packet_sequence_counter_flag) {
program_packet_sequence_counter = stream.readUnsignedByte();
program_packet_sequence_counter &= 0x7f;
original_stuff_length = stream.readUnsignedByte();
MPEG1_MPEG2_identifier = (original_stuff_length >> 6) & 0x01;
original_stuff_length &= 0x3f;
}
// 2B
if (P_STD_buffer_flag) {
P_STD_buffer_size = stream.readUnsignedShort();
// '01'
//int8_t const2bits = (P_STD_buffer_scale >>14) & 0x03;
P_STD_buffer_scale = (P_STD_buffer_scale >>13) & 0x01;
P_STD_buffer_size &= 0x1FFF;
}
// (1+x)B
if (PES_extension_flag_2) {
PES_extension_field_length = stream.readUnsignedByte();
PES_extension_field_length &= 0x07;
if (PES_extension_field_length > 0) {
if (stream.bytesAvailable < PES_extension_field_length) {
throw new Error("ts: demux PSE ext field failed.");
}
PES_extension_field = new ByteArray();
stream.readBytes(PES_extension_field, 0, PES_extension_field_length);
}
}
}
// stuffing_byte
nb_stuffings = PES_header_data_length - (stream.position - pos_header);
if (nb_stuffings > 0) {
if (stream.bytesAvailable < nb_stuffings) {
throw new Error("ts: demux PSE stuffings failed.");
}
stream.position += nb_stuffings;
}
// PES_packet_data_byte, page58.
// the packet size contains the header size.
// The number of PES_packet_data_bytes, N, is specified by the
// PES_packet_length field. N shall be equal to the value
// indicated in the PES_packet_length minus the number of bytes
// between the last byte of the PES_packet_length field and the
// first PES_packet_data_byte.
/**
* when actual packet length > 0xffff(65535),
* which exceed the max u_int16_t packet length,
* use 0 packet length, the next unit start indicates the end of packet.
*/
if (PES_packet_length > 0) {
var nb_packet:uint = PES_packet_length - (stream.position - pos_packet);
msg.PES_packet_length = (uint)(Math.max(0, nb_packet));
}
// xB
nb_bytes = msg.dump(stream);
} else if (sid.equals(SrsTsPESStreamId.ProgramStreamMap)
|| sid.equals(SrsTsPESStreamId.PrivateStream2)
|| sid.equals(SrsTsPESStreamId.EcmStream)
|| sid.equals(SrsTsPESStreamId.EmmStream)
|| sid.equals(SrsTsPESStreamId.ProgramStreamDirectory)
|| sid.equals(SrsTsPESStreamId.DsmccStream)
|| sid.equals(SrsTsPESStreamId.H2221TypeE)
) {
// for (i = 0; i < PES_packet_length; i++) {
// PES_packet_data_byte
// }
// xB
nb_bytes = msg.dump(stream);
} else if (sid.equals(SrsTsPESStreamId.PaddingStream)) {
// for (i = 0; i < PES_packet_length; i++) {
// padding_byte
// }
nb_paddings = stream.length - stream.position;
stream.position = stream.length;
//info("ts: drop %dB padding bytes", nb_paddings);
} else {
var nb_drop:int = stream.length - stream.position;
stream.position = stream.length;
_log.warn("ts: drop the pes packet {0}B for stream_id={1}", nb_drop, stream_id);
}
}
// when fresh and the PES_packet_length is 0,
// the payload_unit_start_indicator always be 1,
// the message should never EOF for the first packet.
if (is_fresh_msg && msg.PES_packet_length == 0) {
return null;
}
// check msg, reap when completed.
if (msg.completed(packet.payload_unit_start_indicator)) {
channel.msg = null;
//info("ts: reap msg for completed.");
return msg;
}
return null;
}
private function decode_33bits_dts_pts(stream:ByteArray):Number
{
if (stream.bytesAvailable < 5) {
throw new Error("ts: demux PSE dts/pts failed");
}
// decode the 33bits schema.
// ===========1B
// 4bits const maybe '0001', '0010' or '0011'.
// 3bits DTS/PTS [32..30]
// 1bit const '1'
var dts_pts_30_32:uint = stream.readUnsignedByte();
if ((dts_pts_30_32 & 0x01) != 0x01) {
throw new Error("ts: demux PSE dts/pts 30-32 failed.");
}
// @remark, we donot check the high 4bits, maybe '0001', '0010' or '0011'.
// so we just ensure the high 4bits is not 0x00.
if (((dts_pts_30_32 >> 4) & 0x0f) == 0x00) {
throw new Error("ts: demux PSE dts/pts 30-32 failed.");
}
dts_pts_30_32 = (dts_pts_30_32 >> 1) & 0x07;
// ===========2B
// 15bits DTS/PTS [29..15]
// 1bit const '1'
var dts_pts_15_29:uint = stream.readUnsignedShort();
if ((dts_pts_15_29 & 0x01) != 0x01) {
throw new Error("ts: demux PSE dts/pts 15-29 failed.");
}
dts_pts_15_29 = (dts_pts_15_29 >> 1) & 0x7fff;
// ===========2B
// 15bits DTS/PTS [14..0]
// 1bit const '1'
var dts_pts_0_14:uint = stream.readUnsignedShort();
if ((dts_pts_0_14 & 0x01) != 0x01) {
throw new Error("ts: demux PSE dts/pts 0-14 failed.");
}
dts_pts_0_14 = (dts_pts_0_14 >> 1) & 0x7fff;
var v:uint = 0x00;
v += (dts_pts_30_32 << 30) & 0x1c0000000;
v += (dts_pts_15_29 << 15) & 0x3fff8000;
v += dts_pts_0_14 & 0x7fff;
return v;
}
};
/**
* the PSI payload of ts packet.
* 2.4.4 Program specific information, hls-mpeg-ts-iso13818-1.pdf, page 59
*/
class SrsTsPayloadPSI extends SrsTsPayload
{
// 1B
/**
* This is an 8-bit field whose value shall be the number of bytes, immediately following the pointer_field
* until the first byte of the first section that is present in the payload of the Transport Stream packet (so a value of 0x00 in
* the pointer_field indicates that the section starts immediately after the pointer_field). When at least one section begins in
* a given Transport Stream packet, then the payload_unit_start_indicator (refer to 2.4.3.2) shall be set to 1 and the first
* byte of the payload of that Transport Stream packet shall contain the pointer. When no section begins in a given
* Transport Stream packet, then the payload_unit_start_indicator shall be set to 0 and no pointer shall be sent in the
* payload of that packet.
*/
public var pointer_field:int;
// 1B
/**
* This is an 8-bit field, which shall be set to 0x00 as shown in Table 2-26.
*/
public var table_id:SrsTsPsiId; //8bits
// 2B
/**
* The section_syntax_indicator is a 1-bit field which shall be set to '1'.
*/
public var section_syntax_indicator:int; //1bit
/**
* const value, must be '0'
*/
public var const0_value:int; //1bit
/**
* reverved value, must be '1'
*/
public var const1_value:int; //2bits
/**
* This is a 12-bit field, the first two bits of which shall be '00'. The remaining 10 bits specify the number
* of bytes of the section, starting immediately following the section_length field, and including the CRC. The value in this
* field shall not exceed 1021 (0x3FD).
*/
public var section_length:int; //12bits
// the specified psi info, for example, PAT fields.
// 4B
/**
* This is a 32-bit field that contains the CRC value that gives a zero output of the registers in the decoder
* defined in Annex A after processing the entire section.
* @remark crc32(bytes without pointer field, before crc32 field)
*/
public var CRC_32:int; //32bits
public function SrsTsPayloadPSI(p:SrsTsPacket)
{
super(p);
pointer_field = 0;
const0_value = 0;
const1_value = 3;
CRC_32 = 0;
}
override public function decode(stream:ByteArray):SrsTsMessage
{
/**
* When the payload of the Transport Stream packet contains PSI data, the payload_unit_start_indicator has the following
* significance: if the Transport Stream packet carries the first byte of a PSI section, the payload_unit_start_indicator value
* shall be '1', indicating that the first byte of the payload of this Transport Stream packet carries the pointer_field. If the
* Transport Stream packet does not carry the first byte of a PSI section, the payload_unit_start_indicator value shall be '0',
* indicating that there is no pointer_field in the payload. Refer to 2.4.4.1 and 2.4.4.2. This also applies to private streams of
* stream_type 5 (refer to Table 2-29).
*/
if (packet.payload_unit_start_indicator) {
if (stream.bytesAvailable < 1) {
throw new Error("ts: demux PSI failed.");
}
pointer_field = stream.readUnsignedByte();
}
// to calc the crc32
var pat_pos:uint = stream.position;
// atleast 3B for all psi.
if (stream.bytesAvailable < 3) {
throw new Error("ts: demux PSI failed.");
}
// 1B
table_id = SrsTsPsiId.parse(stream.readUnsignedByte());
// 2B
var slv:int = stream.readUnsignedShort();
section_syntax_indicator = (slv >> 15) & 0x01;
const0_value = (slv >> 14) & 0x01;
const1_value = (slv >> 12) & 0x03;
section_length = slv & 0x0FFF;
// no section, ignore.
if (section_length == 0) {
// "ts: demux PAT ignore empty section"
return null;
}
if (stream.bytesAvailable < section_length) {
throw new Error("ts: demux PAT section failed.");
}
// call the virtual method of actual PSI.
psi_decode(stream);
// 4B
if (stream.bytesAvailable < 4) {
throw new Error("ts: demux PSI crc32 failed.");
}
CRC_32 = stream.readUnsignedInt();
// verify crc32.
var pos:uint = stream.position;
var crc32Bytes:ByteArray = new ByteArray();
stream.position = pat_pos;
stream.readBytes(crc32Bytes, 0, pos - pat_pos - 4);
stream.position = pos;
var expetCrc32:int = (int)(SrsUtils.srs_crc32(crc32Bytes));
if (expetCrc32 != CRC_32) {
throw new Error("ts: verify PSI crc32 failed.");
}
stream.position = pos;
// consume left stuffings
// TODO: FIXME: all stuffing must be 0xff.
stream.position = stream.length;
return null;
}
protected function psi_decode(stream:ByteArray):void
{
throw new Error("not implements");
}
};
/**
* the program of PAT of PSI ts packet.
*/
class SrsTsPayloadPATProgram
{
// 4B
/**
* Program_number is a 16-bit field. It specifies the program to which the program_map_PID is
* applicable. When set to 0x0000, then the following PID reference shall be the network PID. For all other cases the value
* of this field is user defined. This field shall not take any single value more than once within one version of the Program
* Association Table.
*/
public var number:int; // 16bits
/**
* reverved value, must be '1'
*/
public var const1_value:int; //3bits
/**
* program_map_PID/network_PID 13bits
* network_PID - The network_PID is a 13-bit field, which is used only in conjunction with the value of the
* program_number set to 0x0000, specifies the PID of the Transport Stream packets which shall contain the Network
* Information Table. The value of the network_PID field is defined by the user, but shall only take values as specified in
* Table 2-3. The presence of the network_PID is optional.
*/
public var pid:int; //13bits
public function SrsTsPayloadPATProgram(n:int, p:int)
{
number = n;
pid = p;
const1_value = 0x07;
}
public function decode(stream:ByteArray):void
{
// atleast 4B for PAT program specified
if (stream.bytesAvailable < 4) {
throw new Error("ts: demux PAT failed.");
}
var tmpv:int = stream.readUnsignedInt();
number = ((tmpv >> 16) & 0xFFFF);
const1_value = ((tmpv >> 13) & 0x07);
pid = (tmpv & 0x1FFF);
return;
}
};
/**
* the PAT payload of PSI ts packet.
* 2.4.4.3 Program association Table, hls-mpeg-ts-iso13818-1.pdf, page 61
* The Program Association Table provides the correspondence between a program_number and the PID value of the
* Transport Stream packets which carry the program definition. The program_number is the numeric label associated with
* a program.
*/
class SrsTsPayloadPAT extends SrsTsPayloadPSI
{
// 2B
/**
* This is a 16-bit field which serves as a label to identify this Transport Stream from any other
* multiplex within a network. Its value is defined by the user.
*/
public var transport_stream_id:int; //16bits
// 1B
/**
* reverved value, must be '1'
*/
public var const3_value:int; //2bits
/**
* This 5-bit field is the version number of the whole Program Association Table. The version number
* shall be incremented by 1 modulo 32 whenever the definition of the Program Association Table changes. When the
* current_next_indicator is set to '1', then the version_number shall be that of the currently applicable Program Association
* Table. When the current_next_indicator is set to '0', then the version_number shall be that of the next applicable Program
* Association Table.
*/
public var version_number:int; //5bits
/**
* A 1-bit indicator, which when set to '1' indicates that the Program Association Table sent is
* currently applicable. When the bit is set to '0', it indicates that the table sent is not yet applicable and shall be the next
* table to become valid.
*/
public var current_next_indicator:int; //1bit
// 1B
/**
* This 8-bit field gives the number of this section. The section_number of the first section in the
* Program Association Table shall be 0x00. It shall be incremented by 1 with each additional section in the Program
* Association Table.
*/
public var section_number:int; //8bits
// 1B
/**
* This 8-bit field specifies the number of the last section (that is, the section with the highest
* section_number) of the complete Program Association Table.
*/
public var last_section_number:int; //8bits
// multiple 4B program data, elem is SrsTsPayloadPATProgram
public var programs:Array;
public function SrsTsPayloadPAT(p:SrsTsPacket)
{
super(p);
const3_value = 3;
programs = new Array();
}
override protected function psi_decode(stream:ByteArray):void
{
// atleast 5B for PAT specified
if (stream.bytesAvailable < 5) {
throw new Error("ts: demux PAT failed.");
}
var pos:uint = stream.position;
// 2B
transport_stream_id = stream.readUnsignedShort();
// 1B
var cniv:int = stream.readUnsignedByte();
const3_value = (cniv >> 6) & 0x03;
version_number = (cniv >> 1) & 0x1F;
current_next_indicator = cniv & 0x01;
// TODO: FIXME: check the indicator.
// 1B
section_number = stream.readUnsignedByte();
// 1B
last_section_number = stream.readUnsignedByte();
// multiple 4B program data.
var program_bytes:int = section_length - 4 - (stream.position - pos);
for (var i:int = 0; i < program_bytes; i += 4) {
var program:SrsTsPayloadPATProgram = new SrsTsPayloadPATProgram(0, 0);
program.decode(stream);
// update the apply pid table.
packet.context.setChannel(program.pid, SrsTsPidApply.PMT, SrsTsStream.Reserved);
programs.push(program);
}
// update the apply pid table.
packet.context.setChannel(packet.pid, SrsTsPidApply.PAT, SrsTsStream.Reserved);
return;
}
};
/**
* the esinfo for PMT program.
*/
class SrsTsPayloadPMTESInfo
{
// 1B
/**
* This is an 8-bit field specifying the type of program element carried within the packets with the PID
* whose value is specified by the elementary_PID. The values of stream_type are specified in Table 2-29.
*/
public var stream_type:SrsTsStream; //8bits
// 2B
/**
* reverved value, must be '1'
*/
public var const1_value0:int; //3bits
/**
* This is a 13-bit field specifying the PID of the Transport Stream packets which carry the associated
* program element.
*/
public var elementary_PID:int; //13bits
// (2+x)B
/**
* reverved value, must be '1'
*/
public var const1_value1:int; //4bits
/**
* This is a 12-bit field, the first two bits of which shall be '00'. The remaining 10 bits specify the number
* of bytes of the descriptors of the associated program element immediately following the ES_info_length field.
*/
public var ES_info_length:int; //12bits
public var ES_info:ByteArray; //[ES_info_length] bytes.
public function SrsTsPayloadPMTESInfo(st:SrsTsStream, epid:int)
{
stream_type = st;
elementary_PID = epid;
const1_value0 = 7;
const1_value1 = 0x0f;
ES_info_length = 0;
ES_info = null;
}
public function decode(stream:ByteArray):void
{
// 5B
if (stream.bytesAvailable < 5) {
throw new Error("ts: demux PMT es info failed.");
}
stream_type = SrsTsStream.parse(stream.readUnsignedByte());
var epv:int = stream.readUnsignedShort();
const1_value0 = (epv >> 13) & 0x07;
elementary_PID = epv & 0x1FFF;
var eilv:int = stream.readUnsignedShort();
const1_value1 = (epv >> 12) & 0x0f;
ES_info_length = eilv & 0x0FFF;
if (ES_info_length > 0) {
if (stream.bytesAvailable < ES_info_length) {
throw new Error("ts: demux PMT es info data failed.");
}
ES_info = new ByteArray();
stream.readBytes(ES_info, 0, ES_info_length);
}
}
};
/**
* the PMT payload of PSI ts packet.
* 2.4.4.8 Program Map Table, hls-mpeg-ts-iso13818-1.pdf, page 64
* The Program Map Table provides the mappings between program numbers and the program elements that comprise
* them. A single instance of such a mapping is referred to as a "program definition". The program map table is the
* complete collection of all program definitions for a Transport Stream. This table shall be transmitted in packets, the PID
* values of which are selected by the encoder. More than one PID value may be used, if desired. The table is contained in
* one or more sections with the following syntax. It may be segmented to occupy multiple sections. In each section, the
* section number field shall be set to zero. Sections are identified by the program_number field.
*/
class SrsTsPayloadPMT extends SrsTsPayloadPSI
{
// 2B
/**
* program_number is a 16-bit field. It specifies the program to which the program_map_PID is
* applicable. One program definition shall be carried within only one TS_program_map_section. This implies that a
* program definition is never longer than 1016 (0x3F8). See Informative Annex C for ways to deal with the cases when
* that length is not sufficient. The program_number may be used as a designation for a broadcast channel, for example. By
* describing the different program elements belonging to a program, data from different sources (e.g. sequential events)
* can be concatenated together to form a continuous set of streams using a program_number. For examples of applications
* refer to Annex C.
*/
public var program_number:int; //16bits
// 1B
/**
* reverved value, must be '1'
*/
public var const1_value0:int; //2bits
/**
* This 5-bit field is the version number of the TS_program_map_section. The version number shall be
* incremented by 1 modulo 32 when a change in the information carried within the section occurs. Version number refers
* to the definition of a single program, and therefore to a single section. When the current_next_indicator is set to '1', then
* the version_number shall be that of the currently applicable TS_program_map_section. When the current_next_indicator
* is set to '0', then the version_number shall be that of the next applicable TS_program_map_section.
*/
public var version_number:int; //5bits
/**
* A 1-bit field, which when set to '1' indicates that the TS_program_map_section sent is
* currently applicable. When the bit is set to '0', it indicates that the TS_program_map_section sent is not yet applicable
* and shall be the next TS_program_map_section to become valid.
*/
public var current_next_indicator:int; //1bit
// 1B
/**
* The value of this 8-bit field shall be 0x00.
*/
public var section_number:int; //8bits
// 1B
/**
* The value of this 8-bit field shall be 0x00.
*/
public var last_section_number:int; //8bits
// 2B
/**
* reverved value, must be '1'
*/
public var const1_value1:int; //3bits
/**
* This is a 13-bit field indicating the PID of the Transport Stream packets which shall contain the PCR fields
* valid for the program specified by program_number. If no PCR is associated with a program definition for private
* streams, then this field shall take the value of 0x1FFF. Refer to the semantic definition of PCR in 2.4.3.5 and Table 2-3
* for restrictions on the choice of PCR_PID value.
*/
public var PCR_PID:int; //13bits
// 2B
public var const1_value2:int; //4bits
/**
* This is a 12-bit field, the first two bits of which shall be '00'. The remaining 10 bits specify the
* number of bytes of the descriptors immediately following the program_info_length field.
*/
public var program_info_length:int; //12bits
public var program_info_desc:ByteArray; //[program_info_length]bytes
// array of TSPMTESInfo, elem is SrsTsPayloadPMTESInfo object.
public var infos:Array;
public function SrsTsPayloadPMT(p:SrsTsPacket)
{
super(p);
const1_value0 = 3;
const1_value1 = 7;
const1_value2 = 0x0f;
program_info_length = 0;
program_info_desc = null;
infos = new Array();
}
override protected function psi_decode(stream:ByteArray):void
{
// atleast 9B for PMT specified
if (stream.bytesAvailable < 9) {
throw new Error("ts: demux PMT failed.");
}
// 2B
program_number = stream.readUnsignedShort();
// 1B
var cniv:int = stream.readUnsignedByte();
const1_value0 = (cniv >> 6) & 0x03;
version_number = (cniv >> 1) & 0x1F;
current_next_indicator = cniv & 0x01;
// 1B
section_number = stream.readUnsignedByte();
// 1B
last_section_number = stream.readUnsignedByte();
// 2B
var ppv:int = stream.readUnsignedShort();
const1_value1 = (ppv >> 13) & 0x07;
PCR_PID = ppv & 0x1FFF;
// 2B
var pilv:int = stream.readUnsignedShort();
const1_value2 = (pilv >> 12) & 0x0F;
program_info_length = pilv & 0xFFF;
if (program_info_length > 0) {
if (stream.bytesAvailable < program_info_length) {
throw new Error("ts: demux PMT program info failed.");
}
program_info_desc = new ByteArray();
stream.readBytes(program_info_desc, 0, program_info_length);
}
// [section_length] - 4(CRC) - 9B - [program_info_length]
var ES_EOF_pos:uint = stream.position + section_length - 4 - 9 - program_info_length;
while (stream.position < ES_EOF_pos) {
var info:SrsTsPayloadPMTESInfo = new SrsTsPayloadPMTESInfo(SrsTsStream.Reserved, 0);
infos.push(info);
info.decode(stream);
// update the apply pid table
switch (info.stream_type) {
case SrsTsStream.VideoH264:
case SrsTsStream.VideoMpeg4:
packet.context.setChannel(info.elementary_PID, SrsTsPidApply.Video, info.stream_type);
break;
case SrsTsStream.AudioAAC:
case SrsTsStream.AudioAC3:
case SrsTsStream.AudioDTS:
case SrsTsStream.AudioMp3:
packet.context.setChannel(info.elementary_PID, SrsTsPidApply.Audio, info.stream_type);
break;
default:
// warn("ts: drop pid=%#x, stream=%#x", info->elementary_PID, info->stream_type);
break;
}
}
// update the apply pid table.
packet.context.setChannel(packet.pid, SrsTsPidApply.PMT, SrsTsStream.Reserved);
packet.context.on_pmt_parsed();
}
};
/**
* the m3u8 parser.
*/
class M3u8
{
private var _hls:Hls;
private var _log:ILogger = new TraceLogger("HLS");
private var _tses:Array;
private var _duration:Number;
private var _seq_no:Number;
private var _url:String;
// when variant, all ts url is sub m3u8 url.
private var _variant:Boolean;
public function M3u8(hls:Hls)
{
_hls = hls;
_tses = new Array();
_duration = 0;
_seq_no = 0;
_variant = false;
}
public function getTsUrl(index:Number):String
{
if (index >= _tses.length) {
throw new Error("ts index overflow, index=" + index + ", max=" + _tses.length);
}
var url:String = _tses[index].url;
// if absolute url, return.
if (Utility.stringStartswith(url, "http://")) {
return url;
}
// add prefix of m3u8.
if (_url.lastIndexOf("/") >= 0) {
url = _url.substr(0, _url.lastIndexOf("/") + 1) + url;
}
return url;
}
public function parse(url:String, v:String):void
{
// TODO: FIXME: reset the m3u8 when parse.
_tses = new Array();
_duration = 0;
_url = url;
_variant = false;
var ptl:String = null;
var td:Number = 0;
var seq_no:Number = 0;
var lines:Array = v.split("\n");
for (var i:int = 0; i < lines.length; i++) {
var line:String = String(lines[i]).replace("\r", "").replace(" ", "");
// #EXT-X-VERSION:3
// the version must be 3.0
if (Utility.stringStartswith(line, "#EXT-X-VERSION:")) {
if (!Utility.stringEndswith(line, ":3")) {
_log.warn("m3u8 3.0 required, actual is {0}", line);
}
continue;
}
// #EXT-X-STREAM-INF:BANDWIDTH=3000000
if (Utility.stringStartswith(line, "#EXT-X-STREAM-INF:")) {
_variant = true;
var sub_m3u8_url:String = lines[++i];
_tses.push({
duration: 0,
url: sub_m3u8_url
});
continue;
}
// #EXT-X-PLAYLIST-TYPE:VOD
// the playlist type, vod or nothing.
if (Utility.stringStartswith(line, "#EXT-X-PLAYLIST-TYPE:")) {
ptl = line;
continue;
}
// #EXT-X-MEDIA-SEQUENCE:55
// the seq no of first ts.
if (Utility.stringStartswith(line, "#EXT-X-MEDIA-SEQUENCE:")) {
seq_no = Number(line.substr("#EXT-X-MEDIA-SEQUENCE:".length));
continue;
}
// #EXT-X-TARGETDURATION:12
// the target duration is required.
if (Utility.stringStartswith(line, "#EXT-X-TARGETDURATION:")) {
td = Number(line.substr("#EXT-X-TARGETDURATION:".length));
continue;
}
// #EXT-X-ENDLIST
// parse completed.
if (line == "#EXT-X-ENDLIST") {
break;
}
// #EXTINF:11.401,
// livestream-5.ts
// parse each ts entry, expect current line is inf.
if (!Utility.stringStartswith(line, "#EXTINF:")) {
continue;
}
// expect next line is url.
if (i >= lines.length - 1) {
_log.warn("ts entry unexpected eof, inf={0}", line);
break;
}
if (line.indexOf(",") >= 0) {
line = line.split(",")[0];
}
var ts_duration:Number = Number(line.substr("#EXTINF:".length).replace(",", ""));
var ts_url:String = lines[++i];
_duration += ts_duration;
_tses.push({
duration: ts_duration,
url: ts_url
});
}
_seq_no = seq_no;
// for vod, must specifies the playlist type to vod.
if (false) {
_log.warn("vod required the playlist type, actual is {0}", ptl);
}
if (false) {
_log.info("hls got {0}B {1}L m3u8, td={2}, ts={3}", v.length, lines.length, td, _tses.length);
} else {
_log.debug("hls got {0}B {1}L m3u8, td={2}, ts={3}", v.length, lines.length, td, _tses.length);
}
}
public function get tsCount():Number
{
return _tses.length;
}
public function get duration():Number
{
return _duration;
}
public function get seq_no():Number
{
return _seq_no;
}
public function get variant():Boolean
{
return _variant;
}
}
Reference in a new issue Copy permalink