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
26 #include <sys/types.h>
28 #define STREAMTYPE_DUMMY -1 // for placeholders, when the actual reading is handled in the demuxer
29 #define STREAMTYPE_FILE 0 // read from seekable file
30 #define STREAMTYPE_VCD 1 // raw mode-2 CDROM reading, 2324 bytes/sector
31 #define STREAMTYPE_STREAM 2 // same as FILE but no seeking (for net/stdin)
32 #define STREAMTYPE_DVD 3 // libdvdread
33 #define STREAMTYPE_MEMORY 4 // read data from memory area
34 #define STREAMTYPE_PLAYLIST 6 // FIXME!!! same as STREAMTYPE_FILE now
35 #define STREAMTYPE_DS 8 // read from a demuxer stream
36 #define STREAMTYPE_DVDNAV 9 // we cannot safely "seek" in this...
37 #define STREAMTYPE_CDDA 10 // raw audio CD reader
38 #define STREAMTYPE_SMB 11 // smb:// url, using libsmbclient (samba)
39 #define STREAMTYPE_VCDBINCUE 12 // vcd directly from bin/cue files
40 #define STREAMTYPE_DVB 13
41 #define STREAMTYPE_VSTREAM 14
42 #define STREAMTYPE_SDP 15
43 #define STREAMTYPE_PVR 16
44 #define STREAMTYPE_TV 17
45 #define STREAMTYPE_MF 18
46 #define STREAMTYPE_RADIO 19
48 #define STREAM_BUFFER_SIZE 2048
50 #define VCD_SECTOR_SIZE 2352
51 #define VCD_SECTOR_OFFS 24
52 #define VCD_SECTOR_DATA 2324
54 /// atm it will always use mode == STREAM_READ
55 /// streams that use the new api should check the mode at open
57 #define STREAM_WRITE 1
58 /// Seek flags, if not mannualy set and s->seek isn't NULL
59 /// MP_STREAM_SEEK is automaticly set
60 #define MP_STREAM_SEEK_BW 2
61 #define MP_STREAM_SEEK_FW 4
62 #define MP_STREAM_SEEK (MP_STREAM_SEEK_BW|MP_STREAM_SEEK_FW)
63 /** This is a HACK for live555 that does not respect the
64 separation between stream an demuxer and thus is not
65 actually a stream cache can not be used */
66 #define STREAM_NON_CACHEABLE 8
68 //////////// Open return code
69 #define STREAM_REDIRECTED -2
70 /// This can't open the requested protocol (used by stream wich have a
71 /// * protocol when they don't know the requested protocol)
72 #define STREAM_UNSUPPORTED -1
73 #define STREAM_ERROR 0
76 #define MAX_STREAM_PROTOCOLS 10
78 #define STREAM_CTRL_RESET 0
79 #define STREAM_CTRL_GET_TIME_LENGTH 1
80 #define STREAM_CTRL_SEEK_TO_CHAPTER 2
81 #define STREAM_CTRL_GET_CURRENT_CHAPTER 3
82 #define STREAM_CTRL_GET_NUM_CHAPTERS 4
83 #define STREAM_CTRL_GET_CURRENT_TIME 5
84 #define STREAM_CTRL_SEEK_TO_TIME 6
85 #define STREAM_CTRL_GET_SIZE 7
86 #define STREAM_CTRL_GET_ASPECT_RATIO 8
87 #define STREAM_CTRL_GET_NUM_ANGLES 9
88 #define STREAM_CTRL_GET_ANGLE 10
89 #define STREAM_CTRL_SET_ANGLE 11
97 typedef struct stream_info_st
{
102 /// mode isn't used atm (ie always READ) but it shouldn't be ignored
103 /// opts is at least in it's defaults settings and may have been
104 /// altered by url parsing if enabled and the options string parsing.
105 int (*open
)(struct stream
* st
, int mode
, void* opts
, int* file_format
);
106 const char* protocols
[MAX_STREAM_PROTOCOLS
];
108 int opts_url
; /* If this is 1 we will parse the url as an option string
109 * too. Otherwise options are only parsed from the
110 * options string given to open_stream_plugin */
113 typedef struct stream
{
115 int (*fill_buffer
)(struct stream
*s
, char* buffer
, int max_len
);
117 int (*write_buffer
)(struct stream
*s
, char* buffer
, int len
);
119 int (*seek
)(struct stream
*s
,off_t pos
);
121 // Will be later used to let streams like dvd and cdda report
122 // their structure (ie tracks, chapters, etc)
123 int (*control
)(struct stream
*s
,int cmd
,void* arg
);
125 void (*close
)(struct stream
*s
);
127 int fd
; // file descriptor, see man open(2)
128 int type
; // see STREAMTYPE_*
130 int sector_size
; // sector size (seek will be aligned on this size if non 0)
131 unsigned int buf_pos
,buf_len
;
132 off_t pos
,start_pos
,end_pos
;
134 int mode
; //STREAM_READ or STREAM_WRITE
135 unsigned int cache_pid
;
137 void* priv
; // used for DVD, TV, RTSP etc
138 char* url
; // strdup() of filename/url
140 #ifdef CONFIG_NETWORK
141 streaming_ctrl_t
*streaming_ctrl
;
143 unsigned char buffer
[STREAM_BUFFER_SIZE
>VCD_SECTOR_SIZE
?STREAM_BUFFER_SIZE
:VCD_SECTOR_SIZE
];
146 int stream_fill_buffer(stream_t
*s
);
147 int stream_seek_long(stream_t
*s
, off_t pos
);
149 #ifdef CONFIG_STREAM_CACHE
150 int stream_enable_cache(stream_t
*stream
,int size
,int min
,int prefill
);
151 int cache_stream_fill_buffer(stream_t
*s
);
152 int cache_stream_seek_long(stream_t
*s
,off_t pos
);
154 // no cache, define wrappers:
155 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
156 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
157 #define stream_enable_cache(x,y,z,w) 1
159 void fixup_network_stream_cache(stream_t
*stream
);
160 int stream_write_buffer(stream_t
*s
, unsigned char *buf
, int len
);
162 inline static int stream_read_char(stream_t
*s
){
163 return (s
->buf_pos
<s
->buf_len
)?s
->buffer
[s
->buf_pos
++]:
164 (cache_stream_fill_buffer(s
)?s
->buffer
[s
->buf_pos
++]:-256);
165 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
166 // stream_fill_buffer(s);
167 // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
171 inline static unsigned int stream_read_word(stream_t
*s
){
173 x
=stream_read_char(s
);
174 y
=stream_read_char(s
);
178 inline static unsigned int stream_read_dword(stream_t
*s
){
180 y
=stream_read_char(s
);
181 y
=(y
<<8)|stream_read_char(s
);
182 y
=(y
<<8)|stream_read_char(s
);
183 y
=(y
<<8)|stream_read_char(s
);
187 #define stream_read_fourcc stream_read_dword_le
189 inline static unsigned int stream_read_word_le(stream_t
*s
){
191 x
=stream_read_char(s
);
192 y
=stream_read_char(s
);
196 inline static unsigned int stream_read_dword_le(stream_t
*s
){
198 y
=stream_read_char(s
);
199 y
|=stream_read_char(s
)<<8;
200 y
|=stream_read_char(s
)<<16;
201 y
|=stream_read_char(s
)<<24;
205 inline static uint64_t stream_read_qword(stream_t
*s
){
207 y
= stream_read_char(s
);
208 y
=(y
<<8)|stream_read_char(s
);
209 y
=(y
<<8)|stream_read_char(s
);
210 y
=(y
<<8)|stream_read_char(s
);
211 y
=(y
<<8)|stream_read_char(s
);
212 y
=(y
<<8)|stream_read_char(s
);
213 y
=(y
<<8)|stream_read_char(s
);
214 y
=(y
<<8)|stream_read_char(s
);
218 inline static uint64_t stream_read_qword_le(stream_t
*s
){
220 y
= stream_read_dword_le(s
);
221 y
|=(uint64_t)stream_read_dword_le(s
)<<32;
225 inline static unsigned int stream_read_int24(stream_t
*s
){
227 y
= stream_read_char(s
);
228 y
=(y
<<8)|stream_read_char(s
);
229 y
=(y
<<8)|stream_read_char(s
);
233 inline static int stream_read(stream_t
*s
,char* mem
,int total
){
237 x
=s
->buf_len
-s
->buf_pos
;
239 if(!cache_stream_fill_buffer(s
)) return total
-len
; // EOF
240 x
=s
->buf_len
-s
->buf_pos
;
242 if(s
->buf_pos
>s
->buf_len
) mp_msg(MSGT_DEMUX
, MSGL_WARN
, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
244 memcpy(mem
,&s
->buffer
[s
->buf_pos
],x
);
245 s
->buf_pos
+=x
; mem
+=x
; len
-=x
;
250 inline static unsigned char* stream_read_line(stream_t
*s
,unsigned char* mem
, int max
) {
252 unsigned char* end
,*ptr
= mem
;
254 len
= s
->buf_len
-s
->buf_pos
;
255 // try to fill the buffer
257 (!cache_stream_fill_buffer(s
) ||
258 (len
= s
->buf_len
-s
->buf_pos
) <= 0)) break;
259 end
= (unsigned char*) memchr((void*)(s
->buffer
+s
->buf_pos
),'\n',len
);
260 if(end
) len
= end
- (s
->buffer
+s
->buf_pos
) + 1;
261 if(len
> 0 && max
> 1) {
262 int l
= len
> max
-1 ? max
-1 : len
;
263 memcpy(ptr
,s
->buffer
+s
->buf_pos
,l
);
269 if(s
->eof
&& ptr
== mem
) return NULL
;
270 if(max
> 0) ptr
[0] = 0;
275 inline static int stream_eof(stream_t
*s
){
279 inline static off_t
stream_tell(stream_t
*s
){
280 return s
->pos
+s
->buf_pos
-s
->buf_len
;
283 inline static int stream_seek(stream_t
*s
,off_t pos
){
285 mp_dbg(MSGT_DEMUX
, MSGL_DBG3
, "seek to 0x%qX\n",(long long)pos
);
290 off_t x
=pos
-(s
->pos
-s
->buf_len
);
294 // putchar('*');fflush(stdout);
299 return cache_stream_seek_long(s
,pos
);
302 inline static int stream_skip(stream_t
*s
,off_t len
){
303 if( (len
<0 && (s
->flags
& MP_STREAM_SEEK_BW
)) || (len
>2*STREAM_BUFFER_SIZE
&& (s
->flags
& MP_STREAM_SEEK_FW
)) ) {
304 // negative or big skip!
305 return stream_seek(s
,stream_tell(s
)+len
);
308 int x
=s
->buf_len
-s
->buf_pos
;
310 if(!cache_stream_fill_buffer(s
)) return 0; // EOF
311 x
=s
->buf_len
-s
->buf_pos
;
314 //memcpy(mem,&s->buf[s->buf_pos],x);
315 s
->buf_pos
+=x
; len
-=x
;
321 void stream_reset(stream_t
*s
);
322 int stream_control(stream_t
*s
, int cmd
, void *arg
);
323 stream_t
* new_stream(int fd
,int type
);
324 void free_stream(stream_t
*s
);
325 stream_t
* new_memory_stream(unsigned char* data
,int len
);
326 stream_t
* open_stream(char* filename
, struct MPOpts
*options
,int* file_format
);
327 stream_t
* open_stream_full(char* filename
,int mode
, struct MPOpts
*options
, int* file_format
);
328 stream_t
* open_output_stream(char* filename
,struct MPOpts
*options
);
329 /// Set the callback to be used by libstream to check for user
330 /// interruption during long blocking operations (cache filling, etc).
332 void stream_set_interrupt_callback(int (*cb
)(struct input_ctx
*, int),
333 struct input_ctx
*ctx
);
334 /// Call the interrupt checking callback if there is one.
335 int stream_check_interrupt(int time
);
337 extern int dvd_title
;
338 extern int dvd_chapter
;
339 extern int dvd_last_chapter
;
340 extern int dvd_angle
;
342 extern char * audio_stream
;
345 int id
; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
351 #endif /* MPLAYER_STREAM_H */