stream: uncrustify stream.c/.h

The formatting almost made me break out in tears.

1 files changed, 203 insertions, 173 deletions

diff --git a/stream/stream.h b/stream/stream.h
index 43980197e7..4beefc91bd 100644
--- a/stream/stream.h
+++ b/stream/stream.h
@@ -57,7 +57,7 @@
 #define STREAMTYPE_AVDEVICE 21
 
 #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_OFFS 24
@@ -71,7 +71,7 @@
 /// MP_STREAM_SEEK is automaticly set
 #define MP_STREAM_SEEK_BW  2
 #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
 #define STREAM_REDIRECTED -2
@@ -103,26 +103,28 @@
 #define STREAM_CTRL_GET_CACHE_IDLE 17
 
 struct stream_lang_req {
-	int type; // STREAM_AUDIO, STREAM_SUB
-	int id;
-        char name[50];
+    int type;     // STREAM_AUDIO, STREAM_SUB
+    int id;
+    char name[50];
 };
 
 typedef enum {
-	streaming_stopped_e,
-	streaming_playing_e
+    streaming_stopped_e,
+    streaming_playing_e
 } streaming_status;
 
 typedef struct streaming_control {
-	URL_t *url;
-	streaming_status status;
-	char *buffer;
-	unsigned int buffer_size;
-	unsigned int buffer_pos;
-	unsigned int bandwidth;	// The downstream available
-	int (*streaming_read)( int fd, char *buffer, int buffer_size, struct streaming_control *stream_ctrl );
-	int (*streaming_seek)( int fd, int64_t pos, struct streaming_control *stream_ctrl );
-	void *data;
+    URL_t *url;
+    streaming_status status;
+    char *buffer;
+    unsigned int buffer_size;
+    unsigned int buffer_pos;
+    unsigned int bandwidth;     // The downstream available
+    int (*streaming_read)(int fd, char *buffer, int buffer_size,
+                          struct streaming_control *stream_ctrl);
+    int (*streaming_seek)(int fd, int64_t pos,
+                          struct streaming_control *stream_ctrl);
+    void *data;
     // hacks for asf
     int *audio_id_ptr;
     int *video_id_ptr;
@@ -130,56 +132,58 @@ typedef struct streaming_control {
 
 struct stream;
 typedef struct stream_info_st {
-  const char *info;
-  const char *name;
-  const char *author;
-  const char *comment;
-  /// 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
-  /// altered by url parsing if enabled and the options string parsing.
-  int (*open)(struct stream* st, int mode, void* opts, int* file_format);
-  const char* protocols[MAX_STREAM_PROTOCOLS];
-  const void* opts;
-  int opts_url; /* If this is 1 we will parse the url as an option string
-		 * too. Otherwise options are only parsed from the
-		 * options string given to open_stream_plugin */
+    const char *info;
+    const char *name;
+    const char *author;
+    const char *comment;
+    /// 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
+    /// altered by url parsing if enabled and the options string parsing.
+    int (*open)(struct stream *st, int mode, void *opts, int *file_format);
+    const char *protocols[MAX_STREAM_PROTOCOLS];
+    const void *opts;
+    int opts_url; /* If this is 1 we will parse the url as an option string
+                   * too. Otherwise options are only parsed from the
+                   * options string given to open_stream_plugin */
 } stream_info_t;
 
 typedef struct stream {
-  // Read
-  int (*fill_buffer)(struct stream *s, char* buffer, int max_len);
-  // Write
-  int (*write_buffer)(struct stream *s, char* buffer, int len);
-  // Seek
-  int (*seek)(struct stream *s,int64_t pos);
-  // Control
-  // Will be later used to let streams like dvd and cdda report
-  // their structure (ie tracks, chapters, etc)
-  int (*control)(struct stream *s,int cmd,void* arg);
-  // Close
-  void (*close)(struct stream *s);
-
-  int fd;   // file descriptor, see man open(2)
-  int type; // see STREAMTYPE_*
-  int flags;
-  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)
-  unsigned int buf_pos,buf_len;
-  int64_t pos,start_pos,end_pos;
-  int eof;
-  int mode; //STREAM_READ or STREAM_WRITE
-  bool streaming;       // known to be a network stream if true
-  int cache_size;       // cache size in KB to use if enabled
-  bool cached;          // cache active
-  unsigned int cache_pid;
-  void* cache_data;
-  void* priv; // used for DVD, TV, RTSP etc
-  char* url;  // strdup() of filename/url
-  char *mime_type; // when HTTP streaming is used
-  char *lavf_type; // name of expected demuxer type for lavf
-  struct MPOpts *opts;
-  streaming_ctrl_t *streaming_ctrl;
-  unsigned char buffer[STREAM_BUFFER_SIZE>STREAM_MAX_SECTOR_SIZE?STREAM_BUFFER_SIZE:STREAM_MAX_SECTOR_SIZE];
+    // Read
+    int (*fill_buffer)(struct stream *s, char *buffer, int max_len);
+    // Write
+    int (*write_buffer)(struct stream *s, char *buffer, int len);
+    // Seek
+    int (*seek)(struct stream *s, int64_t pos);
+    // Control
+    // Will be later used to let streams like dvd and cdda report
+    // their structure (ie tracks, chapters, etc)
+    int (*control)(struct stream *s, int cmd, void *arg);
+    // Close
+    void (*close)(struct stream *s);
+
+    int fd; // file descriptor, see man open(2)
+    int type; // see STREAMTYPE_*
+    int flags;
+    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)
+    unsigned int buf_pos, buf_len;
+    int64_t pos, start_pos, end_pos;
+    int eof;
+    int mode; //STREAM_READ or STREAM_WRITE
+    bool streaming;     // known to be a network stream if true
+    int cache_size;     // cache size in KB to use if enabled
+    bool cached;        // cache active
+    unsigned int cache_pid;
+    void *cache_data;
+    void *priv; // used for DVD, TV, RTSP etc
+    char *url; // strdup() of filename/url
+    char *mime_type; // when HTTP streaming is used
+    char *lavf_type; // name of expected demuxer type for lavf
+    struct MPOpts *opts;
+    streaming_ctrl_t *streaming_ctrl;
+    unsigned char buffer[STREAM_BUFFER_SIZE >
+                         STREAM_MAX_SECTOR_SIZE ? STREAM_BUFFER_SIZE :
+                         STREAM_MAX_SECTOR_SIZE];
 } stream_t;
 
 #ifdef CONFIG_NETWORKING
