RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity

stream: uncrustify stream.c/.h 

The formatting almost made me break out in tears.
This commit is contained in:
wm4 2013-01-24 17:43:07 +01:00
parent 42b47624f8
commit 47cec75291
2 changed files with 655 additions and 573 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

854
stream/stream.c
View File

File diff suppressed because it is too large Load Diff

374
stream/stream.h
View File

@ -57,7 +57,7 @@
#define STREAMTYPE_AVDEVICE 21 #define STREAMTYPE_AVDEVICE 21
#define STREAM_BUFFER_SIZE 2048 #define STREAM_BUFFER_SIZE 2048
#define STREAM_MAX_SECTOR_SIZE (8*1024) #define STREAM_MAX_SECTOR_SIZE (8 * 1024)
#define VCD_SECTOR_SIZE 2352 #define VCD_SECTOR_SIZE 2352
#define VCD_SECTOR_OFFS 24 #define VCD_SECTOR_OFFS 24
@ -71,7 +71,7 @@
/// MP_STREAM_SEEK is automaticly set /// MP_STREAM_SEEK is automaticly set
#define MP_STREAM_SEEK_BW 2 #define MP_STREAM_SEEK_BW 2
#define MP_STREAM_SEEK_FW 4 #define MP_STREAM_SEEK_FW 4
#define MP_STREAM_SEEK (MP_STREAM_SEEK_BW|MP_STREAM_SEEK_FW) #define MP_STREAM_SEEK (MP_STREAM_SEEK_BW | MP_STREAM_SEEK_FW)
//////////// Open return code //////////// Open return code
#define STREAM_REDIRECTED -2 #define STREAM_REDIRECTED -2
@ -103,26 +103,28 @@
#define STREAM_CTRL_GET_CACHE_IDLE 17 #define STREAM_CTRL_GET_CACHE_IDLE 17
struct stream_lang_req { struct stream_lang_req {
int type; // STREAM_AUDIO, STREAM_SUB int type; // STREAM_AUDIO, STREAM_SUB
int id; int id;
char name[50]; char name[50];
}; };
typedef enum { typedef enum {
streaming_stopped_e, streaming_stopped_e,
streaming_playing_e streaming_playing_e
} streaming_status; } streaming_status;
typedef struct streaming_control { typedef struct streaming_control {
URL_t *url; URL_t *url;
streaming_status status; streaming_status status;
char *buffer; char *buffer;
unsigned int buffer_size; unsigned int buffer_size;
unsigned int buffer_pos; unsigned int buffer_pos;
unsigned int bandwidth; // The downstream available unsigned int bandwidth; // The downstream available
int (*streaming_read)( int fd, char *buffer, int buffer_size, struct streaming_control *stream_ctrl ); int (*streaming_read)(int fd, char *buffer, int buffer_size,
int (*streaming_seek)( int fd, int64_t pos, struct streaming_control *stream_ctrl ); struct streaming_control *stream_ctrl);
void *data; int (*streaming_seek)(int fd, int64_t pos,
struct streaming_control *stream_ctrl);
void *data;
// hacks for asf // hacks for asf
int *audio_id_ptr; int *audio_id_ptr;
int *video_id_ptr; int *video_id_ptr;
@ -130,56 +132,58 @@ typedef struct streaming_control {
struct stream; struct stream;
typedef struct stream_info_st { typedef struct stream_info_st {
const char *info; const char *info;
const char *name; const char *name;
const char *author; const char *author;
const char *comment; const char *comment;
/// mode isn't used atm (ie always READ) but it shouldn't be ignored /// mode isn't used atm (ie always READ) but it shouldn't be ignored
/// opts is at least in it's defaults settings and may have been /// opts is at least in it's defaults settings and may have been
/// altered by url parsing if enabled and the options string parsing. /// altered by url parsing if enabled and the options string parsing.
int (*open)(struct stream* st, int mode, void* opts, int* file_format); int (*open)(struct stream *st, int mode, void *opts, int *file_format);
const char* protocols[MAX_STREAM_PROTOCOLS]; const char *protocols[MAX_STREAM_PROTOCOLS];
const void* opts; const void *opts;
int opts_url; /* If this is 1 we will parse the url as an option string int opts_url; /* If this is 1 we will parse the url as an option string
* too. Otherwise options are only parsed from the * too. Otherwise options are only parsed from the
* options string given to open_stream_plugin */ * options string given to open_stream_plugin */
} stream_info_t; } stream_info_t;
typedef struct stream { typedef struct stream {
// Read // Read
int (*fill_buffer)(struct stream *s, char* buffer, int max_len); int (*fill_buffer)(struct stream *s, char *buffer, int max_len);
// Write // Write
int (*write_buffer)(struct stream *s, char* buffer, int len); int (*write_buffer)(struct stream *s, char *buffer, int len);
// Seek // Seek
int (*seek)(struct stream *s,int64_t pos); int (*seek)(struct stream *s, int64_t pos);
// Control // Control
// Will be later used to let streams like dvd and cdda report // Will be later used to let streams like dvd and cdda report
// their structure (ie tracks, chapters, etc) // their structure (ie tracks, chapters, etc)
int (*control)(struct stream *s,int cmd,void* arg); int (*control)(struct stream *s, int cmd, void *arg);
// Close // Close
void (*close)(struct stream *s); void (*close)(struct stream *s);
int fd; // file descriptor, see man open(2) int fd; // file descriptor, see man open(2)
int type; // see STREAMTYPE_* int type; // see STREAMTYPE_*
int flags; int flags;
int sector_size; // sector size (seek will be aligned on this size if non 0) int sector_size; // sector size (seek will be aligned on this size if non 0)
int read_chunk; // maximum amount of data to read at once to limit latency (0 for default) int read_chunk; // maximum amount of data to read at once to limit latency (0 for default)
unsigned int buf_pos,buf_len; unsigned int buf_pos, buf_len;
int64_t pos,start_pos,end_pos; int64_t pos, start_pos, end_pos;
int eof; int eof;
int mode; //STREAM_READ or STREAM_WRITE int mode; //STREAM_READ or STREAM_WRITE
bool streaming; // known to be a network stream if true bool streaming; // known to be a network stream if true
int cache_size; // cache size in KB to use if enabled int cache_size; // cache size in KB to use if enabled
bool cached; // cache active bool cached; // cache active
unsigned int cache_pid; unsigned int cache_pid;
void* cache_data; void *cache_data;
void* priv; // used for DVD, TV, RTSP etc void *priv; // used for DVD, TV, RTSP etc
char* url; // strdup() of filename/url char *url; // strdup() of filename/url
char *mime_type; // when HTTP streaming is used char *mime_type; // when HTTP streaming is used
char *lavf_type; // name of expected demuxer type for lavf char *lavf_type; // name of expected demuxer type for lavf
struct MPOpts *opts; struct MPOpts *opts;
streaming_ctrl_t *streaming_ctrl; streaming_ctrl_t *streaming_ctrl;
unsigned char buffer[STREAM_BUFFER_SIZE>STREAM_MAX_SECTOR_SIZE?STREAM_BUFFER_SIZE:STREAM_MAX_SECTOR_SIZE]; unsigned char buffer[STREAM_BUFFER_SIZE >
STREAM_MAX_SECTOR_SIZE ? STREAM_BUFFER_SIZE :
STREAM_MAX_SECTOR_SIZE];
} stream_t; } stream_t;
#ifdef CONFIG_NETWORKING #ifdef CONFIG_NETWORKING
@ -191,156 +195,182 @@ int stream_seek_long(stream_t *s, int64_t pos);
#ifdef CONFIG_STREAM_CACHE #ifdef CONFIG_STREAM_CACHE
int stream_enable_cache_percent(stream_t *stream, int64_t stream_cache_size, int stream_enable_cache_percent(stream_t *stream, int64_t stream_cache_size,
float stream_cache_min_percent, float stream_cache_seek_min_percent); float stream_cache_min_percent,
int stream_enable_cache(stream_t *stream,int64_t size,int64_t min,int64_t prefill); float stream_cache_seek_min_percent);
int stream_enable_cache(stream_t *stream, int64_t size, int64_t min,
int64_t prefill);
int cache_stream_fill_buffer(stream_t *s); int cache_stream_fill_buffer(stream_t *s);
int cache_stream_seek_long(stream_t *s,int64_t pos); int cache_stream_seek_long(stream_t *s, int64_t pos);
#else #else
// no cache, define wrappers: // no cache, define wrappers:
#define cache_stream_fill_buffer(x) stream_fill_buffer(x) #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
#define cache_stream_seek_long(x,y) stream_seek_long(x,y) #define cache_stream_seek_long(x, y) stream_seek_long(x, y)
#define stream_enable_cache(x,y,z,w) 1 #define stream_enable_cache(x, y, z, w) 1
#define stream_enable_cache_percent(x,y,z,w) 1 #define stream_enable_cache_percent(x, y, z, w) 1
#endif #endif
int stream_write_buffer(stream_t *s, unsigned char *buf, int len); int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
inline static int stream_read_char(stream_t *s){ inline static int stream_read_char(stream_t *s)
return (s->buf_pos<s->buf_len)?s->buffer[s->buf_pos++]: {
(cache_stream_fill_buffer(s)?s->buffer[s->buf_pos++]:-256); return (s->buf_pos < s->buf_len) ? s->buffer[s->buf_pos++] :
(cache_stream_fill_buffer(s) ? s->buffer[s->buf_pos++] : -256);
// if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++]; // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
// stream_fill_buffer(s); // stream_fill_buffer(s);
// if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++]; // if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
// return 0; // EOF // return 0; // EOF
} }
inline static unsigned int stream_read_word(stream_t *s){ inline static unsigned int stream_read_word(stream_t *s)
int x,y; {
x=stream_read_char(s); int x, y;
y=stream_read_char(s); x = stream_read_char(s);
return (x<<8)|y; y = stream_read_char(s);
return (x << 8) | y;
} }
inline static unsigned int stream_read_dword(stream_t *s){ inline static unsigned int stream_read_dword(stream_t *s)
unsigned int y; {
y=stream_read_char(s); unsigned int y;
y=(y<<8)|stream_read_char(s); y = stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
return y; y = (y << 8) | stream_read_char(s);
return y;
} }
#define stream_read_fourcc stream_read_dword_le #define stream_read_fourcc stream_read_dword_le
inline static unsigned int stream_read_word_le(stream_t *s){ inline static unsigned int stream_read_word_le(stream_t *s)
int x,y; {
x=stream_read_char(s); int x, y;
y=stream_read_char(s); x = stream_read_char(s);
return (y<<8)|x; y = stream_read_char(s);
return (y << 8) | x;
} }
inline static uint32_t stream_read_dword_le(stream_t *s) inline static uint32_t stream_read_dword_le(stream_t *s)
{ {
unsigned int y; unsigned int y;
y=stream_read_char(s); y = stream_read_char(s);
y|=stream_read_char(s)<<8; y |= stream_read_char(s) << 8;
y|=stream_read_char(s)<<16; y |= stream_read_char(s) << 16;
y|=stream_read_char(s)<<24; y |= stream_read_char(s) << 24;
return y; return y;
} }
inline static uint64_t stream_read_qword(stream_t *s){ inline static uint64_t stream_read_qword(stream_t *s)
uint64_t y; {
y = stream_read_char(s); uint64_t y;
y=(y<<8)|stream_read_char(s); y = stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
return y; y = (y << 8) | stream_read_char(s);
return y;
} }
inline static uint64_t stream_read_qword_le(stream_t *s){ inline static uint64_t stream_read_qword_le(stream_t *s)
uint64_t y; {
y = stream_read_dword_le(s); uint64_t y;
y|=(uint64_t)stream_read_dword_le(s)<<32; y = stream_read_dword_le(s);
return y; y |= (uint64_t)stream_read_dword_le(s) << 32;
return y;
} }
inline static unsigned int stream_read_int24(stream_t *s){ inline static unsigned int stream_read_int24(stream_t *s)
unsigned int y; {
y = stream_read_char(s); unsigned int y;
y=(y<<8)|stream_read_char(s); y = stream_read_char(s);
y=(y<<8)|stream_read_char(s); y = (y << 8) | stream_read_char(s);
return y; y = (y << 8) | stream_read_char(s);
return y;
} }
inline static int stream_read(stream_t *s,char* mem,int total){ inline static int stream_read(stream_t *s, char *mem, int total)
int len=total; {
while(len>0){ int len = total;
int x; while (len > 0) {
x=s->buf_len-s->buf_pos; int x;
if(x==0){ x = s->buf_len - s->buf_pos;
if(!cache_stream_fill_buffer(s)) return total-len; // EOF if (x == 0) {
x=s->buf_len-s->buf_pos; if (!cache_stream_fill_buffer(s))
return total - len; // EOF
x = s->buf_len - s->buf_pos;
}
if (s->buf_pos > s->buf_len)
mp_msg(MSGT_DEMUX, MSGL_WARN,
"stream_read: WARNING! s->buf_pos>s->buf_len\n");
if (x > len)
x = len;
memcpy(mem, &s->buffer[s->buf_pos], x);
s->buf_pos += x;
mem += x;
len -= x;
} }
if(s->buf_pos>s->buf_len) mp_msg(MSGT_DEMUX, MSGL_WARN, "stream_read: WARNING! s->buf_pos>s->buf_len\n"); return total;
if(x>len) x=len;
memcpy(mem,&s->buffer[s->buf_pos],x);
s->buf_pos+=x; mem+=x; len-=x;
}
return total;
} }
unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max, int utf16); unsigned char *stream_read_line(stream_t *s, unsigned char *mem, int max,
int utf16);
inline static int stream_eof(stream_t *s){ inline static int stream_eof(stream_t *s)
return s->eof; {
return s->eof;
} }
inline static int64_t stream_tell(stream_t *s){ inline static int64_t stream_tell(stream_t *s)
return s->pos+s->buf_pos-s->buf_len; {
return s->pos + s->buf_pos - s->buf_len;
} }
inline static int stream_seek(stream_t *s,int64_t pos){ inline static int stream_seek(stream_t *s, int64_t pos)
{
mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%llX\n", (long long)pos); mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%llX\n", (long long)pos);
if (pos < 0) { if (pos < 0) {
mp_msg(MSGT_DEMUX, MSGL_ERR, "Invalid seek to negative position %llx!\n", mp_msg(MSGT_DEMUX, MSGL_ERR,
(long long)pos); "Invalid seek to negative position %llx!\n",
pos = 0; (long long)pos);
} pos = 0;
if(pos<s->pos){ }
int64_t x=pos-(s->pos-s->buf_len); if (pos < s->pos) {
if(x>=0){ int64_t x = pos - (s->pos - s->buf_len);
s->buf_pos=x; if (x >= 0) {
s->eof = 0; s->buf_pos = x;
s->eof = 0;
// putchar('*');fflush(stdout); // putchar('*');fflush(stdout);
return 1; return 1;
}
} }
}
return cache_stream_seek_long(s,pos); return cache_stream_seek_long(s, pos);
} }
inline static int stream_skip(stream_t *s,int64_t len){ inline static int stream_skip(stream_t *s, int64_t len)
if( len<0 || (len>2*STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW)) ) { {
// negative or big skip! if (len < 0 ||
return stream_seek(s,stream_tell(s)+len); (len > 2 * STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW))) {
} // negative or big skip!
while(len>0){ return stream_seek(s, stream_tell(s) + len);
int x=s->buf_len-s->buf_pos;
if(x==0){
if(!cache_stream_fill_buffer(s)) return 0; // EOF
x=s->buf_len-s->buf_pos;
} }
if(x>len) x=len; while (len > 0) {
//memcpy(mem,&s->buf[s->buf_pos],x); int x = s->buf_len - s->buf_pos;
s->buf_pos+=x; len-=x; if (x == 0) {
} if (!cache_stream_fill_buffer(s))
return 1; return 0; // EOF
x = s->buf_len - s->buf_pos;
}
if (x > len)
x = len;
//memcpy(mem,&s->buf[s->buf_pos],x);
s->buf_pos += x;
len -= x;
}
return 1;
} }
struct MPOpts; struct MPOpts;
@ -355,9 +385,9 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
void stream_reset(stream_t *s); void stream_reset(stream_t *s);
int stream_control(stream_t *s, int cmd, void *arg); int stream_control(stream_t *s, int cmd, void *arg);
void stream_update_size(stream_t *s); void stream_update_size(stream_t *s);
stream_t* new_stream(int fd,int type); stream_t *new_stream(int fd, int type);
void free_stream(stream_t *s); void free_stream(stream_t *s);
stream_t* new_memory_stream(unsigned char* data,int len); stream_t *new_memory_stream(unsigned char *data, int len);
stream_t *open_stream(const char *filename, struct MPOpts *options, stream_t *open_stream(const char *filename, struct MPOpts *options,
int *file_format); int *file_format);
stream_t *open_output_stream(const char *filename, struct MPOpts *options); stream_t *open_output_stream(const char *filename, struct MPOpts *options);
@ -367,7 +397,7 @@ struct stream *new_ds_stream(struct demux_stream *ds);
/// Set the callback to be used by libstream to check for user /// Set the callback to be used by libstream to check for user
/// interruption during long blocking operations (cache filling, etc). /// interruption during long blocking operations (cache filling, etc).
struct input_ctx; struct input_ctx;
void stream_set_interrupt_callback(int (*cb)(struct input_ctx*, int), void stream_set_interrupt_callback(int (*cb)(struct input_ctx *, int),
struct input_ctx *ctx); struct input_ctx *ctx);
/// Call the interrupt checking callback if there is one and /// Call the interrupt checking callback if there is one and
/// wait for time milliseconds /// wait for time milliseconds
@ -385,10 +415,10 @@ extern int dvd_angle;
extern char *bluray_device; extern char *bluray_device;
typedef struct { typedef struct {
int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
int language; int language;
int type; int type;
int channels; int channels;
} stream_language_t; } stream_language_t;
#endif /* MPLAYER_STREAM_H */ #endif /* MPLAYER_STREAM_H */