kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/net/liblive/PLIST
wiz 686032b1f9 Update to 20141211. Set LICENSE. 
2014.12.11:
- Changed our implementation of "setBackgroundHandling()" and "moveBackgroundHandling()" in
  "BasicTaskScheduler" to check for (and disallow) socket numbers >= FD_SETSIZE,
  because <sys/select.h> has a bug (at least, in most systems) that causes buffer overflow
  in this case.  (Thanks to Michel Promonet for pointing this out.)

2014.12.09:
- Needed to make the "QuickTimeFileSink" constructor and destructor protected: to allow subclassing.

2014.12.08:
- Fixed a bug in parsing 'absolute' RTSP "Range:" headers with no end time.
  (Thanks to Ken Chow for reporting this.)
- Added a new option "-K" to "openRTSP, to tell the client to periodically send "OPTIONS"
  requests as 'keep-alives' for buggy servers that don't use incoming RTCP "RR" packets to
  indicate client liveness.  (Thanks to Peter Schlaile for this suggestion.)
- Added a new 'protected' virtual member function "noteRecordedFrame()" to "QuickTimeFileSink".
  This function is called whenever a frame is recorded to the output file.
  The default implementation of this virtual function does nothing, but subclasses can redefine
  it if they wish.

2014.11.28:
- When "RTSPClient" parses a RTSP response, we first skip over any blank lines that may be at
  the start of the response.  This can happen if the previous response (e.g., to a "DESCRIBE")
  contained extra whitespace.
  (Thanks to ilwoo Nam for giving an example of a server that exhibited this behavior.)

2014.11.12:
- We had forgotten to initialize the "RTSPClient" member variable "fAllowBasicAuthentication"
  that we introduced in the previous version.

2014.11.07:
- Added a new "RTSPClient" member function "disallowBasicAuthentication()" that you can call if
  you don't want a RTSP client to perform 'basic' authentication (whcih involves sending
  the username and password over the network), even if the server asks for this.
  (Thanks to Tomasz Pala for this suggestion.)
- Updated the debugging printout code in "RTCP.cpp" to identify all known RTCP payload types,
  even if we don't currently handle them.  We also - when doing debugging printout - parse and
  print out the contents of SDES RTCP packets.

2014.11.01:
- Updated "RTSPClient" so that it reuses "fCurrentAuthenticator" if we previously
  updated it with data from a "WWW-Authenticate:" response, even if a non_NULL
  "authenticator" parameter was passed as a parameter to the command.  This reduces the
  number of authetication exchanges that take place if the server asks for authentication
  on more than one command in a RTSP session.
  (Thanks to Tomasz Pala for this suggestion.)
- Updated "DigestAuthenticator" to allow for the possibility of "username" or "password"
  being NULL.
- Updated the "RTSPServer" implementation to add an access check before the first "SETUP"
  (the one that doesn't include a session id), because it's possible, in principle, for a client
  to send such a "SETUP" without first sending a "DESCRIBE".  Therefore, we need to perform
  access checks on both commands.

2014.10.28:
- Added support for the VP9 video RTP payload format (sending and receiving), including the
  demultiplexing and streaming of a VP9 video track from a Matroska-format file.
- Made "VP8VideoRTPSource" more robust against a bad first-byte header field in the payload.

2014.10.21:
- Increased the max output packet size for "MultiFramedRTPSink" and "RTCPInstance" from 1448
  to 1456, because we had a report of problems when proxying incoming JPEG/RTP packets of this
  size (and because 1456 bytes still gives a packet size of no more than 1500 bytes when we add
  in IP, UDP, and UMTP headers).

2014.10.20:
- Increased the RTSP request and response buffer sizes from 10000 to 20000 bytes, because we
  saw a RTSP stream (VP8 video) that had an extremely large "configuration=" string that was
  hiting the previous limit.

2014.10.16:
- Fixed the "RTSPServer" implementation to handle a rare race condition that could cause a
  "ServerMediaSession" object to be deleted while it was being used to implement "DESCRIBE".
  (Thanks to Michel Promonet for reporting this.)

2014.10.07:
- Fixed a bug in the "MultiFramedRTPSource" implementation where we weren't properly checking the
  size of incoming RTP packets that have the "CC" field (i.e., number of "CSRC" fields) non-zero.
- Updated "Groupsock::output()" to be a virtual function.  (This makes it possible to implement
  "Groupsock" subclasses that implement 'bump-in-the-stack' protocols (such as SRT(C)P) below
  RTP/RTCP.)

2014.10.03:
- Fixed a problem in the "timestampString()" routine that occurs if "time_t" is 64 bits, but
  we're on a 32-bit machine.  (Thanks to Deanna Earley for reporting this.)
- Updated the debugging output code in "RTCP.cpp" to make it clearer that SDES and APP packets
  are not invalid; just not (yet) handled by us.

2014.09.22:
- Changed the way in which the "RTSPServer" code handles incoming "OPTIONS" commands that contain
  a "Session:" header.  If the "Session:" header contains a session id that does not exist, then
  we now return a "Session Not Found" error (even though the handling of the "OPTIONS" command is
  not session-specific).  This new behavior will help proxy servers (that use our "RTSPServer"
  implementation as a 'back-end' server) better detect when the back-end server has restarted
  while streaming.  (Thanks to Jonathan Brady for noticing this issue.)

2014.09.11:
- Note that the signature of the virtual function "RTSPServer::lookupServerMediaSession()" has
  changed.  It now takes an extra (in) parameter "Boolean isFirstLookupInSession".
  If you have subclassed "RTSPServer" and redefined this function, you must update your
  redefinition to match this new signature.
- Fixed a bug in the "DynamicRTSPServer" code (used by the "LIVE555 Media Server") that
  had been introduced in version 2014.07.12, and was causing streaming from multi-stream files
  to fail.  (Thanks to Gilles Chanteperdrix for noting this.)

2014.08.26:
- Fixed a bug that was introduced in version 2014.03.25 that could cause excessive CPU usage
  for servers that stream from a single source to both RTP/UDP and RTP/TCP clients.
  Thanks to Chris Richardson for noting this.

2014.08.23:
- Added a new function "attrVal_strToLower()" to "MediaSubsession".  This returns a string
  attribute as a lower-case string.  ("mode" SDP attributes are now looked up using this function.)
  (Thanks to James Huang for noting a problem that made this necessary.)
- Added an alternative form of "strDupSize()" (in the "UsageEnvironment" library) that
  also returns the size of the allocated buffer.

2014.07.25:
- Fixed an obscure bug in "RTPInterface::sendPacket()" when sending a packet over TCP.
  (Thanks to "ChaSeop Im" for reporting this.)
- Added "-DXLOCALE_NOT_USED" to the "COMPILE_OPTS" line in the "config.solaris*" configuration
  files, because someone claimed that this was necessary in order to build the code for Solaris.

2014.07.18:
- Made the "RTSPServer" code more robust, to allow for the possibility of the same substream
  being "SETUP" by the same client more than once.  (This could cause a crash when streaming a
  MPEG Program Stream file, and potentially for other file types as well.)
  (Thanks to Yann Fleutot of "Stormshield" for reporting this.)
- Changed some error message output code that was allegedly causing compiler errors in Debian Linux.

2014.07.13:
- Corrected the previous revision's change to "groupsock/NetCommon.h" to remove a definition
  of "int8_t", because that's apparently already defined for Windows.
  (Thanks to Victor Kulichkin for noting this.)

2014.07.12:
- Updated the "DynamicRTSPServer" code (used by the "LIVE555 Media Server") so that it
  creates a new "ServerMediaSession" object for each new request for a file.  (Any existing
  "ServerMediaSession" for the file will be removed, but any existing client for that
  "ServerMediaSession" will continue streaming.)  This allows for the possibility of
  the underlying file changing size between successive requests.
  (Thanks to Nadir Raimondo for the suggestion.)
- Updated "groupsock/NetCommon.h" to add some new size-specific int definitions that apparently
  weren't already defined for some Windows compilers.

2014.07.04:
- Added an update to "MPEG2TransportStreamMultiplexor" and "MPEG2TransportStreamFromESSource"
  that makes it possible to (optionally) specify a PID for a multiplexed stream.
  (Currently, only the low 8 bits of this PID will be used.)
  The default behavior remains: Use the 8-bit 'stream_id' as the PID.
  (Thanks to Piers Hawksley for the patch.)

2014.06.28:
- Fixed another bug in the RTSP server's handling of incoming Base-64-encoded requests.

2014.06.27:
- Fixed a bug in the RTSP server's handling of incoming Base-64-encoded requests (when handling
  RTSP-tunneled-over-HTTP) that get split over more than one network read.
  (Thanks to Piers Hawksley for the reporting the problem, and providing diagnostic output to
  help track down the bug.)
- Made the RTP/RTCP-over-TCP implementation more robust, by stopping all use of the socket
  if any write to the socket should fail.

2014.06.24:
- Fixed a bug in "MPEG2IndexFromTransportStream" that was causing it to print out error messages
  (but otherwise work OK) when it saw Transport Packets with "adaptation_field_control" == 2.
  (Thanks to Nadir Raimondo for reporting this.)
- Added an "#ifndef" around the definition of OUR_PROGRAM_NUMBER in MPEG2TransportStreamMultiplexor.cpp,
  to allow it to be defined as a different value.  (Suggestion by Piers Hawksley.)
- Fixed (extremely minor and inconsequential) memory leaks in "MatroskaFile" and "StreamReplicator".
- Changed "UsageEnvironment::reclaim()" to return a Boolean value: True if it was actually
  able to reclaim the object's memory; False otherwise.

2014.05.27:
- Updated the "BasicTaskScheduler" 'dummy socket' hack (to work around a bug in Windows'
  "select()" implementation) to make the dummy socket number a member variable.  This allows
  us to close this socket in the "BasicTaskScheduler" destructor.  (Apparently this matters
  to some people...)

2014.05.25:
- Changed the way in which we set the maximum output packet size for RTCP, because the previous
  hack (in "RTCP.cpp") wasn't 'thread safe'.  (Thanks to Liao ChunWei for noting this.)
- Moved "ourMD5.hh" from the "liveMedia" directory to the "liveMedia/include" directory,
  so as to make it accessible to applications.
  We also added a new function "our_MD5DataRaw()", which is similar to the existing
  "our_MD5Data()", except that it returns the digest as a 'raw' 16-byte buffer, rather than
  as an ASCII hex string.
- Added a "RemoveNext()" function to "AddressPortLookupServer".  (It just calls
  "HashTable::RemoveNext()".)

2014.05.14:
- Fixed a bug in the way we implemented a timeout on blocking writes in "RTPInterface" in
  the previous version.
- Added the ability to receive the "audio/G722" RTP payload format (using "SimpleRTPSource").