@@ -191,156 +195,182 @@ int stream_seek_long(stream_t *s, int64_t pos);
 
 #ifdef CONFIG_STREAM_CACHE
 int stream_enable_cache_percent(stream_t *stream, int64_t stream_cache_size,
-    float stream_cache_min_percent, float stream_cache_seek_min_percent);
-int stream_enable_cache(stream_t *stream,int64_t size,int64_t min,int64_t prefill);
+                                float stream_cache_min_percent,
+                                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_seek_long(stream_t *s,int64_t pos);
+int cache_stream_seek_long(stream_t *s, int64_t pos);
 #else
 // no cache, define wrappers:
 #define cache_stream_fill_buffer(x) stream_fill_buffer(x)
-#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_percent(x,y,z,w) 1
+#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_percent(x, y, z, w) 1
 #endif
 int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
 
-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);
+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);
 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 //  stream_fill_buffer(s);
 //  if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
 //  return 0; // EOF
 }
 
-inline static unsigned int stream_read_word(stream_t *s){
-  int x,y;
-  x=stream_read_char(s);
-  y=stream_read_char(s);
-  return (x<<8)|y;
+inline static unsigned int stream_read_word(stream_t *s)
+{
+    int x, y;
+    x = stream_read_char(s);
+    y = stream_read_char(s);
+    return (x << 8) | y;
 }
 
-inline static unsigned int stream_read_dword(stream_t *s){
-  unsigned int y;
-  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);
-  return y;
+inline static unsigned int stream_read_dword(stream_t *s)
+{
+    unsigned int y;
+    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);
+    return y;
 }
 
 #define stream_read_fourcc stream_read_dword_le
 
-inline static unsigned int stream_read_word_le(stream_t *s){
-  int x,y;
-  x=stream_read_char(s);
-  y=stream_read_char(s);
-  return (y<<8)|x;
+inline static unsigned int stream_read_word_le(stream_t *s)
+{
+    int x, y;
+    x = stream_read_char(s);
+    y = stream_read_char(s);
+    return (y << 8) | x;
 }
 
 inline static uint32_t stream_read_dword_le(stream_t *s)
 {
-  unsigned int y;
-  y=stream_read_char(s);
-  y|=stream_read_char(s)<<8;
-  y|=stream_read_char(s)<<16;
-  y|=stream_read_char(s)<<24;
-  return y;
+    unsigned int y;
+    y = stream_read_char(s);
+    y |= stream_read_char(s) << 8;
+    y |= stream_read_char(s) << 16;
+    y |= stream_read_char(s) << 24;
+    return y;
 }
 
-inline static uint64_t stream_read_qword(stream_t *s){
-  uint64_t y;
-  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);
-  return y;
+inline static uint64_t stream_read_qword(stream_t *s)
+{
+    uint64_t y;
+    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);
+    return y;
 }
 
