2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 #ifndef MPLAYER_STREAM_H
20 #define MPLAYER_STREAM_H
28 #include <sys/types.h>
35 #define STREAMTYPE_DUMMY -1 // for placeholders, when the actual reading is handled in the demuxer
36 #define STREAMTYPE_FILE 0 // read from seekable file
37 #define STREAMTYPE_VCD 1 // raw mode-2 CDROM reading, 2324 bytes/sector
38 #define STREAMTYPE_STREAM 2 // same as FILE but no seeking (for net/stdin)
39 #define STREAMTYPE_DVD 3 // libdvdread
40 #define STREAMTYPE_MEMORY 4 // read data from memory area
41 #define STREAMTYPE_PLAYLIST 6 // FIXME!!! same as STREAMTYPE_FILE now
42 #define STREAMTYPE_DS 8 // read from a demuxer stream
43 #define STREAMTYPE_DVDNAV 9 // we cannot safely "seek" in this...
44 #define STREAMTYPE_CDDA 10 // raw audio CD reader
45 #define STREAMTYPE_SMB 11 // smb:// url, using libsmbclient (samba)
46 #define STREAMTYPE_VCDBINCUE 12 // vcd directly from bin/cue files
47 #define STREAMTYPE_DVB 13
48 #define STREAMTYPE_VSTREAM 14
49 #define STREAMTYPE_SDP 15
50 #define STREAMTYPE_PVR 16
51 #define STREAMTYPE_TV 17
52 #define STREAMTYPE_MF 18
53 #define STREAMTYPE_RADIO 19
54 #define STREAMTYPE_BLURAY 20
56 #define STREAM_BUFFER_SIZE 2048
57 #define STREAM_MAX_SECTOR_SIZE (8*1024)
59 #define VCD_SECTOR_SIZE 2352
60 #define VCD_SECTOR_OFFS 24
61 #define VCD_SECTOR_DATA 2324
63 /// atm it will always use mode == STREAM_READ
64 /// streams that use the new api should check the mode at open
66 #define STREAM_WRITE 1
67 /// Seek flags, if not mannualy set and s->seek isn't NULL
68 /// MP_STREAM_SEEK is automaticly set
69 #define MP_STREAM_SEEK_BW 2
70 #define MP_STREAM_SEEK_FW 4
71 #define MP_STREAM_SEEK (MP_STREAM_SEEK_BW|MP_STREAM_SEEK_FW)
72 /** This is a HACK for live555 that does not respect the
73 separation between stream an demuxer and thus is not
74 actually a stream cache can not be used */
75 #define STREAM_NON_CACHEABLE 8
77 //////////// Open return code
78 #define STREAM_REDIRECTED -2
79 /// This can't open the requested protocol (used by stream wich have a
80 /// * protocol when they don't know the requested protocol)
81 #define STREAM_UNSUPPORTED -1
82 #define STREAM_ERROR 0
85 #define MAX_STREAM_PROTOCOLS 10
87 #define STREAM_CTRL_RESET 0
88 #define STREAM_CTRL_GET_TIME_LENGTH 1
89 #define STREAM_CTRL_SEEK_TO_CHAPTER 2
90 #define STREAM_CTRL_GET_CURRENT_CHAPTER 3
91 #define STREAM_CTRL_GET_NUM_CHAPTERS 4
92 #define STREAM_CTRL_GET_CURRENT_TIME 5
93 #define STREAM_CTRL_SEEK_TO_TIME 6
94 #define STREAM_CTRL_GET_SIZE 7
95 #define STREAM_CTRL_GET_ASPECT_RATIO 8
96 #define STREAM_CTRL_GET_NUM_ANGLES 9
97 #define STREAM_CTRL_GET_ANGLE 10
98 #define STREAM_CTRL_SET_ANGLE 11
106 typedef struct streaming_control
{
108 streaming_status status
;
109 int buffering
; // boolean
110 unsigned int prebuffer_size
;
112 unsigned int buffer_size
;
113 unsigned int buffer_pos
;
114 unsigned int bandwidth
; // The downstream available
115 int (*streaming_read
)( int fd
, char *buffer
, int buffer_size
, struct streaming_control
*stream_ctrl
);
116 int (*streaming_seek
)( int fd
, off_t pos
, struct streaming_control
*stream_ctrl
);
124 typedef struct stream_info_st
{
129 /// mode isn't used atm (ie always READ) but it shouldn't be ignored
130 /// opts is at least in it's defaults settings and may have been
131 /// altered by url parsing if enabled and the options string parsing.
132 int (*open
)(struct stream
* st
, int mode
, void* opts
, int* file_format
);
133 const char* protocols
[MAX_STREAM_PROTOCOLS
];
135 int opts_url
; /* If this is 1 we will parse the url as an option string
136 * too. Otherwise options are only parsed from the
137 * options string given to open_stream_plugin */
140 typedef struct stream
{
142 int (*fill_buffer
)(struct stream
*s
, char* buffer
, int max_len
);
144 int (*write_buffer
)(struct stream
*s
, char* buffer
, int len
);
146 int (*seek
)(struct stream
*s
,off_t pos
);
148 // Will be later used to let streams like dvd and cdda report
149 // their structure (ie tracks, chapters, etc)
150 int (*control
)(struct stream
*s
,int cmd
,void* arg
);
152 void (*close
)(struct stream
*s
);
154 int fd
; // file descriptor, see man open(2)
155 int type
; // see STREAMTYPE_*
157 int sector_size
; // sector size (seek will be aligned on this size if non 0)
158 unsigned int buf_pos
,buf_len
;
159 off_t pos
,start_pos
,end_pos
;
161 int mode
; //STREAM_READ or STREAM_WRITE
162 unsigned int cache_pid
;
164 void* priv
; // used for DVD, TV, RTSP etc
165 char* url
; // strdup() of filename/url
166 char *lavf_type
; // name of expected demuxer type for lavf
168 #ifdef CONFIG_NETWORKING
169 streaming_ctrl_t
*streaming_ctrl
;
171 unsigned char buffer
[STREAM_BUFFER_SIZE
>STREAM_MAX_SECTOR_SIZE
?STREAM_BUFFER_SIZE
:STREAM_MAX_SECTOR_SIZE
];
175 #ifdef CONFIG_NETWORKING
179 int stream_fill_buffer(stream_t
*s
);
180 int stream_seek_long(stream_t
*s
, off_t pos
);
181 void stream_capture_do(stream_t
*s
);
183 #ifdef CONFIG_STREAM_CACHE
184 int stream_enable_cache(stream_t
*stream
,int size
,int min
,int prefill
);
185 int cache_stream_fill_buffer(stream_t
*s
);
186 int cache_stream_seek_long(stream_t
*s
,off_t pos
);
188 // no cache, define wrappers:
189 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
190 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
191 #define stream_enable_cache(x,y,z,w) 1
193 int stream_write_buffer(stream_t
*s
, unsigned char *buf
, int len
);
195 inline static int stream_read_char(stream_t
*s
){
196 return (s
->buf_pos
<s
->buf_len
)?s
->buffer
[s
->buf_pos
++]:
197 (cache_stream_fill_buffer(s
)?s
->buffer
[s
->buf_pos
++]:-256);
198 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
199 // stream_fill_buffer(s);
200 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
204 inline static unsigned int stream_read_word(stream_t
*s
){
206 x
=stream_read_char(s
);
207 y
=stream_read_char(s
);
211 inline static unsigned int stream_read_dword(stream_t
*s
){
213 y
=stream_read_char(s
);
214 y
=(y
<<8)|stream_read_char(s
);
215 y
=(y
<<8)|stream_read_char(s
);
216 y
=(y
<<8)|stream_read_char(s
);
220 #define stream_read_fourcc stream_read_dword_le
222 inline static unsigned int stream_read_word_le(stream_t
*s
){
224 x
=stream_read_char(s
);
225 y
=stream_read_char(s
);
229 inline static unsigned int stream_read_dword_le(stream_t
*s
){
231 y
=stream_read_char(s
);
232 y
|=stream_read_char(s
)<<8;
233 y
|=stream_read_char(s
)<<16;
234 y
|=stream_read_char(s
)<<24;
238 inline static uint64_t stream_read_qword(stream_t
*s
){
240 y
= stream_read_char(s
);
241 y
=(y
<<8)|stream_read_char(s
);
242 y
=(y
<<8)|stream_read_char(s
);
243 y
=(y
<<8)|stream_read_char(s
);
244 y
=(y
<<8)|stream_read_char(s
);
245 y
=(y
<<8)|stream_read_char(s
);
246 y
=(y
<<8)|stream_read_char(s
);
247 y
=(y
<<8)|stream_read_char(s
);
251 inline static uint64_t stream_read_qword_le(stream_t
*s
){
253 y
= stream_read_dword_le(s
);
254 y
|=(uint64_t)stream_read_dword_le(s
)<<32;
258 inline static unsigned int stream_read_int24(stream_t
*s
){
260 y
= stream_read_char(s
);
261 y
=(y
<<8)|stream_read_char(s
);
262 y
=(y
<<8)|stream_read_char(s
);
266 inline static int stream_read(stream_t
*s
,char* mem
,int total
){
270 x
=s
->buf_len
-s
->buf_pos
;
272 if(!cache_stream_fill_buffer(s
)) return total
-len
; // EOF
273 x
=s
->buf_len
-s
->buf_pos
;
275 if(s
->buf_pos
>s
->buf_len
) mp_msg(MSGT_DEMUX
, MSGL_WARN
, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
277 memcpy(mem
,&s
->buffer
[s
->buf_pos
],x
);
278 s
->buf_pos
+=x
; mem
+=x
; len
-=x
;
283 unsigned char* stream_read_line(stream_t
*s
,unsigned char* mem
, int max
, int utf16
);
285 inline static int stream_eof(stream_t
*s
){
289 inline static off_t
stream_tell(stream_t
*s
){
290 return s
->pos
+s
->buf_pos
-s
->buf_len
;
293 inline static int stream_seek(stream_t
*s
,off_t pos
){
295 mp_dbg(MSGT_DEMUX
, MSGL_DBG3
, "seek to 0x%qX\n",(long long)pos
);
298 off_t x
=pos
-(s
->pos
-s
->buf_len
);
302 // putchar('*');fflush(stdout);
307 return cache_stream_seek_long(s
,pos
);
310 inline static int stream_skip(stream_t
*s
,off_t len
){
311 if( len
<0 || (len
>2*STREAM_BUFFER_SIZE
&& (s
->flags
& MP_STREAM_SEEK_FW
)) ) {
312 // negative or big skip!
313 return stream_seek(s
,stream_tell(s
)+len
);
316 int x
=s
->buf_len
-s
->buf_pos
;
318 if(!cache_stream_fill_buffer(s
)) return 0; // EOF
319 x
=s
->buf_len
-s
->buf_pos
;
322 //memcpy(mem,&s->buf[s->buf_pos],x);
323 s
->buf_pos
+=x
; len
-=x
;
329 void stream_reset(stream_t
*s
);
330 int stream_control(stream_t
*s
, int cmd
, void *arg
);
331 stream_t
* new_stream(int fd
,int type
);
332 void free_stream(stream_t
*s
);
333 stream_t
* new_memory_stream(unsigned char* data
,int len
);
334 stream_t
*open_stream(const char *filename
, struct MPOpts
*options
,
336 stream_t
*open_stream_full(const char *filename
,int mode
,
337 struct MPOpts
*options
, int *file_format
);
338 stream_t
*open_output_stream(const char *filename
, struct MPOpts
*options
);
339 /// Set the callback to be used by libstream to check for user
340 /// interruption during long blocking operations (cache filling, etc).
342 void stream_set_interrupt_callback(int (*cb
)(struct input_ctx
*, int),
343 struct input_ctx
*ctx
);
344 /// Call the interrupt checking callback if there is one and
345 /// wait for time milliseconds
346 int stream_check_interrupt(int time
);
348 extern int bluray_angle
;
349 extern int bluray_chapter
;
350 extern int dvd_title
;
351 extern int dvd_angle
;
353 extern char *bluray_device
;
354 extern char * audio_stream
;
357 int id
; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
363 #endif /* MPLAYER_STREAM_H */