RTCP is the Real-Time Control Protocol
This page hosts a formal specification of rtcp network payload (single udp packet) using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
import io.kaitai.struct.ByteBufferKaitaiStream;
import io.kaitai.struct.KaitaiStruct;
import io.kaitai.struct.KaitaiStream;
import java.io.IOException;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import io.kaitai.struct.ConsistencyError;
import java.util.Objects;
import java.util.List;
/**
* RTCP is the Real-Time Control Protocol
* @see <a href="https://www.rfc-editor.org/rfc/rfc3550">Source</a>
*/
public class RtcpPayload extends KaitaiStruct.ReadWrite {
public static RtcpPayload fromFile(String fileName) throws IOException {
return new RtcpPayload(new ByteBufferKaitaiStream(fileName));
}
public enum PayloadType {
FIR(192),
NACK(193),
IJ(195),
SR(200),
RR(201),
SDES(202),
BYE(203),
APP(204),
RTPFB(205),
PSFB(206),
XR(207),
AVB(208),
RSI(209);
private final long id;
PayloadType(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, PayloadType> byId = new HashMap<Long, PayloadType>(13);
static {
for (PayloadType e : PayloadType.values())
byId.put(e.id(), e);
}
public static PayloadType byId(long id) { return byId.get(id); }
}
public enum PsfbSubtype {
PLI(1),
SLI(2),
RPSI(3),
FIR(4),
TSTR(5),
TSTN(6),
VBCM(7),
AFB(15);
private final long id;
PsfbSubtype(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, PsfbSubtype> byId = new HashMap<Long, PsfbSubtype>(8);
static {
for (PsfbSubtype e : PsfbSubtype.values())
byId.put(e.id(), e);
}
public static PsfbSubtype byId(long id) { return byId.get(id); }
}
public enum RtpfbSubtype {
NACK(1),
TMMBR(3),
TMMBN(4),
RRR(5),
TRANSPORT_FEEDBACK(15);
private final long id;
RtpfbSubtype(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, RtpfbSubtype> byId = new HashMap<Long, RtpfbSubtype>(5);
static {
for (RtpfbSubtype e : RtpfbSubtype.values())
byId.put(e.id(), e);
}
public static RtpfbSubtype byId(long id) { return byId.get(id); }
}
public enum SdesSubtype {
PAD(0),
CNAME(1),
NAME(2),
EMAIL(3),
PHONE(4),
LOC(5),
TOOL(6),
NOTE(7),
PRIV(8);
private final long id;
SdesSubtype(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, SdesSubtype> byId = new HashMap<Long, SdesSubtype>(9);
static {
for (SdesSubtype e : SdesSubtype.values())
byId.put(e.id(), e);
}
public static SdesSubtype byId(long id) { return byId.get(id); }
}
public RtcpPayload() {
this(null, null, null);
}
public RtcpPayload(KaitaiStream _io) {
this(_io, null, null);
}
public RtcpPayload(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public RtcpPayload(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root == null ? this : _root;
}
public void _read() {
this.rtcpPackets = new ArrayList<RtcpPacket>();
{
int i = 0;
while (!this._io.isEof()) {
RtcpPacket _t_rtcpPackets = new RtcpPacket(this._io, this, _root);
try {
_t_rtcpPackets._read();
} finally {
this.rtcpPackets.add(_t_rtcpPackets);
}
i++;
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.rtcpPackets.size(); i++) {
this.rtcpPackets.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
for (int i = 0; i < this.rtcpPackets.size(); i++) {
if (this._io.isEof())
throw new ConsistencyError("rtcp_packets", 0, this._io.size() - this._io.pos());
this.rtcpPackets.get(((Number) (i)).intValue())._write_Seq(this._io);
}
if (!(this._io.isEof()))
throw new ConsistencyError("rtcp_packets", 0, this._io.size() - this._io.pos());
}
public void _check() {
for (int i = 0; i < this.rtcpPackets.size(); i++) {
if (!Objects.equals(this.rtcpPackets.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("rtcp_packets", _root(), this.rtcpPackets.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.rtcpPackets.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("rtcp_packets", this, this.rtcpPackets.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
public static class PacketStatusChunk extends KaitaiStruct.ReadWrite {
public static PacketStatusChunk fromFile(String fileName) throws IOException {
return new PacketStatusChunk(new ByteBufferKaitaiStream(fileName));
}
public PacketStatusChunk() {
this(null, null, null);
}
public PacketStatusChunk(KaitaiStream _io) {
this(_io, null, null);
}
public PacketStatusChunk(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public PacketStatusChunk(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.t = this._io.readBitsIntBe(1) != 0;
if ((t() ? 1 : 0) == 0) {
this.s2 = this._io.readBitsIntBe(2);
}
if ((t() ? 1 : 0) == 1) {
this.s1 = this._io.readBitsIntBe(1) != 0;
}
if ((t() ? 1 : 0) == 0) {
this.rle = this._io.readBitsIntBe(13);
}
if ((t() ? 1 : 0) == 1) {
this.symbolList = this._io.readBitsIntBe(14);
}
_dirty = false;
}
public void _fetchInstances() {
if ((t() ? 1 : 0) == 0) {
}
if ((t() ? 1 : 0) == 1) {
}
if ((t() ? 1 : 0) == 0) {
}
if ((t() ? 1 : 0) == 1) {
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBitsIntBe(1, (this.t ? 1 : 0));
if ((t() ? 1 : 0) == 0) {
this._io.writeBitsIntBe(2, this.s2);
}
if ((t() ? 1 : 0) == 1) {
this._io.writeBitsIntBe(1, (this.s1 ? 1 : 0));
}
if ((t() ? 1 : 0) == 0) {
this._io.writeBitsIntBe(13, this.rle);
}
if ((t() ? 1 : 0) == 1) {
this._io.writeBitsIntBe(14, this.symbolList);
}
}
public void _check() {
if ((t() ? 1 : 0) == 0) {
}
if ((t() ? 1 : 0) == 1) {
}
if ((t() ? 1 : 0) == 0) {
}
if ((t() ? 1 : 0) == 1) {
}
_dirty = false;
}
private Integer s;
public Integer s() {
if (this.s != null)
return this.s;
this.s = ((Number) (((t() ? 1 : 0) == 0 ? s2() : ((s1() ? 1 : 0) == 0 ? 1 : 0)))).intValue();
return this.s;
}
public void _invalidateS() { this.s = null; }
private boolean t;
private Long s2;
private Boolean s1;
private Long rle;
private Long symbolList;
private RtcpPayload _root;
private KaitaiStruct.ReadWrite _parent;
public boolean t() { return t; }
public void setT(boolean _v) { _dirty = true; t = _v; }
public Long s2() { return s2; }
public void setS2(Long _v) { _dirty = true; s2 = _v; }
public Boolean s1() { return s1; }
public void setS1(Boolean _v) { _dirty = true; s1 = _v; }
public Long rle() { return rle; }
public void setRle(Long _v) { _dirty = true; rle = _v; }
public Long symbolList() { return symbolList; }
public void setSymbolList(Long _v) { _dirty = true; symbolList = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class PsfbAfbPacket extends KaitaiStruct.ReadWrite {
public static PsfbAfbPacket fromFile(String fileName) throws IOException {
return new PsfbAfbPacket(new ByteBufferKaitaiStream(fileName));
}
public PsfbAfbPacket() {
this(null, null, null);
}
public PsfbAfbPacket(KaitaiStream _io) {
this(_io, null, null);
}
public PsfbAfbPacket(KaitaiStream _io, RtcpPayload.PsfbPacket _parent) {
this(_io, _parent, null);
}
public PsfbAfbPacket(KaitaiStream _io, RtcpPayload.PsfbPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.uid = this._io.readU4be();
switch (uid()) {
case 1380273474: {
this._raw_contents = this._io.readBytesFull();
KaitaiStream _io__raw_contents = new ByteBufferKaitaiStream(this._raw_contents);
this.contents = new PsfbAfbRembPacket(_io__raw_contents, this, _root);
((PsfbAfbRembPacket) (this.contents))._read();
break;
}
default: {
this.contents = this._io.readBytesFull();
break;
}
}
_dirty = false;
}
public void _fetchInstances() {
switch (uid()) {
case 1380273474: {
((PsfbAfbRembPacket) (this.contents))._fetchInstances();
break;
}
default: {
break;
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.uid);
switch (uid()) {
case 1380273474: {
final KaitaiStream _io__raw_contents = new ByteBufferKaitaiStream(this._io.size() - this._io.pos());
this._io.addChildStream(_io__raw_contents);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (this._io.size() - this._io.pos()));
final PsfbAfbPacket _this = this;
_io__raw_contents.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_contents = _io__raw_contents.toByteArray();
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_contents)))));
if (!(parent.isEof()))
throw new ConsistencyError("raw(contents)", 0, parent.size() - parent.pos());
}
});
}
((PsfbAfbRembPacket) (this.contents))._write_Seq(_io__raw_contents);
break;
}
default: {
this._io.writeBytes(((byte[]) (((byte[]) (this.contents)))));
if (!(this._io.isEof()))
throw new ConsistencyError("contents", 0, this._io.size() - this._io.pos());
break;
}
}
}
public void _check() {
switch (uid()) {
case 1380273474: {
if (!Objects.equals(((RtcpPayload.PsfbAfbRembPacket) (this.contents))._root(), _root()))
throw new ConsistencyError("contents", _root(), ((RtcpPayload.PsfbAfbRembPacket) (this.contents))._root());
if (!Objects.equals(((RtcpPayload.PsfbAfbRembPacket) (this.contents))._parent(), this))
throw new ConsistencyError("contents", this, ((RtcpPayload.PsfbAfbRembPacket) (this.contents))._parent());
break;
}
default: {
break;
}
}
_dirty = false;
}
private long uid;
private Object contents;
private RtcpPayload _root;
private RtcpPayload.PsfbPacket _parent;
private byte[] _raw_contents;
public long uid() { return uid; }
public void setUid(long _v) { _dirty = true; uid = _v; }
public Object contents() { return contents; }
public void setContents(Object _v) { _dirty = true; contents = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.PsfbPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.PsfbPacket _v) { _dirty = true; _parent = _v; }
public byte[] _raw_contents() { return _raw_contents; }
public void set_raw_Contents(byte[] _v) { _dirty = true; _raw_contents = _v; }
}
public static class PsfbAfbRembPacket extends KaitaiStruct.ReadWrite {
public static PsfbAfbRembPacket fromFile(String fileName) throws IOException {
return new PsfbAfbRembPacket(new ByteBufferKaitaiStream(fileName));
}
public PsfbAfbRembPacket() {
this(null, null, null);
}
public PsfbAfbRembPacket(KaitaiStream _io) {
this(_io, null, null);
}
public PsfbAfbRembPacket(KaitaiStream _io, RtcpPayload.PsfbAfbPacket _parent) {
this(_io, _parent, null);
}
public PsfbAfbRembPacket(KaitaiStream _io, RtcpPayload.PsfbAfbPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.numSsrc = this._io.readU1();
this.brExp = this._io.readBitsIntBe(6);
this.brMantissa = this._io.readBitsIntBe(18);
this.ssrcList = new ArrayList<Long>();
for (int i = 0; i < numSsrc(); i++) {
this.ssrcList.add(this._io.readU4be());
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.ssrcList.size(); i++) {
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.numSsrc);
this._io.writeBitsIntBe(6, this.brExp);
this._io.writeBitsIntBe(18, this.brMantissa);
for (int i = 0; i < this.ssrcList.size(); i++) {
this._io.writeU4be(this.ssrcList.get(((Number) (i)).intValue()));
}
}
public void _check() {
if (this.ssrcList.size() != numSsrc())
throw new ConsistencyError("ssrc_list", numSsrc(), this.ssrcList.size());
for (int i = 0; i < this.ssrcList.size(); i++) {
}
_dirty = false;
}
private Integer maxTotalBitrate;
public Integer maxTotalBitrate() {
if (this.maxTotalBitrate != null)
return this.maxTotalBitrate;
this.maxTotalBitrate = ((Number) (brMantissa() * (1 << brExp()))).intValue();
return this.maxTotalBitrate;
}
public void _invalidateMaxTotalBitrate() { this.maxTotalBitrate = null; }
private int numSsrc;
private long brExp;
private long brMantissa;
private List<Long> ssrcList;
private RtcpPayload _root;
private RtcpPayload.PsfbAfbPacket _parent;
public int numSsrc() { return numSsrc; }
public void setNumSsrc(int _v) { _dirty = true; numSsrc = _v; }
public long brExp() { return brExp; }
public void setBrExp(long _v) { _dirty = true; brExp = _v; }
public long brMantissa() { return brMantissa; }
public void setBrMantissa(long _v) { _dirty = true; brMantissa = _v; }
public List<Long> ssrcList() { return ssrcList; }
public void setSsrcList(List<Long> _v) { _dirty = true; ssrcList = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.PsfbAfbPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.PsfbAfbPacket _v) { _dirty = true; _parent = _v; }
}
public static class PsfbPacket extends KaitaiStruct.ReadWrite {
public static PsfbPacket fromFile(String fileName) throws IOException {
return new PsfbPacket(new ByteBufferKaitaiStream(fileName));
}
public PsfbPacket() {
this(null, null, null);
}
public PsfbPacket(KaitaiStream _io) {
this(_io, null, null);
}
public PsfbPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent) {
this(_io, _parent, null);
}
public PsfbPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrc = this._io.readU4be();
this.ssrcMediaSource = this._io.readU4be();
{
PsfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case AFB: {
this._raw_fciBlock = this._io.readBytesFull();
KaitaiStream _io__raw_fciBlock = new ByteBufferKaitaiStream(this._raw_fciBlock);
this.fciBlock = new PsfbAfbPacket(_io__raw_fciBlock, this, _root);
((PsfbAfbPacket) (this.fciBlock))._read();
break;
}
default: {
this.fciBlock = this._io.readBytesFull();
break;
}
}
} else {
this.fciBlock = this._io.readBytesFull();
}
}
_dirty = false;
}
public void _fetchInstances() {
{
PsfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case AFB: {
((PsfbAfbPacket) (this.fciBlock))._fetchInstances();
break;
}
default: {
break;
}
}
} else {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrc);
this._io.writeU4be(this.ssrcMediaSource);
{
PsfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case AFB: {
final KaitaiStream _io__raw_fciBlock = new ByteBufferKaitaiStream(this._io.size() - this._io.pos());
this._io.addChildStream(_io__raw_fciBlock);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (this._io.size() - this._io.pos()));
final PsfbPacket _this = this;
_io__raw_fciBlock.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_fciBlock = _io__raw_fciBlock.toByteArray();
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_fciBlock)))));
if (!(parent.isEof()))
throw new ConsistencyError("raw(fci_block)", 0, parent.size() - parent.pos());
}
});
}
((PsfbAfbPacket) (this.fciBlock))._write_Seq(_io__raw_fciBlock);
break;
}
default: {
this._io.writeBytes(((byte[]) (((byte[]) (this.fciBlock)))));
if (!(this._io.isEof()))
throw new ConsistencyError("fci_block", 0, this._io.size() - this._io.pos());
break;
}
}
} else {
this._io.writeBytes(((byte[]) (((byte[]) (this.fciBlock)))));
if (!(this._io.isEof()))
throw new ConsistencyError("fci_block", 0, this._io.size() - this._io.pos());
}
}
}
public void _check() {
{
PsfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case AFB: {
if (!Objects.equals(((RtcpPayload.PsfbAfbPacket) (this.fciBlock))._root(), _root()))
throw new ConsistencyError("fci_block", _root(), ((RtcpPayload.PsfbAfbPacket) (this.fciBlock))._root());
if (!Objects.equals(((RtcpPayload.PsfbAfbPacket) (this.fciBlock))._parent(), this))
throw new ConsistencyError("fci_block", this, ((RtcpPayload.PsfbAfbPacket) (this.fciBlock))._parent());
break;
}
default: {
break;
}
}
} else {
}
}
_dirty = false;
}
private PsfbSubtype fmt;
public PsfbSubtype fmt() {
if (this.fmt != null)
return this.fmt;
this.fmt = RtcpPayload.PsfbSubtype.byId(_parent().subtype());
return this.fmt;
}
public void _invalidateFmt() { this.fmt = null; }
private long ssrc;
private long ssrcMediaSource;
private Object fciBlock;
private RtcpPayload _root;
private RtcpPayload.RtcpPacket _parent;
private byte[] _raw_fciBlock;
public long ssrc() { return ssrc; }
public void setSsrc(long _v) { _dirty = true; ssrc = _v; }
public long ssrcMediaSource() { return ssrcMediaSource; }
public void setSsrcMediaSource(long _v) { _dirty = true; ssrcMediaSource = _v; }
public Object fciBlock() { return fciBlock; }
public void setFciBlock(Object _v) { _dirty = true; fciBlock = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtcpPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtcpPacket _v) { _dirty = true; _parent = _v; }
public byte[] _raw_fciBlock() { return _raw_fciBlock; }
public void set_raw_FciBlock(byte[] _v) { _dirty = true; _raw_fciBlock = _v; }
}
public static class ReportBlock extends KaitaiStruct.ReadWrite {
public static ReportBlock fromFile(String fileName) throws IOException {
return new ReportBlock(new ByteBufferKaitaiStream(fileName));
}
public ReportBlock() {
this(null, null, null);
}
public ReportBlock(KaitaiStream _io) {
this(_io, null, null);
}
public ReportBlock(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public ReportBlock(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrcSource = this._io.readU4be();
this.lostVal = this._io.readU1();
this.highestSeqNumReceived = this._io.readU4be();
this.interarrivalJitter = this._io.readU4be();
this.lsr = this._io.readU4be();
this.dlsr = this._io.readU4be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrcSource);
this._io.writeU1(this.lostVal);
this._io.writeU4be(this.highestSeqNumReceived);
this._io.writeU4be(this.interarrivalJitter);
this._io.writeU4be(this.lsr);
this._io.writeU4be(this.dlsr);
}
public void _check() {
_dirty = false;
}
private Integer cumulativePacketsLost;
public Integer cumulativePacketsLost() {
if (this.cumulativePacketsLost != null)
return this.cumulativePacketsLost;
this.cumulativePacketsLost = ((Number) (lostVal() & 16777215)).intValue();
return this.cumulativePacketsLost;
}
public void _invalidateCumulativePacketsLost() { this.cumulativePacketsLost = null; }
private Integer fractionLost;
public Integer fractionLost() {
if (this.fractionLost != null)
return this.fractionLost;
this.fractionLost = ((Number) (lostVal() >> 24)).intValue();
return this.fractionLost;
}
public void _invalidateFractionLost() { this.fractionLost = null; }
private long ssrcSource;
private int lostVal;
private long highestSeqNumReceived;
private long interarrivalJitter;
private long lsr;
private long dlsr;
private RtcpPayload _root;
private KaitaiStruct.ReadWrite _parent;
public long ssrcSource() { return ssrcSource; }
public void setSsrcSource(long _v) { _dirty = true; ssrcSource = _v; }
public int lostVal() { return lostVal; }
public void setLostVal(int _v) { _dirty = true; lostVal = _v; }
public long highestSeqNumReceived() { return highestSeqNumReceived; }
public void setHighestSeqNumReceived(long _v) { _dirty = true; highestSeqNumReceived = _v; }
public long interarrivalJitter() { return interarrivalJitter; }
public void setInterarrivalJitter(long _v) { _dirty = true; interarrivalJitter = _v; }
public long lsr() { return lsr; }
public void setLsr(long _v) { _dirty = true; lsr = _v; }
public long dlsr() { return dlsr; }
public void setDlsr(long _v) { _dirty = true; dlsr = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class RrPacket extends KaitaiStruct.ReadWrite {
public static RrPacket fromFile(String fileName) throws IOException {
return new RrPacket(new ByteBufferKaitaiStream(fileName));
}
public RrPacket() {
this(null, null, null);
}
public RrPacket(KaitaiStream _io) {
this(_io, null, null);
}
public RrPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent) {
this(_io, _parent, null);
}
public RrPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrc = this._io.readU4be();
this.reportBlock = new ArrayList<ReportBlock>();
for (int i = 0; i < _parent().subtype(); i++) {
ReportBlock _t_reportBlock = new ReportBlock(this._io, this, _root);
try {
_t_reportBlock._read();
} finally {
this.reportBlock.add(_t_reportBlock);
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.reportBlock.size(); i++) {
this.reportBlock.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrc);
for (int i = 0; i < this.reportBlock.size(); i++) {
this.reportBlock.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (this.reportBlock.size() != _parent().subtype())
throw new ConsistencyError("report_block", _parent().subtype(), this.reportBlock.size());
for (int i = 0; i < this.reportBlock.size(); i++) {
if (!Objects.equals(this.reportBlock.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("report_block", _root(), this.reportBlock.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.reportBlock.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("report_block", this, this.reportBlock.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private long ssrc;
private List<ReportBlock> reportBlock;
private RtcpPayload _root;
private RtcpPayload.RtcpPacket _parent;
public long ssrc() { return ssrc; }
public void setSsrc(long _v) { _dirty = true; ssrc = _v; }
public List<ReportBlock> reportBlock() { return reportBlock; }
public void setReportBlock(List<ReportBlock> _v) { _dirty = true; reportBlock = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtcpPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtcpPacket _v) { _dirty = true; _parent = _v; }
}
public static class RtcpPacket extends KaitaiStruct.ReadWrite {
public static RtcpPacket fromFile(String fileName) throws IOException {
return new RtcpPacket(new ByteBufferKaitaiStream(fileName));
}
public RtcpPacket() {
this(null, null, null);
}
public RtcpPacket(KaitaiStream _io) {
this(_io, null, null);
}
public RtcpPacket(KaitaiStream _io, RtcpPayload _parent) {
this(_io, _parent, null);
}
public RtcpPacket(KaitaiStream _io, RtcpPayload _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.version = this._io.readBitsIntBe(2);
this.padding = this._io.readBitsIntBe(1) != 0;
this.subtype = this._io.readBitsIntBe(5);
this.payloadType = RtcpPayload.PayloadType.byId(this._io.readU1());
this.length = this._io.readU2be();
{
PayloadType on = payloadType();
if (on != null) {
switch (payloadType()) {
case PSFB: {
this._raw_body = this._io.readBytes(4 * length());
KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(this._raw_body);
this.body = new PsfbPacket(_io__raw_body, this, _root);
((PsfbPacket) (this.body))._read();
break;
}
case RR: {
this._raw_body = this._io.readBytes(4 * length());
KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(this._raw_body);
this.body = new RrPacket(_io__raw_body, this, _root);
((RrPacket) (this.body))._read();
break;
}
case RTPFB: {
this._raw_body = this._io.readBytes(4 * length());
KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(this._raw_body);
this.body = new RtpfbPacket(_io__raw_body, this, _root);
((RtpfbPacket) (this.body))._read();
break;
}
case SDES: {
this._raw_body = this._io.readBytes(4 * length());
KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(this._raw_body);
this.body = new SdesPacket(_io__raw_body, this, _root);
((SdesPacket) (this.body))._read();
break;
}
case SR: {
this._raw_body = this._io.readBytes(4 * length());
KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(this._raw_body);
this.body = new SrPacket(_io__raw_body, this, _root);
((SrPacket) (this.body))._read();
break;
}
default: {
this.body = this._io.readBytes(4 * length());
break;
}
}
} else {
this.body = this._io.readBytes(4 * length());
}
}
_dirty = false;
}
public void _fetchInstances() {
{
PayloadType on = payloadType();
if (on != null) {
switch (payloadType()) {
case PSFB: {
((PsfbPacket) (this.body))._fetchInstances();
break;
}
case RR: {
((RrPacket) (this.body))._fetchInstances();
break;
}
case RTPFB: {
((RtpfbPacket) (this.body))._fetchInstances();
break;
}
case SDES: {
((SdesPacket) (this.body))._fetchInstances();
break;
}
case SR: {
((SrPacket) (this.body))._fetchInstances();
break;
}
default: {
break;
}
}
} else {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBitsIntBe(2, this.version);
this._io.writeBitsIntBe(1, (this.padding ? 1 : 0));
this._io.writeBitsIntBe(5, this.subtype);
this._io.writeU1(((Number) (this.payloadType.id())).intValue());
this._io.writeU2be(this.length);
{
PayloadType on = payloadType();
if (on != null) {
switch (payloadType()) {
case PSFB: {
final KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(4 * length());
this._io.addChildStream(_io__raw_body);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (4 * length()));
final RtcpPacket _this = this;
_io__raw_body.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_body = _io__raw_body.toByteArray();
if (((byte[]) (_this._raw_body)).length != 4 * length())
throw new ConsistencyError("raw(body)", 4 * length(), ((byte[]) (_this._raw_body)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_body)))));
}
});
}
((PsfbPacket) (this.body))._write_Seq(_io__raw_body);
break;
}
case RR: {
final KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(4 * length());
this._io.addChildStream(_io__raw_body);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (4 * length()));
final RtcpPacket _this = this;
_io__raw_body.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_body = _io__raw_body.toByteArray();
if (((byte[]) (_this._raw_body)).length != 4 * length())
throw new ConsistencyError("raw(body)", 4 * length(), ((byte[]) (_this._raw_body)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_body)))));
}
});
}
((RrPacket) (this.body))._write_Seq(_io__raw_body);
break;
}
case RTPFB: {
final KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(4 * length());
this._io.addChildStream(_io__raw_body);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (4 * length()));
final RtcpPacket _this = this;
_io__raw_body.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_body = _io__raw_body.toByteArray();
if (((byte[]) (_this._raw_body)).length != 4 * length())
throw new ConsistencyError("raw(body)", 4 * length(), ((byte[]) (_this._raw_body)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_body)))));
}
});
}
((RtpfbPacket) (this.body))._write_Seq(_io__raw_body);
break;
}
case SDES: {
final KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(4 * length());
this._io.addChildStream(_io__raw_body);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (4 * length()));
final RtcpPacket _this = this;
_io__raw_body.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_body = _io__raw_body.toByteArray();
if (((byte[]) (_this._raw_body)).length != 4 * length())
throw new ConsistencyError("raw(body)", 4 * length(), ((byte[]) (_this._raw_body)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_body)))));
}
});
}
((SdesPacket) (this.body))._write_Seq(_io__raw_body);
break;
}
case SR: {
final KaitaiStream _io__raw_body = new ByteBufferKaitaiStream(4 * length());
this._io.addChildStream(_io__raw_body);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (4 * length()));
final RtcpPacket _this = this;
_io__raw_body.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_body = _io__raw_body.toByteArray();
if (((byte[]) (_this._raw_body)).length != 4 * length())
throw new ConsistencyError("raw(body)", 4 * length(), ((byte[]) (_this._raw_body)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_body)))));
}
});
}
((SrPacket) (this.body))._write_Seq(_io__raw_body);
break;
}
default: {
this._io.writeBytes(((byte[]) (((byte[]) (this.body)))));
break;
}
}
} else {
this._io.writeBytes(((byte[]) (((byte[]) (this.body)))));
}
}
}
public void _check() {
{
PayloadType on = payloadType();
if (on != null) {
switch (payloadType()) {
case PSFB: {
if (!Objects.equals(((RtcpPayload.PsfbPacket) (this.body))._root(), _root()))
throw new ConsistencyError("body", _root(), ((RtcpPayload.PsfbPacket) (this.body))._root());
if (!Objects.equals(((RtcpPayload.PsfbPacket) (this.body))._parent(), this))
throw new ConsistencyError("body", this, ((RtcpPayload.PsfbPacket) (this.body))._parent());
break;
}
case RR: {
if (!Objects.equals(((RtcpPayload.RrPacket) (this.body))._root(), _root()))
throw new ConsistencyError("body", _root(), ((RtcpPayload.RrPacket) (this.body))._root());
if (!Objects.equals(((RtcpPayload.RrPacket) (this.body))._parent(), this))
throw new ConsistencyError("body", this, ((RtcpPayload.RrPacket) (this.body))._parent());
break;
}
case RTPFB: {
if (!Objects.equals(((RtcpPayload.RtpfbPacket) (this.body))._root(), _root()))
throw new ConsistencyError("body", _root(), ((RtcpPayload.RtpfbPacket) (this.body))._root());
if (!Objects.equals(((RtcpPayload.RtpfbPacket) (this.body))._parent(), this))
throw new ConsistencyError("body", this, ((RtcpPayload.RtpfbPacket) (this.body))._parent());
break;
}
case SDES: {
if (!Objects.equals(((RtcpPayload.SdesPacket) (this.body))._root(), _root()))
throw new ConsistencyError("body", _root(), ((RtcpPayload.SdesPacket) (this.body))._root());
if (!Objects.equals(((RtcpPayload.SdesPacket) (this.body))._parent(), this))
throw new ConsistencyError("body", this, ((RtcpPayload.SdesPacket) (this.body))._parent());
break;
}
case SR: {
if (!Objects.equals(((RtcpPayload.SrPacket) (this.body))._root(), _root()))
throw new ConsistencyError("body", _root(), ((RtcpPayload.SrPacket) (this.body))._root());
if (!Objects.equals(((RtcpPayload.SrPacket) (this.body))._parent(), this))
throw new ConsistencyError("body", this, ((RtcpPayload.SrPacket) (this.body))._parent());
break;
}
default: {
if (((byte[]) (this.body)).length != 4 * length())
throw new ConsistencyError("body", 4 * length(), ((byte[]) (this.body)).length);
break;
}
}
} else {
if (((byte[]) (this.body)).length != 4 * length())
throw new ConsistencyError("body", 4 * length(), ((byte[]) (this.body)).length);
}
}
_dirty = false;
}
private long version;
private boolean padding;
private long subtype;
private PayloadType payloadType;
private int length;
private Object body;
private RtcpPayload _root;
private RtcpPayload _parent;
private byte[] _raw_body;
public long version() { return version; }
public void setVersion(long _v) { _dirty = true; version = _v; }
public boolean padding() { return padding; }
public void setPadding(boolean _v) { _dirty = true; padding = _v; }
public long subtype() { return subtype; }
public void setSubtype(long _v) { _dirty = true; subtype = _v; }
public PayloadType payloadType() { return payloadType; }
public void setPayloadType(PayloadType _v) { _dirty = true; payloadType = _v; }
public int length() { return length; }
public void setLength(int _v) { _dirty = true; length = _v; }
public Object body() { return body; }
public void setBody(Object _v) { _dirty = true; body = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload _parent() { return _parent; }
public void set_parent(RtcpPayload _v) { _dirty = true; _parent = _v; }
public byte[] _raw_body() { return _raw_body; }
public void set_raw_Body(byte[] _v) { _dirty = true; _raw_body = _v; }
}
public static class RtpfbPacket extends KaitaiStruct.ReadWrite {
public static RtpfbPacket fromFile(String fileName) throws IOException {
return new RtpfbPacket(new ByteBufferKaitaiStream(fileName));
}
public RtpfbPacket() {
this(null, null, null);
}
public RtpfbPacket(KaitaiStream _io) {
this(_io, null, null);
}
public RtpfbPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent) {
this(_io, _parent, null);
}
public RtpfbPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrc = this._io.readU4be();
this.ssrcMediaSource = this._io.readU4be();
{
RtpfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case TRANSPORT_FEEDBACK: {
this._raw_fciBlock = this._io.readBytesFull();
KaitaiStream _io__raw_fciBlock = new ByteBufferKaitaiStream(this._raw_fciBlock);
this.fciBlock = new RtpfbTransportFeedbackPacket(_io__raw_fciBlock, this, _root);
((RtpfbTransportFeedbackPacket) (this.fciBlock))._read();
break;
}
default: {
this.fciBlock = this._io.readBytesFull();
break;
}
}
} else {
this.fciBlock = this._io.readBytesFull();
}
}
_dirty = false;
}
public void _fetchInstances() {
{
RtpfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case TRANSPORT_FEEDBACK: {
((RtpfbTransportFeedbackPacket) (this.fciBlock))._fetchInstances();
break;
}
default: {
break;
}
}
} else {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrc);
this._io.writeU4be(this.ssrcMediaSource);
{
RtpfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case TRANSPORT_FEEDBACK: {
final KaitaiStream _io__raw_fciBlock = new ByteBufferKaitaiStream(this._io.size() - this._io.pos());
this._io.addChildStream(_io__raw_fciBlock);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (this._io.size() - this._io.pos()));
final RtpfbPacket _this = this;
_io__raw_fciBlock.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_fciBlock = _io__raw_fciBlock.toByteArray();
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_fciBlock)))));
if (!(parent.isEof()))
throw new ConsistencyError("raw(fci_block)", 0, parent.size() - parent.pos());
}
});
}
((RtpfbTransportFeedbackPacket) (this.fciBlock))._write_Seq(_io__raw_fciBlock);
break;
}
default: {
this._io.writeBytes(((byte[]) (((byte[]) (this.fciBlock)))));
if (!(this._io.isEof()))
throw new ConsistencyError("fci_block", 0, this._io.size() - this._io.pos());
break;
}
}
} else {
this._io.writeBytes(((byte[]) (((byte[]) (this.fciBlock)))));
if (!(this._io.isEof()))
throw new ConsistencyError("fci_block", 0, this._io.size() - this._io.pos());
}
}
}
public void _check() {
{
RtpfbSubtype on = fmt();
if (on != null) {
switch (fmt()) {
case TRANSPORT_FEEDBACK: {
if (!Objects.equals(((RtcpPayload.RtpfbTransportFeedbackPacket) (this.fciBlock))._root(), _root()))
throw new ConsistencyError("fci_block", _root(), ((RtcpPayload.RtpfbTransportFeedbackPacket) (this.fciBlock))._root());
if (!Objects.equals(((RtcpPayload.RtpfbTransportFeedbackPacket) (this.fciBlock))._parent(), this))
throw new ConsistencyError("fci_block", this, ((RtcpPayload.RtpfbTransportFeedbackPacket) (this.fciBlock))._parent());
break;
}
default: {
break;
}
}
} else {
}
}
_dirty = false;
}
private RtpfbSubtype fmt;
public RtpfbSubtype fmt() {
if (this.fmt != null)
return this.fmt;
this.fmt = RtcpPayload.RtpfbSubtype.byId(_parent().subtype());
return this.fmt;
}
public void _invalidateFmt() { this.fmt = null; }
private long ssrc;
private long ssrcMediaSource;
private Object fciBlock;
private RtcpPayload _root;
private RtcpPayload.RtcpPacket _parent;
private byte[] _raw_fciBlock;
public long ssrc() { return ssrc; }
public void setSsrc(long _v) { _dirty = true; ssrc = _v; }
public long ssrcMediaSource() { return ssrcMediaSource; }
public void setSsrcMediaSource(long _v) { _dirty = true; ssrcMediaSource = _v; }
public Object fciBlock() { return fciBlock; }
public void setFciBlock(Object _v) { _dirty = true; fciBlock = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtcpPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtcpPacket _v) { _dirty = true; _parent = _v; }
public byte[] _raw_fciBlock() { return _raw_fciBlock; }
public void set_raw_FciBlock(byte[] _v) { _dirty = true; _raw_fciBlock = _v; }
}
public static class RtpfbTransportFeedbackPacket extends KaitaiStruct.ReadWrite {
public static RtpfbTransportFeedbackPacket fromFile(String fileName) throws IOException {
return new RtpfbTransportFeedbackPacket(new ByteBufferKaitaiStream(fileName));
}
public RtpfbTransportFeedbackPacket() {
this(null, null, null);
}
public RtpfbTransportFeedbackPacket(KaitaiStream _io) {
this(_io, null, null);
}
public RtpfbTransportFeedbackPacket(KaitaiStream _io, RtcpPayload.RtpfbPacket _parent) {
this(_io, _parent, null);
}
public RtpfbTransportFeedbackPacket(KaitaiStream _io, RtcpPayload.RtpfbPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.baseSequenceNumber = this._io.readU2be();
this.packetStatusCount = this._io.readU2be();
this.b4 = this._io.readU4be();
this.remaining = this._io.readBytesFull();
_dirty = false;
}
public void _fetchInstances() {
packetStatus();
if (this.packetStatus != null) {
}
recvDelta();
if (this.recvDelta != null) {
}
}
public void _write_Seq() {
_assertNotDirty();
_shouldWritePacketStatus = _enabledPacketStatus;
_shouldWriteRecvDelta = _enabledRecvDelta;
this._io.writeU2be(this.baseSequenceNumber);
this._io.writeU2be(this.packetStatusCount);
this._io.writeU4be(this.b4);
this._io.writeBytes(this.remaining);
if (!(this._io.isEof()))
throw new ConsistencyError("remaining", 0, this._io.size() - this._io.pos());
}
public void _check() {
if (_enabledPacketStatus) {
if (this.packetStatus.length != 0)
throw new ConsistencyError("packet_status", 0, this.packetStatus.length);
}
if (_enabledRecvDelta) {
if (this.recvDelta.length != 0)
throw new ConsistencyError("recv_delta", 0, this.recvDelta.length);
}
_dirty = false;
}
private Integer fbPktCount;
public Integer fbPktCount() {
if (this.fbPktCount != null)
return this.fbPktCount;
this.fbPktCount = ((Number) (b4() & 255)).intValue();
return this.fbPktCount;
}
public void _invalidateFbPktCount() { this.fbPktCount = null; }
private byte[] packetStatus;
private boolean _shouldWritePacketStatus = false;
private boolean _enabledPacketStatus = true;
public byte[] packetStatus() {
if (_shouldWritePacketStatus)
_writePacketStatus();
if (this.packetStatus != null)
return this.packetStatus;
if (!_enabledPacketStatus)
return null;
this.packetStatus = this._io.readBytes(0);
return this.packetStatus;
}
public void setPacketStatus(byte[] _v) { _dirty = true; packetStatus = _v; }
public void setPacketStatus_Enabled(boolean _v) { _dirty = true; _enabledPacketStatus = _v; }
private void _writePacketStatus() {
_shouldWritePacketStatus = false;
this._io.writeBytes(this.packetStatus);
}
private byte[] recvDelta;
private boolean _shouldWriteRecvDelta = false;
private boolean _enabledRecvDelta = true;
public byte[] recvDelta() {
if (_shouldWriteRecvDelta)
_writeRecvDelta();
if (this.recvDelta != null)
return this.recvDelta;
if (!_enabledRecvDelta)
return null;
this.recvDelta = this._io.readBytes(0);
return this.recvDelta;
}
public void setRecvDelta(byte[] _v) { _dirty = true; recvDelta = _v; }
public void setRecvDelta_Enabled(boolean _v) { _dirty = true; _enabledRecvDelta = _v; }
private void _writeRecvDelta() {
_shouldWriteRecvDelta = false;
this._io.writeBytes(this.recvDelta);
}
private Integer referenceTime;
public Integer referenceTime() {
if (this.referenceTime != null)
return this.referenceTime;
this.referenceTime = ((Number) (b4() >> 8)).intValue();
return this.referenceTime;
}
public void _invalidateReferenceTime() { this.referenceTime = null; }
private int baseSequenceNumber;
private int packetStatusCount;
private long b4;
private byte[] remaining;
private RtcpPayload _root;
private RtcpPayload.RtpfbPacket _parent;
public int baseSequenceNumber() { return baseSequenceNumber; }
public void setBaseSequenceNumber(int _v) { _dirty = true; baseSequenceNumber = _v; }
public int packetStatusCount() { return packetStatusCount; }
public void setPacketStatusCount(int _v) { _dirty = true; packetStatusCount = _v; }
public long b4() { return b4; }
public void setB4(long _v) { _dirty = true; b4 = _v; }
public byte[] remaining() { return remaining; }
public void setRemaining(byte[] _v) { _dirty = true; remaining = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtpfbPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtpfbPacket _v) { _dirty = true; _parent = _v; }
}
public static class SdesPacket extends KaitaiStruct.ReadWrite {
public static SdesPacket fromFile(String fileName) throws IOException {
return new SdesPacket(new ByteBufferKaitaiStream(fileName));
}
public SdesPacket() {
this(null, null, null);
}
public SdesPacket(KaitaiStream _io) {
this(_io, null, null);
}
public SdesPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent) {
this(_io, _parent, null);
}
public SdesPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.sourceChunk = new ArrayList<SourceChunk>();
for (int i = 0; i < sourceCount(); i++) {
SourceChunk _t_sourceChunk = new SourceChunk(this._io, this, _root);
try {
_t_sourceChunk._read();
} finally {
this.sourceChunk.add(_t_sourceChunk);
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.sourceChunk.size(); i++) {
this.sourceChunk.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
for (int i = 0; i < this.sourceChunk.size(); i++) {
this.sourceChunk.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (this.sourceChunk.size() != sourceCount())
throw new ConsistencyError("source_chunk", sourceCount(), this.sourceChunk.size());
for (int i = 0; i < this.sourceChunk.size(); i++) {
if (!Objects.equals(this.sourceChunk.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("source_chunk", _root(), this.sourceChunk.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.sourceChunk.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("source_chunk", this, this.sourceChunk.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private Long sourceCount;
public Long sourceCount() {
if (this.sourceCount != null)
return this.sourceCount;
this.sourceCount = ((Number) (_parent().subtype())).longValue();
return this.sourceCount;
}
public void _invalidateSourceCount() { this.sourceCount = null; }
private List<SourceChunk> sourceChunk;
private RtcpPayload _root;
private RtcpPayload.RtcpPacket _parent;
public List<SourceChunk> sourceChunk() { return sourceChunk; }
public void setSourceChunk(List<SourceChunk> _v) { _dirty = true; sourceChunk = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtcpPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtcpPacket _v) { _dirty = true; _parent = _v; }
}
public static class SdesTlv extends KaitaiStruct.ReadWrite {
public static SdesTlv fromFile(String fileName) throws IOException {
return new SdesTlv(new ByteBufferKaitaiStream(fileName));
}
public SdesTlv() {
this(null, null, null);
}
public SdesTlv(KaitaiStream _io) {
this(_io, null, null);
}
public SdesTlv(KaitaiStream _io, RtcpPayload.SourceChunk _parent) {
this(_io, _parent, null);
}
public SdesTlv(KaitaiStream _io, RtcpPayload.SourceChunk _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.type = RtcpPayload.SdesSubtype.byId(this._io.readU1());
if (type() != RtcpPayload.SdesSubtype.PAD) {
this.length = this._io.readU1();
}
if (type() != RtcpPayload.SdesSubtype.PAD) {
this.value = this._io.readBytes(length());
}
_dirty = false;
}
public void _fetchInstances() {
if (type() != RtcpPayload.SdesSubtype.PAD) {
}
if (type() != RtcpPayload.SdesSubtype.PAD) {
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(((Number) (this.type.id())).intValue());
if (type() != RtcpPayload.SdesSubtype.PAD) {
this._io.writeU1(this.length);
}
if (type() != RtcpPayload.SdesSubtype.PAD) {
this._io.writeBytes(this.value);
}
}
public void _check() {
if (type() != RtcpPayload.SdesSubtype.PAD) {
}
if (type() != RtcpPayload.SdesSubtype.PAD) {
if (this.value.length != length())
throw new ConsistencyError("value", length(), this.value.length);
}
_dirty = false;
}
private SdesSubtype type;
private Integer length;
private byte[] value;
private RtcpPayload _root;
private RtcpPayload.SourceChunk _parent;
public SdesSubtype type() { return type; }
public void setType(SdesSubtype _v) { _dirty = true; type = _v; }
public Integer length() { return length; }
public void setLength(Integer _v) { _dirty = true; length = _v; }
public byte[] value() { return value; }
public void setValue(byte[] _v) { _dirty = true; value = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.SourceChunk _parent() { return _parent; }
public void set_parent(RtcpPayload.SourceChunk _v) { _dirty = true; _parent = _v; }
}
public static class SourceChunk extends KaitaiStruct.ReadWrite {
public static SourceChunk fromFile(String fileName) throws IOException {
return new SourceChunk(new ByteBufferKaitaiStream(fileName));
}
public SourceChunk() {
this(null, null, null);
}
public SourceChunk(KaitaiStream _io) {
this(_io, null, null);
}
public SourceChunk(KaitaiStream _io, RtcpPayload.SdesPacket _parent) {
this(_io, _parent, null);
}
public SourceChunk(KaitaiStream _io, RtcpPayload.SdesPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrc = this._io.readU4be();
this.sdesTlv = new ArrayList<SdesTlv>();
{
int i = 0;
while (!this._io.isEof()) {
SdesTlv _t_sdesTlv = new SdesTlv(this._io, this, _root);
try {
_t_sdesTlv._read();
} finally {
this.sdesTlv.add(_t_sdesTlv);
}
i++;
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.sdesTlv.size(); i++) {
this.sdesTlv.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrc);
for (int i = 0; i < this.sdesTlv.size(); i++) {
if (this._io.isEof())
throw new ConsistencyError("sdes_tlv", 0, this._io.size() - this._io.pos());
this.sdesTlv.get(((Number) (i)).intValue())._write_Seq(this._io);
}
if (!(this._io.isEof()))
throw new ConsistencyError("sdes_tlv", 0, this._io.size() - this._io.pos());
}
public void _check() {
for (int i = 0; i < this.sdesTlv.size(); i++) {
if (!Objects.equals(this.sdesTlv.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("sdes_tlv", _root(), this.sdesTlv.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.sdesTlv.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("sdes_tlv", this, this.sdesTlv.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private long ssrc;
private List<SdesTlv> sdesTlv;
private RtcpPayload _root;
private RtcpPayload.SdesPacket _parent;
public long ssrc() { return ssrc; }
public void setSsrc(long _v) { _dirty = true; ssrc = _v; }
public List<SdesTlv> sdesTlv() { return sdesTlv; }
public void setSdesTlv(List<SdesTlv> _v) { _dirty = true; sdesTlv = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.SdesPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.SdesPacket _v) { _dirty = true; _parent = _v; }
}
public static class SrPacket extends KaitaiStruct.ReadWrite {
public static SrPacket fromFile(String fileName) throws IOException {
return new SrPacket(new ByteBufferKaitaiStream(fileName));
}
public SrPacket() {
this(null, null, null);
}
public SrPacket(KaitaiStream _io) {
this(_io, null, null);
}
public SrPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent) {
this(_io, _parent, null);
}
public SrPacket(KaitaiStream _io, RtcpPayload.RtcpPacket _parent, RtcpPayload _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.ssrc = this._io.readU4be();
this.ntpMsw = this._io.readU4be();
this.ntpLsw = this._io.readU4be();
this.rtpTimestamp = this._io.readU4be();
this.senderPacketCount = this._io.readU4be();
this.senderOctetCount = this._io.readU4be();
this.reportBlock = new ArrayList<ReportBlock>();
for (int i = 0; i < _parent().subtype(); i++) {
ReportBlock _t_reportBlock = new ReportBlock(this._io, this, _root);
try {
_t_reportBlock._read();
} finally {
this.reportBlock.add(_t_reportBlock);
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.reportBlock.size(); i++) {
this.reportBlock.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.ssrc);
this._io.writeU4be(this.ntpMsw);
this._io.writeU4be(this.ntpLsw);
this._io.writeU4be(this.rtpTimestamp);
this._io.writeU4be(this.senderPacketCount);
this._io.writeU4be(this.senderOctetCount);
for (int i = 0; i < this.reportBlock.size(); i++) {
this.reportBlock.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (this.reportBlock.size() != _parent().subtype())
throw new ConsistencyError("report_block", _parent().subtype(), this.reportBlock.size());
for (int i = 0; i < this.reportBlock.size(); i++) {
if (!Objects.equals(this.reportBlock.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("report_block", _root(), this.reportBlock.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.reportBlock.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("report_block", this, this.reportBlock.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private Integer ntp;
public Integer ntp() {
if (this.ntp != null)
return this.ntp;
this.ntp = ((Number) (ntpMsw() << 32 & ntpLsw())).intValue();
return this.ntp;
}
public void _invalidateNtp() { this.ntp = null; }
private long ssrc;
private long ntpMsw;
private long ntpLsw;
private long rtpTimestamp;
private long senderPacketCount;
private long senderOctetCount;
private List<ReportBlock> reportBlock;
private RtcpPayload _root;
private RtcpPayload.RtcpPacket _parent;
public long ssrc() { return ssrc; }
public void setSsrc(long _v) { _dirty = true; ssrc = _v; }
public long ntpMsw() { return ntpMsw; }
public void setNtpMsw(long _v) { _dirty = true; ntpMsw = _v; }
public long ntpLsw() { return ntpLsw; }
public void setNtpLsw(long _v) { _dirty = true; ntpLsw = _v; }
public long rtpTimestamp() { return rtpTimestamp; }
public void setRtpTimestamp(long _v) { _dirty = true; rtpTimestamp = _v; }
public long senderPacketCount() { return senderPacketCount; }
public void setSenderPacketCount(long _v) { _dirty = true; senderPacketCount = _v; }
public long senderOctetCount() { return senderOctetCount; }
public void setSenderOctetCount(long _v) { _dirty = true; senderOctetCount = _v; }
public List<ReportBlock> reportBlock() { return reportBlock; }
public void setReportBlock(List<ReportBlock> _v) { _dirty = true; reportBlock = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public RtcpPayload.RtcpPacket _parent() { return _parent; }
public void set_parent(RtcpPayload.RtcpPacket _v) { _dirty = true; _parent = _v; }
}
private List<RtcpPacket> rtcpPackets;
private RtcpPayload _root;
private KaitaiStruct.ReadWrite _parent;
public List<RtcpPacket> rtcpPackets() { return rtcpPackets; }
public void setRtcpPackets(List<RtcpPacket> _v) { _dirty = true; rtcpPackets = _v; }
public RtcpPayload _root() { return _root; }
public void set_root(RtcpPayload _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}