Use http instead of https in gvctrl getLogin request. Gave RTP client a close method so that the conn can
be closed after we're done with the client. Put timeout on reading from the RTP client PacketConn so that
we don't hang on the ReadFrom call if the conn is closed. Closing the RTSP and RTP clients when
startRTSPCamera is returned.
Now adopting an RTCP client so that the RTP stream from the RTSP server can be maintained past 1 minute.
This change involved some refactor.
The rtcp.NewClient signature has been simplified. There is now a default send interval and name for use
in the source description in the receiver reports. These can be customised if required with the new
SetSendInterval and SetName funcs. The rtcp.NewClient signature now takes an rtp.Client, so that it
can get information from the RTP stream, like most recent sequence number. As a result of this requirement
the rtp package parse file has been extended with some functions for parsing out the sequence number and
ssrc from RTP packets and the RTP client provides getters for these things.
Removed buffering in rtp client. This simplified things alot e.g. the recv routine has been removed, and therefore anything that was there to help with handling of the routine is also gone
like the Start() and Stop() methods as well as signalling channels and waitgroups. The client is now just effectively a wrapper for a udp conn.
Simplified clien_test.go file by testing two different RTP packet operations using loop. We now first test no operation,
and then test a rtp.Payload operation, which gets the payload of the packets and stores them in the client ringbuffer for the
user of the client to read.
Wrote test TestReceiveNoOP to check that client works correctly when we give no operation to perform on RTP packets before
storing in the client ringBuffer, which calling io.Reader implementation Read will get packets form.
Added client.go which contains a struct to describe an RTP client. It provides a method, Start, which will
invoke a recv routine to start receiving packets and process them using an op function passed on the Client's
creation. Client implements io.Reader, so that the client may be read from.
Saxon