stream/stream.h

   1 /*
   2  * This file is part of MPlayer.
   3  *
   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.
   8  *
   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.
  13  *
  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.
  17  */
  18
  19 #ifndef MPLAYER_STREAM_H
  20 #define MPLAYER_STREAM_H
  21
  22 #include "config.h"
  23 #include "mp_msg.h"
  24 #include <string.h>
  25 #include <inttypes.h>
  26 #include <sys/types.h>
  27
  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
  47
  48 #define STREAM_BUFFER_SIZE 2048
  49
  50 #define VCD_SECTOR_SIZE 2352
  51 #define VCD_SECTOR_OFFS 24
  52 #define VCD_SECTOR_DATA 2324
  53
  54 /// atm it will always use mode == STREAM_READ
  55 /// streams that use the new api should check the mode at open
  56 #define STREAM_READ  0
  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
  67
  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
  74 #define STREAM_OK    1
  75
  76 #define MAX_STREAM_PROTOCOLS 10
  77
  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
  90
  91
  92 #ifdef CONFIG_NETWORK
  93 #include "network.h"
  94 #endif
  95
  96 struct stream_st;
  97 typedef struct stream_info_st {
  98   const char *info;
  99   const char *name;
 100   const char *author;
 101   const char *comment;
 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* st, int mode, void* opts, int* file_format);
 106   const char* protocols[MAX_STREAM_PROTOCOLS];
 107   const void* opts;
 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 */
 111 } stream_info_t;
 112
 113 typedef struct stream_st {
 114   // Read
 115   int (*fill_buffer)(struct stream_st *s, char* buffer, int max_len);
 116   // Write
 117   int (*write_buffer)(struct stream_st *s, char* buffer, int len);
 118   // Seek
 119   int (*seek)(struct stream_st *s,off_t pos);
 120   // Control
 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_st *s,int cmd,void* arg);
 124   // Close
 125   void (*close)(struct stream_st *s);
 126
 127   int fd;   // file descriptor, see man open(2)
 128   int type; // see STREAMTYPE_*
 129   int flags;
 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;
 133   int eof;
 134   int mode; //STREAM_READ or STREAM_WRITE
 135   unsigned int cache_pid;
 136   void* cache_data;
 137   void* priv; // used for DVD, TV, RTSP etc
 138   char* url;  // strdup() of filename/url
 139 #ifdef CONFIG_NETWORK
 140   streaming_ctrl_t *streaming_ctrl;
 141 #endif
 142   unsigned char buffer[STREAM_BUFFER_SIZE>VCD_SECTOR_SIZE?STREAM_BUFFER_SIZE:VCD_SECTOR_SIZE];
 143 } stream_t;
 144
 145 #ifdef CONFIG_STREAM_CACHE
 146 int stream_enable_cache(stream_t *stream,int size,int min,int prefill);
 147 int cache_stream_fill_buffer(stream_t *s);
 148 int cache_stream_seek_long(stream_t *s,off_t pos);
 149 #else
 150 // no cache, define wrappers:
 151 int stream_fill_buffer(stream_t *s);
 152 int stream_seek_long(stream_t *s,off_t pos);
 153 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
 154 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
 155 #define stream_enable_cache(x,y,z,w) 1
 156 #endif
 157 void fixup_network_stream_cache(stream_t *stream);
 158 int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
 159
 160 inline static int stream_read_char(stream_t *s){
 161   return (s->buf_pos<s->buf_len)?s->buffer[s->buf_pos++]:
 162     (cache_stream_fill_buffer(s)?s->buffer[s->buf_pos++]:-256);
 163 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 164 //  stream_fill_buffer(s);
 165 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 166 //  return 0; // EOF
 167 }
 168
 169 inline static unsigned int stream_read_word(stream_t *s){
 170   int x,y;
 171   x=stream_read_char(s);
 172   y=stream_read_char(s);
 173   return (x<<8)|y;
 174 }
 175
 176 inline static unsigned int stream_read_dword(stream_t *s){
 177   unsigned int y;
 178   y=stream_read_char(s);
 179   y=(y<<8)|stream_read_char(s);
 180   y=(y<<8)|stream_read_char(s);
 181   y=(y<<8)|stream_read_char(s);
 182   return y;
 183 }
 184
 185 #define stream_read_fourcc stream_read_dword_le
 186
 187 inline static unsigned int stream_read_word_le(stream_t *s){
 188   int x,y;
 189   x=stream_read_char(s);
 190   y=stream_read_char(s);
 191   return (y<<8)|x;
 192 }
 193
 194 inline static unsigned int stream_read_dword_le(stream_t *s){
 195   unsigned int y;
 196   y=stream_read_char(s);
 197   y|=stream_read_char(s)<<8;
 198   y|=stream_read_char(s)<<16;
 199   y|=stream_read_char(s)<<24;
 200   return y;
 201 }
 202
 203 inline static uint64_t stream_read_qword(stream_t *s){
 204   uint64_t y;
 205   y = stream_read_char(s);
 206   y=(y<<8)|stream_read_char(s);
 207   y=(y<<8)|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   return y;
 214 }
 215
 216 inline static uint64_t stream_read_qword_le(stream_t *s){
 217   uint64_t y;
 218   y = stream_read_dword_le(s);
 219   y|=(uint64_t)stream_read_dword_le(s)<<32;
 220   return y;
 221 }
 222
 223 inline static unsigned int stream_read_int24(stream_t *s){
 224   unsigned int y;
 225   y = stream_read_char(s);
 226   y=(y<<8)|stream_read_char(s);
 227   y=(y<<8)|stream_read_char(s);
 228   return y;
 229 }
 230
 231 inline static int stream_read(stream_t *s,char* mem,int total){
 232   int len=total;
 233   while(len>0){
 234     int x;
 235     x=s->buf_len-s->buf_pos;
 236     if(x==0){
 237       if(!cache_stream_fill_buffer(s)) return total-len; // EOF
 238       x=s->buf_len-s->buf_pos;
 239     }
 240     if(s->buf_pos>s->buf_len) mp_msg(MSGT_DEMUX, MSGL_WARN, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
 241     if(x>len) x=len;
 242     memcpy(mem,&s->buffer[s->buf_pos],x);
 243     s->buf_pos+=x; mem+=x; len-=x;
 244   }
 245   return total;
 246 }
 247
 248 inline static unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max) {
 249   int len;
 250   unsigned char* end,*ptr = mem;
 251   do {
 252     len = s->buf_len-s->buf_pos;
 253     // try to fill the buffer
 254     if(len <= 0 &&
 255        (!cache_stream_fill_buffer(s) ||
 256         (len = s->buf_len-s->buf_pos) <= 0)) break;
 257     end = (unsigned char*) memchr((void*)(s->buffer+s->buf_pos),'\n',len);
 258     if(end) len = end - (s->buffer+s->buf_pos) + 1;
 259     if(len > 0 && max > 1) {
 260       int l = len > max-1 ? max-1 : len;
 261       memcpy(ptr,s->buffer+s->buf_pos,l);
 262       max -= l;
 263       ptr += l;
 264     }
 265     s->buf_pos += len;
 266   } while(!end);
 267   if(s->eof && ptr == mem) return NULL;
 268   if(max > 0) ptr[0] = 0;
 269   return mem;
 270 }
 271
 272
 273 inline static int stream_eof(stream_t *s){
 274   return s->eof;
 275 }
 276
 277 inline static off_t stream_tell(stream_t *s){
 278   return s->pos+s->buf_pos-s->buf_len;
 279 }
 280
 281 inline static int stream_seek(stream_t *s,off_t pos){
 282
 283   mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%qX\n",(long long)pos);
 284
 285   if(pos<s->pos){
 286     off_t x=pos-(s->pos-s->buf_len);
 287     if(x>=0){
 288       s->buf_pos=x;
 289 //      putchar('*');fflush(stdout);
 290       return 1;
 291     }
 292   }
 293
 294   return cache_stream_seek_long(s,pos);
 295 }
 296
 297 inline static int stream_skip(stream_t *s,off_t len){
 298   if( (len<0 && (s->flags & MP_STREAM_SEEK_BW)) || (len>2*STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW)) ) {
 299     // negative or big skip!
 300     return stream_seek(s,stream_tell(s)+len);
 301   }
 302   while(len>0){
 303     int x=s->buf_len-s->buf_pos;
 304     if(x==0){
 305       if(!cache_stream_fill_buffer(s)) return 0; // EOF
 306       x=s->buf_len-s->buf_pos;
 307     }
 308     if(x>len) x=len;
 309     //memcpy(mem,&s->buf[s->buf_pos],x);
 310     s->buf_pos+=x; len-=x;
 311   }
 312   return 1;
 313 }
 314
 315 void stream_reset(stream_t *s);
 316 int stream_control(stream_t *s, int cmd, void *arg);
 317 stream_t* new_stream(int fd,int type);
 318 void free_stream(stream_t *s);
 319 stream_t* new_memory_stream(unsigned char* data,int len);
 320 stream_t* open_stream(char* filename,char** options,int* file_format);
 321 stream_t* open_stream_full(char* filename,int mode, char** options, int* file_format);
 322 stream_t* open_output_stream(char* filename,char** options);
 323 /// Set the callback to be used by libstream to check for user
 324 /// interruption during long blocking operations (cache filling, etc).
 325 void stream_set_interrupt_callback(int (*cb)(int));
 326 /// Call the interrupt checking callback if there is one.
 327 int stream_check_interrupt(int time);
 328
 329 extern int dvd_title;
 330 extern int dvd_chapter;
 331 extern int dvd_last_chapter;
 332 extern int dvd_angle;
 333
 334 extern char * audio_stream;
 335
 336 typedef struct {
 337  int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
 338  int language;
 339  int type;
 340  int channels;
 341 } stream_language_t;
 342
 343 #endif /* MPLAYER_STREAM_H */