libmpdemux/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
  25 #define STREAM_BUFFER_SIZE 2048
  26
  27 #define VCD_SECTOR_SIZE 2352
  28 #define VCD_SECTOR_OFFS 24
  29 #define VCD_SECTOR_DATA 2324
  30
  31 /// atm it will always use mode == STREAM_READ
  32 /// streams that use the new api should check the mode at open
  33 #define STREAM_READ  0
  34 #define STREAM_WRITE 1
  35 /// Seek flags, if not mannualy set and s->seek isn't NULL
  36 /// STREAM_SEEK is automaticly set
  37 #define STREAM_SEEK_BW  2
  38 #define STREAM_SEEK_FW  4
  39 #define STREAM_SEEK  (STREAM_SEEK_BW|STREAM_SEEK_FW)
  40
  41 //////////// Open return code
  42 /// This can't open the requested protocol (used by stream wich have a
  43 /// * protocol when they don't know the requested protocol)
  44 #define STREAM_UNSUPORTED -1
  45 #define STREAM_ERROR 0
  46 #define STREAM_OK    1
  47
  48 #define MAX_STREAM_PROTOCOLS 10
  49
  50 #define STREAM_CTRL_RESET 0
  51 #define STREAM_CTRL_GET_TIME_LENGTH 1
  52
  53 #ifdef MPLAYER_NETWORK
  54 #include "network.h"
  55 #endif
  56
  57 struct stream_st;
  58 typedef struct stream_info_st {
  59   const char *info;
  60   const char *name;
  61   const char *author;
  62   const char *comment;
  63   /// mode isn't used atm (ie always READ) but it shouldn't be ignored
  64   /// opts is at least in it's defaults settings and may have been
  65   /// altered by url parsing if enabled and the options string parsing.
  66   int (*open)(struct stream_st* st, int mode, void* opts, int* file_format);
  67   char* protocols[MAX_STREAM_PROTOCOLS];
  68   void* opts;
  69   int opts_url; /* If this is 1 we will parse the url as an option string
  70                  * too. Otherwise options are only parsed from the
  71                  * options string given to open_stream_plugin */
  72 } stream_info_t;
  73
  74 typedef struct stream_st {
  75   // Read
  76   int (*fill_buffer)(struct stream_st *s, char* buffer, int max_len);
  77   // Write
  78   int (*write_buffer)(struct stream_st *s, char* buffer, int len);
  79   // Seek
  80   int (*seek)(struct stream_st *s,off_t pos);
  81   // Control
  82   // Will be later used to let streams like dvd and cdda report
  83   // their structure (ie tracks, chapters, etc)
  84   int (*control)(struct stream_st *s,int cmd,void* arg);
  85   // Close
  86   void (*close)(struct stream_st *s);
  87
  88   int fd;   // file descriptor, see man open(2)
  89   int type; // see STREAMTYPE_*
  90   int flags;
  91   int sector_size; // sector size (seek will be aligned on this size if non 0)
  92   unsigned int buf_pos,buf_len;
  93   off_t pos,start_pos,end_pos;
  94   int eof;
  95   unsigned int cache_pid;
  96   void* cache_data;
  97   void* priv; // used for DVD, TV, RTSP etc
  98   char* url;  // strdup() of filename/url
  99 #ifdef MPLAYER_NETWORK
 100   streaming_ctrl_t *streaming_ctrl;
 101 #endif
 102   unsigned char buffer[STREAM_BUFFER_SIZE>VCD_SECTOR_SIZE?STREAM_BUFFER_SIZE:VCD_SECTOR_SIZE];
 103 } stream_t;
 104
 105 #ifdef USE_STREAM_CACHE
 106 int stream_enable_cache(stream_t *stream,int size,int min,int prefill);
 107 int cache_stream_fill_buffer(stream_t *s);
 108 int cache_stream_seek_long(stream_t *s,off_t pos);
 109 #else
 110 // no cache, define wrappers:
 111 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
 112 #define cache_stream_seek_long(x,y) stream_seek_long(x,y)
 113 #define stream_enable_cache(x,y,z,w) 1
 114 #endif
 115 void fixup_network_stream_cache(stream_t *stream);
 116
 117 inline static int stream_read_char(stream_t *s){
 118   return (s->buf_pos<s->buf_len)?s->buffer[s->buf_pos++]:
 119     (cache_stream_fill_buffer(s)?s->buffer[s->buf_pos++]:-256);
 120 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 121 //  stream_fill_buffer(s);
 122 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 123 //  return 0; // EOF
 124 }
 125
 126 inline static unsigned int stream_read_word(stream_t *s){
 127   int x,y;
 128   x=stream_read_char(s);
 129   y=stream_read_char(s);
 130   return (x<<8)|y;
 131 }
 132
 133 inline static unsigned int stream_read_dword(stream_t *s){
 134   unsigned int y;
 135   y=stream_read_char(s);
 136   y=(y<<8)|stream_read_char(s);
 137   y=(y<<8)|stream_read_char(s);
 138   y=(y<<8)|stream_read_char(s);
 139   return y;
 140 }
 141
 142 #define stream_read_fourcc stream_read_dword_le
 143
 144 inline static unsigned int stream_read_word_le(stream_t *s){
 145   int x,y;
 146   x=stream_read_char(s);
 147   y=stream_read_char(s);
 148   return (y<<8)|x;
 149 }
 150
 151 inline static unsigned int stream_read_dword_le(stream_t *s){
 152   unsigned int y;
 153   y=stream_read_char(s);
 154   y|=stream_read_char(s)<<8;
 155   y|=stream_read_char(s)<<16;
 156   y|=stream_read_char(s)<<24;
 157   return y;
 158 }
 159
 160 inline static uint64_t stream_read_qword(stream_t *s){
 161   uint64_t y;
 162   y = stream_read_char(s);
 163   y=(y<<8)|stream_read_char(s);
 164   y=(y<<8)|stream_read_char(s);
 165   y=(y<<8)|stream_read_char(s);
 166   y=(y<<8)|stream_read_char(s);
 167   y=(y<<8)|stream_read_char(s);
 168   y=(y<<8)|stream_read_char(s);
 169   y=(y<<8)|stream_read_char(s);
 170   return y;
 171 }
 172
 173 inline static uint64_t stream_read_qword_le(stream_t *s){
 174   uint64_t y;
 175   y = stream_read_char(s);
 176   y|=stream_read_char(s)<<8;
 177   y|=stream_read_char(s)<<16;
 178   y|=stream_read_char(s)<<24;
 179   y|=(uint64_t)stream_read_char(s)<<32;
 180   y|=(uint64_t)stream_read_char(s)<<40;
 181   y|=(uint64_t)stream_read_char(s)<<48;
 182   y|=(uint64_t)stream_read_char(s)<<56;
 183   return y;
 184 }
 185
 186 inline static unsigned int stream_read_int24(stream_t *s){
 187   unsigned int y;
 188   y = stream_read_char(s);
 189   y=(y<<8)|stream_read_char(s);
 190   y=(y<<8)|stream_read_char(s);
 191   return y;
 192 }
 193
 194 inline static int stream_read(stream_t *s,char* mem,int total){
 195   int len=total;
 196   while(len>0){
 197     int x;
 198     x=s->buf_len-s->buf_pos;
 199     if(x==0){
 200       if(!cache_stream_fill_buffer(s)) return total-len; // EOF
 201       x=s->buf_len-s->buf_pos;
 202     }
 203     if(s->buf_pos>s->buf_len) mp_msg(MSGT_DEMUX, MSGL_WARN, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
 204     if(x>len) x=len;
 205     memcpy(mem,&s->buffer[s->buf_pos],x);
 206     s->buf_pos+=x; mem+=x; len-=x;
 207   }
 208   return total;
 209 }
 210
 211 inline static unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max) {
 212   int len;
 213   unsigned char* end,*ptr = mem;;
 214   do {
 215     len = s->buf_len-s->buf_pos;
 216     // try to fill the buffer
 217     if(len <= 0 &&
 218        (!cache_stream_fill_buffer(s) ||
 219         (len = s->buf_len-s->buf_pos) <= 0)) break;
 220     end = (unsigned char*) memchr((void*)(s->buffer+s->buf_pos),'\n',len);
 221     if(end) len = end - (s->buffer+s->buf_pos) + 1;
 222     if(len > 0 && max > 1) {
 223       int l = len > max-1 ? max-1 : len;
 224       memcpy(ptr,s->buffer+s->buf_pos,l);
 225       max -= l;
 226       ptr += l;
 227     }
 228     s->buf_pos += len;
 229   } while(!end);
 230   if(s->eof && ptr == mem) return NULL;
 231   if(max > 0) ptr[0] = 0;
 232   return mem;
 233 }
 234
 235
 236 inline static int stream_eof(stream_t *s){
 237   return s->eof;
 238 }
 239
 240 inline static off_t stream_tell(stream_t *s){
 241   return s->pos+s->buf_pos-s->buf_len;
 242 }
 243
 244 inline static int stream_seek(stream_t *s,off_t pos){
 245
 246   mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%qX\n",(long long)pos);
 247
 248   if(pos<s->pos){
 249     off_t x=pos-(s->pos-s->buf_len);
 250     if(x>=0){
 251       s->buf_pos=x;
 252 //      putchar('*');fflush(stdout);
 253       return 1;
 254     }
 255   }
 256
 257   return cache_stream_seek_long(s,pos);
 258 }
 259
 260 inline static int stream_skip(stream_t *s,off_t len){
 261   if( (len<0 && (s->flags & STREAM_SEEK_BW)) || (len>2*STREAM_BUFFER_SIZE && (s->flags & STREAM_SEEK_FW)) ) {
 262     // negative or big skip!
 263     return stream_seek(s,stream_tell(s)+len);
 264   }
 265   while(len>0){
 266     int x=s->buf_len-s->buf_pos;
 267     if(x==0){
 268       if(!cache_stream_fill_buffer(s)) return 0; // EOF
 269       x=s->buf_len-s->buf_pos;
 270     }
 271     if(x>len) x=len;
 272     //memcpy(mem,&s->buf[s->buf_pos],x);
 273     s->buf_pos+=x; len-=x;
 274   }
 275   return 1;
 276 }
 277
 278 void stream_reset(stream_t *s);
 279 int stream_control(stream_t *s, int cmd, void *arg);
 280 stream_t* new_stream(int fd,int type);
 281 void free_stream(stream_t *s);
 282 stream_t* new_memory_stream(unsigned char* data,int len);
 283 stream_t* open_stream(char* filename,char** options,int* file_format);
 284 stream_t* open_stream_full(char* filename,int mode, char** options, int* file_format);
 285
 286 //#ifdef USE_DVDREAD
 287 extern int dvd_title;
 288 extern int dvd_chapter;
 289 extern int dvd_last_chapter;
 290 extern int dvd_angle;
 291 //#endif
 292
 293 extern char * audio_stream;
 294
 295 #ifdef USE_DVDNAV
 296 #include "dvdnav_stream.h"
 297 #endif
 298
 299 #ifdef USE_DVDREAD
 300
 301 #ifdef USE_MPDVDKIT
 302 #include "libmpdvdkit2/dvd_reader.h"
 303 #include "libmpdvdkit2/ifo_types.h"
 304 #include "libmpdvdkit2/ifo_read.h"
 305 #include "libmpdvdkit2/nav_read.h"
 306 #else
 307 #include <dvdread/dvd_reader.h>
 308 #include <dvdread/ifo_types.h>
 309 #include <dvdread/ifo_read.h>
 310 #include <dvdread/nav_read.h>
 311 #endif
 312
 313 typedef struct {
 314  int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
 315  int language;
 316  int type;
 317  int channels;
 318 } stream_language_t;
 319
 320 typedef struct {
 321   dvd_reader_t *dvd;
 322   dvd_file_t *title;
 323   ifo_handle_t *vmg_file;
 324   tt_srpt_t *tt_srpt;
 325   ifo_handle_t *vts_file;
 326   vts_ptt_srpt_t *vts_ptt_srpt;
 327   pgc_t *cur_pgc;
 328 //
 329   int cur_title;
 330   int cur_cell;
 331   int last_cell;
 332   int cur_pack;
 333   int cell_last_pack;
 334 // Navi:
 335   int packs_left;
 336   dsi_t dsi_pack;
 337   int angle_seek;
 338 // audio datas
 339   int nr_of_channels;
 340   stream_language_t audio_streams[32];
 341 // subtitles
 342   int nr_of_subtitles;
 343   stream_language_t subtitles[32];
 344 } dvd_priv_t;
 345
 346 int dvd_number_of_subs(stream_t *stream);
 347 int dvd_lang_from_sid(stream_t *stream, int id);
 348 int dvd_aid_from_lang(stream_t *stream, unsigned char* lang);
 349 int dvd_sid_from_lang(stream_t *stream, unsigned char* lang);
 350 int dvd_chapter_from_cell(dvd_priv_t *dvd,int title,int cell);
 351
 352 #endif
 353
 354 #endif // __STREAM_H