public void ReadBits_ReadSeveralBits_ValidResult()
        {
            var bytes  = new byte[] { 0x31 };
            var reader = new BitStreamReader();

            reader.ReInitialize(new ArraySegment <byte>(bytes));

            int bits = reader.ReadBits(5);

            Assert.AreEqual(6, bits);
        }
        public void ReadUe_TestCode_ValidResult()
        {
            const int testCode = 4;
            var       bytes    = new byte[] { (testCode + 1) << 3 };
            var       reader   = new BitStreamReader();

            reader.ReInitialize(new ArraySegment <byte>(bytes));

            int code = reader.ReadUe();

            Assert.AreEqual(testCode, code);
        }
        public override void Parse(TimeSpan timeOffset, ArraySegment <byte> byteSegment, bool markerBit)
        {
            int auHeadersBitLength   = BigEndianConverter.ReadUInt16(byteSegment.Array, byteSegment.Offset);
            int auHeadersLengthBytes = (auHeadersBitLength + 7) / 8;

            int headerBitSize  = _codecInfo.SizeLength + _codecInfo.IndexLength;
            int audioBitsAvail = auHeadersBitLength - headerBitSize;

            if (audioBitsAvail < 0 || headerBitSize <= 0)
            {
                return;
            }

            int framesCount = 1 + audioBitsAvail / (_codecInfo.SizeLength + _codecInfo.IndexDeltaLength);

            _bitStreamReader.ReInitialize(byteSegment.SubSegment(2));

            int offset = byteSegment.Offset + auHeadersLengthBytes;

            for (int i = 0; i < framesCount; ++i)
            {
                int frameSize = _bitStreamReader.ReadBits(_codecInfo.SizeLength);

                if (i == 0)
                {
                    _bitStreamReader.ReadBits(_codecInfo.IndexLength);
                }
                else if (_codecInfo.IndexDeltaLength != 0)
                {
                    _bitStreamReader.ReadBits(_codecInfo.IndexDeltaLength);
                }

                Debug.Assert(byteSegment.Array != null, "byteSegment.Array != null");
                var frameBytes = new ArraySegment <byte>(byteSegment.Array, offset, frameSize);

                DateTime timestamp = GetFrameTimestamp(timeOffset);

                var aacFrame = new RawAACFrame(timestamp, frameBytes,
                                               new ArraySegment <byte>(_codecInfo.ConfigBytes));

                OnFrameGenerated(aacFrame);
                offset += frameSize;
            }
        }
        public void ReadBit_ReadSeveralBits_ValidResult()
        {
            var bytes  = new byte[] { 0x31 };
            var reader = new BitStreamReader();

            reader.ReInitialize(new ArraySegment <byte>(bytes));

            int bit1 = reader.ReadBit();
            int bit2 = reader.ReadBit();
            int bit3 = reader.ReadBit();
            int bit4 = reader.ReadBit();
            int bit5 = reader.ReadBit();

            Assert.AreEqual(0, bit1);
            Assert.AreEqual(0, bit2);
            Assert.AreEqual(1, bit3);
            Assert.AreEqual(1, bit4);
            Assert.AreEqual(0, bit5);
        }
Example #5
0
        private void ProcessSpsOrPps(ArraySegment <byte> byteSegment, bool hasStartMarker, int offset,
                                     Dictionary <int, byte[]> idToBytesMap)
        {
            _bitStreamReader.ReInitialize(hasStartMarker
                ? byteSegment.SubSegment(RawH264Frame.StartMarker.Length + offset)
                : byteSegment.SubSegment(offset));

            int id = _bitStreamReader.ReadUe();

            if (id == -1)
            {
                return;
            }

            if (hasStartMarker)
            {
                byteSegment = byteSegment.SubSegment(RawH264Frame.StartMarker.Length);
            }

            if (TryUpdateSpsOrPps(byteSegment, id, idToBytesMap))
            {
                _updateSpsPpsBytes = true;
            }
        }