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>
37 #define STREAMTYPE_DUMMY -1 // for placeholders, when the actual reading is handled in the demuxer
38 #define STREAMTYPE_FILE 0 // read from seekable file
39 #define STREAMTYPE_VCD 1 // raw mode-2 CDROM reading, 2324 bytes/sector
40 #define STREAMTYPE_STREAM 2 // same as FILE but no seeking (for net/stdin)
41 #define STREAMTYPE_DVD 3 // libdvdread
42 #define STREAMTYPE_MEMORY 4 // read data from memory area
43 #define STREAMTYPE_PLAYLIST 6 // FIXME!!! same as STREAMTYPE_FILE now
44 #define STREAMTYPE_DS 8 // read from a demuxer stream
45 #define STREAMTYPE_DVDNAV 9 // we cannot safely "seek" in this...
46 #define STREAMTYPE_CDDA 10 // raw audio CD reader
47 #define STREAMTYPE_SMB 11 // smb:// url, using libsmbclient (samba)
48 #define STREAMTYPE_VCDBINCUE 12 // vcd directly from bin/cue files
49 #define STREAMTYPE_DVB 13
50 #define STREAMTYPE_VSTREAM 14
51 #define STREAMTYPE_SDP 15
52 #define STREAMTYPE_PVR 16
53 #define STREAMTYPE_TV 17
54 #define STREAMTYPE_MF 18
55 #define STREAMTYPE_RADIO 19
56 #define STREAMTYPE_BLURAY 20
58 #define STREAM_BUFFER_SIZE 2048
59 #define STREAM_MAX_SECTOR_SIZE (8*1024)
61 #define VCD_SECTOR_SIZE 2352
62 #define VCD_SECTOR_OFFS 24
63 #define VCD_SECTOR_DATA 2324
65 /// atm it will always use mode == STREAM_READ
66 /// streams that use the new api should check the mode at open
68 #define STREAM_WRITE 1
69 /// Seek flags, if not mannualy set and s->seek isn't NULL
70 /// MP_STREAM_SEEK is automaticly set
71 #define MP_STREAM_SEEK_BW 2
72 #define MP_STREAM_SEEK_FW 4
73 #define MP_STREAM_SEEK (MP_STREAM_SEEK_BW|MP_STREAM_SEEK_FW)
74 /** This is a HACK for live555 that does not respect the
75 separation between stream an demuxer and thus is not
76 actually a stream cache can not be used */
77 #define STREAM_NON_CACHEABLE 8
79 //////////// Open return code
80 #define STREAM_REDIRECTED -2
81 /// This can't open the requested protocol (used by stream wich have a
82 /// * protocol when they don't know the requested protocol)
83 #define STREAM_UNSUPPORTED -1
84 #define STREAM_ERROR 0
87 #define MAX_STREAM_PROTOCOLS 10
89 #define STREAM_CTRL_RESET 0
90 #define STREAM_CTRL_GET_TIME_LENGTH 1
91 #define STREAM_CTRL_SEEK_TO_CHAPTER 2
92 #define STREAM_CTRL_GET_CURRENT_CHAPTER 3
93 #define STREAM_CTRL_GET_NUM_CHAPTERS 4
94 #define STREAM_CTRL_GET_CURRENT_TIME 5
95 #define STREAM_CTRL_SEEK_TO_TIME 6
96 #define STREAM_CTRL_GET_SIZE 7
97 #define STREAM_CTRL_GET_ASPECT_RATIO 8
98 #define STREAM_CTRL_GET_NUM_ANGLES 9
99 #define STREAM_CTRL_GET_ANGLE 10
100 #define STREAM_CTRL_SET_ANGLE 11
108 typedef struct streaming_control
{
110 streaming_status status
;
111 int buffering
; // boolean
112 unsigned int prebuffer_size
;
114 unsigned int buffer_size
;
115 unsigned int buffer_pos
;
116 unsigned int bandwidth
; // The downstream available
117 int (*streaming_read
)( int fd
, char *buffer
, int buffer_size
, struct streaming_control
*stream_ctrl
);
118 int (*streaming_seek
)( int fd
, off_t pos
, struct streaming_control
*stream_ctrl
);
126 typedef struct stream_info_st
{
131 /// mode isn't used atm (ie always READ) but it shouldn't be ignored
132 /// opts is at least in it's defaults settings and may have been
133 /// altered by url parsing if enabled and the options string parsing.
134 int (*open
)(struct stream
* st
, int mode
, void* opts
, int* file_format
);
135 const char* protocols
[MAX_STREAM_PROTOCOLS
];
137 int opts_url
; /* If this is 1 we will parse the url as an option string
138 * too. Otherwise options are only parsed from the
139 * options string given to open_stream_plugin */
142 typedef struct stream
{
144 int (*fill_buffer
)(struct stream
*s
, char* buffer
, int max_len
);
146 int (*write_buffer
)(struct stream
*s
, char* buffer
, int len
);
148 int (*seek
)(struct stream
*s
,off_t pos
);
150 // Will be later used to let streams like dvd and cdda report
151 // their structure (ie tracks, chapters, etc)
152 int (*control
)(struct stream
*s
,int cmd
,void* arg
);
154 void (*close
)(struct stream
*s
);
156 int fd
; // file descriptor, see man open(2)
157 int type
; // see STREAMTYPE_*
159 int sector_size
; // sector size (seek will be aligned on this size if non 0)
160 int read_chunk
; // maximum amount of data to read at once to limit latency (0 for default)
161 unsigned int buf_pos
,buf_len
;
162 off_t pos
,start_pos
,end_pos
;
164 int mode
; //STREAM_READ or STREAM_WRITE
165 unsigned int cache_pid
;
167 void* priv
; // used for DVD, TV, RTSP etc
168 char* url
; // strdup() of filename/url
169 char *lavf_type
; // name of expected demuxer type for lavf
171 #ifdef CONFIG_NETWORKING
172 streaming_ctrl_t
*streaming_ctrl
;
174 unsigned char buffer
[STREAM_BUFFER_SIZE
>STREAM_MAX_SECTOR_SIZE
?STREAM_BUFFER_SIZE
:STREAM_MAX_SECTOR_SIZE
];
178 #ifdef CONFIG_NETWORKING
182 int stream_fill_buffer(stream_t
*s
);
183 int stream_seek_long(stream_t
*s
, off_t pos
);
184 void stream_capture_do(stream_t
*s
);
186 #ifdef CONFIG_STREAM_CACHE
187 int stream_enable_cache(stream_t
*stream
,int size
,int min
,int prefill
);
188 int cache_stream_fill_buffer(stream_t
*s
);
189 int cache_stream_seek_long(stream_t
*s
,off_t pos
);
191 // no cache, define wrappers:
192 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
193 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
194 #define stream_enable_cache(x,y,z,w) 1
196 int stream_write_buffer(stream_t
*s
, unsigned char *buf
, int len
);
198 inline static int stream_read_char(stream_t
*s
){
199 return (s
->buf_pos
<s
->buf_len
)?s
->buffer
[s
->buf_pos
++]:
200 (cache_stream_fill_buffer(s
)?s
->buffer
[s
->buf_pos
++]:-256);
201 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
202 // stream_fill_buffer(s);
203 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
207 inline static unsigned int stream_read_word(stream_t
*s
){
209 x
=stream_read_char(s
);
210 y
=stream_read_char(s
);
214 inline static unsigned int stream_read_dword(stream_t
*s
){
216 y
=stream_read_char(s
);
217 y
=(y
<<8)|stream_read_char(s
);
218 y
=(y
<<8)|stream_read_char(s
);
219 y
=(y
<<8)|stream_read_char(s
);
223 #define stream_read_fourcc stream_read_dword_le
225 inline static unsigned int stream_read_word_le(stream_t
*s
){
227 x
=stream_read_char(s
);
228 y
=stream_read_char(s
);
232 inline static uint32_t stream_read_dword_le(stream_t
*s
)
235 y
=stream_read_char(s
);
236 y
|=stream_read_char(s
)<<8;
237 y
|=stream_read_char(s
)<<16;
238 y
|=stream_read_char(s
)<<24;
242 inline static uint64_t stream_read_qword(stream_t
*s
){
244 y
= 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
);
248 y
=(y
<<8)|stream_read_char(s
);
249 y
=(y
<<8)|stream_read_char(s
);
250 y
=(y
<<8)|stream_read_char(s
);
251 y
=(y
<<8)|stream_read_char(s
);
255 inline static uint64_t stream_read_qword_le(stream_t
*s
){
257 y
= stream_read_dword_le(s
);
258 y
|=(uint64_t)stream_read_dword_le(s
)<<32;
262 inline static unsigned int stream_read_int24(stream_t
*s
){
264 y
= stream_read_char(s
);
265 y
=(y
<<8)|stream_read_char(s
);
266 y
=(y
<<8)|stream_read_char(s
);
270 inline static int stream_read(stream_t
*s
,char* mem
,int total
){
274 x
=s
->buf_len
-s
->buf_pos
;
276 if(!cache_stream_fill_buffer(s
)) return total
-len
; // EOF
277 x
=s
->buf_len
-s
->buf_pos
;
279 if(s
->buf_pos
>s
->buf_len
) mp_msg(MSGT_DEMUX
, MSGL_WARN
, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
281 memcpy(mem
,&s
->buffer
[s
->buf_pos
],x
);
282 s
->buf_pos
+=x
; mem
+=x
; len
-=x
;
287 unsigned char* stream_read_line(stream_t
*s
,unsigned char* mem
, int max
, int utf16
);
289 inline static int stream_eof(stream_t
*s
){
293 inline static off_t
stream_tell(stream_t
*s
){
294 return s
->pos
+s
->buf_pos
-s
->buf_len
;
297 inline static int stream_seek(stream_t
*s
,off_t pos
){
299 mp_dbg(MSGT_DEMUX
, MSGL_DBG3
, "seek to 0x%qX\n",(long long)pos
);
302 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "Invalid seek to negative position %llx!\n",
307 off_t x
=pos
-(s
->pos
-s
->buf_len
);
311 // putchar('*');fflush(stdout);
316 return cache_stream_seek_long(s
,pos
);
319 inline static int stream_skip(stream_t
*s
,off_t len
){
320 if( len
<0 || (len
>2*STREAM_BUFFER_SIZE
&& (s
->flags
& MP_STREAM_SEEK_FW
)) ) {
321 // negative or big skip!
322 return stream_seek(s
,stream_tell(s
)+len
);
325 int x
=s
->buf_len
-s
->buf_pos
;
327 if(!cache_stream_fill_buffer(s
)) return 0; // EOF
328 x
=s
->buf_len
-s
->buf_pos
;
331 //memcpy(mem,&s->buf[s->buf_pos],x);
332 s
->buf_pos
+=x
; len
-=x
;
339 * Return allocated buffer for all data until EOF.
340 * If amount of data would be more than max_size return NULL as data ptr.
341 * Make the allocated buffer padding_bytes larger than the data read.
342 * Write number of bytes read at *amount_read.
344 struct bstr
stream_read_complete(struct stream
*s
, void *talloc_ctx
,
345 int max_size
, int padding_bytes
);
346 void stream_reset(stream_t
*s
);
347 int stream_control(stream_t
*s
, int cmd
, void *arg
);
348 stream_t
* new_stream(int fd
,int type
);
349 void free_stream(stream_t
*s
);
350 stream_t
* new_memory_stream(unsigned char* data
,int len
);
351 stream_t
*open_stream(const char *filename
, struct MPOpts
*options
,
353 stream_t
*open_stream_full(const char *filename
,int mode
,
354 struct MPOpts
*options
, int *file_format
);
355 stream_t
*open_output_stream(const char *filename
, struct MPOpts
*options
);
357 struct stream
*new_ds_stream(struct demux_stream
*ds
);
359 /// Set the callback to be used by libstream to check for user
360 /// interruption during long blocking operations (cache filling, etc).
362 void stream_set_interrupt_callback(int (*cb
)(struct input_ctx
*, int),
363 struct input_ctx
*ctx
);
364 /// Call the interrupt checking callback if there is one and
365 /// wait for time milliseconds
366 int stream_check_interrupt(int time
);
367 /// Internal read function bypassing the stream buffer
368 int stream_read_internal(stream_t
*s
, void *buf
, int len
);
369 /// Internal seek function bypassing the stream buffer
370 int stream_seek_internal(stream_t
*s
, off_t newpos
);
372 extern int bluray_angle
;
373 extern int bluray_chapter
;
374 extern int dvd_title
;
375 extern int dvd_angle
;
377 extern char *bluray_device
;
380 int id
; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
386 #endif /* MPLAYER_STREAM_H */