av/packets/packets_test.go

/*
NAME
  MpegTs.go - provides a data structure intended to encapsulate the properties
  of an MpegTs packet.

DESCRIPTION
  See Readme.md

AUTHOR
  Saxon Nelson-Milton <saxon.milton@gmail.com>

LICENSE
  MpegTs.go is Copyright (C) 2017 the Australian Ocean Lab (AusOcean)

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It 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 General Public License
 for more details.

  You should have received a copy of the GNU General Public License
  along with revid in gpl.txt.  If not, see [GNU licenses](http://www.gnu.org/licenses).
*/

package packets

import (
	//"bytes"
	"fmt"
	"io"
	"log"
	"net"
	"reflect"
	"testing"
	"time"

	"github.com/beatgammit/rtsp"
)

/*******************************************************
Testing stuff related to connection i.e. rtsp, rtp, rtcp
********************************************************/
const (
	rtpPort  = 17300
	rtcpPort = 17319
	rtspUrl  = "rtsp://192.168.0.50:8554/CH002.sdp"
	rtpUrl   = "rtsp://192.168.0.50:8554/CH002.sdp/track1"
)

/* Let's see if we can connect to an rtsp device then read an rtp stream,
and then convert the rtp packets to mpegts packets and output. */
func TestRTSP(t *testing.T) {
	sess := rtsp.NewSession()
	res, err := sess.Options(rtspUrl)
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	res, err = sess.Describe(rtspUrl)
	if err != nil {
		log.Fatalln(err)
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	p, err := rtsp.ParseSdp(&io.LimitedReader{R: res.Body, N: res.ContentLength})
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Printf("%+v", p)
	res, err = sess.Setup(rtpUrl, fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", rtpPort, rtcpPort))
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Println(res)
	res, err = sess.Play(rtspUrl, res.Header.Get("Session"))
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Println(res)
}

func TestRTP(t *testing.T) {
	sess := rtsp.NewSession()
	res, err := sess.Options(rtspUrl)
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	res, err = sess.Describe(rtspUrl)
	if err != nil {
		log.Fatalln(err)
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	p, err := rtsp.ParseSdp(&io.LimitedReader{R: res.Body, N: res.ContentLength})
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Printf("%+v", p)
	res, err = sess.Setup(rtpUrl, fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", rtpPort, rtcpPort))
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Println(res)
	res, err = sess.Play(rtspUrl, res.Header.Get("Session"))
	if err != nil {
		t.Errorf("Shouldn't have got error: %v\n", err)
	}
	log.Println(res)
	// create udp connection for rtp stuff
	rtpLaddr, err := net.ResolveUDPAddr("udp", "192.168.0.109:17300")
	if err != nil {
		t.Errorf("Local rtp addr not set! %v\n", err)
	}
	rtpAddr, err := net.ResolveUDPAddr("udp", "192.168.0.50:17300")
	if err != nil {
		t.Errorf("Resolving rtp address didn't work! %v\n", err)
	}
	rtpConn, err := net.DialUDP("udp", rtpLaddr, rtpAddr)
	if err != nil {
		t.Errorf("Conncection not established! %v\n", err)
	}
	// Create udp connection for rtcp stuff
	rtcpLaddr, err := net.ResolveUDPAddr("udp", "192.168.0.109:17319")
	if err != nil {
		t.Errorf("Local RTCP address not resolved! %v\n", err)
	}
	rtcpAddr, err := net.ResolveUDPAddr("udp", "192.168.0.50:17301")
	if err != nil {
		t.Errorf("Remote RTCP address not resolved! %v\n", err)
	}
	rtcpConn, err := net.DialUDP("udp", rtcpLaddr, rtcpAddr)
	if err != nil {
		t.Errorf("Connection not established! %v\n", err)
	}
	// let's create a session that will store useful stuff from the connections
	rtpSession := NewSession(rtpConn, rtcpConn)
	time.Sleep(2 * time.Second)
	select {
	default:
		t.Errorf("Should have got rtpPacket!")
	case rtpPacket := <-rtpSession.RtpChan:
		fmt.Printf("RTP packet: %v\n", rtpPacket)
	}
}

/*******************************************************
Testing stuff related to the Nal.go file
********************************************************/
var parseInput = []byte{
	0x6C, // 3NalUnitBits = 101(5), Fragment type = 1100 (type = 12 )
	0x94, // starbit = 1, endbit = 0, Reservedbit = 0, 5NalUnitBits = 10100 (20)
	0x8E, // 10001110 random frame byte
	0x26, // 00100110 random frame byte
	0xD0, // 11010000 random frame byte
}

var expectedParsing = []interface{}{
	byte(3),
	byte(12),
	bool(true),
	bool(false),
	bool(false),
	byte(20),
	[]byte{0x8E, 0x26, 0xD0},
}

const (
	nalTestType = 12
)

func TestNalFragmentParsing(t *testing.T) {
	nalUnit := ParseNALFragment(parseInput)
	value := reflect.ValueOf(*nalUnit)
	length := value.NumField()
	fields := make([]interface{}, length)
	for ii := 0; ii < length; ii++ {
		fields[ii] = value.Field(ii).Interface()
	}
	for ii := range fields {
		if !reflect.DeepEqual(fields[ii], expectedParsing[ii]) {
			t.Errorf("Bad Parsing! Field: %v wanted: %v got: %v\n", ii, expectedParsing[ii],
				fields[ii])
		}
	}
}

func TestNalFragmentToByteSlice(t *testing.T) {
	nalUnit := ParseNALFragment(parseInput)
	output := nalUnit.ToByteSlice()
	for ii := range output {
		if output[ii] != parseInput[ii] {
			t.Errorf("Bad conversion to byte slice at %vth byte! wanted: %v got: %v",
				parseInput[ii], output[ii])
		}
	}
}

func TestNalFragmentType(t *testing.T) {
	nalUnit := ParseNALFragment(parseInput)
	nalType := nalUnit.GetType()
	if nalType != nalTestType {
		t.Errorf("Returned wrong type!")
	}
}

func TestNalSpsPpsParsing(t *testing.T) {
	nalSpsPps := ParseNALSpsPps(parseInput)
	for ii := range parseInput {
		if nalSpsPps.Data[ii] != parseInput[ii] {
			t.Errorf("Bad Parsing! Byte: %v wanted: %v got: %v\n", ii, parseInput[ii],
				nalSpsPps.Data[ii])
		}
	}
}

func TestNalSpsPpsToByteSlice(t *testing.T) {
	nalSpsPps := ParseNALSpsPps(parseInput)
	nalSpsPpsByteSlice := nalSpsPps.ToByteSlice()
	for ii := range parseInput {
		if nalSpsPpsByteSlice[ii] != parseInput[ii] {
			t.Errorf("Bad conversion to byte slice! Byte: %v wanted: %v got: %v\n", ii,
				parseInput[ii], nalSpsPpsByteSlice[ii])
		}
	}
}

func TestNalSpsPpsType(t *testing.T) {
	nalSpsPps := ParseNALSpsPps(parseInput)
	if nalSpsPps.GetType() != nalTestType {
		t.Errorf("Returned wrong type!")
	}
}

/*******************************************************
Pes Packet testing!
********************************************************/
const (
	dataLength = 3 // bytes
)

func TestPesToByteSlice(t *testing.T) {
	pesPkt := PESPacket{
		byte(0xE0),  // StreamID
		uint16(6),  // Length
		byte(0),     // ScramblingControl
		bool(true),  // Priority
		bool(false), // DAI
		bool(false), // copyright
		bool(true),  // Original
		byte(0),     // PDI
		bool(false), // Escr
		bool(false), // ESRate
		bool(false), // DSMTrickMode
		bool(false), // ACI
		bool(false), // CRC
		bool(false), // Ext
		byte(0),     // header length
		[]byte{},
		[]byte{},
		[]byte{ // data
			0xEA,
			0x4B,
			0x12,
		},
	}
	pesExpectedOutput := []byte{
		0x00, // packet start code prefix byte 1
		0x00, // packet start code prefix byte 2
		0x01, // packet start code prefix byte 3
		0xE0, // stream ID
		0x00, // PES Packet length byte 1
		0x06, // PES packet length byte 2
		0x89, // Marker bits,ScramblingControl, Priority, DAI, Copyright, Original
		0x00, // PDI, ESCR, ESRate, DSMTrickMode, ACI, CRC, Ext
		0x00, // header length
		0xEA, // data byte 1
		0x4B, // data byte 2
		0x12, // data byte 3
	}
	pesPktAsByteSlice := pesPkt.ToByteSlice()
	for ii := range pesPktAsByteSlice {
		if pesPktAsByteSlice[ii] != pesExpectedOutput[ii] {
			t.Errorf("Conversion to byte slice bad! Byte: %v Wanted: %v Got: %v",
				ii, pesExpectedOutput[ii], pesPktAsByteSlice[ii])
		}
	}
}

/*******************************************************
Mpegts testing
********************************************************/

func TestMpegTsToByteSlice(t *testing.T){
	afRemainderLength := 180
	afField := make([]byte, afRemainderLength+1)
	afField[0] = byte(afRemainderLength)
	afField[1] = byte(0)
	for i := 2; i < len(afField); i++ {
		afField[i] = 0xFF
	}
	tsPkt := MpegTsPacket{
		byte(0x47), 	// sync byte
		bool(false),	// TEI
		bool(false),	// PUSI
		bool(false),	// Priority
		uint16(256),	// PID
		byte(0),			// TSC
		byte(3),			// AFC
		byte(6), 			// CC
		afField,			// AF
		[]byte{				// data
			0x67,
			0xB2,
			0xE3,
		},
	}
	expectedOutput := []byte{
		0x47,
		0x01,
		0x00,
		0x36,
		byte(afRemainderLength),
		0x00,
		// this is where stuffing is, expect that to be 0xFF
		0x67,
		0xB2,
		0xE3,
	}
	tsPktAsByteSlice := tsPkt.ToByteSlice()
	for ii := 0; ii < 6; ii++ {
		if tsPktAsByteSlice[ii] != expectedOutput[ii] {
			t.Errorf("Conversion to byte slice bad! Byte: %v Wanted: %v Got: %v",
				ii, expectedOutput[ii], tsPktAsByteSlice[ii])
		}
	}
	// Check that the stuffing is all there
	for ii := 6; ii < 185; ii++ {
		if tsPktAsByteSlice[ii] != 0xFF {
			t.Errorf("Conversion to byte slice bad! Byte: %v Wanted: %v Got: %v",
				ii, byte(0xFF), tsPktAsByteSlice[ii])
		}
	}
	for ii := 185; ii < 188; ii++ {
		if tsPktAsByteSlice[ii] != expectedOutput[ii-185+6] {
			t.Errorf("Conversion to byte slice bad! Byte: %v Wanted: %v Got: %v",
				ii, expectedOutput[ii], tsPktAsByteSlice[ii])
		}
	}
}

/*******************************************************
RtpToTsConverter testing
********************************************************/

func TestRtpToTsConverter(t *testing.T){

}