2010-01-30 23:26:47 +01:00
|
|
|
/*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* MPlayer is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2008-02-22 10:09:46 +01:00
|
|
|
#ifndef MPLAYER_STREAM_H
|
|
|
|
#define MPLAYER_STREAM_H
|
2001-04-22 18:56:20 +02:00
|
|
|
|
2010-01-04 19:58:35 +01:00
|
|
|
#include "config.h"
|
2012-11-09 01:06:43 +01:00
|
|
|
#include "core/mp_msg.h"
|
2010-02-22 14:27:58 +01:00
|
|
|
#include "url.h"
|
2012-11-17 18:12:13 +01:00
|
|
|
#include <stdbool.h>
|
2010-11-02 02:17:41 +01:00
|
|
|
#include <stdio.h>
|
2002-09-16 00:38:01 +02:00
|
|
|
#include <string.h>
|
2002-01-07 10:22:01 +01:00
|
|
|
#include <inttypes.h>
|
2002-03-23 22:52:13 +01:00
|
|
|
#include <sys/types.h>
|
2010-03-06 08:24:41 +01:00
|
|
|
#include <fcntl.h>
|
|
|
|
|
2012-11-09 01:06:43 +01:00
|
|
|
#include "core/bstr.h"
|
2011-02-25 17:10:00 +01:00
|
|
|
|
2010-03-06 08:24:41 +01:00
|
|
|
#ifndef O_BINARY
|
|
|
|
#define O_BINARY 0
|
|
|
|
#endif
|
2002-01-07 10:22:01 +01:00
|
|
|
|
2002-09-15 21:47:49 +02:00
|
|
|
#define STREAMTYPE_DUMMY -1 // for placeholders, when the actual reading is handled in the demuxer
|
|
|
|
#define STREAMTYPE_FILE 0 // read from seekable file
|
|
|
|
#define STREAMTYPE_VCD 1 // raw mode-2 CDROM reading, 2324 bytes/sector
|
|
|
|
#define STREAMTYPE_STREAM 2 // same as FILE but no seeking (for net/stdin)
|
|
|
|
#define STREAMTYPE_DVD 3 // libdvdread
|
|
|
|
#define STREAMTYPE_PLAYLIST 6 // FIXME!!! same as STREAMTYPE_FILE now
|
|
|
|
#define STREAMTYPE_CDDA 10 // raw audio CD reader
|
2002-10-06 20:03:12 +02:00
|
|
|
#define STREAMTYPE_SMB 11 // smb:// url, using libsmbclient (samba)
|
2003-01-04 21:11:06 +01:00
|
|
|
#define STREAMTYPE_VCDBINCUE 12 // vcd directly from bin/cue files
|
2003-03-16 21:13:28 +01:00
|
|
|
#define STREAMTYPE_DVB 13
|
2005-02-27 05:25:12 +01:00
|
|
|
#define STREAMTYPE_VSTREAM 14
|
2005-05-29 14:54:00 +02:00
|
|
|
#define STREAMTYPE_SDP 15
|
2006-07-10 23:32:19 +02:00
|
|
|
#define STREAMTYPE_PVR 16
|
2006-08-03 21:12:31 +02:00
|
|
|
#define STREAMTYPE_TV 17
|
2006-08-03 21:43:02 +02:00
|
|
|
#define STREAMTYPE_MF 18
|
2006-08-28 19:05:18 +02:00
|
|
|
#define STREAMTYPE_RADIO 19
|
2010-07-05 19:04:46 +02:00
|
|
|
#define STREAMTYPE_BLURAY 20
|
demux_lavf: add support for libavdevice
libavdevice supports various "special" video and audio inputs, such
as screen-capture or libavfilter filter graphs.
libavdevice inputs are implemented as demuxers. They don't use the
custom stream callbacks (in AVFormatContext.pb). Instead, input
parameters are passed as filename. This means the mpv stream layer has
to be disabled. Do this by adding the pseudo stream handler avdevice://,
whose only purpose is passing the filename to demux_lavf, without
actually doing anything.
Change the logic how the filename is passed to libavformat. Remove
handling of the filename from demux_open_lavf() and move it to
lavf_check_file(). (This also fixes a possible bug when skipping the
"lavf://" prefix.)
libavdevice now can be invoked by specifying demuxer and args as in:
mpv avdevice://demuxer:args
The args are passed as filename to libavformat. When using libavdevice
demuxers, their actual meaning is highly implementation specific. They
don't refer to actual filenames.
Note:
libavdevice is disabled by default. There is one problem: libavdevice
pulls in libavfilter, which in turn causes symbol clashes with mpv
internals. The problem is that libavfilter includes a mplayer filter
bridge, which is used to interface with a set of nearly unmodified
mplayer filters copied into libavfilter. This filter bridge uses the
same symbol names as mplayer/mpv's filter chain, which results in symbol
clashes at link-time.
This can be prevented by building ffmpeg with --disable-filter=mp, but
unfortunately this is not the default.
This means linking to libavdevice (which in turn forces linking with
libavfilter by default) must be disabled. We try doing this by compiling
a test file that defines one of the clashing symbols (vf_mpi_clear).
To enable libavdevice input, ffmpeg should be built with the options:
--disable-filter=mp
and mpv with:
--enable-libavdevice
Originally, I tried to auto-detect it. But the resulting complications
in configure did't seem worth the trouble.
2012-11-30 18:41:04 +01:00
|
|
|
#define STREAMTYPE_AVDEVICE 21
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
#define STREAMTYPE_CACHE 22
|
2001-04-22 18:56:20 +02:00
|
|
|
|
2002-09-16 00:38:01 +02:00
|
|
|
#define STREAM_BUFFER_SIZE 2048
|
2013-01-24 17:43:07 +01:00
|
|
|
#define STREAM_MAX_SECTOR_SIZE (8 * 1024)
|
2002-09-16 00:38:01 +02:00
|
|
|
|
stream: add stream_unread_buffer()
demux_lavf probes up to 2 MB of data in the worst case. When the ffmpeg
demuxer is actually opened, the stream is seeked back to 0, and the
previously read data is thrown away.
This wasn't a problem for playback of local files, but it's less than
ideal for playing from slow media (like web streams), and breaks
completely if the media is not seekable (pipes, some web streams).
This new function is intended to allow fixing this. demux_lavf will use
it to put the read probe data back into the buffer.
The simplest way of implementing this function is by making it
transparently extend the normal stream buffer. This makes sure no
existing code is broken by new weird special cases. For simplicity
and to avoid possible performance loss due to extra dereferencing
when accessing the buffer, we just extend the static buffer from
8 KB to 2 MB. Normally, most of these 2 MB will stay uncommitted, so
there's no associated waste of memory. If demux_lavf really reads all
2 MB, the memory will be committed and stay unused, though.
2013-05-24 23:20:09 +02:00
|
|
|
// Max buffer for initial probe.
|
|
|
|
#define STREAM_MAX_BUFFER_SIZE (2 * 1024 * 1024)
|
|
|
|
|
2013-06-06 20:39:53 +02:00
|
|
|
|
|
|
|
// stream->mode
|
2003-04-02 18:25:07 +02:00
|
|
|
#define STREAM_READ 0
|
|
|
|
#define STREAM_WRITE 1
|
2013-06-06 20:39:53 +02:00
|
|
|
|
|
|
|
// stream->flags
|
2009-11-22 16:18:21 +01:00
|
|
|
#define MP_STREAM_SEEK_BW 2
|
|
|
|
#define MP_STREAM_SEEK_FW 4
|
2013-01-24 17:43:07 +01:00
|
|
|
#define MP_STREAM_SEEK (MP_STREAM_SEEK_BW | MP_STREAM_SEEK_FW)
|
2003-04-02 18:25:07 +02:00
|
|
|
|
2007-11-26 01:41:21 +01:00
|
|
|
#define STREAM_REDIRECTED -2
|
2007-08-29 00:38:45 +02:00
|
|
|
#define STREAM_UNSUPPORTED -1
|
2003-04-02 18:25:07 +02:00
|
|
|
#define STREAM_ERROR 0
|
|
|
|
#define STREAM_OK 1
|
|
|
|
|
2012-12-08 15:41:03 +01:00
|
|
|
#define MAX_STREAM_PROTOCOLS 20
|
2003-04-02 18:25:07 +02:00
|
|
|
|
2006-02-27 22:06:47 +01:00
|
|
|
#define STREAM_CTRL_GET_TIME_LENGTH 1
|
2006-08-18 18:44:24 +02:00
|
|
|
#define STREAM_CTRL_SEEK_TO_CHAPTER 2
|
2006-08-18 20:58:38 +02:00
|
|
|
#define STREAM_CTRL_GET_CURRENT_CHAPTER 3
|
2006-08-21 21:10:18 +02:00
|
|
|
#define STREAM_CTRL_GET_NUM_CHAPTERS 4
|
2006-11-07 23:46:35 +01:00
|
|
|
#define STREAM_CTRL_GET_CURRENT_TIME 5
|
|
|
|
#define STREAM_CTRL_SEEK_TO_TIME 6
|
2006-12-18 21:54:38 +01:00
|
|
|
#define STREAM_CTRL_GET_SIZE 7
|
2007-09-01 17:50:52 +02:00
|
|
|
#define STREAM_CTRL_GET_ASPECT_RATIO 8
|
2008-01-05 15:20:47 +01:00
|
|
|
#define STREAM_CTRL_GET_NUM_ANGLES 9
|
|
|
|
#define STREAM_CTRL_GET_ANGLE 10
|
|
|
|
#define STREAM_CTRL_SET_ANGLE 11
|
2011-12-31 13:20:08 +01:00
|
|
|
#define STREAM_CTRL_GET_NUM_TITLES 12
|
2012-02-19 14:15:41 +01:00
|
|
|
#define STREAM_CTRL_GET_LANG 13
|
2012-10-21 16:56:50 +02:00
|
|
|
#define STREAM_CTRL_GET_CURRENT_TITLE 14
|
2012-12-01 23:28:58 +01:00
|
|
|
#define STREAM_CTRL_GET_CACHE_SIZE 15
|
|
|
|
#define STREAM_CTRL_GET_CACHE_FILL 16
|
2012-12-02 00:22:54 +01:00
|
|
|
#define STREAM_CTRL_GET_CACHE_IDLE 17
|
2013-01-24 18:45:24 +01:00
|
|
|
#define STREAM_CTRL_RECONNECT 18
|
2013-05-03 19:52:28 +02:00
|
|
|
// DVD/Bluray, signal general support for GET_CURRENT_TIME etc.
|
|
|
|
#define STREAM_CTRL_MANAGES_TIMELINE 19
|
2013-05-03 20:11:46 +02:00
|
|
|
#define STREAM_CTRL_GET_START_TIME 20
|
stream: report chapter times, use time seeks for DVD chapters
Allow the stream layer to report chapter times. Extend stream_dvd to do
this. I'm not 100% sure whether the re-used code is bug-free (because it
was used for slave-mode and/or debugging only).
MAke the frontend do time-based seeks when switching DVD chapters. I'm
not sure if there's a real reason STREAM_CTRL_SEEK_TO_CHAPTER exists
(maybe/hopefully not), but we will see.
Note that querying chapter times in demuxer_chapter_time() with the new
STREAM_CTRL_GET_CHAPTER_TIME could be excessively slow, especially with
the cache enabled. The frontend likes to query chapter times very often.
Additionally, stream_dvd uses some sort of quadratic algorithm to list
times for all chapters. For this reason, we try to query all chapters on
start (after the demuxer is opened), and add the chapters to the demuxer
chapter list. demuxer_chapter_time() will get the time from that list,
instead of asking the stream layer over and over again.
This assumes stream_dvd knows the list of chapters at the start, and
also that the list of chapters never changes during playback. This
seems to be true, and the only exception, switching DVD titles, is not
supported at runtime (and doesn't need to be supported).
2013-05-04 01:20:39 +02:00
|
|
|
#define STREAM_CTRL_GET_CHAPTER_TIME 21
|
2013-06-05 01:59:04 +02:00
|
|
|
#define STREAM_CTRL_GET_DVD_INFO 22
|
2003-04-02 18:25:07 +02:00
|
|
|
|
2012-02-19 14:15:41 +01:00
|
|
|
struct stream_lang_req {
|
2013-01-24 17:43:07 +01:00
|
|
|
int type; // STREAM_AUDIO, STREAM_SUB
|
|
|
|
int id;
|
|
|
|
char name[50];
|
2012-02-19 14:15:41 +01:00
|
|
|
};
|
2008-10-16 20:28:38 +02:00
|
|
|
|
2013-06-05 01:59:04 +02:00
|
|
|
struct stream_dvd_info_req {
|
|
|
|
unsigned int palette[16];
|
|
|
|
int num_subs;
|
|
|
|
};
|
|
|
|
|
2010-02-22 14:27:58 +01:00
|
|
|
typedef enum {
|
2013-01-24 17:43:07 +01:00
|
|
|
streaming_stopped_e,
|
|
|
|
streaming_playing_e
|
2010-02-22 14:27:58 +01:00
|
|
|
} streaming_status;
|
|
|
|
|
2013-06-06 20:39:53 +02:00
|
|
|
// All this is for legacy http streams (and other things using tcp/udp)
|
2010-02-22 14:27:58 +01:00
|
|
|
typedef struct streaming_control {
|
2013-01-24 17:43:07 +01:00
|
|
|
URL_t *url;
|
|
|
|
streaming_status status;
|
|
|
|
char *buffer;
|
|
|
|
unsigned int buffer_size;
|
|
|
|
unsigned int buffer_pos;
|
|
|
|
unsigned int bandwidth; // The downstream available
|
|
|
|
int (*streaming_read)(int fd, char *buffer, int buffer_size,
|
|
|
|
struct streaming_control *stream_ctrl);
|
|
|
|
int (*streaming_seek)(int fd, int64_t pos,
|
|
|
|
struct streaming_control *stream_ctrl);
|
|
|
|
void *data;
|
2010-03-10 00:08:50 +01:00
|
|
|
// hacks for asf
|
|
|
|
int *audio_id_ptr;
|
|
|
|
int *video_id_ptr;
|
2010-02-22 14:27:58 +01:00
|
|
|
} streaming_ctrl_t;
|
2001-11-20 23:21:20 +01:00
|
|
|
|
2008-04-24 04:49:44 +02:00
|
|
|
struct stream;
|
2003-04-02 18:25:07 +02:00
|
|
|
typedef struct stream_info_st {
|
2013-01-24 17:43:07 +01:00
|
|
|
const char *info;
|
|
|
|
const char *name;
|
|
|
|
const char *author;
|
|
|
|
const char *comment;
|
2013-06-06 20:39:53 +02:00
|
|
|
// opts is set from ->opts
|
2013-01-24 17:43:07 +01:00
|
|
|
int (*open)(struct stream *st, int mode, void *opts, int *file_format);
|
|
|
|
const char *protocols[MAX_STREAM_PROTOCOLS];
|
|
|
|
const void *opts;
|
|
|
|
int opts_url; /* If this is 1 we will parse the url as an option string
|
|
|
|
* too. Otherwise options are only parsed from the
|
|
|
|
* options string given to open_stream_plugin */
|
2003-04-02 18:25:07 +02:00
|
|
|
} stream_info_t;
|
|
|
|
|
2008-04-24 04:49:44 +02:00
|
|
|
typedef struct stream {
|
2013-01-24 17:43:07 +01:00
|
|
|
// Read
|
|
|
|
int (*fill_buffer)(struct stream *s, char *buffer, int max_len);
|
|
|
|
// Write
|
|
|
|
int (*write_buffer)(struct stream *s, char *buffer, int len);
|
|
|
|
// Seek
|
|
|
|
int (*seek)(struct stream *s, int64_t pos);
|
|
|
|
// Control
|
|
|
|
// Will be later used to let streams like dvd and cdda report
|
|
|
|
// their structure (ie tracks, chapters, etc)
|
|
|
|
int (*control)(struct stream *s, int cmd, void *arg);
|
|
|
|
// Close
|
|
|
|
void (*close)(struct stream *s);
|
|
|
|
|
|
|
|
int fd; // file descriptor, see man open(2)
|
|
|
|
int type; // see STREAMTYPE_*
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
int uncached_type; // like (uncached_stream ? uncached_stream->type : type)
|
|
|
|
int flags; // MP_STREAM_SEEK_* or'ed flags
|
2013-01-24 17:43:07 +01:00
|
|
|
int sector_size; // sector size (seek will be aligned on this size if non 0)
|
2013-05-25 15:03:30 +02:00
|
|
|
int read_chunk; // maximum amount of data to read at once to limit latency
|
2013-01-24 17:43:07 +01:00
|
|
|
unsigned int buf_pos, buf_len;
|
|
|
|
int64_t pos, start_pos, end_pos;
|
|
|
|
int eof;
|
|
|
|
int mode; //STREAM_READ or STREAM_WRITE
|
|
|
|
bool streaming; // known to be a network stream if true
|
|
|
|
int cache_size; // cache size in KB to use if enabled
|
|
|
|
void *priv; // used for DVD, TV, RTSP etc
|
|
|
|
char *url; // strdup() of filename/url
|
|
|
|
char *mime_type; // when HTTP streaming is used
|
|
|
|
char *lavf_type; // name of expected demuxer type for lavf
|
|
|
|
struct MPOpts *opts;
|
|
|
|
streaming_ctrl_t *streaming_ctrl;
|
2013-05-11 22:19:33 +02:00
|
|
|
|
|
|
|
FILE *capture_file;
|
|
|
|
char *capture_filename;
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
|
|
|
|
struct stream *uncached_stream;
|
stream: add stream_unread_buffer()
demux_lavf probes up to 2 MB of data in the worst case. When the ffmpeg
demuxer is actually opened, the stream is seeked back to 0, and the
previously read data is thrown away.
This wasn't a problem for playback of local files, but it's less than
ideal for playing from slow media (like web streams), and breaks
completely if the media is not seekable (pipes, some web streams).
This new function is intended to allow fixing this. demux_lavf will use
it to put the read probe data back into the buffer.
The simplest way of implementing this function is by making it
transparently extend the normal stream buffer. This makes sure no
existing code is broken by new weird special cases. For simplicity
and to avoid possible performance loss due to extra dereferencing
when accessing the buffer, we just extend the static buffer from
8 KB to 2 MB. Normally, most of these 2 MB will stay uncommitted, so
there's no associated waste of memory. If demux_lavf really reads all
2 MB, the memory will be committed and stay unused, though.
2013-05-24 23:20:09 +02:00
|
|
|
|
|
|
|
// Includes additional padding in case sizes get rounded up by sector size.
|
|
|
|
unsigned char buffer[];
|
2001-04-22 18:56:20 +02:00
|
|
|
} stream_t;
|
|
|
|
|
2010-07-17 15:14:53 +02:00
|
|
|
#ifdef CONFIG_NETWORKING
|
2010-02-22 14:27:58 +01:00
|
|
|
#include "network.h"
|
|
|
|
#endif
|
|
|
|
|
2008-08-12 11:49:37 +02:00
|
|
|
int stream_fill_buffer(stream_t *s);
|
stream: add stream_unread_buffer()
demux_lavf probes up to 2 MB of data in the worst case. When the ffmpeg
demuxer is actually opened, the stream is seeked back to 0, and the
previously read data is thrown away.
This wasn't a problem for playback of local files, but it's less than
ideal for playing from slow media (like web streams), and breaks
completely if the media is not seekable (pipes, some web streams).
This new function is intended to allow fixing this. demux_lavf will use
it to put the read probe data back into the buffer.
The simplest way of implementing this function is by making it
transparently extend the normal stream buffer. This makes sure no
existing code is broken by new weird special cases. For simplicity
and to avoid possible performance loss due to extra dereferencing
when accessing the buffer, we just extend the static buffer from
8 KB to 2 MB. Normally, most of these 2 MB will stay uncommitted, so
there's no associated waste of memory. If demux_lavf really reads all
2 MB, the memory will be committed and stay unused, though.
2013-05-24 23:20:09 +02:00
|
|
|
void stream_unread_buffer(stream_t *s, void *buffer, size_t buffer_size);
|
2010-02-22 00:30:34 +01:00
|
|
|
|
2013-05-11 22:19:33 +02:00
|
|
|
void stream_set_capture_file(stream_t *s, const char *filename);
|
|
|
|
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
int stream_enable_cache_percent(stream_t **stream, int64_t stream_cache_size,
|
2013-01-24 17:43:07 +01:00
|
|
|
float stream_cache_min_percent,
|
|
|
|
float stream_cache_seek_min_percent);
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
int stream_enable_cache(stream_t **stream, int64_t size, int64_t min,
|
|
|
|
int64_t seek_limit);
|
|
|
|
|
|
|
|
// Internal
|
|
|
|
int stream_cache_init(stream_t *cache, stream_t *stream, int64_t size,
|
|
|
|
int64_t min, int64_t seek_limit);
|
|
|
|
|
2006-12-18 21:50:31 +01:00
|
|
|
int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
|
2001-08-01 01:18:16 +02:00
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static int stream_read_char(stream_t *s)
|
|
|
|
{
|
|
|
|
return (s->buf_pos < s->buf_len) ? s->buffer[s->buf_pos++] :
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
(stream_fill_buffer(s) ? s->buffer[s->buf_pos++] : -256);
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static unsigned int stream_read_word(stream_t *s)
|
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
x = stream_read_char(s);
|
|
|
|
y = stream_read_char(s);
|
|
|
|
return (x << 8) | y;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static unsigned int stream_read_dword(stream_t *s)
|
|
|
|
{
|
|
|
|
unsigned int y;
|
|
|
|
y = stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
return y;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2002-01-16 04:25:07 +01:00
|
|
|
#define stream_read_fourcc stream_read_dword_le
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static unsigned int stream_read_word_le(stream_t *s)
|
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
x = stream_read_char(s);
|
|
|
|
y = stream_read_char(s);
|
|
|
|
return (y << 8) | x;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2011-04-28 09:36:00 +02:00
|
|
|
inline static uint32_t stream_read_dword_le(stream_t *s)
|
|
|
|
{
|
2013-01-24 17:43:07 +01:00
|
|
|
unsigned int y;
|
|
|
|
y = stream_read_char(s);
|
|
|
|
y |= stream_read_char(s) << 8;
|
|
|
|
y |= stream_read_char(s) << 16;
|
|
|
|
y |= stream_read_char(s) << 24;
|
|
|
|
return y;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static uint64_t stream_read_qword(stream_t *s)
|
|
|
|
{
|
|
|
|
uint64_t y;
|
|
|
|
y = stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
y = (y << 8) | stream_read_char(s);
|
|
|
|
return y;
|
2002-01-05 20:21:06 +01:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static uint64_t stream_read_qword_le(stream_t *s)
|
|
|
|
{
|
|
|
|
uint64_t y;
|
|
|
|
y = stream_read_dword_le(s);
|
|
|
|
y |= (uint64_t)stream_read_dword_le(s) << 32;
|
|
|
|
return y;
|
2004-01-19 20:16:10 +01:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
unsigned char *stream_read_line(stream_t *s, unsigned char *mem, int max,
|
|
|
|
int utf16);
|
2006-03-16 15:42:51 +01:00
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static int stream_eof(stream_t *s)
|
|
|
|
{
|
|
|
|
return s->eof;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2013-01-24 17:43:07 +01:00
|
|
|
inline static int64_t stream_tell(stream_t *s)
|
|
|
|
{
|
|
|
|
return s->pos + s->buf_pos - s->buf_len;
|
2001-04-22 18:56:20 +02:00
|
|
|
}
|
|
|
|
|
2013-05-24 11:56:49 +02:00
|
|
|
int stream_skip(stream_t *s, int64_t len);
|
|
|
|
int stream_seek(stream_t *s, int64_t pos);
|
|
|
|
int stream_read(stream_t *s, char *mem, int total);
|
2013-05-27 21:53:40 +02:00
|
|
|
int stream_read_partial(stream_t *s, char *buf, int buf_size);
|
2001-04-22 18:56:20 +02:00
|
|
|
|
2008-04-23 05:35:36 +02:00
|
|
|
struct MPOpts;
|
2013-06-11 12:16:42 +02:00
|
|
|
|
2011-02-25 17:10:00 +01:00
|
|
|
struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
|
2013-06-11 12:16:42 +02:00
|
|
|
int max_size);
|
2006-03-01 22:56:30 +01:00
|
|
|
int stream_control(stream_t *s, int cmd, void *arg);
|
2012-11-18 21:23:17 +01:00
|
|
|
void stream_update_size(stream_t *s);
|
2001-04-22 18:56:20 +02:00
|
|
|
void free_stream(stream_t *s);
|
2010-03-10 00:46:46 +01:00
|
|
|
stream_t *open_stream(const char *filename, struct MPOpts *options,
|
|
|
|
int *file_format);
|
|
|
|
stream_t *open_output_stream(const char *filename, struct MPOpts *options);
|
2013-06-21 00:47:58 +02:00
|
|
|
stream_t *open_memory_stream(void *data, int len);
|
2011-02-10 11:15:21 +01:00
|
|
|
struct demux_stream;
|
|
|
|
|
2008-04-09 02:36:28 +02:00
|
|
|
/// Set the callback to be used by libstream to check for user
|
|
|
|
/// interruption during long blocking operations (cache filling, etc).
|
2008-04-30 06:15:52 +02:00
|
|
|
struct input_ctx;
|
2013-01-24 17:43:07 +01:00
|
|
|
void stream_set_interrupt_callback(int (*cb)(struct input_ctx *, int),
|
2008-04-30 06:15:52 +02:00
|
|
|
struct input_ctx *ctx);
|
2010-05-28 20:45:25 +02:00
|
|
|
/// Call the interrupt checking callback if there is one and
|
|
|
|
/// wait for time milliseconds
|
2008-04-09 02:36:28 +02:00
|
|
|
int stream_check_interrupt(int time);
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 18:49:09 +02:00
|
|
|
|
2013-05-03 19:52:28 +02:00
|
|
|
bool stream_manages_timeline(stream_t *s);
|
|
|
|
|
2001-10-30 18:03:11 +01:00
|
|
|
extern int dvd_title;
|
|
|
|
extern int dvd_angle;
|
2001-06-04 19:51:17 +02:00
|
|
|
|
2013-04-26 21:50:19 +02:00
|
|
|
extern int bluray_angle;
|
2010-07-05 19:04:46 +02:00
|
|
|
extern char *bluray_device;
|
2002-07-03 00:31:50 +02:00
|
|
|
|
2001-11-16 23:26:57 +01:00
|
|
|
typedef struct {
|
2013-01-24 17:43:07 +01:00
|
|
|
int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
|
|
|
|
int language;
|
|
|
|
int type;
|
|
|
|
int channels;
|
2001-12-26 00:31:37 +01:00
|
|
|
} stream_language_t;
|
2001-11-21 11:30:59 +01:00
|
|
|
|
2008-02-22 10:09:46 +01:00
|
|
|
#endif /* MPLAYER_STREAM_H */
|