Merge commit '8075c3d8bb1f6aade0cc7c5c40db9bc1bcd84cab'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 12 Mar 2014 02:16:21 +0000 (03:16 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 12 Mar 2014 02:18:12 +0000 (03:18 +0100)
* commit '8075c3d8bb1f6aade0cc7c5c40db9bc1bcd84cab':
  http: Add support reading ICY metadata

Conflicts:
doc/protocols.texi
libavformat/http.c

See: a92fbe16f2dc118c0d3adc222484268831388648
See: 636273d3d4a8c42f51832e8bf83e566e875916bf
Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/protocols.texi
libavformat/http.c

diff --combined doc/protocols.texi
@@@ -1,10 -1,10 +1,10 @@@
  @chapter Protocols
  @c man begin PROTOCOLS
  
 -Protocols are configured elements in Libav which allow to access
 -resources which require the use of a particular protocol.
 +Protocols are configured elements in FFmpeg that enable access to
 +resources that require specific protocols.
  
 -When you configure your Libav build, all the supported protocols are
 +When you configure your FFmpeg build, all the supported protocols are
  enabled by default. You can list all available ones using the
  configure option "--list-protocols".
  
@@@ -14,51 -14,11 +14,51 @@@ option "--enable-protocol=@var{PROTOCOL
  particular protocol using the option
  "--disable-protocol=@var{PROTOCOL}".
  
 -The option "-protocols" of the av* tools will display the list of
 +The option "-protocols" of the ff* tools will display the list of
  supported protocols.
  
  A description of the currently available protocols follows.
  
 +@section bluray
 +
 +Read BluRay playlist.
 +
 +The accepted options are:
 +@table @option
 +
 +@item angle
 +BluRay angle
 +
 +@item chapter
 +Start chapter (1...N)
 +
 +@item playlist
 +Playlist to read (BDMV/PLAYLIST/?????.mpls)
 +
 +@end table
 +
 +Examples:
 +
 +Read longest playlist from BluRay mounted to /mnt/bluray:
 +@example
 +bluray:/mnt/bluray
 +@end example
 +
 +Read angle 2 of playlist 4 from BluRay mounted to /mnt/bluray, start from chapter 2:
 +@example
 +-playlist 4 -angle 2 -chapter 2 bluray:/mnt/bluray
 +@end example
 +
 +@section cache
 +
 +Caching wrapper for input stream.
 +
 +Cache the input stream to temporary file. It brings seeking capability to live streams.
 +
 +@example
 +cache:@var{URL}
 +@end example
 +
  @section concat
  
  Physical concatenation protocol.
@@@ -76,114 -36,30 +76,114 @@@ resource to be concatenated, each one p
  protocol.
  
  For example to read a sequence of files @file{split1.mpeg},
 -@file{split2.mpeg}, @file{split3.mpeg} with @command{avplay} use the
 +@file{split2.mpeg}, @file{split3.mpeg} with @command{ffplay} use the
  command:
  @example
 -avplay concat:split1.mpeg\|split2.mpeg\|split3.mpeg
 +ffplay concat:split1.mpeg\|split2.mpeg\|split3.mpeg
  @end example
  
  Note that you may need to escape the character "|" which is special for
  many shells.
  
 +@section crypto
 +
 +AES-encrypted stream reading protocol.
 +
 +The accepted options are:
 +@table @option
 +@item key
 +Set the AES decryption key binary block from given hexadecimal representation.
 +
 +@item iv
 +Set the AES decryption initialization vector binary block from given hexadecimal representation.
 +@end table
 +
 +Accepted URL formats:
 +@example
 +crypto:@var{URL}
 +crypto+@var{URL}
 +@end example
 +
 +@section data
 +
 +Data in-line in the URI. See @url{http://en.wikipedia.org/wiki/Data_URI_scheme}.
 +
 +For example, to convert a GIF file given inline with @command{ffmpeg}:
 +@example
 +ffmpeg -i "data:image/gif;base64,R0lGODdhCAAIAMIEAAAAAAAA//8AAP//AP///////////////ywAAAAACAAIAAADF0gEDLojDgdGiJdJqUX02iB4E8Q9jUMkADs=" smiley.png
 +@end example
 +
  @section file
  
  File access protocol.
  
 -Allow to read from or read to a file.
 +Allow to read from or write to a file.
 +
 +A file URL can have the form:
 +@example
 +file:@var{filename}
 +@end example
 +
 +where @var{filename} is the path of the file to read.
  
 -For example to read from a file @file{input.mpeg} with @command{avconv}
 +An URL that does not have a protocol prefix will be assumed to be a
 +file URL. Depending on the build, an URL that looks like a Windows
 +path with the drive letter at the beginning will also be assumed to be
 +a file URL (usually not the case in builds for unix-like systems).
 +
 +For example to read from a file @file{input.mpeg} with @command{ffmpeg}
  use the command:
  @example
 -avconv -i file:input.mpeg output.mpeg
 +ffmpeg -i file:input.mpeg output.mpeg
 +@end example
 +
 +This protocol accepts the following options:
 +
 +@table @option
 +@item truncate
 +Truncate existing files on write, if set to 1. A value of 0 prevents
 +truncating. Default value is 1.
 +
 +@item blocksize
 +Set I/O operation maximum block size, in bytes. Default value is
 +@code{INT_MAX}, which results in not limiting the requested block size.
 +Setting this value reasonably low improves user termination request reaction
 +time, which is valuable for files on slow medium.
 +@end table
 +
 +@section ftp
 +
 +FTP (File Transfer Protocol).
 +
 +Allow to read from or write to remote resources using FTP protocol.
 +
 +Following syntax is required.
 +@example
 +ftp://[user[:password]@@]server[:port]/path/to/remote/resource.mpeg
  @end example
  
 -The av* tools default to the file protocol, that is a resource
 -specified with the name "FILE.mpeg" is interpreted as the URL
 -"file:FILE.mpeg".
 +This protocol accepts the following options.
 +
 +@table @option
 +@item timeout
 +Set timeout of socket I/O operations used by the underlying low level
 +operation. By default it is set to -1, which means that the timeout is
 +not specified.
 +
 +@item ftp-anonymous-password
 +Password used when login as anonymous user. Typically an e-mail address
 +should be used.
 +
 +@item ftp-write-seekable
 +Control seekability of connection during encoding. If set to 1 the
 +resource is supposed to be seekable, if set to 0 it is assumed not
 +to be seekable. Default value is 0.
 +@end table
 +
 +NOTE: Protocol can be used as output, but it is recommended to not do
 +it, unless special care is taken (tests, customized server configuration
 +etc.). Different FTP servers behave in different way during seek
 +operation. ff* tools may produce incomplete content due to server limitations.
  
  @section gopher
  
@@@ -213,43 -89,9 +213,43 @@@ m3u8 files
  
  HTTP (Hyper Text Transfer Protocol).
  
- This protocol accepts the following options.
+ This protocol accepts the following options:
  
  @table @option
 +@item seekable
 +Control seekability of connection. If set to 1 the resource is
 +supposed to be seekable, if set to 0 it is assumed not to be seekable,
 +if set to -1 it will try to autodetect if it is seekable. Default
 +value is -1.
 +
 +@item chunked_post
 +If set to 1 use chunked transfer-encoding for posts, default is 1.
 +
 +@item headers
 +Set custom HTTP headers, can override built in default headers. The
 +value must be a string encoding the headers.
 +
 +@item content_type
 +Force a content type.
 +
 +@item user-agent
 +Override User-Agent header. If not specified the protocol will use a
 +string describing the libavformat build.
 +
 +@item multiple_requests
 +Use persistent connections if set to 1. By default it is 0.
 +
 +@item post_data
 +Set custom HTTP post data.
 +
 +@item timeout
 +Set timeout of socket I/O operations used by the underlying low level
 +operation. By default it is set to -1, which means that the timeout is
 +not specified.
 +
 +@item mime_type
 +Set MIME type.
 +
  @item icy
  If set to 1 request ICY (SHOUTcast) metadata from the server. If the server
  supports this, the metadata has to be retrieved by the application by reading
@@@ -257,33 -99,16 +257,35 @@@ the @option{icy_metadata_headers} and @
  The default is 0.
  
  @item icy_metadata_headers
- If the server supports ICY metadata, this contains the ICY specific HTTP reply
- headers, separated with newline characters.
+ If the server supports ICY metadata, this contains the ICY-specific HTTP reply
+ headers, separated by newline characters.
  
  @item icy_metadata_packet
  If the server supports ICY metadata, and @option{icy} was set to 1, this
- contains the last non-empty metadata packet sent by the server.
+ contains the last non-empty metadata packet sent by the server. It should be
+ polled in regular intervals by applications interested in mid-stream metadata
+ updates.
 +
 +@item cookies
 +Set the cookies to be sent in future requests. The format of each cookie is the
 +same as the value of a Set-Cookie HTTP response field. Multiple cookies can be
 +delimited by a newline character.
  @end table
  
 +@subsection HTTP Cookies
 +
 +Some HTTP requests will be denied unless cookie values are passed in with the
 +request. The @option{cookies} option allows these cookies to be specified. At
 +the very least, each cookie must specify a value along with a path and domain.
 +HTTP requests that match both the domain and path will automatically include the
 +cookie value in the HTTP Cookie header field. Multiple cookies can be delimited
 +by a newline.
 +
 +The required syntax to play a stream specifying a cookie is:
 +@example
 +ffplay -cookies "nlqptid=nltid=tsn; path=/; domain=somedomain.com;" http://somedomain.com/somestream.m3u8
 +@end example
 +
  @section mmst
  
  MMS (Microsoft Media Server) protocol over TCP.
@@@ -308,10 -133,10 +310,10 @@@ be used to test muxers without writing 
  Some examples follow.
  @example
  # Write the MD5 hash of the encoded AVI file to the file output.avi.md5.
 -avconv -i input.flv -f avi -y md5:output.avi.md5
 +ffmpeg -i input.flv -f avi -y md5:output.avi.md5
  
  # Write the MD5 hash of the encoded AVI file to stdout.
 -avconv -i input.flv -f avi -y md5:
 +ffmpeg -i input.flv -f avi -y md5:
  @end example
  
  Note that some formats (typically MOV) require the output protocol to
@@@ -333,30 -158,20 +335,30 @@@ pipe (e.g. 0 for stdin, 1 for stdout, 
  is not specified, by default the stdout file descriptor will be used
  for writing, stdin for reading.
  
 -For example to read from stdin with @command{avconv}:
 +For example to read from stdin with @command{ffmpeg}:
  @example
 -cat test.wav | avconv -i pipe:0
 +cat test.wav | ffmpeg -i pipe:0
  # ...this is the same as...
 -cat test.wav | avconv -i pipe:
 +cat test.wav | ffmpeg -i pipe:
  @end example
  
 -For writing to stdout with @command{avconv}:
 +For writing to stdout with @command{ffmpeg}:
  @example
 -avconv -i test.wav -f avi pipe:1 | cat > test.avi
 +ffmpeg -i test.wav -f avi pipe:1 | cat > test.avi
  # ...this is the same as...
 -avconv -i test.wav -f avi pipe: | cat > test.avi
 +ffmpeg -i test.wav -f avi pipe: | cat > test.avi
  @end example
  
 +This protocol accepts the following options:
 +
 +@table @option
 +@item blocksize
 +Set I/O operation maximum block size, in bytes. Default value is
 +@code{INT_MAX}, which results in not limiting the requested block size.
 +Setting this value reasonably low improves user termination request reaction
 +time, which is valuable if data transmission is slow.
 +@end table
 +
  Note that some formats (typically MOV), require the output protocol to
  be seekable, so they will fail with the pipe output protocol.
  
@@@ -476,16 -291,16 +478,16 @@@ URL of the target stream. Defaults to p
  
  @end table
  
 -For example to read with @command{avplay} a multimedia resource named
 +For example to read with @command{ffplay} a multimedia resource named
  "sample" from the application "vod" from an RTMP server "myserver":
  @example
 -avplay rtmp://myserver/vod/sample
 +ffplay rtmp://myserver/vod/sample
  @end example
  
  To publish to a password protected server, passing the playpath and
  app names separately:
  @example
 -avconv -re -i <input> -f flv -rtmp_playpath some/long/path -rtmp_app long/app/name rtmp://username:password@@myserver/
 +ffmpeg -re -i <input> -f flv -rtmp_playpath some/long/path -rtmp_app long/app/name rtmp://username:password@@myserver/
  @end example
  
  @section rtmpe
@@@ -528,42 -343,6 +530,42 @@@ The Real-Time Messaging Protocol tunnel
  for streaming multimedia content within HTTPS requests to traverse
  firewalls.
  
 +@section libssh
 +
 +Secure File Transfer Protocol via libssh
 +
 +Allow to read from or write to remote resources using SFTP protocol.
 +
 +Following syntax is required.
 +
 +@example
 +sftp://[user[:password]@@]server[:port]/path/to/remote/resource.mpeg
 +@end example
 +
 +This protocol accepts the following options.
 +
 +@table @option
 +@item timeout
 +Set timeout of socket I/O operations used by the underlying low level
 +operation. By default it is set to -1, which means that the timeout
 +is not specified.
 +
 +@item truncate
 +Truncate existing files on write, if set to 1. A value of 0 prevents
 +truncating. Default value is 1.
 +
 +@item private_key
 +Specify the path of the file containing private key to use during authorization.
 +By default libssh searches for keys in the @file{~/.ssh/} directory.
 +
 +@end table
 +
 +Example: Play a file stored on remote server.
 +
 +@example
 +ffplay sftp://user:password@@server_address:22/home/user/resource.mpeg
 +@end example
 +
  @section librtmp rtmp, rtmpe, rtmps, rtmpt, rtmpte
  
  Real-Time Messaging Protocol and its variants supported through
@@@ -594,87 -373,22 +596,87 @@@ meaning as specified for the RTMP nativ
  See the librtmp manual page (man 3 librtmp) for more information.
  
  For example, to stream a file in real-time to an RTMP server using
 -@command{avconv}:
 +@command{ffmpeg}:
  @example
 -avconv -re -i myfile -f flv rtmp://myserver/live/mystream
 +ffmpeg -re -i myfile -f flv rtmp://myserver/live/mystream
  @end example
  
 -To play the same stream using @command{avplay}:
 +To play the same stream using @command{ffplay}:
  @example
 -avplay "rtmp://myserver/live/mystream live=1"
 +ffplay "rtmp://myserver/live/mystream live=1"
  @end example
  
  @section rtp
  
 -Real-Time Protocol.
 +Real-time Transport Protocol.
 +
 +The required syntax for an RTP URL is:
 +rtp://@var{hostname}[:@var{port}][?@var{option}=@var{val}...]
 +
 +@var{port} specifies the RTP port to use.
 +
 +The following URL options are supported:
 +
 +@table @option
 +
 +@item ttl=@var{n}
 +Set the TTL (Time-To-Live) value (for multicast only).
 +
 +@item rtcpport=@var{n}
 +Set the remote RTCP port to @var{n}.
 +
 +@item localrtpport=@var{n}
 +Set the local RTP port to @var{n}.
 +
 +@item localrtcpport=@var{n}'
 +Set the local RTCP port to @var{n}.
 +
 +@item pkt_size=@var{n}
 +Set max packet size (in bytes) to @var{n}.
 +
 +@item connect=0|1
 +Do a @code{connect()} on the UDP socket (if set to 1) or not (if set
 +to 0).
 +
 +@item sources=@var{ip}[,@var{ip}]
 +List allowed source IP addresses.
 +
 +@item block=@var{ip}[,@var{ip}]
 +List disallowed (blocked) source IP addresses.
 +
 +@item write_to_source=0|1
 +Send packets to the source address of the latest received packet (if
 +set to 1) or to a default remote address (if set to 0).
 +
 +@item localport=@var{n}
 +Set the local RTP port to @var{n}.
 +
 +This is a deprecated option. Instead, @option{localrtpport} should be
 +used.
 +
 +@end table
 +
 +Important notes:
 +
 +@enumerate
 +
 +@item
 +If @option{rtcpport} is not set the RTCP port will be set to the RTP
 +port value plus 1.
 +
 +@item
 +If @option{localrtpport} (the local RTP port) is not set any available
 +port will be used for the local RTP and RTCP ports.
 +
 +@item
 +If @option{localrtcpport} (the local RTCP port) is not set it will be
 +set to the the local RTP port value plus 1.
 +@end enumerate
  
  @section rtsp
  
 +Real-Time Streaming Protocol.
 +
  RTSP is not technically a protocol handler in libavformat, it is a demuxer
  and muxer. The demuxer supports both normal RTSP (with data transferred
  over RTP; this is used by e.g. Apple and Microsoft) and Real-RTSP (with
@@@ -689,22 -403,14 +691,22 @@@ The required syntax for a RTSP url is
  rtsp://@var{hostname}[:@var{port}]/@var{path}
  @end example
  
 -The following options (set on the @command{avconv}/@command{avplay} command
 -line, or set in code via @code{AVOption}s or in @code{avformat_open_input}),
 -are supported:
 +Options can be set on the @command{ffmpeg}/@command{ffplay} command
 +line, or set in code via @code{AVOption}s or in
 +@code{avformat_open_input}.
  
 -Flags for @code{rtsp_transport}:
 +The following options are supported.
  
  @table @option
 +@item initial_pause
 +Do not start playing the stream immediately if set to 1. Default value
 +is 0.
 +
 +@item rtsp_transport
 +Set RTSP trasport protocols.
  
 +It accepts the following values:
 +@table @samp
  @item udp
  Use UDP as lower transport protocol.
  
@@@ -722,56 -428,15 +724,56 @@@ passing proxies
  
  Multiple lower transport protocols may be specified, in that case they are
  tried one at a time (if the setup of one fails, the next one is tried).
 -For the muxer, only the @code{tcp} and @code{udp} options are supported.
 +For the muxer, only the @samp{tcp} and @samp{udp} options are supported.
  
 -Flags for @code{rtsp_flags}:
 +@item rtsp_flags
 +Set RTSP flags.
  
 -@table @option
 +The following values are accepted:
 +@table @samp
  @item filter_src
  Accept packets only from negotiated peer address and port.
  @item listen
  Act as a server, listening for an incoming connection.
 +@item prefer_tcp
 +Try TCP for RTP transport first, if TCP is available as RTSP RTP transport.
 +@end table
 +
 +Default value is @samp{none}.
 +
 +@item allowed_media_types
 +Set media types to accept from the server.
 +
 +The following flags are accepted:
 +@table @samp
 +@item video
 +@item audio
 +@item data
 +@end table
 +
 +By default it accepts all media types.
 +
 +@item min_port
 +Set minimum local UDP port. Default value is 5000.
 +
 +@item max_port
 +Set maximum local UDP port. Default value is 65000.
 +
 +@item timeout
 +Set maximum timeout (in seconds) to wait for incoming connections.
 +
 +A value of -1 mean infinite (default). This option implies the
 +@option{rtsp_flags} set to @samp{listen}.
 +
 +@item reorder_queue_size
 +Set number of packets to buffer for handling of reordered packets.
 +
 +@item stimeout
 +Set socket TCP I/O timeout in micro seconds.
 +
 +@item user-agent
 +Override User-Agent header. If not specified, it default to the
 +libavformat identifier string.
  @end table
  
  When receiving data over UDP, the demuxer tries to reorder received packets
  can be disabled by setting the maximum demuxing delay to zero (via
  the @code{max_delay} field of AVFormatContext).
  
 -When watching multi-bitrate Real-RTSP streams with @command{avplay}, the
 +When watching multi-bitrate Real-RTSP streams with @command{ffplay}, the
  streams to display can be chosen with @code{-vst} @var{n} and
  @code{-ast} @var{n} for video and audio respectively, and can be switched
  on the fly by pressing @code{v} and @code{a}.
  
 -Example command lines:
 +@subsection Examples
  
 -To watch a stream over UDP, with a max reordering delay of 0.5 seconds:
 +The following examples all make use of the @command{ffplay} and
 +@command{ffmpeg} tools.
  
 +@itemize
 +@item
 +Watch a stream over UDP, with a max reordering delay of 0.5 seconds:
  @example
 -avplay -max_delay 500000 -rtsp_transport udp rtsp://server/video.mp4
 +ffplay -max_delay 500000 -rtsp_transport udp rtsp://server/video.mp4
  @end example
  
 -To watch a stream tunneled over HTTP:
 -
 +@item
 +Watch a stream tunneled over HTTP:
  @example
 -avplay -rtsp_transport http rtsp://server/video.mp4
 +ffplay -rtsp_transport http rtsp://server/video.mp4
  @end example
  
 -To send a stream in realtime to a RTSP server, for others to watch:
 -
 +@item
 +Send a stream in realtime to a RTSP server, for others to watch:
  @example
 -avconv -re -i @var{input} -f rtsp -muxdelay 0.1 rtsp://server/live.sdp
 +ffmpeg -re -i @var{input} -f rtsp -muxdelay 0.1 rtsp://server/live.sdp
  @end example
  
 -To receive a stream in realtime:
 -
 +@item
 +Receive a stream in realtime:
  @example
 -avconv -rtsp_flags listen -i rtsp://ownaddress/live.sdp @var{output}
 +ffmpeg -rtsp_flags listen -i rtsp://ownaddress/live.sdp @var{output}
  @end example
 +@end itemize
  
  @section sap
  
@@@ -864,19 -524,19 +866,19 @@@ Example command lines follow
  To broadcast a stream on the local subnet, for watching in VLC:
  
  @example
 -avconv -re -i @var{input} -f sap sap://224.0.0.255?same_port=1
 +ffmpeg -re -i @var{input} -f sap sap://224.0.0.255?same_port=1
  @end example
  
 -Similarly, for watching in avplay:
 +Similarly, for watching in @command{ffplay}:
  
  @example
 -avconv -re -i @var{input} -f sap sap://224.0.0.255
 +ffmpeg -re -i @var{input} -f sap sap://224.0.0.255
  @end example
  
 -And for watching in avplay, over IPv6:
 +And for watching in @command{ffplay}, over IPv6:
  
  @example
 -avconv -re -i @var{input} -f sap sap://[ff0e::1:2:3:4]
 +ffmpeg -re -i @var{input} -f sap sap://[ff0e::1:2:3:4]
  @end example
  
  @subsection Demuxer
@@@ -898,125 -558,43 +900,125 @@@ Example command lines follow
  To play back the first stream announced on the normal SAP multicast address:
  
  @example
 -avplay sap://
 +ffplay sap://
  @end example
  
  To play back the first stream announced on one the default IPv6 SAP multicast address:
  
  @example
 -avplay sap://[ff0e::2:7ffe]
 +ffplay sap://[ff0e::2:7ffe]
 +@end example
 +
 +@section sctp
 +
 +Stream Control Transmission Protocol.
 +
 +The accepted URL syntax is:
 +@example
 +sctp://@var{host}:@var{port}[?@var{options}]
  @end example
  
 +The protocol accepts the following options:
 +@table @option
 +@item listen
 +If set to any value, listen for an incoming connection. Outgoing connection is done by default.
 +
 +@item max_streams
 +Set the maximum number of streams. By default no limit is set.
 +@end table
 +
 +@section srtp
 +
 +Secure Real-time Transport Protocol.
 +
 +The accepted options are:
 +@table @option
 +@item srtp_in_suite
 +@item srtp_out_suite
 +Select input and output encoding suites.
 +
 +Supported values:
 +@table @samp
 +@item AES_CM_128_HMAC_SHA1_80
 +@item SRTP_AES128_CM_HMAC_SHA1_80
 +@item AES_CM_128_HMAC_SHA1_32
 +@item SRTP_AES128_CM_HMAC_SHA1_32
 +@end table
 +
 +@item srtp_in_params
 +@item srtp_out_params
 +Set input and output encoding parameters, which are expressed by a
 +base64-encoded representation of a binary block. The first 16 bytes of
 +this binary block are used as master key, the following 14 bytes are
 +used as master salt.
 +@end table
 +
 +@section subfile
 +
 +Virtually extract a segment of a file or another stream.
 +The underlying stream must be seekable.
 +
 +Accepted options:
 +@table @option
 +@item start
 +Start offset of the extracted segment, in bytes.
 +@item end
 +End offset of the extracted segment, in bytes.
 +@end table
 +
 +Examples:
 +
 +Extract a chapter from a DVD VOB file (start and end sectors obtained
 +externally and multiplied by 2048):
 +@example
 +subfile,,start,153391104,end,268142592,,:/media/dvd/VIDEO_TS/VTS_08_1.VOB
 +@end example
 +
 +Play an AVI file directly from a TAR archive:
 +subfile,,start,183241728,end,366490624,,:archive.tar
 +
  @section tcp
  
 -Trasmission Control Protocol.
 +Transmission Control Protocol.
  
  The required syntax for a TCP url is:
  @example
  tcp://@var{hostname}:@var{port}[?@var{options}]
  @end example
  
 +@var{options} contains a list of &-separated options of the form
 +@var{key}=@var{val}.
 +
 +The list of supported options follows.
 +
  @table @option
 +@item listen=@var{1|0}
 +Listen for an incoming connection. Default value is 0.
  
 -@item listen
 -Listen for an incoming connection
 +@item timeout=@var{microseconds}
 +Set raise error timeout, expressed in microseconds.
  
 -@example
 -avconv -i @var{input} -f @var{format} tcp://@var{hostname}:@var{port}?listen
 -avplay tcp://@var{hostname}:@var{port}
 -@end example
 +This option is only relevant in read mode: if no data arrived in more
 +than this time interval, raise error.
  
 +@item listen_timeout=@var{microseconds}
 +Set listen timeout, expressed in microseconds.
  @end table
  
 +The following example shows how to setup a listening TCP connection
 +with @command{ffmpeg}, which is then accessed with @command{ffplay}:
 +@example
 +ffmpeg -i @var{input} -f @var{format} tcp://@var{hostname}:@var{port}?listen
 +ffplay tcp://@var{hostname}:@var{port}
 +@end example
 +
  @section tls
  
  Transport Layer Security (TLS) / Secure Sockets Layer (SSL)
  
 -The required syntax for a TLS url is:
 +The required syntax for a TLS/SSL url is:
  @example
 -tls://@var{hostname}:@var{port}
 +tls://@var{hostname}:@var{port}[?@var{options}]
  @end example
  
  The following parameters can be set via command line options
  
  @table @option
  
 -@item ca_file
 +@item ca_file, cafile=@var{filename}
  A file containing certificate authority (CA) root certificates to treat
  as trusted. If the linked TLS library contains a default this might not
  need to be specified for verification to work, but not all libraries and
  setups have defaults built in.
 +The file must be in OpenSSL PEM format.
  
  @item tls_verify=@var{1|0}
  If enabled, try to verify the peer that we are communicating with.
@@@ -1042,13 -619,13 +1044,13 @@@ the host name is validated as well.
  This is disabled by default since it requires a CA database to be
  provided by the caller in many cases.
  
 -@item cert_file
 +@item cert_file, cert=@var{filename}
  A file containing a certificate to use in the handshake with the peer.
  (When operating as server, in listen mode, this is more often required
  by the peer, while client certificates only are mandated in certain
  setups.)
  
 -@item key_file
 +@item key_file, key=@var{filename}
  A file containing the private key for the certificate.
  
  @item listen=@var{1|0}
@@@ -1057,45 -634,25 +1059,45 @@@ the server role in the handshake instea
  
  @end table
  
 +Example command lines:
 +
 +To create a TLS/SSL server that serves an input stream.
 +
 +@example
 +ffmpeg -i @var{input} -f @var{format} tls://@var{hostname}:@var{port}?listen&cert=@var{server.crt}&key=@var{server.key}
 +@end example
 +
 +To play back a stream from the TLS/SSL server using @command{ffplay}:
 +
 +@example
 +ffplay tls://@var{hostname}:@var{port}
 +@end example
 +
  @section udp
  
  User Datagram Protocol.
  
 -The required syntax for a UDP url is:
 +The required syntax for an UDP URL is:
  @example
  udp://@var{hostname}:@var{port}[?@var{options}]
  @end example
  
  @var{options} contains a list of &-separated options of the form @var{key}=@var{val}.
 -Follow the list of supported options.
  
 -@table @option
 +In case threading is enabled on the system, a circular buffer is used
 +to store the incoming data, which allows one to reduce loss of data due to
 +UDP socket buffer overruns. The @var{fifo_size} and
 +@var{overrun_nonfatal} options are related to this buffer.
  
 +The list of supported options follows.
 +
 +@table @option
  @item buffer_size=@var{size}
 -set the UDP buffer size in bytes
 +Set the UDP socket buffer size in bytes. This is used both for the
 +receiving and the sending buffer size.
  
  @item localport=@var{port}
 -override the local UDP port to bind with
 +Override the local UDP port to bind with.
  
  @item localaddr=@var{addr}
  Choose the local IP address. This is useful e.g. if sending multicast
@@@ -1103,13 -660,13 +1105,13 @@@ and the host has multiple interfaces, w
  which interface to send on by specifying the IP address of that interface.
  
  @item pkt_size=@var{size}
 -set the size in bytes of UDP packets
 +Set the size in bytes of UDP packets.
  
  @item reuse=@var{1|0}
 -explicitly allow or disallow reusing UDP sockets
 +Explicitly allow or disallow reusing UDP sockets.
  
  @item ttl=@var{ttl}
 -set the time to live value (for multicast only)
 +Set the time to live value (for multicast only).
  
  @item connect=@var{1|0}
  Initialize the UDP socket with @code{connect()}. In this case, the
@@@ -1129,44 -686,24 +1131,44 @@@ specified sender IP addresses
  @item block=@var{address}[,@var{address}]
  Ignore packets sent to the multicast group from the specified
  sender IP addresses.
 +
 +@item fifo_size=@var{units}
 +Set the UDP receiving circular buffer size, expressed as a number of
 +packets with size of 188 bytes. If not specified defaults to 7*4096.
 +
 +@item overrun_nonfatal=@var{1|0}
 +Survive in case of UDP receiving circular buffer overrun. Default
 +value is 0.
 +
 +@item timeout=@var{microseconds}
 +Set raise error timeout, expressed in microseconds.
 +
 +This option is only relevant in read mode: if no data arrived in more
 +than this time interval, raise error.
  @end table
  
 -Some usage examples of the udp protocol with @command{avconv} follow.
 +@subsection Examples
  
 -To stream over UDP to a remote endpoint:
 +@itemize
 +@item
 +Use @command{ffmpeg} to stream over UDP to a remote endpoint:
  @example
 -avconv -i @var{input} -f @var{format} udp://@var{hostname}:@var{port}
 +ffmpeg -i @var{input} -f @var{format} udp://@var{hostname}:@var{port}
  @end example
  
 -To stream in mpegts format over UDP using 188 sized UDP packets, using a large input buffer:
 +@item
 +Use @command{ffmpeg} to stream in mpegts format over UDP using 188
 +sized UDP packets, using a large input buffer:
  @example
 -avconv -i @var{input} -f mpegts udp://@var{hostname}:@var{port}?pkt_size=188&buffer_size=65535
 +ffmpeg -i @var{input} -f mpegts udp://@var{hostname}:@var{port}?pkt_size=188&buffer_size=65535
  @end example
  
 -To receive over UDP from a remote endpoint:
 +@item
 +Use @command{ffmpeg} to receive over UDP from a remote endpoint:
  @example
 -avconv -i udp://[@var{multicast-address}]:@var{port}
 +ffmpeg -i udp://[@var{multicast-address}]:@var{port} ...
  @end example
 +@end itemize
  
  @section unix
  
diff --combined libavformat/http.c
@@@ -1,21 -1,21 +1,21 @@@
  /*
 - * HTTP protocol for avconv client
 + * HTTP protocol for ffmpeg client
   * Copyright (c) 2000, 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -33,7 -33,7 +33,7 @@@
  #include <zlib.h>
  #endif
  
 -/* XXX: POST protocol is not completely implemented because avconv uses
 +/* XXX: POST protocol is not completely implemented because ffmpeg uses
     only a subset of it. */
  
  /* The IO buffer size is unrelated to the max URL size in itself, but needs
@@@ -51,11 -51,7 +51,9 @@@ typedef struct 
      int http_code;
      /* Used if "Transfer-Encoding: chunked" otherwise -1. */
      int64_t chunksize;
 -    int64_t off, filesize;
 +    char *content_type;
 +    char *user_agent;
 +    int64_t off, filesize, req_end_offset;
-     int icy_data_read;      ///< how much data was read since last ICY metadata packet
-     int icy_metaint;        ///< after how many bytes of read data a new metadata packet will be found
      char *location;
      HTTPAuthState auth_state;
      HTTPAuthState proxy_auth_state;
@@@ -63,7 -59,6 +61,7 @@@
      /* Set if the server correctly handles Connection: close and will close
       * the connection after feeding us the content. */
      int willclose;
 +    int seekable;           /**< Control seekability, 0 = disable, 1 = enable, -1 = probe. */
      int chunked_post;
      /* A flag which indicates if the end of chunked encoding has been sent. */
      int end_chunked_post;
      int multiple_requests;
      uint8_t *post_data;
      int post_datalen;
 +    int is_akamai;
 +    int is_mediagateway;
 +    char *mime_type;
 +    char *cookies;          ///< holds newline (\n) delimited Set-Cookie header field values (without the "Set-Cookie: " field name)
      int icy;
+     /* how much data was read since the last ICY metadata packet */
+     int icy_data_read;
+     /* after how many bytes of read data a new metadata packet will be found */
+     int icy_metaint;
      char *icy_metadata_headers;
      char *icy_metadata_packet;
  #if CONFIG_ZLIB
  #define OFFSET(x) offsetof(HTTPContext, x)
  #define D AV_OPT_FLAG_DECODING_PARAM
  #define E AV_OPT_FLAG_ENCODING_PARAM
 +#define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
  static const AVOption options[] = {
 +{"seekable", "control seekability of connection", OFFSET(seekable), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, D },
  {"chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
 -{"headers", "custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
 +{"headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
 +{"content_type", "force a content type", OFFSET(content_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
 +{"user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
  {"multiple_requests", "use persistent connections", OFFSET(multiple_requests), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D|E },
 -{"post_data", "custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
 +{"post_data", "set custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
 +{"mime_type", "set MIME type", OFFSET(mime_type), AV_OPT_TYPE_STRING, {0}, 0, 0, 0 },
 +{"cookies", "set cookies to be sent in applicable future requests, use newline delimited Set-Cookie HTTP field value syntax", OFFSET(cookies), AV_OPT_TYPE_STRING, {0}, 0, 0, D },
  {"icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D },
- {"icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, {0}, 0, 0, 0 },
- {"icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, {0}, 0, 0, 0 },
+ {"icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
+ {"icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
  {"auth_type", "HTTP authentication type", OFFSET(auth_state.auth_type), AV_OPT_TYPE_INT, {.i64 = HTTP_AUTH_NONE}, HTTP_AUTH_NONE, HTTP_AUTH_BASIC, D|E, "auth_type" },
  {"none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_NONE}, 0, 0, D|E, "auth_type" },
  {"basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_BASIC}, 0, 0, D|E, "auth_type" },
  {"send_expect_100", "Force sending an Expect: 100-continue header for POST", OFFSET(send_expect_100), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
  {"location", "The actual location of the data received", OFFSET(location), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
 +{"offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
 +{"end_offset", "try to limit the request to bytes preceding this offset", OFFSET(req_end_offset), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
  {NULL}
  };
  #define HTTP_CLASS(flavor)\
@@@ -204,7 -191,8 +206,7 @@@ static int http_open_cnx(URLContext *h
      if (s->http_code == 401) {
          if ((cur_auth_type == HTTP_AUTH_NONE || s->auth_state.stale) &&
              s->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
 -            ffurl_close(s->hd);
 -            s->hd = NULL;
 +            ffurl_closep(&s->hd);
              goto redo;
          } else
              goto fail;
      if (s->http_code == 407) {
          if ((cur_proxy_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
              s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
 -            ffurl_close(s->hd);
 -            s->hd = NULL;
 +            ffurl_closep(&s->hd);
              goto redo;
          } else
              goto fail;
      if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307)
          && location_changed == 1) {
          /* url moved, get next */
 -        ffurl_close(s->hd);
 -        s->hd = NULL;
 +        ffurl_closep(&s->hd);
          if (redirects++ >= MAX_REDIRECTS)
              return AVERROR(EIO);
          /* Restart the authentication process with the new target, which
      return 0;
   fail:
      if (s->hd)
 -        ffurl_close(s->hd);
 -    s->hd = NULL;
 +        ffurl_closep(&s->hd);
      return AVERROR(EIO);
  }
  
@@@ -262,10 -253,7 +264,10 @@@ static int http_open(URLContext *h, con
      HTTPContext *s = h->priv_data;
      int ret;
  
 -    h->is_streamed = 1;
 +    if( s->seekable == 1 )
 +        h->is_streamed = 0;
 +    else
 +        h->is_streamed = 1;
  
      s->filesize = -1;
      s->location = av_strdup(uri);
@@@ -366,8 -354,7 +368,8 @@@ static void parse_content_range(URLCont
          if ((slash = strchr(p, '/')) && strlen(slash) > 0)
              s->filesize = strtoll(slash+1, NULL, 10);
      }
 -    h->is_streamed = 0; /* we _can_ in fact seek */
 +    if (s->seekable == -1 && (!s->is_akamai || s->filesize != 2147483647))
 +        h->is_streamed = 0; /* we _can_ in fact seek */
  }
  
  static int parse_content_encoding(URLContext *h, char *p)
          // the header at all if this is the case).
      } else {
          av_log(h, AV_LOG_WARNING, "Unknown content coding: %s\n", p);
 -        return AVERROR(ENOSYS);
      }
      return 0;
  }
  
+ // Concat all Icy- header lines
+ static int parse_icy(HTTPContext *s, const char *tag, const char *p)
+ {
+     int len = 4 + strlen(p) + strlen(tag);
+     int ret;
+     if (s->icy_metadata_headers)
+         len += strlen(s->icy_metadata_headers);
+     if ((ret = av_reallocp(&s->icy_metadata_headers, len)) < 0)
+         return ret;
+     av_strlcatf(s->icy_metadata_headers, len, "%s: %s\n", tag, p);
+     return 0;
+ }
  static int process_line(URLContext *h, char *line, int line_count,
                          int *new_location)
  {
              p++;
          s->http_code = strtol(p, &end, 10);
  
 -        av_dlog(NULL, "http_code=%d\n", s->http_code);
 +        av_log(h, AV_LOG_DEBUG, "http_code=%d\n", s->http_code);
  
          if ((ret = check_http_code(h, s->http_code, end)) < 0)
              return ret;
          } else if (!av_strcasecmp(tag, "Content-Range")) {
              parse_content_range(h, p);
          } else if (!av_strcasecmp(tag, "Accept-Ranges") &&
 -                   !strncmp(p, "bytes", 5)) {
 +                   !strncmp(p, "bytes", 5) &&
 +                   s->seekable == -1) {
              h->is_streamed = 0;
          } else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
                     !av_strncasecmp(p, "chunked", 7)) {
          } else if (!av_strcasecmp(tag, "Connection")) {
              if (!strcmp(p, "close"))
                  s->willclose = 1;
 +        } else if (!av_strcasecmp (tag, "Server")) {
 +            if (!av_strcasecmp (p, "AkamaiGHost")) {
 +                s->is_akamai = 1;
 +            } else if (!av_strncasecmp (p, "MediaGateway", 12)) {
 +                s->is_mediagateway = 1;
 +            }
 +        } else if (!av_strcasecmp (tag, "Content-Type")) {
 +            av_free(s->mime_type); s->mime_type = av_strdup(p);
 +        } else if (!av_strcasecmp (tag, "Set-Cookie")) {
 +            if (!s->cookies) {
 +                if (!(s->cookies = av_strdup(p)))
 +                    return AVERROR(ENOMEM);
 +            } else {
 +                char *tmp = s->cookies;
 +                size_t str_size = strlen(tmp) + strlen(p) + 2;
 +                if (!(s->cookies = av_malloc(str_size))) {
 +                    s->cookies = tmp;
 +                    return AVERROR(ENOMEM);
 +                }
 +                snprintf(s->cookies, str_size, "%s\n%s", tmp, p);
 +                av_free(tmp);
 +            }
          } else if (!av_strcasecmp (tag, "Icy-MetaInt")) {
              s->icy_metaint = strtoll(p, NULL, 10);
          } else if (!av_strncasecmp(tag, "Icy-", 4)) {
-             // Concat all Icy- header lines
-             char *buf = av_asprintf("%s%s: %s\n",
-                 s->icy_metadata_headers ? s->icy_metadata_headers : "", tag, p);
-             if (!buf)
-                 return AVERROR(ENOMEM);
-             av_freep(&s->icy_metadata_headers);
-             s->icy_metadata_headers = buf;
+             if ((ret = parse_icy(s, tag, p)) < 0)
+                 return ret;
          } else if (!av_strcasecmp(tag, "Content-Encoding")) {
              if ((ret = parse_content_encoding(h, p)) < 0)
                  return ret;
      return 1;
  }
  
 +/**
 + * Create a string containing cookie values for use as a HTTP cookie header
 + * field value for a particular path and domain from the cookie values stored in
 + * the HTTP protocol context. The cookie string is stored in *cookies.
 + *
 + * @return a negative value if an error condition occurred, 0 otherwise
 + */
 +static int get_cookies(HTTPContext *s, char **cookies, const char *path,
 +                       const char *domain)
 +{
 +    // cookie strings will look like Set-Cookie header field values.  Multiple
 +    // Set-Cookie fields will result in multiple values delimited by a newline
 +    int ret = 0;
 +    char *next, *cookie, *set_cookies = av_strdup(s->cookies), *cset_cookies = set_cookies;
 +
 +    if (!set_cookies) return AVERROR(EINVAL);
 +
 +    *cookies = NULL;
 +    while ((cookie = av_strtok(set_cookies, "\n", &next))) {
 +        int domain_offset = 0;
 +        char *param, *next_param, *cdomain = NULL, *cpath = NULL, *cvalue = NULL;
 +        set_cookies = NULL;
 +
 +        while ((param = av_strtok(cookie, "; ", &next_param))) {
 +            cookie = NULL;
 +            if        (!av_strncasecmp("path=",   param, 5)) {
 +                av_free(cpath);
 +                cpath = av_strdup(&param[5]);
 +            } else if (!av_strncasecmp("domain=", param, 7)) {
 +                // if the cookie specifies a sub-domain, skip the leading dot thereby
 +                // supporting URLs that point to sub-domains and the master domain
 +                int leading_dot = (param[7] == '.');
 +                av_free(cdomain);
 +                cdomain = av_strdup(&param[7+leading_dot]);
 +            } else if (!av_strncasecmp("secure",  param, 6) ||
 +                       !av_strncasecmp("comment", param, 7) ||
 +                       !av_strncasecmp("max-age", param, 7) ||
 +                       !av_strncasecmp("version", param, 7)) {
 +                // ignore Comment, Max-Age, Secure and Version
 +            } else {
 +                av_free(cvalue);
 +                cvalue = av_strdup(param);
 +            }
 +        }
 +        if (!cdomain)
 +            cdomain = av_strdup(domain);
 +
 +        // ensure all of the necessary values are valid
 +        if (!cdomain || !cpath || !cvalue) {
 +            av_log(s, AV_LOG_WARNING,
 +                   "Invalid cookie found, no value, path or domain specified\n");
 +            goto done_cookie;
 +        }
 +
 +        // check if the request path matches the cookie path
 +        if (av_strncasecmp(path, cpath, strlen(cpath)))
 +            goto done_cookie;
 +
 +        // the domain should be at least the size of our cookie domain
 +        domain_offset = strlen(domain) - strlen(cdomain);
 +        if (domain_offset < 0)
 +            goto done_cookie;
 +
 +        // match the cookie domain
 +        if (av_strcasecmp(&domain[domain_offset], cdomain))
 +            goto done_cookie;
 +
 +        // cookie parameters match, so copy the value
 +        if (!*cookies) {
 +            if (!(*cookies = av_strdup(cvalue))) {
 +                ret = AVERROR(ENOMEM);
 +                goto done_cookie;
 +            }
 +        } else {
 +            char *tmp = *cookies;
 +            size_t str_size = strlen(cvalue) + strlen(*cookies) + 3;
 +            if (!(*cookies = av_malloc(str_size))) {
 +                ret = AVERROR(ENOMEM);
 +                goto done_cookie;
 +            }
 +            snprintf(*cookies, str_size, "%s; %s", tmp, cvalue);
 +            av_free(tmp);
 +        }
 +
 +        done_cookie:
 +        av_free(cdomain);
 +        av_free(cpath);
 +        av_free(cvalue);
 +        if (ret < 0) {
 +            if (*cookies) av_freep(cookies);
 +            av_free(cset_cookies);
 +            return ret;
 +        }
 +    }
 +
 +    av_free(cset_cookies);
 +
 +    return 0;
 +}
 +
  static inline int has_header(const char *str, const char *header)
  {
      /* header + 2 to skip over CRLF prefix. (make sure you have one!) */
@@@ -624,7 -501,7 +638,7 @@@ static int http_read_header(URLContext 
          if ((err = http_get_line(s, line, sizeof(line))) < 0)
              return err;
  
 -        av_dlog(NULL, "header='%s'\n", line);
 +        av_log(h, AV_LOG_DEBUG, "header='%s'\n", line);
  
          err = process_line(h, line, s->line_count, new_location);
          if (err < 0)
          s->line_count++;
      }
  
 +    if (s->seekable == -1 && s->is_mediagateway && s->filesize == 2000000000)
 +        h->is_streamed = 1; /* we can in fact _not_ seek */
 +
      return err;
  }
  
@@@ -646,7 -520,7 +660,7 @@@ static int http_connect(URLContext *h, 
  {
      HTTPContext *s = h->priv_data;
      int post, err;
 -    char headers[1024] = "";
 +    char headers[4096] = "";
      char *authstr = NULL, *proxyauthstr = NULL;
      int64_t off = s->off;
      int len = 0;
  
      /* set default headers if needed */
      if (!has_header(s->headers, "\r\nUser-Agent: "))
 -       len += av_strlcatf(headers + len, sizeof(headers) - len,
 -                          "User-Agent: %s\r\n", LIBAVFORMAT_IDENT);
 +        len += av_strlcatf(headers + len, sizeof(headers) - len,
 +                           "User-Agent: %s\r\n", s->user_agent);
      if (!has_header(s->headers, "\r\nAccept: "))
          len += av_strlcpy(headers + len, "Accept: */*\r\n",
                            sizeof(headers) - len);
 -    if (!has_header(s->headers, "\r\nRange: ") && !post)
 +    // Note: we send this on purpose even when s->off is 0 when we're probing,
 +    // since it allows us to detect more reliably if a (non-conforming)
 +    // server supports seeking by analysing the reply headers.
 +    if (!has_header(s->headers, "\r\nRange: ") && !post && (s->off > 0 || s->req_end_offset || s->seekable == -1)) {
          len += av_strlcatf(headers + len, sizeof(headers) - len,
 -                           "Range: bytes=%"PRId64"-\r\n", s->off);
 +                           "Range: bytes=%"PRId64"-", s->off);
 +        if (s->req_end_offset)
 +            len += av_strlcatf(headers + len, sizeof(headers) - len,
 +                               "%"PRId64, s->req_end_offset - 1);
 +        len += av_strlcpy(headers + len, "\r\n",
 +                          sizeof(headers) - len);
 +    }
      if (send_expect_100 && !has_header(s->headers, "\r\nExpect: "))
          len += av_strlcatf(headers + len, sizeof(headers) - len,
                             "Expect: 100-continue\r\n");
      if (!has_header(s->headers, "\r\nContent-Length: ") && s->post_data)
          len += av_strlcatf(headers + len, sizeof(headers) - len,
                             "Content-Length: %d\r\n", s->post_datalen);
 +    if (!has_header(s->headers, "\r\nContent-Type: ") && s->content_type)
 +        len += av_strlcatf(headers + len, sizeof(headers) - len,
 +                           "Content-Type: %s\r\n", s->content_type);
 +    if (!has_header(s->headers, "\r\nCookie: ") && s->cookies) {
 +        char *cookies = NULL;
 +        if (!get_cookies(s, &cookies, path, hoststr)) {
 +            len += av_strlcatf(headers + len, sizeof(headers) - len,
 +                               "Cookie: %s\r\n", cookies);
 +            av_free(cookies);
 +        }
 +    }
      if (!has_header(s->headers, "\r\nIcy-MetaData: ") && s->icy) {
          len += av_strlcatf(headers + len, sizeof(headers) - len,
                             "Icy-MetaData: %d\r\n", 1);
  
      av_freep(&authstr);
      av_freep(&proxyauthstr);
 +
 +    av_log(h, AV_LOG_DEBUG, "request: %s\n", s->buffer);
 +
      if ((err = ffurl_write(s->hd, s->buffer, strlen(s->buffer))) < 0)
          return err;
  
@@@ -891,8 -742,6 +905,8 @@@ static int http_read_stream(URLContext 
      return http_buf_read(h, buf, size);
  }
  
 +// Like http_read_stream(), but no short reads.
 +// Assumes partial reads are an error.
  static int http_read_stream_all(URLContext *h, uint8_t *buf, int size)
  {
      int pos = 0;
      return pos;
  }
  
+ static int store_icy(URLContext *h, int size)
+ {
+     HTTPContext *s = h->priv_data;
+     /* until next metadata packet */
+     int remaining = s->icy_metaint - s->icy_data_read;
+     if (remaining < 0)
+         return AVERROR_INVALIDDATA;
+     if (!remaining) {
+         // The metadata packet is variable sized. It has a 1 byte header
+         // which sets the length of the packet (divided by 16). If it's 0,
+         // the metadata doesn't change. After the packet, icy_metaint bytes
+         // of normal data follow.
+         uint8_t ch;
+         int len = http_read_stream_all(h, &ch, 1);
+         if (len < 0)
+             return len;
+         if (ch > 0) {
+             char data[255 * 16 + 1];
+             int ret;
+             len = ch * 16;
+             ret = http_read_stream_all(h, data, len);
+             if (ret < 0)
+                 return ret;
+             data[len + 1] = 0;
+             if ((ret = av_opt_set(s, "icy_metadata_packet", data, 0)) < 0)
+                 return ret;
+         }
+         s->icy_data_read = 0;
+         remaining = s->icy_metaint;
+     }
+     return FFMIN(size, remaining);
+ }
  static int http_read(URLContext *h, uint8_t *buf, int size)
  {
      HTTPContext *s = h->priv_data;
  
      if (s->icy_metaint > 0) {
-         int remaining = s->icy_metaint - s->icy_data_read; /* until next metadata packet */
-         if (!remaining) {
-             // The metadata packet is variable sized. It has a 1 byte header
-             // which sets the length of the packet (divided by 16). If it's 0,
-             // the metadata doesn't change. After the packet, icy_metaint bytes
-             // of normal data follow.
-             uint8_t ch;
-             int len = http_read_stream_all(h, &ch, 1);
-             if (len < 1)
-                 return len;
-             if (ch > 0) {
-                 char data[255 * 16 + 1];
-                 int ret;
-                 len = ch * 16;
-                 ret = http_read_stream_all(h, data, len);
-                 if (ret < len)
-                     return ret;
-                 data[len + 1] = 0;
-                 if ((ret = av_opt_set(s, "icy_metadata_packet", data, 0)) < 0)
-                     return ret;
-             }
-             s->icy_data_read = 0;
-             remaining = s->icy_metaint;
-         }
-         size = FFMIN(size, remaining);
+         size = store_icy(h, size);
+         if (size < 0)
+             return size;
      }
      size = http_read_stream(h, buf, size);
      if (size > 0)
          s->icy_data_read += size;
@@@ -1001,7 -865,7 +1030,7 @@@ static int http_close(URLContext *h
      }
  
      if (s->hd)
 -        ffurl_close(s->hd);
 +        ffurl_closep(&s->hd);
      av_dict_free(&s->chained_options);
      return ret;
  }
@@@ -1017,26 -881,19 +1046,26 @@@ static int64_t http_seek(URLContext *h
  
      if (whence == AVSEEK_SIZE)
          return s->filesize;
 +    else if ((whence == SEEK_CUR && off == 0) || (whence == SEEK_SET && off == s->off))
 +        return s->off;
      else if ((s->filesize == -1 && whence == SEEK_END) || h->is_streamed)
          return AVERROR(ENOSYS);
  
 -    /* we save the old context in case the seek fails */
 -    old_buf_size = s->buf_end - s->buf_ptr;
 -    memcpy(old_buf, s->buf_ptr, old_buf_size);
 -    s->hd = NULL;
      if (whence == SEEK_CUR)
          off += s->off;
      else if (whence == SEEK_END)
          off += s->filesize;
 +    else if (whence != SEEK_SET)
 +        return AVERROR(EINVAL);
 +    if (off < 0)
 +        return AVERROR(EINVAL);
      s->off = off;
  
 +    /* we save the old context in case the seek fails */
 +    old_buf_size = s->buf_end - s->buf_ptr;
 +    memcpy(old_buf, s->buf_ptr, old_buf_size);
 +    s->hd = NULL;
 +
      /* if it fails, continue on old connection */
      av_dict_copy(&options, s->chained_options, 0);
      if ((ret = http_open_cnx(h, &options)) < 0) {
@@@ -1096,7 -953,7 +1125,7 @@@ static int http_proxy_close(URLContext 
  {
      HTTPContext *s = h->priv_data;
      if (s->hd)
 -        ffurl_close(s->hd);
 +        ffurl_closep(&s->hd);
      return 0;
  }
  
@@@ -1111,10 -968,7 +1140,10 @@@ static int http_proxy_open(URLContext *
      char *authstr;
      int new_loc;
  
 -    h->is_streamed = 1;
 +    if( s->seekable == 1 )
 +        h->is_streamed = 0;
 +    else
 +        h->is_streamed = 1;
  
      av_url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
                   pathbuf, sizeof(pathbuf), uri);
@@@ -1170,7 -1024,8 +1199,7 @@@ redo
      if (s->http_code == 407 &&
          (cur_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
          s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2) {
 -        ffurl_close(s->hd);
 -        s->hd = NULL;
 +        ffurl_closep(&s->hd);
          goto redo;
      }