2014.05.08:
- Updated the 'blocking send()' hack in "RTPInterface::sendDataOverTCP()" so that the
  'blocking send()' (if called) will have a timeout (default value: 500 ms), rather than
  blocking indefinitely (which might happen if the TCP connection has hung for some reason).
  (If you wish, you can change this by compiling "RTPInterface.cpp" with
   RTPINTERFACE_BLOCKING_WRITE_TIMEOUT_MS defined to be some other value.  A value of 0 means:
   Don't timeout - i.e., the previous behavior.)
  If the 'blocking send()' does time out, then the socket is closed, which will cause all
  network activity (RTSP,RTP,RTCP) on the socket to cease.  (If this is a RTSP server,
  then all state for the connection will eventually be reclaimed normally.)
  (Thanks to Gord Umphrey for suggesting the 'setsockopt()' call that sets the timeout.)
- Removed the "profile_level_id" parameter from the 'optional' variants of
  "H264VideoRTPSink::createNew()", because this value can instead be extracted from the
  SPS NAL unit (after removing 'emulation' bytes).
  Simularly, we removed the "profileSpace", "profileId", "tierFlag", "levelId", and
  "interopConstraintsStr" parameters from the 'optional' variants of
  "H265VideoRTPSink::createNew()", because these values can instead be extracted from the
  VPS NAL unit (again, after removing 'emulation' bytes).

2014.04.23:
- Added a new function "RTSPServer::disableStreamingRTPOverTCP()" that you can call - on a
  RTSP server - to deny clients that request RTP/RTCP-over-TCP streaming.
- Made the constructors and destructors for the classes "RTSPServer::RTSPClientConnection"
  and "RTSPServer::RTSPClientSession" 'protected' rather than 'public', because objects of these
  classes should be created only via the "createNewClientConnection()" and
  "createNewClientSession()" virtual functions, and destroyed only by the "RTSPServer" code.
- Change the "reuse_connection" Transport parameter for our RTSP "REGISTER" command to be a
  simple flag (present, or not present), rather than a parameter that takes a value.
  (This change is also noted in the most recent update of our Internet-Draft:
  "draft-finlayson-rtsp-register-command-01.txt")
- Fixed a compilation error in "OggFileServerDemux.cpp" that occurred when DEBUG is defined.

2014.03.25:
- We can now handle incoming RTCP packets that are multiplexed on the same port as RTP packets.
  A "RTCPInstance" does this by 'registering' itself with the corresponding "RTPSource".
  The "RTPSource" network handler then forwards any multiplexed RTCP packets to the
  "RTCPInstance".
  Multiplexed RTP/RTCP packets are signaled by an "a=rtcp-mux" line in the SDP descriptor.
- Allow a RTP-transmitting server to (optionally) multiplex RTCP on the same port as RTP.
  If this is done, a "a=rtcp-mux" line (as defined in RFC 5761) will be automatically added
  to the SDP description.
  Also, if this option is chosen, the RTP (and RTCP) port may be odd-numbered.
  For "OnDemandServerMediaSubsession"s, this option is specified via a parameter
  "multiplexRTCPWithRTP" (default value: False) in the constructor, or using a new
  public member function "multiplexRTCPWithRTP()".
  For "PassiveServerMediaSubsession"s, this option is specified by passing (in "createNew()")
  a "rtcpInstance" parameter that has the same 'groupsock' as the "rtpSink" parameter.
  NOTE: RTSP clients that are built using previous versions of this library (or perhaps using
  some other software) will not handle RTCP that's multiplexed with RTP.  Therefore, this
  option should be enabled ONLY IF you know that all RTSP clients will be using this version
  of the software, or later.
- Fixed a bug in "QuickTimeFileSink" and "AVIFileSink" that could apparently cause a NULL
  pointer to be dereferenced.  (Thanks to Martijn van den Broek for reporting this.)
- Fixed an issue in the "RTPInterface" code that could cause "SetSpecificRRHandler()" to not
  work properly when RTP/RTCP is being carried over TCP.

2014.03.18:
- Fixed a bug in "H264VideoFileServerMediaSubsession" (and "H265VideoFileServerMediaSubsession"
  and "MPEG4VideoFileServerMediaSubsession") that could cause a crash (due to a 'race condition')
  if the input file ended before 'configuration' data could be extracted.
  (Thanks to Robert Sujker for finding and analyzing this problem.)

2014.03.17:
- Fixed a bad "#ifndef" in "DVVideoRTPSource.hh"

2014.03.16:
- Added support for demultiplexing and streaming Opus audio tracks from Matroska/Webm files.

2014.02.26:
- Updated the H.265/RTP implementation to remove the "tx-mode" attribute, to conform to the latest
  version of the H.265 RTP payload format specification.
- Added a new function "OutPacketBuffer::increaseMaxSizeTo()" that sets "OutPacketBuffer::maxSize"
  to a new value only if it's bigger than the current value.  Thanks to Michael Brimer for
  motivating this.
- Fixed a couple of minor code 'nits' that Nikolai Vorontsov discovered using a code analyzer.

2014.02.19:
- Fixed a bug that was causing some bytes to be deleted when receiving H.265/RTP streams.
  (Thanks for Michel Promonet for bringing this to our attention.)
- Added support for streaming Opus audio tracks from Ogg files.  Also updated "OpusFileSink"
  (which is used by "openRTSP") to write Opus audio streams into Ogg-format files.
- Updated the "ProxyServerMediaSession" implementation - and thus the "LIVE555 Proxy Server"
  to support proxying of Opus audio RTSP/RTP streams.
- Added a "test.opus" file option to the "testOnDemandRTSPServer" demo application.
- Made minor changes to "OggFileParser.cpp" to eliminate compiler warnings on some platforms.

2014.02.17:
- Added a new class "TheoraVideoRTPSource" to implement reception of Theora Video RTP streams.
- Updated "ProxyServerMediaSession" to support proxying of Theora video RTSP/RTP streams.
- Updated the signature of "TheoraVideoRTPSink::createNew()" to remove the "width", "height",
  and "pf" parameters, because we can extract these from the 'identification' header parameter.

2014.02.13:
- Added support for streaming Theora video tracks from Matroska files.
- Updated "OutputSocket::write()" to do a "setsockopt()" call to set the TTL, even if
  the TTL is 0.  (As before, however, we don't do the "setsockopt()" call if the TTL is the
  same as before (an optimization.)  (Thanks to Daniel Martinez Contador for the suggestion.)
- Changed the "RTSPServer" destructor to delete "RTSPClientSession" objects before deleting
  "RTSPClientConnection" objects.  We do this because each "RTSPClientSession" object
  is created from a "RTSPClientConnection", and passes its "RTSPClientConnection" object to
  "handleAlternativeRequestByte()" (for RTP-over-TCP streaming).

2014.02.10:
- Added classes ("OggFile", "OggFileServerDemux") for demultiplexing and streaming from 'Ogg'
  files.  At present, only 'Vorbis' audio tracks can be streamed.  Later, however, we'll also
  support 'Theora' video and 'Opus' audio.
- Added support for streaming from an Ogg-format file (named "test.ogg") to the
  "testOnDemandRTSPServer" demo application.
- Added a new demo application "testOggStreamer" (similar to the existing "testMKVStreamer") for
  streaming an Ogg-format file via IP multicast.
- Added support for streaming from Ogg-format files (with filename suffix ".ogg", ".ogv", or
  ".opus") to the "LIVE555 Media Server".  (Note, however, that we don't yet support streaming
  Theora video tracks or Opus audio tracks from Ogg-format files.  That will come later.)
- Updated "MPEG2IndexFromTransportStream.cpp" to check for the prefix 0x00 0x00 0x01 before
  assuming that a Transport Stream payload begins a PES packet (if "payload_unit_start_indicator"
  is set).
- Made "ServerMediaSession::generateSDPDescription()" more bullet-proof against the possibility
  of media subsession SDP lines' length changing from the first time they are calculated, and
  the second time.  (Thanks to Michael Brimer for raising this issue.)
- Updated the "LIVE555 Media Server" code to eliminated a potential problem if more than one
  Matroska (or Ogg)-format file were being streamed concurrently.  (The 'watch variables' used
  for setting up "ServerMediaSubsession"s for these files are no longer global variables.)
- Fixed a minor bug in "openRTSP" that could cause a 'double free' if the RTSP "PLAY" command failed.

2014.02.08:
- We now properly handle "Range:" headers of the form "a=npt=now-".  (The previous version had
  appeared to handle this, but didn't do so properly.)

2014.02.07:
- Updated the RTSP server's "Range:" header parsing routine to properly handle a "Range:" header
  of the form "npt= -0", which can be given when requesting reverse play.
  (Thanks to Manickam Nambirajan for noting this problem.)

2014.02.04:
- Added a new class "OggFileSink" for writing data (from a Vorbis audio, Theora video, or
  Opus audio track) into an 'Ogg'-format file.  (This writes only a single track to the file;
  it does not multiplex multiple tracks into the file.)
  Also updated the "openRTSP" application to use this class when recording incoming Vorbis audio,
  Theora video, or Opus audio RTP streams, so that the resulting files can be played
  directly by media players.
- Exported the "calculateCRC()" routine that "MPEG2TransportStreamMultiplexor" uses to
  calculate its CRCs, because the same CRC algorithm ends up being used in Ogg files.
- Made the "testMKVStreamer" demo application more robust when handling unknown track types.
- Updated the Matroska file parsing code to ignore tracks that exist, but which don't have
  a MIME (media) type that we know about.
- Changed "TheoraVideoRTPSink::createNew()" to no longer take a 'RTP timestamp frequency' as
  parameter, because the RTP payload format specification states that a frequency of 90000 Hz
  MUST be used.
- Removed some duplicate code that was being used in both "VorbisAudioRTPSink"
  and "TheoraVideoRTPSink".

2014.01.29:
- Updated the "RTSPServer" code to properly handle RTSP "PLAY" requests that have a "Range:"
  header of "npt=now-", "npt=now-<endTime>", or "npt=-<endTime>".
  (Thanks to Manickam Nambirajan for bringing this to our attention.)

2014.01.28:
- Removed a lot of code duplication from the "*MatroskaFileServerMediaSubsession" classes,
 by defining and implementing a base class "MatroskaFileServerMediaSubsession".
 We also added a new member functions "MatroskaFile::createSourceForStreaming()" and
 "MatroskaFile::createRTPSinkForTrackNumber()" which create - from a track in a Matroska file -
 source and "RTPSink" objects suitable for streaming.  These functions are used not only
 to implement the "MatroskaFileServerMediaSubsession::createNewStreamSource()" and
 "MatroskaFileServerMediaSubsession::createNewRTPSink()" virtual functions, but also to
 support multicast streaming from a Matroska file.
- We added a new 'test program' "testMKVStreamer", for streaming from a Matroska file via
  IP multicast.

2014.01.24:
- The previous version's change to "OnDemandServerMediaSubsession::getStreamParameters()"
  inadvertently broke RTP-over-TCP streaming.  This version fixes it again.
  (Thanks to KC Chao for noting the problem.)
- Considerably simplified the parsing and accessing of "a=fmtp:" SDP attributes
  (in "MediaSession.cpp").  Now, instead of having individual member variables and accessor
  functions for a set of 'hard-wired' attribute names, we automatically parse and record *any*
  attribute that happens to appear in a "a=fmtp:" SDP line, and have general-purpose accessor
  functions - MediaSubsession::attrVal_str/int/unsigned/bool() - that can lookup any
  "a=fmtp:" attribute by name (returning an appropriate 'null' value if it wasn't present in
  the SDP description).  (For backwards-compatibility, however, we have kept a few of the
  most commonly-used old accessor functions, such as "fmtp_spropparametersets()".)
  This will simplify the adding of support for new RTP payload formats.

2014.01.21:
- Updated the implementation of "OnDemandServerMediaSubsession::getStreamParameters()" to
  not create 'destination' objects (i.e., "RTPSink"s, "RTCPInstance"s, and their "groupsock"s)
  if the 'client port number' parameter is 0.  For normal RTSP streaming, this will never be the
  case.  However, it will be the case when "getStreamParameters()" is called as a hack when
  setting up HTTP Live Streaming.  Consequently, extraneous UDP sockets will no longer be created
  when HTTP Live Streaming is set up.

2014.01.20:
- Fixed another bug in "TCPStreamSink" (hopefully the last one for a while :-)

2014.01.19:
- Fixed a bug in "TCPStreamSink" that could cause a crash in servers that implement HTTP Live
  Streaming.  (Thanks to Park Chen for bringing this to our attention.)
- Added a non-static version of "FramedSource::handleClosure()".  This allows code
  to call "<object>->handleClosure()"rather than the unwieldy "FramedSource::handleClosure(this)".

2014.01.18:
- Fixed a bug in "RTSPServer" whereby it would access a recently-deleted "RTSPClientSession"
  object shortly after handling "TEARDOWN".  (Thanks to Michel Promonet for reporting this.)

2014.01.17:
- Fixed a bug in "H265VideoRTPSource" (when reconstructing the first fragment of a fragmented
  NAL unit).

2014.01.16:
- Added a "H265VideoFileSink" class, similar to the existing "H264VideoFileSink".
  Also updated the "openRTSP" application to write received H.265 Streams using this new class.
- Updated the "ProxyServerMediaSession" code (and thus also the "LIVE555 Proxy Server") to
  handle proxying of H.265/RTP streams.
- Fixed a bug in "H264VideoRTPSink" (and "H265VideoRTPSink") - introduced in previous versions
  - that would have prevented proxy servers from working properly on H.264 (and H.265) streams.

2014.01.15:
- Implemented "H265VideoRTPSource" for receiving H.265/RTP streams.
- Make "H264VideoRTPSource" more robust against unusually short NAL units.
- Fixed an incorrect #ifndef in "H265VideoStreamDiscreteFramer.hh"

2014.01.14:
- In the "TCPStreamSink" destructor, we now make sure that all pending background handling on the
  output (TCP) socket has been disabled. (Thanks to Park Chan for bringing this to our attention.)

2014.01.13:
- Changed the implementation of "Authenticator::reclaimDigestResponse()" to do a "delete[]"
  rather than a "free()", because we had previously changed "our_MD5Data()" from C code that
  called "malloc()" to C++ code that called "new[]".
  (Thanks to Michel Promonet for reporting this issue.)
- Added support for streaming H.265 tracks from Matroska files.
- Fixed a bug (introduced in the previous version) that would cause a RTSP server streaming from
  a Matroska file containing H.264 video to report an incorrect "profile_level_id" value.
- Added support for indexing (and subsequent 'trick play' (seeking) operation on) Transport Stream
  files that contain H.265 video.  (This has not been fully tested yet.)
- Added a new demo application "testH265VideoToTransportStream", similar to the existing
  "testH264VideoToTransportStream".
- Changed the implementation of the (rarely-called) "Socket::changePort()" function so
  that the new socket gets the same 'receive buffer size' and 'send buffer size' that
  the old socket had.  (Thanks to Cristian Jerez for noting this issue.)

2014.01.11:
- Updated the "ourIPAddress()" code in "groupsock/GroupsockHelper.cpp" to use
  "ReceivingInterfaceAddr" as our IP address, if it was set to something other than INADDR_ANY.
  (Thanks to Gilles Chanteperdrix for this suggestion.)
- Added a new class "H265VideoRTPSink" for streaming H.265 video.
- Added a new class "H265VideoFileServerMediaSubsession" for streaming a H.265 file from a RTSP
  server, similar to the existing "H264VideoFileServerMediaSubsession" class.
- Created a new abstract base class "H264or5VideoStreamDiscreteFramer", and made
  "H264VideoStreamDiscreteFramer" and "H265VideoStreamDiscreteFramer" subclasses of this.
  (This eliminated some duplicate code.)  Note, however, that now "H264VideoStreamDiscreteFramer"
  is no longer a subclass of "H264VideoStreamFramer".  (Ditto for "H265*".)  This means that any
  existing code that might have cast a "H264VideoStreamDiscreteFramer" as
  a "H264VideoStreamFramer" will now be broken, and will need to change.
- Updated the "LIVE555 Media Server" application (currently, just the source code version)
  to allow it to stream from H.265 Elementary Stream ("*.265") files.
- Updated the "testOnDemandRTSPServer" demo application to allow it to stream from
  a H.265 Elementary Stream file ("test.265").
- Fixed a potential (though unlikely) problem in "H264VideoRTPSink" that might
  have caused an incorrect "profile_level_id" value to be set in SDP descriptions
  (due to the presence of 'emulation bytes' in the SPS NAL unit).
- Updated the "FileSink" implementation to make it work better when the "oneFilePerFrame" flag
  is set.  Now, the right thing will happen if "addFrame()" is called more than once before
  "afterGettingFrame()" is called - as is done by "H264VideoFileSink" (to prepend a 'start code').
  Also, if successive frames happen to have the same presentation time, we now use a filename
  suffix to distinguish them.  (Before, the second frame's data would overwrite the first.)
- Improved the "openRTSP" command's error messages when the user gives it incompatible
  command-line options.

2014.01.07:
- Added "Host:" headers to the HTTP "GET" and "POST" requests that "RTSPClient" sends when
  setting up RTSP/RTP/RTCP tunneling over HTTP.  Some HTTP servers complain if the "Host:" header
  isn't present.  (Thanks to Victor Gottardi for reporting this issue.)
- Added initial support for H.265 video, by defining two new classes "H265VideoStreamFramer" and
  "H265VideoStreamDiscreteFramer".  Because H.265 is similar to H.265, these classes - along with
  their old H.264 equivalent ("H264VideoStreamFramer" and "H264VideoStreamDiscreteFramer") are
  now subclassed from a single abstract class "H264or5VideoStreamFramer".
  Support for H.265 is still a 'work in progress'; we still need to define new RTP source and
  sink classes for it, along with RTSP server and Matroska demultiplexing support, as well
  as new and updated test programs.
- Cleaned up the "RTSPServer" request handling code to improve the handling of session ids in
  requests.  (We also now make sure that a valid session id in *any* request will cause the
  request to be counted as indicating 'liveness' on the session.)
- Removed some old, unused code from "MP3StreamState".

2013.12.31:
- In "BasicUsageEnvironment", moved the implementation of the constants "DELAY_MINUTE",
  "DELAY_HOUR", and "DELAY_DAY" from "DelayQueue.hh" to "DelayQueue.cpp", because of a report
  that some compilers were allegedly having problems with the previous code.
- In "groupsock/GroupsockHelper.cpp", changed a couple of "#ifdef ANDROID"s
  to "#ifdef __ANDROID__", because the latter definition is allegedly what 'Android' uses.

2013.12.29:
- Rewrote our MD5 implementation (and, in particular, the "our_MD5Data()" function) in C++.
- Updated the years in the copyright notice on each file.

2013.12.21:
- Fixed a potential 'double free' issue in "MediaSession.cpp".
  (Thanks to ChanMin Kim for noticing this.)
- Updated "RTSPClient" to move the code that sends short 'dummy' UDP packets (to improve the
  chances of receiving packets from a server that's behind a NAT) into its own member function.
  Also, we now call this before sending a "PLAY" command, rather than after receiving the response
  to a "SETUP" command.  (This is so that the packets will also be sent when resuming after
  a "PAUSE"; thanks to Gilles Chanteperdrix for this suggestion.)
- Added a Windows-specific definition to one file to compensate for the fact that the "fileno()"
  function is deprecated in recent versions of Windows.

2013.12.18:
- Added an implementation of a new class "TheoraVideoRTPSink" - for Theora video.
  (This was developed using the "VorbisAudioRTPSink" code as a base;
  thanks to Gilles Chanteperdrix.)
- Updated the new "openRTSP -P <interval-in-seconds>" option to work with the
  "-F <filename-prefix>" option, if you also specified "-q", "-4", or "-i".

2013.12.17:
- Removed a stray #define DEBUG from "RTSPServer.cpp"

2013.12.16:
- Fixed a bug in the "RTSPServer" code that was causing it not to handle pipelined
  Base64-encoded requests (sent over a RTSP-over-HTTP connection) properly.  Also updated the
  "parseRTSPRequestString()" code to make it more tolerant of whitespace (or NULL) characters
  at the start of requests; we now skip over them.
  (Thanks to Bob Bischan for providing an example that illustrated this problem.)

2013.12.15:
- Updated the "ProxyServerMediaSession" code to change the way in which the code can create
  an instance of your subclass of "ProxyRTSPClient" (if you've defined one).
  Previously, this was done by calling a virtual function - but that didn't work, because it was
  being called from the "ProxyServerMediaSession" constructor.  Now, instead, you will
  define a (non-member) function that returns a new object of your "ProxyRTSPClient" subclass,
  and then (in the constructor of your "ProxyServerMediaSession" subclass) pass this function
  as a parameter to the constructor of the parent class (i.e., "ProxyServerMediaSession").
  (Thanks to Craig Matsuura for bringing this problem to our attention.)
- Fixed a bug in "QuickTimeFileSink" and "AVIFileSink": When closing the object, we need to call
  "stopGettingFrames()" on each input source.
- Added a new option "-P <interval-in-seconds>" to "openRTSP".  This option tells "openRTSP"
  to write a new output file periodically.
- Updated "RTSPServer" to add an optional "timeout=" parameter to the end of the "Session:" header
  in each "SETUP" response (unless "fReclamationTestSeconds" was 0).  (Note that compliant
  RTSP/RTP clients are still expected to send RTCP "RR" packets, which the server uses to note
  client liveness.)

2013.12.05:
- Fixed a line of code in "RTPInterface.cpp" that was breaking 'Win64' compilers.
  (Thanks to the VLC developers for noting this.)

2013.12.04:
- Updated the "sendDataOverTCP()" function (in "RTPInterface.cpp") to allow for the possibility of
  one of the "send()" calls partially succeeding - i.e., writing some, but not all, of its data.
- Fixed a couple of minor bugs.  (Thanks to "maksqwe1@ukr.net".)

2013.12.03:
- Made a minor change to the "ProxyRTSPClient" code to prevent a potential divide-by-zero
  error.

2013.11.29:
- Updated the previous bug fix to close another vulnerability.  All applications that include
  RTSP server or RTSP client SHOULD UPGRADE to the latest version of the code!
  (Thanks to iSEC Partners <http://isecpartners.com/> for discovering and reporting this bug.)

2013.11.26:
- Fixed a serious buffer overflow bug in RTSP command parsing.  Because this bug was a security
  hole (potentially allowing an attacker to cause arbitrary code execution), all applications
  that include a RTSP server or RTSP client SHOULD UPGRADE to the latest version of the code!
  (Note that RTSP clients are affected, because they - like RTSP servers - can receive RTSP
  commands.)
  (Thanks to iSEC Partners <http://isecpartners.com/> for discovering and reporting this bug.)
- In "StreamState::endPlaying()"("OnDemandServerMediaSubsession.cpp"), removed the call to
  "RTPInterface::clearServerRequestAlternativeByteHandler()" (when streaming RTP-over-TCP)
  that we had added in version 2013.07.31.  This was preventing the "RTSPClientConnection"
  object (and its socket) from being deleted when the client closed its end of the TCP connection
  following a "TEARDOWN".
  (Thanks to Bruno Abreu for reporting this problem.)

2013.11.25:
- Made a minor change to the random retransmission interval used in "ProxyServerMediaSession".

2013.11.15:
- Fixed a bug that might cause a "MediaSink" to incorrectly continue operating after its input
  source object has indicated that it's closed.  (Thanks to Michel Promonet for reporting this.)

2013.11.14:
- Added a new option "-g" to "openRTSP" and "playSIP" to allow the user to specify an
  alternative user agent in outgoing requests.  (Thanks to Marco Vlahovic for the suggestion.)

2013.11.10:
- Updated the Matroska file parsing code to better handle skipping over very large tracks
  (such as embedded file attachments).  (Thanks to Michel Promonet for reporting this issue.)

2013.11.06:
- Changed the function "MatroskaDemux::newDemuxedTrack()" to return 'preferred' tracks
  (based on the file's language preference) only.  This mirrors the functionality of
  "MatroskaFileServerDemux::newServerMediaSubsession()", and makes it easier for applications
  to iterate through the tracks of a demultiplexed Matroska file.
- Added an optional "preferredLanguage" parameter to "MatroskaFileServerDemux::createNew()"
  (to mirror the corresponding parameter that's in "MatroskaFile::createNew()").
- Cleaned up the "MatroskaFile.hh" header file to remove some definitions that should not
  be exposed to developers.
- The "ServerMediaSession" and "ServerMediaSubsession" destructors had accidentally been made
  public.  Changed them to be protected instead.  (Thanks to Michel Promonet for noting this.)

2013.10.25:
- Updated the "TCPStreamSink" code to check for an 'EPIPE' errno if the "send()" fails, because apparently - in this case -
  the socket can still be considered 'writable' (by "select()"), even though it's no longer usable.
  (Thanks to Park Chan for suggesting this.)

2013.10.24:
- Fixed a bug in "ByteStreamMemoryBufferSource":" The fLimitNumBytesToStream" member variable was not being initialized.
  (Thanks to Park Chan for reporting this.)

2013.10.22:
- Added a new class "RTSPRegisterSender" that sends (and handles the response to) our custom RTSP "REGISTER" command.
  This class uses a "RTSPClient" to do the sending, thereby simplifying the handling of the RTSP response, and also
  handing authentication.  We also use this class to improve and simplify the implementation of "RTSPServer::registerStream()".
- Added a new demo application "registerRTSPStream" to the "testProgs" directory.  This application can be used to send
  a custom RTSP "REGISTER" command to a RTSP client or proxy server.  (Note, however, that servers that wish to register their
  own streams should continue to use the "RTSPServer::registerStream()" method to do so - not this application.)
- Updated the "LIVE555 Proxy Server" application to take an optional '-U <username> <password>' command-line option.
  This option specifies a username,password pair to use to authenticate (if necessary) incoming "REGISTER" commands.
- Added the ability to authenticate incoming RTSP "REGISTER" commands, and added a new option "-k <username> <password>"
  to "openRTSP" to allow the user (in combination with the "-R" option) to specify access control on incoming REGISTER commands.
- Added the ability for "RTSPServer" subclasses to have different 'authentication databases' for different RTSP commands.
- Moved some of the implementation of "RTSPClient::sendRequest()" into a new virtual function "setRequestFields()".
  This makes it easier for a subclass to implement a new custom RTSP command, if desired.  (We now use this to implement
  the sending of our custom "REGISTER" command.)
- Reordered the member function implementations in "RTSPClient.cpp" to better match the order that they're defined
  in "RTSPClient.hh".

2013.10.18:
- Updated the implementation of the "REGISTER" command to conform with our recent IETF Internet-Draft
  ("draft-finlayson-rtsp-register-command-00").  The "RTSPServer::registerStream()" function has been modified accordingly to take
  two new optional parameters: "receiveOurStreamViaTCP" (Boolean), and "proxyURLSuffix" (string).
- Made the "RTSPServer" code's parsing of "Transport:" headers a little more robust.

2013.10.16:
- Updated the way that "RTSPClient" sends "OPTIONS" commands.  If we are currently part of a session, then we add a
  "Session:" header to the request.
- Changed the HTTP version - used in our RTSP-over-HTTP implementation - from 1.0 to 1.1.  (I don't think this matters at all,
  but most HTTP used elsewhere is version 1.1.)

2013.10.11:
- Fixed a bug in the interpretation of bits in the 'video-specific header' in "MPEG1or2VideoRTPSource", when slices
  are present.  (Thanks to David Verbieren for reporting this.)
- Fixed "RTSPServerWithREGISTERProxying" to include "REGISTER_REMOTE" in the list of supported command names returned in response
  to an "OPTIONS" command.  (Thanks to Bob Bischan for noting this.)

2013.10.09:
- Updated the signature of "RTSPServerWithREGISTERProxying::createNew()" to take a Boolean "streamOverTCP" parameter
  (default value: False), which tells the server whether or not to enable RTP/RTCP-over-TCP streaming for each newly created
  "ProxyServerMediaSession".
  (Thanks to Bob Bischan for bringing this to our attention.)

2013.10.08:
- Updated "RTSPServerWithREGISTERProxying" to automatically generate a proxy stream name "registeredProxyStream-N"
  for the URL of each proxy stream that's created using the "REGISTER" or "REGISTER_REMOTE" command, rather than trying to use
  the suffix in the back-end stream URL - in case that's excessively complex (e.g., with parameters).

2013.10.07:
- The "LIVE555 Proxy Server" was not properly passing the 'verbosity level' (specified by the "-v" or "-V" option)
  to a new "ProxyServerMediaSubsession" object created as a result of a RTSP "REGISTER" command (handled if the "-R"
  option was given).  To fix this we needed to update the signature of "RTSPServerWithREGISTERProxying::createNew()"
  to take a new "verbosityLevelForProxying" optional parameter.
  (Thanks to Bob Bischan for bringing this to our attention.)

2013.10.03:
- Updated the "socketJoinGroup()" and "socketJoinGroupSSM()" functions to set the IP_MULTICAST_ALL socket option to 0,
  if that option is defined.  (The P_MULTICAST_ALL socket option is defined in modern versions of Linux to overcome
  a bug in the Linux kernel's default behavior.  This option, when set to 0, ensures that we receive only packets that were sent
  to the specified IP multicast address, even if some other process on the same system has joined a different multicast group
  with the same port number.)
  (Thanks to Michel Promonet for the suggestion.)
- Made some changes to the server implementation of RTSP-over-HTTP to potentially make it possible for web browsers to
  use this.

2013.10.02:
- Updated the change made in version 2013.09.27 to ensure that we don't have any background reading still taking
  place on the datagram sockets that we close when we switch to RTP/RTCP-over-TCP streaming.

2013.10.01:
- Made a minor fix to the previous release (to stop the proxy server from attempting to send a "PAUSE" command
  immediately after it receives a RTCP "BYE" from the back-end server).

2013.09.30:
- Updated the way that the "ProxyServerMediaSession" code handles a RTCP "BYE" packet from the back-end server.  It now
  treats this as if the connection to the back-end server had closed, by reopening the connection, and sending another "DESCRIBE".
  (Thanks to Yogev Cohen for the suggestion.)

2013.09.27:
- When a RTSP client requests RTP/RTCP over TCP streaming, we now close the datagram sockets that would have otherwise been
  used for receiving RTP and RTCP, because we know that they're no longer needed.

2013.09.18:
- Fixed an obscure bug - triggered by the "ProxyServerMediaSession" code - that could sometimes cause a previously deleted object
  to be accessed.  (Thanks to Yogev Cohen for reporting this.)

2013.09.11:
- It turns out that the fix that we'd made back in version 2012.10.04 to (try to) prevent RTCP reports from being sent over
  TCP connections prematurely was incomplete.  (It had prevented only "SR" reports - not "RR" - from being sent.)
  This version fixes this.  (Thanks to Stanley Biggs for reporting this.)
- Made an update to the previous change to the way that "openRTSP" handles the "-Q" option.

2013.09.08:
- Made a minor change to the way that "openRTSP" handles the "-Q" option (to address an issue that someone reported).

2013.09.07:
- Improved the bugfix that was in the previous release (because that fix still had a deleted object being accessed).

2013.08.31:
- Fixed an obscure bug in the "RTPInterface" implementation that could cause a "SocketDescriptor" object to get deleted twice
  (when receiving RTP-over-TCP).  (Thanks to Subhankar Saha for reporting this bug, and tracking down the cause.)

2013.08.28:
- Updated "H264VideoStreamFramer" to Improve (the accuracy and efficiency of) the test whether the current NAL unit
  ends an 'access unit'.  (This also fixes a bug reported by Philipp Schrader.)
- Fixed a minor memory leak in "RTCPInstance::setSpecificRRHandler()" (if this function is called more than once).
  (Thanks to Eric Pronovost for the report.)

2013.08.16:
- Fixed a bug in "MatroskaFileParser" that was causing it not to parse 8-byte float values properly.
- Added parsing of some previously unknown Matroska ids.
- Corrected two diagnostic output messages in "MatroskaFileParser".
- Corrected a disgnostic output message in "testWAVAudioStreamer" (if the audio is converted to u-law).

2013.08.15:
- Fixed the implementation of the 'trimTrailingZeros' option in "base64Decode()" so that it trims only extraneous 'padding' bytes.
  (Thanks to Chris Richardson for the suggestion.)
- Changed the way that some "RTSPServer" command implementations call "setRTSPResponse()", to make it more obvious to developers
  how a subclass could reimplement these commands.

2013.08.05:
- Updated the "openRTSP" client application so that we no longer wait for a response to the "TEARDOWN" command if we were
  signaled (via "kill -HUP") to end.  (This ensures that the program will end even if the server hangs on the "TEARDOWN" command.)
- Fixed a tiny memory leak that can sometimes occur when destroying a "RTSPClient" object.  (Thanks to Michel Promonet.)

2013.07.31:
- Changed "setServerRequestAlternativeByteHandler()" to be a static member function of "RTPInterface", because it doesn't
  need to refer to a specific "RTPInterface" object.  Also added a corresponding function
  "clearServerRequestAlternativeByteHandler()" (that just sets the 'handler' and 'client data' parameters to NULL).
  We also make sure that we call this latter function in the "RTSPClient" destructor.  This fixes the *real* bug that
  Andrey Shvyrkin reported.)
- Added a new "-C" option to "openRTSP" to specify that the RTSP client should ask for a multicast stream, if the server doesn't
  already specify one.  (Note that not all servers will support this.)  (Thanks to Michel Promonet for the suggestion.)

2013.07.30:
- Moved the call to "RTPInterface::stopNetworkReading()" from the "RTCPInstance" and "(MultiFramed)RTPSource" destructors to the
  "RTPInterface" destructor.  This means that it will also be called when a "RTPSink" is destroyed.  Even though a "RTPSink"
  doesn't actually do any 'network reading', calling "stopNetworkReading()" when it's destroyed will cause its socket to get
  deregistered properly if it's streaming RTP-over-TCP.  (This fixes a bug that was reported by Andrey Shvyrkin.)

2013.07.16:
- Fixed a problem that might cause a crash when deleting a "RTSPServer" object while a RTP-over-TCP stream was
  currently taking place.  (Thanks to Piers Hawksley for reporting this.)
- Fixed a minor memory leak in "RTSPClient" when it sends a HTTP "GET" command for RTSP-over-HTTP tunneling.
  (Thanks to Jianliang Zhang for reporting this.)
- Moved the "parseScaleHeader()" function to "RTSPCommon.hh", to make it available to subclasses of "RTSPServer".
  (Thanks to Michel Promonet for the suggestion.)

2013.07.03:
- Fixed some minor memory leaks in "RTPInterface".  (Thanks to Chris Richardson.)

2013.06.30:
- Fixed an obscure bug in our implementation of RTP/RTCP-over-TCP that could cause a "select()" error (due to an already-closed
  socket being checked) if the TCP connection was not closed cleanly.
  (Thanks to Andrey for reporting and helping track this bug down.)
- Updated the implementation of "RTSPServer"s handling of RTSP-over-HTTP to allow for the possibility of the input Base64
  command string containing whitespace.  We now strip this whitespace (if any) before calling "base64Decode()" on the data.
  (Thanks to Chris Richardson for this suggestion.)
- Added a new, alternative version of "base64Decode()" that takes the length of the input string as a parameter.
  This saves a call to "strlen()" if we already know the length of the input string.
- In "MPEG2TransportStreamMultiplexor.cpp", we rename the constants "PAT_FREQUENCY" and "PMT_FREQUENCY" to the more accurate
  names "PAT_PERIOD" and "PMT_PERIOD".

2013.06.18:
- We now support two new, custom RTSP requests: "REGISTER" and "REGISTER_REMOTE".  These RTSP requests are currently non-standard;
  however, we will be submitting an IETF Internet-Draft document that describes them.
  These requests make it possible for a server (or some 3rd party) to 'advertise' a RTSP stream (given by a "rtsp://" URL) to
  a RTSP client application, or to a proxy server.  The client application - or proxy server - can then start accessing this
  RTSP stream, as it normally would.  However, as a special feature (if the request name was "REGISTER" and not "REGISTER_REMOTE"),
  the client application or proxy server gets to reuse the TCP connection that was used to send the "REGISTER" request.
  This can be useful if the server is behind a firewall or NAT, but the client application (or proxy server) is on
  the public Internet.
  To send a "REGISTER" request (for an existing stream, described by a "ServerMediaSession" object that was added to a "RTSPServer"
      object), call the new member function
	   "RTSPServer::registerStream()"
      specifying the remote client (or proxy server)'s name or IP address, and port number.
  To create a simple server that accepts incoming "REGISTER" (or "REGISTER_REMOTE") requests, and then creates a new "RTSPClient"
      object to handle the "rtsp://" URL specified by each such incoming request, create a
	 "HandlerServerForREGISTERCommand"
      object, by calling "HandlerServerForREGISTERCommand::createNew()" (see "liveMedia/include/RTSPClient.hh").
      (For an illustration of this, note how we implement the new '-R' command-line option for the "openRTSP" application.)
  To create a proxy server that automatically accepts incoming "REGISTER" (or "REGISTER_REMOTE") requests, and proxies the
      "rtsp://" URL specified by each such incoming request, create a
         "RTSPServerWithREGISTERProxying"
      rather than a usual "RTSPServer".
      (For an illustration of this, note how we implement the new '-R' command-line option for the "LIVE555 Proxy Server".)
- Added a new command-line option '-R' to the "LIVE555 Proxy Server" application.  This option tells the server to accept incoming
  "REGISTER" (or "REGISTER_REMOTE") requests - telling the server about a new stream to proxy.  This also allows a 'back-end'
  server to "REGISTER" one or more of its streams with the proxy server - with the proxy server then getting to reuse
  the TCP connection that the server had used to contact the proxy server.  (This can be useful if the 'back-end' server is behind
  a firewall or NAT, with the proy server being on the public Internet; in this case, you may also wish to use the "-t" option,
  telling the proxy server to also request RTP-over-TCP streaming from the back-end server.)
  Note also that if you give the '-R' option to the "LIVE555 Proxy Server", then you no longer need to specify any back-end
  "rtsp://" URL(s) on the command line (though you still may do this).
- Added a new command-line option '-R' (or '-R <port-num>') to the "openRTSP" RTSP client demo application.
  This option - which can be given instead of a "rtsp://" URL - tells "openRTSP" to wait - on the specified port number - for
  an incoming "REGISTER" or "REGISTER_REMOTE" request, announcing a "rtsp://" URL.  When it receives such a request, it opens and
  streams from the specified "rtsp://" URL, as normal.
  (If <port-num> is omitted from the '-R' option, then "openRTSP" will choose (and display) its own port number.)
- Some RTSP clients apparently periodically send an "OPTIONS" request - with a "Session:" id - to indicate client liveness.
  This is of dubious legality (and these clients should really be sending RTCP "RR"s anyway), but we now recognize such requests
  as indicating client 'liveness'.  (Thanks to Chris Richardson for the suggestion.)

2013.06.14:
- Updated the constructor to "RTSPClient" (and its subclasses - in particular "ProxyRTSPClient") to add a
  'socket number to server' parameter.  This socket number (if >=0) is the socket of an existing TCP connection to the
  server.  This allows you to create a RTSP client object from an existing TCP connection.  (If this is done, the supplied
  "rtsp://" URL must point to the server that's at the endpoint of the TCP connection.)
  The "RTSPClient::createNew()" function also takes a 'socket number to server' parameter, but this has a default value of -1,
  so existing code that creates "RTSPClient"s using only the "createNew()" function will not need to change.
- Fixed a very minor bug (that would, in practice, likely never get triggered) in the "H264VideoStreamParser" code.
  (Thanks to Julien Vary for the report.)

2013.06.06:
- Removed a "#define DEBUG 1" that had accidentally been left in "RTSPServer.cpp".  (Thanks to Warren Young for noting this.)

2013.05.30:
- Support for the old, deprecated 'synchronous' "RTSPClient" interface has now been completely removed.  Developers have had
  three years now to upgrade to using the asynchronous "RTSPClient" interface.
- We temporarily disabled the RTCP "BYE"-sending change that we made in version 2013.04.23, because that doesn't work correctly
  for multiple clients that are streaming from the same data source (i.e., if "reuseFirstSource" is True).
  (This means that once again, for now, RTCP "BYE"s will not get sent when "closeAllClientSessionsForServerMediaSession()" or
  "deleteServerMediaSession()" is called.  However, this will get fixed in some future release.)
  (Thanks to Subhankar Saha for noting this.)
- We now recogize the "width" and "height" parameters in "a=fmtp:" SDP lines.  These parameters are non-standard, but
  are sometimes used to specify the video width and/or height.  (Thanks to Claes Erlandsson.)
- Added "protected:" "setRTSPResponse()" function shortcuts to "RTSPClientSession", so that subclasses of "RTSPClientSession"
  can call them, if desired.
  (Thanks to Scott Taylor for the suggestion.)
- Changed the definition of "Boolean" (for newer Windows compilers) from a #define to a typedef.
- Moved "BitVector.hh" to the liveMedia "include" directory, so that applications can use the "BitVector" class, if desired.
- Removed <cr> characters that were at the end of each line of "config.armlinux".
- Began adding support for a new, custom "REGISTER" (server->client) RTSP command.  This is not finished, so don't use it yet.

2013.04.30:
- The bugfix in the previous version was incomplete.  This should fix it for real.

2013.04.29:
- Fixed a bug that was introduced in version 2013.04.21 when we added an optimization for handling RTP-over-TCP channels.
  (Sometimes a "SocketDescriptor" structure might have been accessed just after it was deleted.)

2013.04.23:
- Make sure that the "RTSPServer" sends a RTCP "BYE" whenever a "ServerMediaSubsession" object is deleted.  In particular,
  a RTCP "BYE" will now be sent (for each subsession) whenever "closeAllClientSessionsForServerMediaSession()" or
  "deleteServerMediaSession()" is called.
- Fixed a bug that would sometimes cause a proxy RTSP server to send invalid RTCP reports to front-end clients.

2013.04.22:
- Fixed a bug in the support for decoding '%<hex><hex>' sequences defined in version 2013.03.31
- Updated the #ifdef in "Boolean.hh" to allow Windows developers to use our "Boolean" type even if "bool" is defined.
  (To do this, define "USE_LIVE555_BOOLEAN" on the command line.)

2013.04.21:
- Fixed a bug in "MultiFramedRTPSource" that could cause a buffer data structure to be accessed after deletion in rare
  circumstances (if a RTP-over-TCP read failed).  (This may fix a problem reported by Jeff Shanab.)
- Modified the way that the "RTPInterface" code handles the reading and processing of RTP-over-TCP channels, to perform better
  in the case when we are not handling all subsessions of a RTSP stream.  (Thanks to Colin Caughie for this suggestion.)
- Updated the "MPEG2TransportStreamMultiplexor::doGetNextFrame()" implementation to occasionally complete delivery
  to its downstream object by returning to the event loop, rather than by calling "FramedSource;:afterGetting()" directly.
  This eliminates the possibility of stack overflow caused by excessively large input frames.
  (Thanks to Markus Schumann for bringing this issue to our attention.)

2013.04.16:
- Added a #define to the "testRTSPClient" code to specify that the application requests, by default, RTP/UDP streaming.
  If you wish, you can easily change this to request RTP-over-TCP streaming.
- Made "RTPSource::curPacketRTPTimestamp()" "private:", to make it clear that receiving (client) code never needs to see
  RTP timestamps, because the RTP timestamp <-> presentation time translation is done automatically by our software.
- Moved some "RTPSink" member functions from "public:" to "protected:", because they're not intended to be used outside
  this class (or by the RTCP implementation).
- Updated the "RTPInterface" code to ensure that the socket hash table is always deleted when it's empty, to further satisfy
  memory-leak obsessive people.
- Made some minor changes to the "ProxyServerMediaSession" code to avoid some compiler warnings.

2013.04.08:
- Some systems needed to #include <ctype.h> in "RTSPCommon.cpp" to compile "isdigit()", used by the code that we added in
  version 2013.03.31.  (Thanks to Michel Promonet for noting this.)

2013.04.06:
- Updated the change to the proxying code that we made in version 2013.04.04.  By default, we now *never* send "GET_PARAMETER"
  as our 'liveness indicator' command, because some IP cameras seem to crash whenever they receive "GET_PARAMETER".
  (The old code that sent "GET_PARAMETER" is still there, but #ifdef'd out, in case anyone wants to send "GET_PARAMETER".)
- Increased "OutPacketBuffer::maxSize" in the "live555ProxyServer" application to 100,000 bytes, to accommodate some camera servers
  that send ridiculously large frames.  (Note, however, that if the back-end network (from the proxy to clients) has any significant
  packet loss, then these ridiculously large frames might not end up getting delivered to clients.  Instead, you should fix your
  back-end server to not send frames this large.)
- Updated the "RTPReceptionStats" code (in "liveMedia/RTPSource.cpp") to eliminate the possible use of some uninitialized variables
  (if a RTCP "RR" report is sent before we have received any RTP packets).  (Thanks to Michel Promonet for noting this.)

2013.04.05:
- Updated the "RTSPClient" implementation of "GET_PARAMETER" to handle response stringss that don't begin with the parameter name.
  In this case, we return the entire result string.

2013.04.04:
- Because at least one IP camera out there seems to crash whenever it receives a "GET_PARAMETER" command, even though it
  reported - in response to our earlier "OPTIONS" command - that it supported "GET_PARAMETER", we updated the
  "ProxyServerMediaSession" code to send "GET_PARAMETER" as a 'liveness' command only if the server earlier reported
  (in the "SETUP" response's "Session:" header) a non-zero "timeout" parameter.  (Thanks to Roman Gaufman for demonstrating
  such a buggy server.)

2013.04.01:
- Our "ProxyServerMediaSession" code can now proxy JPEG video RTP streams.  (It does so by copying the raw JPEG/RTP payloads from
  a "SimpleRTPSource" to a "SimpleRTPSink", without interpreting the JPEG-specific header fields at all.  We also had to add
  a hack for 'copying' the RTP 'M' bit as well.)
- Some minor changes to eliminate some compiler warnings.

2013.03.31:
- Added support for decoding '%<hex><hex>' sequences if they exist in RTSP URL stream names.  (This allows media server file
  names to contain spaces, or non-ASCII UTF-8 characters, for example.)  (Thanks to Warren Young for proposing this.)
- Our "ProxyServerMediaSession" code currently does not support the proxying of JPEG video or AMR audio streams
  (because the data output by the "RTPSource" object is not in a form that can be fed directly into the corresponding
  "RTPSink" object).  This may be fixed sometime in the future, but, in the meantime, we output an error message
  (when in 'verbose' output mode) if we try to proxy such streams.

2013.03.23:
- Updated our RTSP server implementation so that we send an initial RTCP "SR" packet before sending the first RTP packet.
  This will make it likely (though still not certain) that the receiver will immediately start getting RTCP-synchronized
  presentation times.
  (Note that client application code must still allow for the possibility of initial presentation times not being RTCP-synchronized,
  in case they don't receive this initial "SR" packet (or in case they are streaming from a server other than this one).)
- Updated the "RTSPClient" NAT 'hole punching' hack that we made in version 2012.02.03 so that it also sends dummy packets
  on the RTCP port, as well as the RTP port.  This increases the chance that clients that are behind a NAT will receive the
  initial RTCP "SR" packet that we noted above.
- The RTSP server modification that we made in version 2013.02.27 (to better support "PLAY" requests with no "Range:" header)
  had a bug computing the current 'normal play time' if more than one such consecutive "PLAY" requests were received.
  This is now fixed.  (Thanks to 'kingaceck' for reporting this.)

2013.03.07:
- The bugfix that we made in version 2013.02.11 was accidentally backed out in version 2013.02.27.  We restore it here.
- Fixed a bug that could cause problems if a server streamed from the same Matroska file more than once.
  (Thanks to Sebastien Escudier for noting this.)
- Fixed a couple of cases where the "testRTSPClient" and "openRTSP" applications were not delete[]ing the "resultString"
  in RTSP response handler functions.  (This caused a minor memory leak, although only in situations where RTSP commands failed.)

2013.02.27:
- When the RTSP server receives a "PLAY" request with no "Range:" header, it now includes a "Range:" header in its response,
  using the stream's current 'normal play time' as the start time.  This allows receiving clients to correctly compute
  'normal play time' after such a request (e.g., after PLAYing following a PAUSE).
  (Thanks to Sebastien Escudier for raising this issue.)
  To implement this, we added a new virtual function "getCurrentNPT()" to "ServerMediaSubsession" (and subclasses).
- Fixed "RTSPClient" to properly handle "SETUP" responses that (erroneously) do not contain a "Transport:" header.
  (Thanks to Eric Huertel for noting this.)
- Changed the destructors of "AVIFileSink" and "QuickTimeFileSink" to delete chained data structures iteratively,
  rather than recursively, to avoid possible stack overflow if we these chains are very long.
  (Thanks to Anton Chmelev for this suggestion.)
- Removed some unused member fields from a few classes.

2013.02.11:
- Fixed an obscure bug in the way that "RTSPClient" handles some responses.  (Thanks to Michel Promonet for finding this.)

2013.02.05:
- Fixed an obscure bug in "MultiFramedRTPSource": When such a source is 'stopped', we need to make sure that any pending delivery
  to the downstream object has also been unscheduled.  (Thanks for Claes Erlandsson for helping to track this down.)
- Updated "liveMedia/include/InputFile.hh" to reflect the fact that WinCE - like other versions of Windows - supposedly does not
  support treating open files as "select()"able sockets.  (Thanks to Simon Roehrl.)
- Updated "config.iphoneos" and "config.iphone-simulator" to update "IOS_VERSION" to 6.1

2013.01.25:
- Added a fix to "StreamReplica::doStopGettingFrames()" so that ot doesn't try to 'deactivate' a replica that hasn't yet been
  activated.  (Thanks to Bruno Abreu.)

2013.01.23:
- Added a hack to "StreamReplicator" to handle the case of a replica being deleted
  while it's in the process of having a frame delivered to it.
  (Thanks to Bruno Abreu.)
- Made a minor fix to the way that "FileSink" reacts to any error that it gets when writing its target file.
  (We also made the "continuePlaying()" function "protected:".)  (Thanks to Bruno Abreu.)

2013.01.22:
- Improved the way that proxy RTSP servers respond to a back-end stream signaling its closure (by sending a RTCP "BYE").
  (This also fixes a bug (and abort) that some people were seeing in this situation.)

2013.01.21:
- Fixed a bug in the "RTSPServer" request parsing code that we changed in version 2013.01.18.  (It wasn't properly parsing
  RTSP requests that ended with the "CSeq:" header.)  (Thanks to Rafael Gil for noting this.)
- The "LIVE555 Media Server" (currently just the source code version, not the pre-built binary versions)
  now support streaming from ".vob" files (i.e., VOB files, containing MPEG-2 video and AC-3 audio).

2013.01.19:
Made several changes to the implementation of "ProxyServerMediaSession" (and related classes):
- Fixed a bug in the way that it was resetting its state whenever it needs to close, then reopen its connection
  with the back-end server.
- We now reset the connection whenever the "OPTIONS" command returns any error, not just when we lose the RTSP connection.
- We change the periodic 'liveness' command that we send to the back-end server.  When possible, we send a (empty) "GET_PARAMETER"
  command, rather than "OPTIONS" (because some servers erroneously use "GET_PARAMETER" - rather than RTCP "RR" packets - to
  indicate client liveness).
- Added some more debugging (verbose) output.

2013.01.18:
- Changed the "RTSPServer" request parsing code so that it passes only the first incoming request's header portion to
  the call to "parseRTSPRequestString()".  Previously, it was passing the entire input buffer, which could cause
  "parseRTSPRequestString()" to return incorrect results if more than one request was pipelined, and the first request
  did not include a "Content-Length:" header, but some subsequent pipelined request did.
- More changes to some Makefile definitions that were apparently breaking in some versions of Windows.

2013.01.15:
- Updated the "RTSPClient" parsing code to ignore "RTP-Info:" headers (in "PLAY" responses) that don't define *both* the
  "seq" and "rtptime" parameters.  We need both of those parameters to be present in order for the "RTP-Info:" header to be useful
  to us.
- Some minor changes to the library "Makefile.head" and "Makefile.tail" files.
- Made a minor fix to the debugging output from the "testRTSPClient" demo application, to display the 'seconds' part of
  presentation times as "int"s, rather than "unsigned".

2013.01.05:
- Fixed some Makefile definitions what were apparently breaking in some versions of Windows.
  (Thanks to Claes Erlandsson for noting this.)
- Added a new virtual function hack - "specialClientUserAccessCheck() - to allow subclasses of "RTSPServer" to perform an
  additional access check on a user, after the username has already been validated using digest authentication.
  (This is in addition to the existing "specialClientAccessCheck()" hack that allows subclasses to do an additional acces check
  *before* digest authentication.)  (Thanks to Chris Richardson for the suggestion.)

2013.01.04:
- Fixed a bug in the RTSP server handling of "RTSP-over-HTTP" that could cause a crash in unusual circumstances.
  (Thanks to Chris Richardson for noting this.)
- Removed a bogus, unnecessary binary file that had somehow found its way into the "liveMedia" directory.

2013.01.03:
- Fixed a bug in our RTSP server's implementation of RTSP-over-HTTP that could cause a "Bad file descriptor" select() error
  to occur when a RTSP-over-HTTP session gets closed.  (Thanks to Rafael Gil for bringing this to our attention.)
- Updated the "BasicTaskScheduler" implementation to print out some extra debugging information if the "select()" call failed
  (e.g., with a "Bad file descriptor" error).  Because these errors are typically caused by an invalid socket number
  (i.e., a socket number that had already been closed) being used in "select()", we now print out the sockets that were
  being used in the "select()" call.

2012.12.24:
- Argh! Really fixed this time.

2012.12.23:
- Fixed the "install" Makefile target in the previous release (stupid Makefile syntax!).

2012.12.22:
- In the previous release, we had forgotten to add an "install:" target to the top-level Makefile.  (Thanks to Benjamin Drung for
  noting this.)

2012.12.21:
- Updated the support for building shared libraries - first introduced in version 2012.12.15 - to add an "install:" Makefile
  rule, and to make symbolic links to alternative names of the shared libraries.  (Thanks to Benjamin Drung.)

2012.12.18:
- Updated the "MatroskaFile" implementation to signal that the input file has been parsed even if the specified file name
  doesn't exist.  (In particular, this stops the "testOnDemandRTSPServer" demo application from blocking if the test files
  "test.mkv" or "test.webm" do not exist.  I don't know why this wasn't caught before...)

2012.12.15:
- Added an experimental new configuration file "config.linux-with-shared-libraries", for building for Linux with shared libraries
  only (i.e., no static libraries).  (Thanks to Benjamin Drung for proposing and assisting with this.)

2012.11.30:
- Fixed another bug in the "ProxyServerMediaSession" destructor: We need to delete the "MediaSession" object before we delete
  the "ProxyRTSPClient" object, in case the "MediaSession"s RTP/RTCP objects have an 'alternative byte handler' reference back
  to the "ProxyRTSPClient".  (Thanks to Sergei Bastrakov for reporting this.)

2012.11.29:
- Fixed a bug in "ProxyServerMediaSession" that would be triggered if a "RTSPServer" that uses such an object were deleted.
  (This also fixes a memory leak that would occur if a proxy's back-end server failed, but then restarted.)
  (Thanks to Sergei Bastrakov for reporting this bug.)

2012.11.28:
- Fixed a bug in "ProxyRTSPClient" that was causing some background tasks to not be halted when a "ProxyServerMediaSession" is
  deleted.  (Thanks to Sergei Bastrakov for bringing this to our attention.)

2012.11.22:
- Fixed a minor memory leak in "RTSPServer::closeAllClientSessionsForServerMediaSession()".  (Thanks to Matt Norman.)
- Fixed an issue that caused "sapWatch" to fail to compile for at least one version of Debian.  (Thanks to Alessio Treglia.)

2012.11.17:
- Fixed a bug in "ProxyRTSPClient".  When we discover that the connection to the back-end server has failed, we need to
  close any existing front-end RTSP client connections before we delete all of the "ProxyServerMediaSubsession"s.
  The signature to "ProxyServerMediaSession::createNew()" has also changed; it now takes a pointer to the "RTSPServer" as parameter.

2012.11.16:
- Added a new configuration file "config.iphone-simulator" for building for Apple's iPhone simulator (running on a Mac).
  (Note that we already had a configuration file "config.iphoneos" for building for the iPhone (or iPad) itself.)
- Updated "SIPClient" and the "playSIP" demo application with a fix (suggested by Frederic Nadeau) to make "playSIP" send
  RTCP "RR" packets back to the correct address.  This is a hack, and should be fixed by upgrading "SIPClient" to make it
  asyncronous (like "RTSPClient").

2012.11.08:
- Updated the (Windows-only) implementation of "gettimeofday()" to be 'thread safe' (and also work correctly in WinCE).
  (Thanks to Simon Roehrl.)
- Made a change to the implementation of "RTPSink::convertToRTPTimestamp()" to overcome a possible integer overflow problem.
  (Thanks to Simon Roehrl for noting this issue.)

2012.11.05:
- Made the "ProxyServerMediaSubsession" implementation a little more robust, by making sure that an object doesn't try to handle
  reception of a RTCP "BYE" after it's been deleted.
- Updated "config.iphoneos" to update "LINK_OPTS" to fix a linking problem (and also update "IOS_VERSION" to 6.0).
  (Thanks to Chris Ballinger.)

2012.10.24:
- Made the "addNewInputSource()" function of "MPEG2TransportStreamFromESSource" "protected:", to allow subclasses of
  "MPEG2TransportStreamFromESSource" to support adding new kinds of input stream, if desired.

2012.10.22:
- Updated "AVIFileSink" to add an index at the end.  (Thanks to "qiuchangyong qiuchangyong".)
- Updated the "MediaSession" implementation to accept "audio/OPUS" as a valid RTP payload format (which can be implemented
  using a "SimpleRTPSource").

2012.10.21:
- Fixed a bug in "PresentationTimeSessionNormalizer".  (Thanks to Bruno Marchand.)

2012.10.19:
- Fixed a bug in the way that our RTSP proxy implementation reinitializes itself after reestablishing connectivity with the
  back-end server.  It now deletes all "ProxyServerMediaSubsession"s, so that they will get reestablished when the response
  to the new "DESCRIBE" command comes back.  (This also makes it possible for the back-end stream to restart with different
  parameters.)  (Thanks to Aashish Kaushik for reporting this problem.)
- Moved the definition of the "PresentationTimeSessionNormalizer" and "PresentationTimeSubessionNormalizer" classes to
  "include/ProxyServerMediaSession.hh", so that developers can use them if they wish.  (Note, though, that those classes were
  intended for use only within our "ProxyServerMediaSession" (etc.) implementation, so don't complain if they don't do what you
  want.)
- Added a "#ifndef RTSP_BUFFER_SIZE"/"#endif" around the definition of RTSP_BUFFER_SIZE in "liveMedia/include/RTSPServer.hh",
  to allow this definition to be changed at compile time if desired.  (Suggestion from Matt Schuckmann.)

2012.10.18:
- Updated the "RTPInterface" RTP/RTCP-over-TCP handling code to properly handle the case where we know about the
  'stream channel id' for an embedded RTP or RTCP packet, but haven't yet registered a read handler function for it.
  (This can occur in rare situations if our server starts sending RTP or RTCP packets before sending the RTSP "PLAY" response,
  and the client (e.g., VLC) doesn't start reading from its input source until after it receives the "PLAY" response.)
  (Thanks to Ralf Globisch for noticing this issue, and proposing a solution.)

2012.10.17:
- Maved "RTSPClient::reset()" from "private:" to "protected:", and made "ProxyRTSPClient::reset()" call "RTSPClient::reset()"
  (at the end).  This causes the "ProxyRTSPClient" object to properly get reset (and, in particular, the 'session id' to get
  reset) if we have to restart a connection with a back-end server.
  (Thanks to Aashish Kaushik for reporting this issue.)
- Made the implementation of ending RTP/RTCP-over-TCP a little more efficient (by implementing each packet send using 2 calls
  to "send()", rather than 4).

2012.10.16:
- Updated our implementation of sending RTP/RTCP-over-TCP so that if the initial '$' send() succeeds, we force the send()s of
  the remaining data (the 'stream channel id', packet size, and packet data) to succeed, even if it means that we have to
  temporarily block by doing so.  This makes servers whose RTP/RTCP-over-TCP streams exceed the capacity of the network
  handle this a bit more gracefully, avoiding the possibility that 'incomplete' packet data will appear on receivers'
  TCP connections.

2012.10.12:
- We backed out the change that we made (back in version 2012.06.12) to ignore SDP-specified port numbers for unicast streams,
  because this broke our SIP client (which has no way of telling the server that it wants to use a different port number).
  Now, if you want to ignore SDP-specified port numbers, you'll need to compile "MediaSession.cpp" with the definition
  -DIGNORE_UNICAST_SDP_PORTS=1

2012.10.11:
- Fixed a bug that would cause "playSIP" to crash if run without a username/password parameter.  (Thanks to Sam Machin.)
- Added "#include <errno.h>" to "groupsock/include/NetCommon.h", to reduce the likelihood of compiler warning messages
  when compiling for Windows.  (Thanks to Bruno Marchand for the suggestion.)
- Updated "StreamReplicator" to call "stopPlaying()" on the upstream source if/when all replicas have closed.
  (Thanks to Bruno Marchand for the suggestion.)

2012.10.04:
- Updated the fix that we made in version 2012.09.11: When a "RTSPClient" requests RTP/RTCP-over-TCP streaming, it is
  prepared to handle incoming RTP/RTCP-over-TCP data as soon as it receives the "SETUP" response, but doesn't start sending
  RTCP "RR" packets until after it receives the "PLAY" response.

2012.10.01:
- Made the code for receiving RTP/RTSP-over-TCP streams a little more robust.  (Thanks to Rex Wolf.)
- Made a minor fix to the way that "SIPClient" sends a "BYE".  (Thanks to Frederic Nadeau.)
- Made the "fDestinationsHashTable" field in "OnDemandServerMediaSubsession" "protected:" rather than "private:", to allow
  subclasses to access it, if desired.  (They should only do lookups in the table, though.)
  (Thanks to Matt Schuckmann for this suggestion.)

2012.09.27:
- Fixed the RTSP proxying implementation so that the presentation times of relayed frames are properly aligned with
  'wall clock' time, so that receivers will get these presentation times accurately (using RTCP).  We also defer RTCP "SR"
  reports on the outgoing ('front-end') streams until the incomong streams' presentation times have been RTCP-synchronized
  (because until then, the incoming presentation times are not accurate).
  (Thanks to Bruno Marchand for bringing this issue to our attention.)
- Updated the "ProxyRTSPClient" implementation so that if the connection to the back-end server fails, it tries to restore the
  connection by sending a new "DESCRIBE" command. This is more reliable (especially for back-end servers that use authentication.)
  (Thanks to Lei Wu for this suggestion.)
- Added optional Boolean parameters to the "createNew()" functions for the "MPEG4VideoStreamDiscreteFramer",
  "MPEG1or2VideoStreamDiscreteFramer", and "DVVideoStreamFramer" filters, to specify that the input frames' presentation
  times should be passed through unmodified.  (The default behavior for these filters is to modify at least some presentation
  times.)  This parameter is necessary for our RTSP proxying implementation (because it wants to relay frames' presentation times
  unmodified.)
- Updated "RTSPClient.hh" to move the "fCSeq" and "fCurrentAuthenticator" from "private:" to "protected:".
  This makes it possible for subclasses to implement variants of RTSP commands.
  (Thanks to Matt Schuckmann for this suggestion.)
- Updated the "MediaSession" implementation to accept "audio/ILBC" as a valid RTP payload format (which can be implemented
  using a "SimpleRTPSource").
- Added a "usesTCPTransport()" Boolean function to "RTSPServer::RTSPClientSession" so that subclasses can easily know whether
  (at least one subsession of) the session is being streamed via TCP.
- Removed a small piece of unnecessary code from the "testRTSPClient" code.  (Thanks to Anton Zvyagintsev for noticing this.)

2012.09.13:
- Minor bugfix in "RTSPClient" when implementing RTSP-over-HTTP: Don't enqueue "POST" request records (after sending the command),
  because we don't expect a response to this request.  (Thanks to Daniel Peng.)
- Print an error message (in "RTCP.cpp" and "MultiFramedRTPSource.cpp") when we hit a buffer limit when reading
  a (RTCP or RTP) packet over TCP.
- Increased MAX_PACKET_SIZE in "MultiFramedRTPSource.cpp" (for reading incoming packets) to 20000, because of a report
  of a server sending packets larger than 10000 bytes.
- Added support for receiving the "application/VND.ONVIF.METADATA" RTP payload format.  This is just a XML document packed into
  simple RTP packets (but with the "M" bit used to indicate the end of the document).
  (Thanks to Michel Promonet for this suggestion.)
- Updated the meaning of the "doNormalMBitRule" parameter to "SimpleRTPSource::createNew()" and "SimpleRTPSink::createNew()".
  It now applies for all media types other than "audio".  (Previously, it applied only to "video".)
  This change makes it possible to use "doNormalMBitRule" = True for the "application/VND.ONVIF.METADATA" RTP payload format.

2012.09.12:
- Fixed a bug in the URL parsing code in "RTSPCommon.cpp" that would cause parsing to fail for RTSP urls that don't have any
  slashes after the "host" or "host:port" part.  (Such URLs would usually be used only for operations - such as "OPTIONS" - on the
  entire server.)  (Thanks to Tamas Vincze for reporting this.)

2012.09.11:
- Fixed a problem whereby a "RTSPClient" streaming RTP/RTCP-over-TCP would sometimes send its first RTCP "RR" packet before
  the server had had a chance to handle the "PLAY" command.  This caused a problem for our server, because it would receive
  the RTCP "RR" packet over the RTSP command connection, before it knew how to deal with this.
  (Thanks to Ralf Globisch for reporting this issue.)
- Fixed a bug in "MPEG2TransportStreamFromESSource": Its destructor wasn't stopping the delivery from upstream objects.
  (Thanks to Jing Li for reporting this.)
- Updated "AVIFileSink" to add a 'start code' before each H.264 NAL unit that it writes to the file.
  (Thanks to 'giuchangyong' for the suggestion.)
- Added "-DTIME_BASE=int" to the COMPILE_OPTS for each of the "config.macosx*" configuration files (because someone reported
  that it seems to be necessary for them).

2012.09.07:
- The socket error handling improvement that we made back in version 2012.07.24 inadvertently broke a workaround that we had
  made (much earlier) for a bug in Windows.  This caused problems for some Windows clients that receive via RTP-over-TCP.
  This version should fix those problems.
- Modified the implementation of "MatroskaFileParser::parseEBMLVal_float()" to remove some aliasing that might cause
  some compilers to generate incorrect code when optimizing.  (Thanks to 'Owen' for noting this issue.)

2012.09.06:
- Fixed a bug in "RTSPServer" that would cause incorrect RTSP responses to be sent back in response to "PAUSE"
  (and some "GET_PARAMETER" and "SET_PARAMETER") commands.  (Thanks to Matthias Meding for reporting this.)

2012.08.31:
- Fixed a bug in "WAVAudioFileServerMediaSubsession" that could cause problems when seeking within very large WAV files.
  (Thanks to 'Raph' for noting this problem.)
- Fixed a bug in "VorbisAudioRTPSink".  (Thanks to Owen Wallace for reporting this.)

2012.08.30:
- Fixed an obscure bug in the "MatroskaFile" constructor if the specified input file does not exist.
  Also, fixed an obscure bug in "RTSPServer" if it receives a malformed request.
  (Thanks to Kevin Kuo for reporting this.)

2012.08.29:
- The private->protected change to "fPreferredFrameSize" in the previous release was done in the wrong header file.  It should
  have been done in "WAVAudioFileSource.hh", not "ByteStreamFileSource.hh".

2012.08.28:
- Added a new 'filter' class "EndianSwap24", for byte-swapping 24-bit values between little and big-endian.
- Updated "WAVAudioFileServerMediaSubsession" to support the streaming of 24-bit (or 20-bit) WAV audio files.
  (Thanks to 'Raph' for this suggestion, and for providing an example file.)
- Brought the "testWAVAudioStreamer" demo application up-to-date, by increasing the variety of WAV file formats that it can support.
- Added a "-U <absolute-start-time-string>" option to "openRTSP", to support seeking by 'absolute' time (if, of course, the
  server supports this).  (Thanks to Michel Promonet for this suggestion.)
- Updated the RTSP server implementation so that, by default, if a client tries to "PLAY" a stream using an 'absolute' time,
  then the server will refuse by sending back a regular (NPT) "Range:" header instead.  (If you want the server to handle
  seeking by 'absolute' time, then you need to reimplement "ServerMediaSession::seekStream()" or
  "OnDemandServerMediaSubsession::seekStreamSource()".)
- Made the "fPreferredFrameSize" variable in "ByteStreamFileSource.hh" "protected:" rather than "private:", to allow subclasses
  of "WAVAudioFileSource" to change its value, if desired.

2012.08.20:
- Added optional RTSP server and RTSP client support for streams that are indexed by 'absolute' time - i.e., using strings
  of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
  - For RTSP server developers (i.e., developers who have their own subclasses of "OnDemandServerMediaSubsession"):
    - To automatically have your streams advertised (in their SDP description) as supporting absolute time indexing,
      reimplement (in your subclass) the virtual function:
        "virtual void getAbsoluteTimeRange(char*& absStartTime, char*& absEndTime) const;"
	  (see "liveMedia/include/ServerMediaSession.hh").
      This function should set "absStartTime" to a string value (of the form noted above), and should set "absEndTime" to
      a corresponding string value, if the stream has an end time, otherwise NULL.
    - To implement seeking by absolute time, reimplement (in your subclass) the virtual function:
        "virtual void seekStreamSource(FramedSource* inputSource, char*& absStart, char*& absEnd);"
	  (see "liveMedia/include/OnDemandServerMediaSubsession.hh").
      "absStart" (and "absEnd", if non-NULL) are strings (of the form noted above).
      (The function *may* change them, to make them more accurate.)
  - For RTSP client developers:
    - To check whether a stream supports indexing by absolute time,
      call "MediaSession::absStartTime()" or "MediaSubsession::absStartTime()", and check whether this (string) value is non-NULL.
    - To play a stream, indexed by absolute time, call one of the new, alternative forms of "RTSPClient::sendPlayCommand()"
      that take "absStartTime" (and optional "absEndTime") strings as parameters.
      (see "liveMedia/include/RTSPClient.hh")
- Updated the "BasicTaskScheduler" class to make the 'maxSchedulerGranularity' time (in microseconds) an optional parameter to
  "BasicTaskScheduler::createNew()".  This parameter (default value: 10000 (i.e., 10 ms)) specifies the maximum time that we
  wait (in "select()") before returning to the event loop to handle non-socket or non-timer-based events,
  such as 'triggered events'.  You can change this is you wish (but only if you know what you're doing!),
  or set it to 0, to specify no such maximum time.
  (You should set it to 0 only if you know that you will not be using 'event triggers'.)

2012.08.17:
- Fixed the RTSP server support for MPEG Transport Stream 'trick play' to stream the correct amount of data when a stream
  'duration' is specified for fast forward or reverse play.  (Thanks to Michael Boom for reporting this bug.)
- Made some changes to "liveMedia/include/RTSPServer.hh" to make old compilers happy.

2012.08.12:
- Modified the change to the definitions of EINTR, EAGAIN, EINPROGRESS, EDOULDBLOCK in "groupsock/include/NetCommon.h"
  (made in the previous release) to ensure that they are always mapped to the "WSA*" equivalents.

2012.08.08
- A major update to the RTSP server implementation.  A single RTSP client session (i.e, the streaming of one particular stream
  to one particular client) can now use an arbitrary number (>=1) of TCP connections.
  For more details, see:
      http://lists.live555.com/pipermail/live-devel/2012-July/015571.html
- Put #ifndef/#endif around the (Windows-only) definitions of EINTR, EAGAIN, EINPROGRESS, EDOULDBLOCK in
  "groupsock/include/NetCommon.h", in case they are already defined by the system's header files.
  (Thanks to Hyunho Kim for bringing this to our attention.)
- Made a small modification to "H264VideoStreamFramer.cpp" to eliminate some 'unused variable' compiler warnings
  (when compiling without DEBUG defined).

2012.07.26:
- Made the "RTPInterface" code for handling RTP/RTCP-over-TCP a little more robust.
- Updated the "WAVAudioFileSource" WAV-file parser to skip any extraneous 'chunks' between RIFF and FORMAT.
  (Thanks to Sid Price for suggesting this.)

2012.07.24:
- Updated the "RTPInterface" code to better handle socket errors when reading from TCP sockets.  (Thanks to Barry Stump for
  bringing this issue to our attention.)
- Made sure that some code that calls "fileno()" for doing asynchronous file reading never gets compiled under Windows
  (where all file reading is synchronous), because some versions of Windows redefine the result type of "fileno()".
  (Thanks to Sid Price for bringing this to our attention.)
- A member variable of "ProxyServerMediaSession" was not being initialized correctly (causing a "valgrind" error).
  (Thanks to Jesus Leganes for reporting this.)
- Removed some unnecessary "abort()" calls from the code.

2012.07.18:
- Fixed a minor bug in the "H264VideoStreamParser" code that could sometimes cause a very short trailing NAL unit to not
  get parsed properly.  (Thanks to John McNamara for reporting this issue.)
- Made some changes to RTSP header parsing, to make it more robust.  (Thanks to Lionel Orry for the suggestion.)

2012.07.14:
- Updated the RTSP server code to properly handle "Range:" headers of the form "npt=-<endtime>".
  (Thanks to Michael Boom for bringing this to our attention.)

2012.07.06:
- Modified the implementation of "ServerMediaSession::generateSDPDescription()" to ignore (skip over) subsessions that use
  medium or codec names that we don't understand.  (Previously, subsessions like this would cause a NULL SDP description to be
  returned.)  This allows "ProxyServerMediaSession" to properly handle sessions like this.  (Thanks to Kiran Thakkar for
  alerting us to an example that illustrated this problem.)

2012.07.03:
- Moved "ProxyRTSPClient" - which had previously been hidden inside the implementation of "ProxyServerMediaSession" - to
  the "ProxyServerMediaSession.hh" header file, in case developers want to subclass it.  We also define a new virtual function
  "ProxyServerMediaSession::createNewProxyRTSPClient()" whichh can be reimplemented to create such subclasses.
  (Thanks to Jesus Leganes for this suggestion.)
- Made "RTSPClient::sendRequest()" a virtual function, and made it "protected:" rather than "private:", in case subclasses
  want to redefine it (e.g., to do additional functions such as logging).
  (Thanks to Jesus Leganes for this suggestion.)

2012.06.26:
- Moved the code for ignoring the SIGPIPE signal to "RTSPCommon.cpp", and made it a function.  We now call this function from
  the "RTSPClient" code, as well as the "RTSPServer" code.  (Thanks to Barry Stump for the suggestion.)
- Added a new public member flag "describeCompletedFlag" to "ProxyServerMediaSession".  This can be used as a 'watch variable'
  in a call to "doEventLoop()", to 'block' in the event loop until the back-end "DESCRIBE" command sent for a newly-created
  "ProxyServerMediaSession" has completed.

2012.06.23:
- Fixed a bug in "H264VideoStreamParser" that affected the "testH264VideoToTransportStream" demo application.
  (Thanks to John McNamara for helping to debug the problem.)
- We no longer set a non-default "FileSink" buffer size in the "testH264VideoToTransportStream" demo application, because the
  "FileSink" is fed by a "MPEG2TransportStreamFromESSource", ehich delivers only one 188-byte Transport Stream packet at a time.

2012.06.17:
- Fixed a bug in "HTTP Live Streaming" server support.  (Thanks to Daniel Wang for reporting the problem.)
- Updated the implementation of "triggerEvent()" in "BasicTaskScheduler" to avoid a possible race condition (if "triggerEvent()"
  is called from a non-LIVE555 thread).  (Thanks to Matthais Doering for noting this issue.)
- Updated the "ProxyServerMediaSession" code to ensure that all front-end "RTCPInstance" objects are created with non-zero
  bandwidth estimates.

2012.06.12:
- If a SDP description specifies a port number for a unicast stream, then we still choose an ephemeral client port number,
  just as we would if the SDP description had not specified a port number (the usual case). Renato Mauro reports that some Sony
  network cameras do this; this change lets the client choose a different port number (which is useful if one host is receiving
  from more than one such camera at once).
- Fixed some minor bugs with Matroska file parsing.  (Thanks to Petr Novak.)
- A field in "RTPTransmissionStats" was not being initialized in the constructor.  (Thanks to Michel Promonet for noting this.)
- Updated "UsageEnvironment/include/Boolean.hh" to use the 'bool' type defined for "MSVC++ 8.0, Visual Studio 2005 and higher",
  if that development environment is being used.  Also, fixed a few places in the code where we were using boolean types
  incorrectly.  (Thanks to Nikolai Vorontsov for these suggestions.)

2012.05.17:
- Changed the implementation of "RTSPServer::removeServerMediaSession(char const* streamName)" to not
  call "lookupServerMediaSession()", in case that (virtual) function has been overridden in a subclass to do something different.
  Now we just call the hash table 'remove' function directly.  (Thanks to Bruno Abreu for bringing this to our attention.)
- Updated the "config.iphoneos" configuration file.  (Developers may need to change the definition of "IOS_VERSION", however.)
- Added "#include <ctype.h>" to "MPEG4GenericRTPSink.cpp", because some systems apparently need this to define "tolower()".
  (Thanks to Michel Promonet for noting this.)

2012.05.11:
- Really fixed the bug in the implementation of "StreamReplicator::deleteReplica()" that I was supposed to have fixed in
  the previous revision.  (Thanks to Bruno Abreu for setting us straight.)
- Fixed the signature of "MultiFramedRTPSink::curFragmentationOffset()" to return an "unsigned" rather than a "Boolean".
  (Thanks to Nikolai Vorontsov for noticing this.)

2012.05.03:
- Fixed the "testReplicator" demo application code to actually do what it claims - transmit one replica stream via UDP,
  while writing the other replica stream to a file.
  (We had accidentally omitted the line that transmits one replica stream via UDP.)
- Fixed a bug in the implementation of "StreamReplicator::deleteReplica()".  (Thanks to Bruno Abreu for reporting this.)
- Fixed a bug in "RTSPServer" that would occur if you tried to add two different "ServerMediaSession" objects using the same
  stream name.  (Thanks to Vadim Kosarev for noting this.)
- Added "-DXLOCALE_NOT_USED=1" to "config.cygwin" (on the suggestion of Warren Young).

2012.04.27:
- Modified the "RTSPClient" implementation to be more careful about not accessing the "RTSPClient" object's state after
  calling "handleRequestError()", in case the handler function handles the error by deleting the "RTSPClient" object itself.
  (The "testRTSPClient" demo application does this, for example.)  (Thanks to Gord Umphrey for reporting a problem,
  and to Guy Bonneau for pointing out this as a possible cause.)
- Fixed a typo in the "Makefile.tail" file for the "mediaServer" directory.  (Thanks to 'Nix Lo' for the report.)
- Removed an unneeded "typedef" from "Locale.hh"; it was causing compiler warnings.  (Thanks to Barry Stump and Warren Young
  for reporting this.)

2012.04.26:
- Added a debugging error message to various "*Sink" classes, to warn when the "numTruncatedBytes" parameter in the 'after getting'
  function is >0.  When this happens, you need to increase the "bufferSize" parameter in the appropriate "*::createNew()" call.
- Changed the buffer size used by the "testH264VideoToTransportStream" demo application from 10000 to 100000, because input H.264
  NAL units are often larger than 10000 bytes.
- Changed the default 'buffer size' parameter in "H264VideoFileSink::createNew()" from 10000 to 100000, because input H.264
  NAL units are often larger than 10000 bytes.
- Changed the signature of "AuxHandlerFunc()" (used by the "setAuxilliaryReadHandler()" hack) to pass "packetSize" by reference
  instead of by value.  (Thanks to Keary Griffin for this suggestion; he was using this mechanism to implement SRTP.)
- Changed the way that we disable the handling of SIGPIPE signals in "RTSPServer.cpp" (so that the server doesn't get killed
  when clients, running on the same host, get killed).  (Phillipe Clavel reported that the old method
  - "signal(SIGPIPE, SIG_IGN);" - wasn't working properly on Mac OS X.)

2012.04.21:
- Made some cosmetic changes to the "live555ProxyServer" code, prior to its official announcement.

2012.04.18:
- Added "ProxyServerMediaSession" - a subclass of "ServerMediaSession" that can be used to create a (unicast) RTSP servers
  that acts as a 'proxy' for another (unicast or multicast) RTSP/RTP stream.
- Added a new application "live555ProxyServer", and included it in a new subdirectory "proxyServer/" in the
  "LIVE555 Streaming Media" distribution.  This application - which uses the new "ProxyServerMediaSession" class - acts as
  a unicast RTSP server 'proxy' for one or more 'back end' (unicast or multicast) RTSP streams, specified on the command line.
- Fixed an obscure bug in RTP/RTCP-over-TCP reading.  (Thanks to Shiyong Zhang for reporting this.)
- Changed the definition of "Boolean" in "UsageEnvironment/include/Boolean.hh" from "unsigned" to "unsigned char",
  to avoid an apparent conflict when compiling for Mac OS X (and also to save some space).
  (Thanks to Barry Stump for the suggestion.)
- Madea a minor change to "RTPInterface" to accommodate RTSP clients that call 'startPlaying()' on a "RTPSource" object prior
  to the handling of a RTSP "SETUP" response.  (This change affected only RTP-over-TCP streams.)
- Changed the "RTSPClient" "fVerbosityLevel" field from "private:" to "protected:", to allow subclasses to use it in their own
  debugging output.
- Made some changes to "GroupsockHelper.cpp" that were allegedly needed for compilation for 'Android'.
- Made a minor change to "NetCommon.h" that allegedly improves/fixes compilation for some version of Windoze.
- Removed the "MP3HTTPSource" class; it was old code that shouldn't be used.

2012.04.04:
- Made some changes to "H264VideoRTPSink" and "T140TextRTPSink" to correct some minor bugs.
- Improved the way that "H264VideoStreamDIscreteFramer" detects and reports NAL units that erroneously begin with
  MPEG 'start codes'.
- Fixed a bug in the way in which the "ServerMediaSession" reference count is updated by "RTSPServer::RTSPClientSession" objects.
  (Thanks to Daniel Liu for reporting this.)
- Modified the "MultiFramedRTPSource" code to optimize the case when the 'packet reordering threshold' has been set to 0.
  (Doing this is not recommended, however, unless you're only going to be on networks where packet reordering is extremely
  unlikely.)
- Added a new member function "reassignInputSource()" to "FramedFilter", to allow a filter's input source to be changed.
- Changed some comments in "testRTSPClient.cpp" to make it clearer that if you (for whatever reason) choose to reclaim the
  "UsageEnvironment" and "TaskScheduler" objects, then you can do so only *outside* the event loop (e.g., in "main()", after
  "doEventLoop()" has returned).

2012.03.22:
- Fixed a bug in the way that "MPEG1or2DemuxedServerMediaSubsession" creates "AC3AudioStreamFramer" objects.
  This was causing errors in the way that AC3 audio tracks in VOB files were being streamed by "testOnDemandRTSPServer".
  (Thanks to "Rustam" for reporting this issue.)
- Corrected a potentially misleading error message in "RTSPClient".  (Thanks to Sebastien Escudier for reporting this.)

2012.03.20:
- Fixed a bug in the "RTSPServer" implementation that could prevent it from properly handling 'pipelined' requests
  (such as "SETUP" requests) from a single client.
- Updated the "RTSPClient" code to (when "verbosityLevel" > 0) output a warning message when the server 'skips over' one of our
  earlier requests.  If this happens, it indicates a bug in the server (perhaps a bug in the way that the server handles
  pipelined requests - such as the bug that we just fixed in our own server here).
- Fixed a bug in the "RTSPClient" code that prevented it from properly handling 'pipelined' responses from a single server.
- Fixed a bug in the Matroska file parsing code that could cause an infinite loop when streaming from a multi-track file.
- Updated the "RTSPServer" code to no longer attempt to seek, or set the scale of, a subsession within a multi-subsession
  stream.  (Instead, these operations can be done only on the 'aggregate' session.)
- Added a new member function "addFilter()" to "MediaSubsession".  This allows RTP receivers to add a filter (such as a 'framer')
  in front of the subsession's "readSource()", changing "readSource()" to be this new filter.
- Fixed a minor bug in "ServerMediaSession" that was causing it to generate incomplete default 'info' and 'description' strings
  in SDP descriptions.
- Fixed a minor bug in "T140TextRTPSink": Make sure that the 'idle timer' (for delivering empty frames downstream) gets turned
  off when the input source closes.
- Fixed the testing of the "mpeg4Mode" parameter to the "MPEG4GenericRTPSink" constructor, to make it case-insensitive.
- Added new versions of "H264VideoRTPSink::createNew()" that (optionally) take SPS and PPS NAL units
  (either in raw binary form, or as a 'sprop-parameter-string') as parameters.  This is useful if you know this information in
  advance, rather than having to get it from the input 'framer' object.
- Added a new version of "H264VideoStreamFramer::setSPSandPPS()" that takes a 'sprop-parameter-string'
  (instead of the raw binary NAL units) as parameter.
- Added a new version of "MPEG4ESVideoRTPSink::createNew()" that takes stream configuration information as a parameter.  This is
  useful if you know this information in advance, and don't want to rely upon the sink getting this from the input 'framer' object.
- Added a member function "MPEG4VideoStreamFramer::setConfigInfo()" that can be used to (optionally) set stream configuration
  information, without requiring the framer to read it from the input source.
- Added a new version of "VorbisAudioRTPSink::createNew()" that takes a Base-64-encoded 'configuration' string - rather than
  raw configuration headers - as parameter.
- Added a minor hack to "MediaSubsession" to allow ADU-ized MP3 frames to optionally be received 'as is',
  instead of always converting them back to MP3 frames for delivery.
- Added a new member function "ServerMediaSession::numSubsessions()" to return the number of "ServerMediaSubsessions" that have
  been added to the "ServerMediaSession".
- Changed the signature of "base64Decode()" to make its string argument "char const*" instead of "char*" (for extra type safety).

2012.02.29:
- We no longer define RTSPCLIENT_SYNCHRONOUS_INTERFACE by default.  Consequently, the old, now-deprecated 'synchronous' "RTSPClient"
  interface will no longer be available, by default.  If you still want this, however, you can get it by "#define"ing
  RTSPCLIENT_SYNCHRONOUS_INTERFACE before "RTSPClient.hh" gets included the first time.
- Modified the 'multicast loopback' mechanism for getting our own IP address to check the source address of the received
  multicast packet, to make sure that it's valid (e.g., not 127.0.0.1).  (Thanks to Stefan Spurling for this suggestion.)
- Updated "MediaSubsession::initiate()" to better handle the (relatively rare) case of UDP-only (i.e., non-RTP) streams that
  specify a port number in the SDP description.  In this case, because RTP is not being used, we accept the provided port number
  even if it's odd, and we don't bother creating a RTCP 'groupsock'.  (Thanks to John Orr for this suggestion.)
2014-12-13 09:20:02 +00:00

192 lines
7.7 KiB
Text
Raw Blame History

@comment $NetBSD: PLIST,v 1.8 2014/12/13 09:20:02 wiz Exp $
include/BasicUsageEnvironment/BasicHashTable.hh
include/BasicUsageEnvironment/BasicUsageEnvironment.hh
include/BasicUsageEnvironment/BasicUsageEnvironment0.hh
include/BasicUsageEnvironment/BasicUsageEnvironment_version.hh
include/BasicUsageEnvironment/DelayQueue.hh
include/BasicUsageEnvironment/HandlerSet.hh
include/UsageEnvironment/Boolean.hh
include/UsageEnvironment/HashTable.hh
include/UsageEnvironment/UsageEnvironment.hh
include/UsageEnvironment/UsageEnvironment_version.hh
include/UsageEnvironment/strDup.hh
include/groupsock/GroupEId.hh
include/groupsock/Groupsock.hh
include/groupsock/GroupsockHelper.hh
include/groupsock/IOHandlers.hh
include/groupsock/NetAddress.hh
include/groupsock/NetCommon.h
include/groupsock/NetInterface.hh
include/groupsock/TunnelEncaps.hh
include/groupsock/groupsock_version.hh
include/liveMedia/AC3AudioFileServerMediaSubsession.hh
include/liveMedia/AC3AudioRTPSink.hh
include/liveMedia/AC3AudioRTPSource.hh
include/liveMedia/AC3AudioStreamFramer.hh
include/liveMedia/ADTSAudioFileServerMediaSubsession.hh
include/liveMedia/ADTSAudioFileSource.hh
include/liveMedia/AMRAudioFileServerMediaSubsession.hh
include/liveMedia/AMRAudioFileSink.hh
include/liveMedia/AMRAudioFileSource.hh
include/liveMedia/AMRAudioRTPSink.hh
include/liveMedia/AMRAudioRTPSource.hh
include/liveMedia/AMRAudioSource.hh
include/liveMedia/AVIFileSink.hh
include/liveMedia/AudioInputDevice.hh
include/liveMedia/AudioRTPSink.hh
include/liveMedia/Base64.hh
include/liveMedia/BasicUDPSink.hh
include/liveMedia/BasicUDPSource.hh
include/liveMedia/BitVector.hh
include/liveMedia/ByteStreamFileSource.hh
include/liveMedia/ByteStreamMemoryBufferSource.hh
include/liveMedia/ByteStreamMultiFileSource.hh
include/liveMedia/DVVideoFileServerMediaSubsession.hh
include/liveMedia/DVVideoRTPSink.hh
include/liveMedia/DVVideoRTPSource.hh
include/liveMedia/DVVideoStreamFramer.hh
include/liveMedia/DarwinInjector.hh
include/liveMedia/DeviceSource.hh
include/liveMedia/DigestAuthentication.hh
include/liveMedia/FileServerMediaSubsession.hh
include/liveMedia/FileSink.hh
include/liveMedia/FramedFileSource.hh
include/liveMedia/FramedFilter.hh
include/liveMedia/FramedSource.hh
include/liveMedia/GSMAudioRTPSink.hh
include/liveMedia/H261VideoRTPSource.hh
include/liveMedia/H263plusVideoFileServerMediaSubsession.hh
include/liveMedia/H263plusVideoRTPSink.hh
include/liveMedia/H263plusVideoRTPSource.hh
include/liveMedia/H263plusVideoStreamFramer.hh
include/liveMedia/H264VideoFileServerMediaSubsession.hh
include/liveMedia/H264VideoFileSink.hh
include/liveMedia/H264VideoRTPSink.hh
include/liveMedia/H264VideoRTPSource.hh
include/liveMedia/H264VideoStreamDiscreteFramer.hh
include/liveMedia/H264VideoStreamFramer.hh
include/liveMedia/H264or5VideoFileSink.hh
include/liveMedia/H264or5VideoRTPSink.hh
include/liveMedia/H264or5VideoStreamDiscreteFramer.hh
include/liveMedia/H264or5VideoStreamFramer.hh
include/liveMedia/H265VideoFileServerMediaSubsession.hh
include/liveMedia/H265VideoFileSink.hh
include/liveMedia/H265VideoRTPSink.hh
include/liveMedia/H265VideoRTPSource.hh
include/liveMedia/H265VideoStreamDiscreteFramer.hh
include/liveMedia/H265VideoStreamFramer.hh
include/liveMedia/InputFile.hh
include/liveMedia/JPEGVideoRTPSink.hh
include/liveMedia/JPEGVideoRTPSource.hh
include/liveMedia/JPEGVideoSource.hh
include/liveMedia/Locale.hh
include/liveMedia/MP3ADU.hh
include/liveMedia/MP3ADURTPSink.hh
include/liveMedia/MP3ADURTPSource.hh
include/liveMedia/MP3ADUTranscoder.hh
include/liveMedia/MP3ADUinterleaving.hh
include/liveMedia/MP3AudioFileServerMediaSubsession.hh
include/liveMedia/MP3FileSource.hh
include/liveMedia/MP3Transcoder.hh
include/liveMedia/MPEG1or2AudioRTPSink.hh
include/liveMedia/MPEG1or2AudioRTPSource.hh
include/liveMedia/MPEG1or2AudioStreamFramer.hh
include/liveMedia/MPEG1or2Demux.hh
include/liveMedia/MPEG1or2DemuxedElementaryStream.hh
include/liveMedia/MPEG1or2DemuxedServerMediaSubsession.hh
include/liveMedia/MPEG1or2FileServerDemux.hh
include/liveMedia/MPEG1or2VideoFileServerMediaSubsession.hh
include/liveMedia/MPEG1or2VideoRTPSink.hh
include/liveMedia/MPEG1or2VideoRTPSource.hh
include/liveMedia/MPEG1or2VideoStreamDiscreteFramer.hh
include/liveMedia/MPEG1or2VideoStreamFramer.hh
include/liveMedia/MPEG2IndexFromTransportStream.hh
include/liveMedia/MPEG2TransportFileServerMediaSubsession.hh
include/liveMedia/MPEG2TransportStreamFramer.hh
include/liveMedia/MPEG2TransportStreamFromESSource.hh
include/liveMedia/MPEG2TransportStreamFromPESSource.hh
include/liveMedia/MPEG2TransportStreamIndexFile.hh
include/liveMedia/MPEG2TransportStreamMultiplexor.hh
include/liveMedia/MPEG2TransportStreamTrickModeFilter.hh
include/liveMedia/MPEG2TransportUDPServerMediaSubsession.hh
include/liveMedia/MPEG4ESVideoRTPSink.hh
include/liveMedia/MPEG4ESVideoRTPSource.hh
include/liveMedia/MPEG4GenericRTPSink.hh
include/liveMedia/MPEG4GenericRTPSource.hh
include/liveMedia/MPEG4LATMAudioRTPSink.hh
include/liveMedia/MPEG4LATMAudioRTPSource.hh
include/liveMedia/MPEG4VideoFileServerMediaSubsession.hh
include/liveMedia/MPEG4VideoStreamDiscreteFramer.hh
include/liveMedia/MPEG4VideoStreamFramer.hh
include/liveMedia/MPEGVideoStreamFramer.hh
include/liveMedia/MatroskaFile.hh
include/liveMedia/MatroskaFileServerDemux.hh
include/liveMedia/Media.hh
include/liveMedia/MediaSession.hh
include/liveMedia/MediaSink.hh
include/liveMedia/MediaSource.hh
include/liveMedia/MultiFramedRTPSink.hh
include/liveMedia/MultiFramedRTPSource.hh
include/liveMedia/OggFile.hh
include/liveMedia/OggFileServerDemux.hh
include/liveMedia/OggFileSink.hh
include/liveMedia/OnDemandServerMediaSubsession.hh
include/liveMedia/OutputFile.hh
include/liveMedia/PassiveServerMediaSubsession.hh
include/liveMedia/ProxyServerMediaSession.hh
include/liveMedia/QCELPAudioRTPSource.hh
include/liveMedia/QuickTimeFileSink.hh
include/liveMedia/QuickTimeGenericRTPSource.hh
include/liveMedia/RTCP.hh
include/liveMedia/RTPInterface.hh
include/liveMedia/RTPSink.hh
include/liveMedia/RTPSource.hh
include/liveMedia/RTSPClient.hh
include/liveMedia/RTSPCommon.hh
include/liveMedia/RTSPRegisterSender.hh
include/liveMedia/RTSPServer.hh
include/liveMedia/RTSPServerSupportingHTTPStreaming.hh
include/liveMedia/SIPClient.hh
include/liveMedia/ServerMediaSession.hh
include/liveMedia/SimpleRTPSink.hh
include/liveMedia/SimpleRTPSource.hh
include/liveMedia/StreamReplicator.hh
include/liveMedia/T140TextRTPSink.hh
include/liveMedia/TCPStreamSink.hh
include/liveMedia/TextRTPSink.hh
include/liveMedia/TheoraVideoRTPSink.hh
include/liveMedia/TheoraVideoRTPSource.hh
include/liveMedia/VP8VideoRTPSink.hh
include/liveMedia/VP8VideoRTPSource.hh
include/liveMedia/VP9VideoRTPSink.hh
include/liveMedia/VP9VideoRTPSource.hh
include/liveMedia/VideoRTPSink.hh
include/liveMedia/VorbisAudioRTPSink.hh
include/liveMedia/VorbisAudioRTPSource.hh
include/liveMedia/WAVAudioFileServerMediaSubsession.hh
include/liveMedia/WAVAudioFileSource.hh
include/liveMedia/liveMedia.hh
include/liveMedia/liveMedia_version.hh
include/liveMedia/ourMD5.hh
include/liveMedia/uLawAudioFilter.hh
lib/libBasicUsageEnvironment.la
lib/libUsageEnvironment.la
lib/libgroupsock.la
lib/libliveMedia.la
share/examples/liblive/openRTSP
share/examples/liblive/playSIP
share/examples/liblive/sapWatch
share/examples/liblive/testAMRAudioStreamer
share/examples/liblive/testMP3Receiver
share/examples/liblive/testMP3Streamer
share/examples/liblive/testMPEG1or2AudioVideoStreamer
share/examples/liblive/testMPEG1or2ProgramToTransportStream
share/examples/liblive/testMPEG1or2Splitter
share/examples/liblive/testMPEG1or2VideoReceiver
share/examples/liblive/testMPEG1or2VideoStreamer
share/examples/liblive/testMPEG2TransportStreamer
share/examples/liblive/testMPEG4VideoStreamer
share/examples/liblive/testOnDemandRTSPServer
share/examples/liblive/testRelay
share/examples/liblive/testWAVAudioStreamer
share/examples/liblive/vobStreamer
Reference in a new issue View git blame Copy permalink