stream/stream.h

   1 #ifndef STREAM_H
   2 #define STREAM_H
   3
   4 #include "mp_msg.h"
   5 #include <string.h>
   6 #include <inttypes.h>
   7 #include <sys/types.h>
   8
   9 #define STREAMTYPE_DUMMY -1    // for placeholders, when the actual reading is handled in the demuxer
  10 #define STREAMTYPE_FILE 0      // read from seekable file
  11 #define STREAMTYPE_VCD  1      // raw mode-2 CDROM reading, 2324 bytes/sector
  12 #define STREAMTYPE_STREAM 2    // same as FILE but no seeking (for net/stdin)
  13 #define STREAMTYPE_DVD  3      // libdvdread
  14 #define STREAMTYPE_MEMORY  4   // read data from memory area
  15 #define STREAMTYPE_PLAYLIST 6  // FIXME!!! same as STREAMTYPE_FILE now
  16 #define STREAMTYPE_DS   8      // read from a demuxer stream
  17 #define STREAMTYPE_DVDNAV 9    // we cannot safely "seek" in this...
  18 #define STREAMTYPE_CDDA 10     // raw audio CD reader
  19 #define STREAMTYPE_SMB 11      // smb:// url, using libsmbclient (samba)
  20 #define STREAMTYPE_VCDBINCUE 12      // vcd directly from bin/cue files
  21 #define STREAMTYPE_DVB 13
  22 #define STREAMTYPE_VSTREAM 14
  23 #define STREAMTYPE_SDP 15
  24 #define STREAMTYPE_PVR 16
  25 #define STREAMTYPE_TV 17
  26 #define STREAMTYPE_MF 18
  27 #define STREAMTYPE_RADIO 19
  28
  29 #define STREAM_BUFFER_SIZE 2048
  30
  31 #define VCD_SECTOR_SIZE 2352
  32 #define VCD_SECTOR_OFFS 24
  33 #define VCD_SECTOR_DATA 2324
  34
  35 /// atm it will always use mode == STREAM_READ
  36 /// streams that use the new api should check the mode at open
  37 #define STREAM_READ  0
  38 #define STREAM_WRITE 1
  39 /// Seek flags, if not mannualy set and s->seek isn't NULL
  40 /// STREAM_SEEK is automaticly set
  41 #define STREAM_SEEK_BW  2
  42 #define STREAM_SEEK_FW  4
  43 #define STREAM_SEEK  (STREAM_SEEK_BW|STREAM_SEEK_FW)
  44
  45 //////////// Open return code
  46 #define STREAM_REDIRECTED -2
  47 /// This can't open the requested protocol (used by stream wich have a
  48 /// * protocol when they don't know the requested protocol)
  49 #define STREAM_UNSUPPORTED -1
  50 #define STREAM_ERROR 0
  51 #define STREAM_OK    1
  52
  53 #define MAX_STREAM_PROTOCOLS 10
  54
  55 #define STREAM_CTRL_RESET 0
  56 #define STREAM_CTRL_GET_TIME_LENGTH 1
  57 #define STREAM_CTRL_SEEK_TO_CHAPTER 2
  58 #define STREAM_CTRL_GET_CURRENT_CHAPTER 3
  59 #define STREAM_CTRL_GET_NUM_CHAPTERS 4
  60 #define STREAM_CTRL_GET_CURRENT_TIME 5
  61 #define STREAM_CTRL_SEEK_TO_TIME 6
  62 #define STREAM_CTRL_GET_SIZE 7
  63 #define STREAM_CTRL_GET_ASPECT_RATIO 8
  64
  65 #ifdef MPLAYER_NETWORK
  66 #include "network.h"
  67 #endif
  68
  69 struct stream_st;
  70 typedef struct stream_info_st {
  71   const char *info;
  72   const char *name;
  73   const char *author;
  74   const char *comment;
  75   /// mode isn't used atm (ie always READ) but it shouldn't be ignored
  76   /// opts is at least in it's defaults settings and may have been
  77   /// altered by url parsing if enabled and the options string parsing.
  78   int (*open)(struct stream_st* st, int mode, void* opts, int* file_format);
  79   char* protocols[MAX_STREAM_PROTOCOLS];
  80   void* opts;
  81   int opts_url; /* If this is 1 we will parse the url as an option string
  82                  * too. Otherwise options are only parsed from the
  83                  * options string given to open_stream_plugin */
  84 } stream_info_t;
  85
  86 typedef struct stream_st {
  87   // Read
  88   int (*fill_buffer)(struct stream_st *s, char* buffer, int max_len);
  89   // Write
  90   int (*write_buffer)(struct stream_st *s, char* buffer, int len);
  91   // Seek
  92   int (*seek)(struct stream_st *s,off_t pos);
  93   // Control
  94   // Will be later used to let streams like dvd and cdda report
  95   // their structure (ie tracks, chapters, etc)
  96   int (*control)(struct stream_st *s,int cmd,void* arg);
  97   // Close
  98   void (*close)(struct stream_st *s);
  99
 100   int fd;   // file descriptor, see man open(2)
 101   int type; // see STREAMTYPE_*
 102   int flags;
 103   int sector_size; // sector size (seek will be aligned on this size if non 0)
 104   unsigned int buf_pos,buf_len;
 105   off_t pos,start_pos,end_pos;
 106   int eof;
 107   int mode; //STREAM_READ or STREAM_WRITE
 108   unsigned int cache_pid;
 109   void* cache_data;
 110   void* priv; // used for DVD, TV, RTSP etc
 111   char* url;  // strdup() of filename/url
 112 #ifdef MPLAYER_NETWORK
 113   streaming_ctrl_t *streaming_ctrl;
 114 #endif
 115   unsigned char buffer[STREAM_BUFFER_SIZE>VCD_SECTOR_SIZE?STREAM_BUFFER_SIZE:VCD_SECTOR_SIZE];
 116 } stream_t;
 117
 118 #ifdef USE_STREAM_CACHE
 119 int stream_enable_cache(stream_t *stream,int size,int min,int prefill);
 120 int cache_stream_fill_buffer(stream_t *s);
 121 int cache_stream_seek_long(stream_t *s,off_t pos);
 122 #else
 123 // no cache, define wrappers:
 124 int stream_fill_buffer(stream_t *s);
 125 int stream_seek_long(stream_t *s,off_t pos);
 126 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
 127 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
 128 #define stream_enable_cache(x,y,z,w) 1
 129 #endif
 130 void fixup_network_stream_cache(stream_t *stream);
 131 int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
 132
 133 inline static int stream_read_char(stream_t *s){
 134   return (s->buf_pos<s->buf_len)?s->buffer[s->buf_pos++]:
 135     (cache_stream_fill_buffer(s)?s->buffer[s->buf_pos++]:-256);
 136 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 137 //  stream_fill_buffer(s);
 138 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 139 //  return 0; // EOF
 140 }
 141
 142 inline static unsigned int stream_read_word(stream_t *s){
 143   int x,y;
 144   x=stream_read_char(s);
 145   y=stream_read_char(s);
 146   return (x<<8)|y;
 147 }
 148
 149 inline static unsigned int stream_read_dword(stream_t *s){
 150   unsigned int y;
 151   y=stream_read_char(s);
 152   y=(y<<8)|stream_read_char(s);
 153   y=(y<<8)|stream_read_char(s);
 154   y=(y<<8)|stream_read_char(s);
 155   return y;
 156 }
 157
 158 #define stream_read_fourcc stream_read_dword_le
 159
 160 inline static unsigned int stream_read_word_le(stream_t *s){
 161   int x,y;
 162   x=stream_read_char(s);
 163   y=stream_read_char(s);
 164   return (y<<8)|x;
 165 }
 166
 167 inline static unsigned int stream_read_dword_le(stream_t *s){
 168   unsigned int y;
 169   y=stream_read_char(s);
 170   y|=stream_read_char(s)<<8;
 171   y|=stream_read_char(s)<<16;
 172   y|=stream_read_char(s)<<24;
 173   return y;
 174 }
 175
 176 inline static uint64_t stream_read_qword(stream_t *s){
 177   uint64_t 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   y=(y<<8)|stream_read_char(s);
 183   y=(y<<8)|stream_read_char(s);
 184   y=(y<<8)|stream_read_char(s);
 185   y=(y<<8)|stream_read_char(s);
 186   return y;
 187 }
 188
 189 inline static uint64_t stream_read_qword_le(stream_t *s){
 190   uint64_t y;
 191   y = stream_read_dword_le(s);
 192   y|=(uint64_t)stream_read_dword_le(s)<<32;
 193   return y;
 194 }
 195
 196 inline static unsigned int stream_read_int24(stream_t *s){
 197   unsigned int y;
 198   y = stream_read_char(s);
 199   y=(y<<8)|stream_read_char(s);
 200   y=(y<<8)|stream_read_char(s);
 201   return y;
 202 }
 203
 204 inline static int stream_read(stream_t *s,char* mem,int total){
 205   int len=total;
 206   while(len>0){
 207     int x;
 208     x=s->buf_len-s->buf_pos;
 209     if(x==0){
 210       if(!cache_stream_fill_buffer(s)) return total-len; // EOF
 211       x=s->buf_len-s->buf_pos;
 212     }
 213     if(s->buf_pos>s->buf_len) mp_msg(MSGT_DEMUX, MSGL_WARN, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
 214     if(x>len) x=len;
 215     memcpy(mem,&s->buffer[s->buf_pos],x);
 216     s->buf_pos+=x; mem+=x; len-=x;
 217   }
 218   return total;
 219 }
 220
 221 inline static unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max) {
 222   int len;
 223   unsigned char* end,*ptr = mem;;
 224   do {
 225     len = s->buf_len-s->buf_pos;
 226     // try to fill the buffer
 227     if(len <= 0 &&
 228        (!cache_stream_fill_buffer(s) ||
 229         (len = s->buf_len-s->buf_pos) <= 0)) break;
 230     end = (unsigned char*) memchr((void*)(s->buffer+s->buf_pos),'\n',len);
 231     if(end) len = end - (s->buffer+s->buf_pos) + 1;
 232     if(len > 0 && max > 1) {
 233       int l = len > max-1 ? max-1 : len;
 234       memcpy(ptr,s->buffer+s->buf_pos,l);
 235       max -= l;
 236       ptr += l;
 237     }
 238     s->buf_pos += len;
 239   } while(!end);
 240   if(s->eof && ptr == mem) return NULL;
 241   if(max > 0) ptr[0] = 0;
 242   return mem;
 243 }
 244
 245
 246 inline static int stream_eof(stream_t *s){
 247   return s->eof;
 248 }
 249
 250 inline static off_t stream_tell(stream_t *s){
 251   return s->pos+s->buf_pos-s->buf_len;
 252 }
 253
 254 inline static int stream_seek(stream_t *s,off_t pos){
 255
 256   mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%qX\n",(long long)pos);
 257
 258   if(pos<s->pos){
 259     off_t x=pos-(s->pos-s->buf_len);
 260     if(x>=0){
 261       s->buf_pos=x;
 262 //      putchar('*');fflush(stdout);
 263       return 1;
 264     }
 265   }
 266
 267   return cache_stream_seek_long(s,pos);
 268 }
 269
 270 inline static int stream_skip(stream_t *s,off_t len){
 271   if( (len<0 && (s->flags & STREAM_SEEK_BW)) || (len>2*STREAM_BUFFER_SIZE && (s->flags & STREAM_SEEK_FW)) ) {
 272     // negative or big skip!
 273     return stream_seek(s,stream_tell(s)+len);
 274   }
 275   while(len>0){
 276     int x=s->buf_len-s->buf_pos;
 277     if(x==0){
 278       if(!cache_stream_fill_buffer(s)) return 0; // EOF
 279       x=s->buf_len-s->buf_pos;
 280     }
 281     if(x>len) x=len;
 282     //memcpy(mem,&s->buf[s->buf_pos],x);
 283     s->buf_pos+=x; len-=x;
 284   }
 285   return 1;
 286 }
 287
 288 void stream_reset(stream_t *s);
 289 int stream_control(stream_t *s, int cmd, void *arg);
 290 stream_t* new_stream(int fd,int type);
 291 void free_stream(stream_t *s);
 292 stream_t* new_memory_stream(unsigned char* data,int len);
 293 stream_t* open_stream(char* filename,char** options,int* file_format);
 294 stream_t* open_stream_full(char* filename,int mode, char** options, int* file_format);
 295 stream_t* open_output_stream(char* filename,char** options);
 296
 297 extern int dvd_title;
 298 extern int dvd_chapter;
 299 extern int dvd_last_chapter;
 300 extern int dvd_angle;
 301
 302 extern char * audio_stream;
 303
 304 typedef struct {
 305  int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
 306  int language;
 307  int type;
 308  int channels;
 309 } stream_language_t;
 310
 311 #endif // STREAM_H