-inline static uint64_t stream_read_qword_le(stream_t *s){
-  uint64_t y;
-  y = stream_read_dword_le(s);
-  y|=(uint64_t)stream_read_dword_le(s)<<32;
-  return y;
+inline static uint64_t stream_read_qword_le(stream_t *s)
+{
+    uint64_t y;
+    y = stream_read_dword_le(s);
+    y |= (uint64_t)stream_read_dword_le(s) << 32;
+    return y;
 }
 
-inline static unsigned int stream_read_int24(stream_t *s){
-  unsigned int y;
-  y = stream_read_char(s);
-  y=(y<<8)|stream_read_char(s);
-  y=(y<<8)|stream_read_char(s);
-  return y;
+inline static unsigned int stream_read_int24(stream_t *s)
+{
+    unsigned int y;
+    y = stream_read_char(s);
+    y = (y << 8) | stream_read_char(s);
+    y = (y << 8) | stream_read_char(s);
+    return y;
 }
 
-inline static int stream_read(stream_t *s,char* mem,int total){
-  int len=total;
-  while(len>0){
-    int x;
-    x=s->buf_len-s->buf_pos;
-    if(x==0){
-      if(!cache_stream_fill_buffer(s)) return total-len; // EOF
-      x=s->buf_len-s->buf_pos;
+inline static int stream_read(stream_t *s, char *mem, int total)
+{
+    int len = total;
+    while (len > 0) {
+        int x;
+        x = s->buf_len - s->buf_pos;
+        if (x == 0) {
+            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");
-    if(x>len) x=len;
-    memcpy(mem,&s->buffer[s->buf_pos],x);
-    s->buf_pos+=x; mem+=x; len-=x;
-  }
-  return total;
+    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){
-  return s->eof;
+inline static int stream_eof(stream_t *s)
+{
+    return s->eof;
 }
 
-inline static int64_t stream_tell(stream_t *s){
-  return s->pos+s->buf_pos-s->buf_len;
+inline static int64_t stream_tell(stream_t *s)
+{
+    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) {
-    mp_msg(MSGT_DEMUX, MSGL_ERR, "Invalid seek to negative position %llx!\n",
-           (long long)pos);
-    pos = 0;
-  }
-  if(pos<s->pos){
-    int64_t x=pos-(s->pos-s->buf_len);
-    if(x>=0){
-      s->buf_pos=x;
-      s->eof = 0;
+    if (pos < 0) {
+        mp_msg(MSGT_DEMUX, MSGL_ERR,
+               "Invalid seek to negative position %llx!\n",
+               (long long)pos);
+        pos = 0;
+    }
+    if (pos < s->pos) {
+        int64_t x = pos - (s->pos - s->buf_len);
+        if (x >= 0) {
+            s->buf_pos = x;
+            s->eof = 0;
 //      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){
-  if( len<0 || (len>2*STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW)) ) {
-    // negative or big skip!
-    return stream_seek(s,stream_tell(s)+len);
-  }
-  while(len>0){
-    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;
+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!
+        return stream_seek(s, stream_tell(s) + len);
+    }
+    while (len > 0) {
+        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;
+        //memcpy(mem,&s->buf[s->buf_pos],x);
+        s->buf_pos += x;
+        len -= x;
     }
-    if(x>len) x=len;
-    //memcpy(mem,&s->buf[s->buf_pos],x);
-    s->buf_pos+=x; len-=x;
-  }
-  return 1;
+    return 1;
 }
 
 struct MPOpts;
@@ -355,9 +385,9 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
 void stream_reset(stream_t *s);
 int stream_control(stream_t *s, int cmd, void *arg);
 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);
-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,
                       int *file_format);
 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
 /// interruption during long blocking operations (cache filling, etc).
 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);
 /// Call the interrupt checking callback if there is one and
 /// wait for time milliseconds
@@ -385,10 +415,10 @@ extern int dvd_angle;
 extern char *bluray_device;
 
 typedef struct {
- int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
- int language;
- int type;
- int channels;
+    int id; // 0 - 31 mpeg; 128 - 159 ac3; 160 - 191 pcm
+    int language;
+    int type;
+    int channels;
 } stream_language_t;
 
 #endif /* MPLAYER_STREAM_H */