libavformat/avio.c

   1 /*
   2  * Unbuffered io for ffmpeg system
   3  * Copyright (c) 2001 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avstring.h"
  23 #include "libavcodec/opt.h"
  24 #include "avformat.h"
  25
  26 #if LIBAVFORMAT_VERSION_MAJOR >= 53
  27 /** @name Logging context. */
  28 /*@{*/
  29 static const char *urlcontext_to_name(void *ptr)
  30 {
  31     URLContext *h = (URLContext *)ptr;
  32     if(h->prot) return h->prot->name;
  33     else        return "NULL";
  34 }
  35 static const AVOption options[] = {{NULL}};
  36 static const AVClass urlcontext_class =
  37         { "URLContext", urlcontext_to_name, options };
  38 /*@}*/
  39 #endif
  40
  41 static int default_interrupt_cb(void);
  42
  43 URLProtocol *first_protocol = NULL;
  44 URLInterruptCB *url_interrupt_cb = default_interrupt_cb;
  45
  46 URLProtocol *av_protocol_next(URLProtocol *p)
  47 {
  48     if(p) return p->next;
  49     else  return first_protocol;
  50 }
  51
  52 int register_protocol(URLProtocol *protocol)
  53 {
  54     URLProtocol **p;
  55     p = &first_protocol;
  56     while (*p != NULL) p = &(*p)->next;
  57     *p = protocol;
  58     protocol->next = NULL;
  59     return 0;
  60 }
  61
  62 int url_open_protocol (URLContext **puc, struct URLProtocol *up,
  63                        const char *filename, int flags)
  64 {
  65     URLContext *uc;
  66     int err;
  67
  68     uc = av_malloc(sizeof(URLContext) + strlen(filename) + 1);
  69     if (!uc) {
  70         err = AVERROR(ENOMEM);
  71         goto fail;
  72     }
  73 #if LIBAVFORMAT_VERSION_MAJOR >= 53
  74     uc->av_class = &urlcontext_class;
  75 #endif
  76     uc->filename = (char *) &uc[1];
  77     strcpy(uc->filename, filename);
  78     uc->prot = up;
  79     uc->flags = flags;
  80     uc->is_streamed = 0; /* default = not streamed */
  81     uc->max_packet_size = 0; /* default: stream file */
  82     err = up->url_open(uc, filename, flags);
  83     if (err < 0) {
  84         av_free(uc);
  85         *puc = NULL;
  86         return err;
  87     }
  88
  89     //We must be carefull here as url_seek() could be slow, for example for http
  90     if(   (flags & (URL_WRONLY | URL_RDWR))
  91        || !strcmp(up->name, "file"))
  92         if(!uc->is_streamed && url_seek(uc, 0, SEEK_SET) < 0)
  93             uc->is_streamed= 1;
  94     *puc = uc;
  95     return 0;
  96  fail:
  97     *puc = NULL;
  98     return err;
  99 }
 100
 101 int url_open(URLContext **puc, const char *filename, int flags)
 102 {
 103     URLProtocol *up;
 104     const char *p;
 105     char proto_str[128], *q;
 106
 107     p = filename;
 108     q = proto_str;
 109     while (*p != '\0' && *p != ':') {
 110         /* protocols can only contain alphabetic chars */
 111         if (!isalpha(*p))
 112             goto file_proto;
 113         if ((q - proto_str) < sizeof(proto_str) - 1)
 114             *q++ = *p;
 115         p++;
 116     }
 117     /* if the protocol has length 1, we consider it is a dos drive */
 118     if (*p == '\0' || (q - proto_str) <= 1) {
 119     file_proto:
 120         strcpy(proto_str, "file");
 121     } else {
 122         *q = '\0';
 123     }
 124
 125     up = first_protocol;
 126     while (up != NULL) {
 127         if (!strcmp(proto_str, up->name))
 128             return url_open_protocol (puc, up, filename, flags);
 129         up = up->next;
 130     }
 131     *puc = NULL;
 132     return AVERROR(ENOENT);
 133 }
 134
 135 int url_read(URLContext *h, unsigned char *buf, int size)
 136 {
 137     int ret;
 138     if (h->flags & URL_WRONLY)
 139         return AVERROR(EIO);
 140     ret = h->prot->url_read(h, buf, size);
 141     return ret;
 142 }
 143
 144 int url_write(URLContext *h, unsigned char *buf, int size)
 145 {
 146     int ret;
 147     if (!(h->flags & (URL_WRONLY | URL_RDWR)))
 148         return AVERROR(EIO);
 149     /* avoid sending too big packets */
 150     if (h->max_packet_size && size > h->max_packet_size)
 151         return AVERROR(EIO);
 152     ret = h->prot->url_write(h, buf, size);
 153     return ret;
 154 }
 155
 156 offset_t url_seek(URLContext *h, offset_t pos, int whence)
 157 {
 158     offset_t ret;
 159
 160     if (!h->prot->url_seek)
 161         return AVERROR(EPIPE);
 162     ret = h->prot->url_seek(h, pos, whence);
 163     return ret;
 164 }
 165
 166 int url_close(URLContext *h)
 167 {
 168     int ret = 0;
 169     if (!h) return 0; /* can happen when url_open fails */
 170
 171     if (h->prot->url_close)
 172         ret = h->prot->url_close(h);
 173     av_free(h);
 174     return ret;
 175 }
 176
 177 int url_exist(const char *filename)
 178 {
 179     URLContext *h;
 180     if (url_open(&h, filename, URL_RDONLY) < 0)
 181         return 0;
 182     url_close(h);
 183     return 1;
 184 }
 185
 186 offset_t url_filesize(URLContext *h)
 187 {
 188     offset_t pos, size;
 189
 190     size= url_seek(h, 0, AVSEEK_SIZE);
 191     if(size<0){
 192         pos = url_seek(h, 0, SEEK_CUR);
 193         if ((size = url_seek(h, -1, SEEK_END)) < 0)
 194             return size;
 195         size++;
 196         url_seek(h, pos, SEEK_SET);
 197     }
 198     return size;
 199 }
 200
 201 int url_get_max_packet_size(URLContext *h)
 202 {
 203     return h->max_packet_size;
 204 }
 205
 206 void url_get_filename(URLContext *h, char *buf, int buf_size)
 207 {
 208     av_strlcpy(buf, h->filename, buf_size);
 209 }
 210
 211
 212 static int default_interrupt_cb(void)
 213 {
 214     return 0;
 215 }
 216
 217 void url_set_interrupt_cb(URLInterruptCB *interrupt_cb)
 218 {
 219     if (!interrupt_cb)
 220         interrupt_cb = default_interrupt_cb;
 221     url_interrupt_cb = interrupt_cb;
 222 }
 223
 224 int av_url_read_pause(URLContext *h, int pause)
 225 {
 226     if (!h->prot->url_read_pause)
 227         return AVERROR(ENOSYS);
 228     return h->prot->url_read_pause(h, pause);
 229 }
 230
 231 offset_t av_url_read_seek(URLContext *h,
 232         int stream_index, int64_t timestamp, int flags)
 233 {
 234     if (!h->prot->url_read_seek)
 235         return AVERROR(ENOSYS);
 236     return h->prot->url_read_seek(h, stream_index, timestamp, flags);
 237 }