示例#1
0
        public byte[] doPackaging(byte[] nalu)
        {
            if (IsAVC)
            {
                var naluLength = new byte[4];

                var buf = BitConverter.GetBytes(nalu.Length).Take(4).Reverse().ToArray();

                Array.Copy(buf, 0, naluLength, 0, buf.Length);

                var naluLengthList = naluLength.ToList();
                naluLengthList.AddRange(nalu);
                naluLength = naluLengthList.ToArray();
            }

            var tmp     = H264PacketExtended.annexbNALUStartCode();
            var tmpList = tmp.ToList();

            tmpList.AddRange(nalu);

            tmp = tmpList.ToArray();
            return(tmp);
        }
示例#2
0
        //ペイロードは、1つ以上のバイト配列にわたってH264パケットをフラグメント化します
        public byte[][] Payload(int mtu, byte[] payload)
        {
            var payloads = new byte[][] { };

            if (payload.Length == 0)
            {
                return(payloads);
            }

            Action <byte[]> func = delegate(byte[] nalu)
            {
                if (nalu.Length == 0)
                {
                    return;
                }

                var naluType = nalu[0] & H264PacketExtended.naluTypeBitmask;

                var naluRefIdc = nalu[0] & H264PacketExtended.naluRefIdcBitmask;

                if (naluType == 9 || naluType == 12)
                {
                    return;
                }

                // Single NALU
                if (nalu.Length <= mtu)
                {
                    var output = new byte[nalu.Length];

                    output = nalu;

                    var payloadsList = payloads.ToList();
                    payloadsList.Add(output);
                    payloads = payloadsList.ToArray();

                    return;
                }

                // FU-A
                var maxFragmentSize = mtu - H264PacketExtended.fuaHeaderSize;

                var naluData = nalu;

                var naluDataIndex = 1;

                var naluDataLength = nalu.Length - naluDataIndex;

                var naluDataRemaining = naluDataLength;

                if (common.min(maxFragmentSize, naluDataRemaining) <= 0)
                {
                    return;
                }

                for (; naluDataRemaining > 0;)
                {
                    var currentFragmentSize = common.min(maxFragmentSize, naluDataRemaining);

                    var output = new byte[H264PacketExtended.fuaHeaderSize + currentFragmentSize];

                    output[0] = H264PacketExtended.fuaNALUType;

                    output[0] |= Convert.ToByte(naluRefIdc);

                    output[1] = Convert.ToByte(naluType);

                    if (naluDataRemaining == naluDataLength)
                    {
                        // Set start bit
                        output[1] |= 1 << 7;
                    }
                    else if ((naluDataRemaining - currentFragmentSize) == 0)
                    {
                        // Send end bit
                        output[1] |= 1 << 6;
                    }

                    Array.Copy(naluData, naluDataIndex, output, H264PacketExtended.fuaHeaderSize, currentFragmentSize);

                    var payloadsList = payloads.ToList();
                    payloadsList.Add(output);
                    payloads = payloadsList.ToArray();

                    naluDataRemaining -= currentFragmentSize;

                    naluDataIndex += currentFragmentSize;
                }
            };

            H264PacketExtended.emitNalus(payload, func);

            return(payloads);
        }