libavformat/concat.c

   1 /*
   2  * Concat URL protocol
   3  * Copyright (c) 2006 Steve Lhomme
   4  * Copyright (c) 2007 Wolfram Gloger
   5  * Copyright (c) 2010 Michele Orrù
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "libavutil/avstring.h"
  25 #include "libavutil/bprint.h"
  26 #include "libavutil/mem.h"
  27
  28 #include "avformat.h"
  29 #include "avio_internal.h"
  30 #include "url.h"
  31
  32 #define AV_CAT_SEPARATOR "|"
  33
  34 struct concat_nodes {
  35     URLContext *uc;                ///< node's URLContext
  36     int64_t     size;              ///< url filesize
  37 };
  38
  39 struct concat_data {
  40     struct concat_nodes *nodes;    ///< list of nodes to concat
  41     size_t               length;   ///< number of cat'ed nodes
  42     size_t               current;  ///< index of currently read node
  43     uint64_t total_size;
  44 };
  45
  46 static av_cold int concat_close(URLContext *h)
  47 {
  48     int err = 0;
  49     size_t i;
  50     struct concat_data  *data  = h->priv_data;
  51     struct concat_nodes *nodes = data->nodes;
  52
  53     for (i = 0; i != data->length; i++)
  54         err |= ffurl_closep(&nodes[i].uc);
  55
  56     av_freep(&data->nodes);
  57
  58     return err < 0 ? -1 : 0;
  59 }
  60
  61 #if CONFIG_CONCAT_PROTOCOL
  62 static av_cold int concat_open(URLContext *h, const char *uri, int flags)
  63 {
  64     char *node_uri = NULL;
  65     int err = 0;
  66     int64_t size, total_size = 0;
  67     size_t len, i;
  68     URLContext *uc;
  69     struct concat_data  *data = h->priv_data;
  70     struct concat_nodes *nodes;
  71
  72     if (!av_strstart(uri, "concat:", &uri)) {
  73         av_log(h, AV_LOG_ERROR, "URL %s lacks prefix\n", uri);
  74         return AVERROR(EINVAL);
  75     }
  76
  77     for (i = 0, len = 1; uri[i]; i++) {
  78         if (uri[i] == *AV_CAT_SEPARATOR) {
  79             len++;
  80         }
  81     }
  82
  83     if (!(nodes = av_realloc_array(NULL, len, sizeof(*nodes))))
  84         return AVERROR(ENOMEM);
  85     else
  86         data->nodes = nodes;
  87
  88     /* handle input */
  89     if (!*uri)
  90         err = AVERROR(ENOENT);
  91     for (i = 0; *uri; i++) {
  92         /* parsing uri */
  93         len = strcspn(uri, AV_CAT_SEPARATOR);
  94         if ((err = av_reallocp(&node_uri, len + 1)) < 0)
  95             break;
  96         av_strlcpy(node_uri, uri, len + 1);
  97         uri += len + strspn(uri + len, AV_CAT_SEPARATOR);
  98
  99         /* creating URLContext */
 100         err = ffurl_open_whitelist(&uc, node_uri, flags,
 101                                    &h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist, h);
 102         if (err < 0)
 103             break;
 104
 105         /* creating size */
 106         if ((size = ffurl_size(uc)) < 0) {
 107             ffurl_close(uc);
 108             err = AVERROR(ENOSYS);
 109             break;
 110         }
 111
 112         /* assembling */
 113         nodes[i].uc   = uc;
 114         nodes[i].size = size;
 115         total_size += size;
 116     }
 117     av_free(node_uri);
 118     data->length = i;
 119
 120     if (err < 0)
 121         concat_close(h);
 122     else if (!(nodes = av_realloc(nodes, data->length * sizeof(*nodes)))) {
 123         concat_close(h);
 124         err = AVERROR(ENOMEM);
 125     } else
 126         data->nodes = nodes;
 127     data->total_size = total_size;
 128     return err;
 129 }
 130 #endif
 131
 132 static int concat_read(URLContext *h, unsigned char *buf, int size)
 133 {
 134     int result, total = 0;
 135     struct concat_data  *data  = h->priv_data;
 136     struct concat_nodes *nodes = data->nodes;
 137     size_t i                   = data->current;
 138
 139     while (size > 0) {
 140         result = ffurl_read(nodes[i].uc, buf, size);
 141         if (result == AVERROR_EOF) {
 142             if (i + 1 == data->length ||
 143                 ffurl_seek(nodes[++i].uc, 0, SEEK_SET) < 0)
 144                 break;
 145             result = 0;
 146         }
 147         if (result < 0)
 148             return total ? total : result;
 149         total += result;
 150         buf   += result;
 151         size  -= result;
 152     }
 153     data->current = i;
 154     return total ? total : result;
 155 }
 156
 157 static int64_t concat_seek(URLContext *h, int64_t pos, int whence)
 158 {
 159     int64_t result;
 160     struct concat_data  *data  = h->priv_data;
 161     struct concat_nodes *nodes = data->nodes;
 162     size_t i;
 163
 164     if ((whence & AVSEEK_SIZE))
 165         return data->total_size;
 166     switch (whence) {
 167     case SEEK_END:
 168         for (i = data->length - 1; i && pos < -nodes[i].size; i--)
 169             pos += nodes[i].size;
 170         break;
 171     case SEEK_CUR:
 172         /* get the absolute position */
 173         for (i = 0; i != data->current; i++)
 174             pos += nodes[i].size;
 175         pos += ffurl_seek(nodes[i].uc, 0, SEEK_CUR);
 176         whence = SEEK_SET;
 177         /* fall through with the absolute position */
 178     case SEEK_SET:
 179         for (i = 0; i != data->length - 1 && pos >= nodes[i].size; i++)
 180             pos -= nodes[i].size;
 181         break;
 182     default:
 183         return AVERROR(EINVAL);
 184     }
 185
 186     result = ffurl_seek(nodes[i].uc, pos, whence);
 187     if (result >= 0) {
 188         data->current = i;
 189         while (i)
 190             result += nodes[--i].size;
 191     }
 192     return result;
 193 }
 194
 195 #if CONFIG_CONCAT_PROTOCOL
 196 const URLProtocol ff_concat_protocol = {
 197     .name           = "concat",
 198     .url_open       = concat_open,
 199     .url_read       = concat_read,
 200     .url_seek       = concat_seek,
 201     .url_close      = concat_close,
 202     .priv_data_size = sizeof(struct concat_data),
 203     .default_whitelist = "concat,file,subfile",
 204 };
 205 #endif
 206
 207 #if CONFIG_CONCATF_PROTOCOL
 208 static av_cold int concatf_open(URLContext *h, const char *uri, int flags)
 209 {
 210     AVBPrint bp;
 211     struct concat_data *data = h->priv_data;
 212     AVIOContext *in = NULL;
 213     const char *cursor;
 214     int64_t total_size = 0;
 215     unsigned int nodes_size = 0;
 216     size_t i = 0;
 217     int err;
 218
 219     if (!av_strstart(uri, "concatf:", &uri)) {
 220         av_log(h, AV_LOG_ERROR, "URL %s lacks prefix\n", uri);
 221         return AVERROR(EINVAL);
 222     }
 223
 224     /* handle input */
 225     if (!*uri)
 226         return AVERROR(ENOENT);
 227
 228     err = ffio_open_whitelist(&in, uri, AVIO_FLAG_READ, &h->interrupt_callback,
 229                               NULL, h->protocol_whitelist, h->protocol_blacklist);
 230     if (err < 0)
 231         return err;
 232
 233     av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
 234     err = avio_read_to_bprint(in, &bp, SIZE_MAX);
 235     avio_closep(&in);
 236     if (err < 0) {
 237         av_bprint_finalize(&bp, NULL);
 238         return err;
 239     }
 240
 241     cursor = bp.str;
 242     while (*cursor) {
 243         struct concat_nodes *nodes;
 244         URLContext *uc;
 245         char *node_uri;
 246         int64_t size;
 247         size_t len = i;
 248         int leading_spaces = strspn(cursor, " \n\t\r");
 249
 250         if (!cursor[leading_spaces])
 251             break;
 252
 253         node_uri = av_get_token(&cursor, "\r\n");
 254         if (!node_uri) {
 255             err = AVERROR(ENOMEM);
 256             break;
 257         }
 258         if (*cursor)
 259             cursor++;
 260
 261         if (++len == SIZE_MAX / sizeof(*nodes)) {
 262             av_free(node_uri);
 263             err = AVERROR(ENAMETOOLONG);
 264             break;
 265         }
 266
 267         /* creating URLContext */
 268         err = ffurl_open_whitelist(&uc, node_uri, flags,
 269                                    &h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist, h);
 270         av_free(node_uri);
 271         if (err < 0)
 272             break;
 273
 274         /* creating size */
 275         if ((size = ffurl_size(uc)) < 0) {
 276             ffurl_close(uc);
 277             err = AVERROR(ENOSYS);
 278             break;
 279         }
 280
 281         nodes = av_fast_realloc(data->nodes, &nodes_size, sizeof(*nodes) * len);
 282         if (!nodes) {
 283             ffurl_close(uc);
 284             err = AVERROR(ENOMEM);
 285             break;
 286         }
 287         data->nodes = nodes;
 288
 289         /* assembling */
 290         data->nodes[i].uc   = uc;
 291         data->nodes[i++].size = size;
 292         total_size += size;
 293     }
 294     av_bprint_finalize(&bp, NULL);
 295     data->length = i;
 296
 297     if (err < 0)
 298         concat_close(h);
 299
 300     data->total_size = total_size;
 301     return err;
 302 }
 303
 304 const URLProtocol ff_concatf_protocol = {
 305     .name           = "concatf",
 306     .url_open       = concatf_open,
 307     .url_read       = concat_read,
 308     .url_seek       = concat_seek,
 309     .url_close      = concat_close,
 310     .priv_data_size = sizeof(struct concat_data),
 311     .default_whitelist = "concatf,concat,file,subfile",
 312 };
 313 #endif