Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2012 Nicolas George
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public License
  8.  * as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
  18.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include "libavutil/avassert.h"
  22. #include "libavutil/avstring.h"
  23. #include "libavutil/intreadwrite.h"
  24. #include "libavutil/opt.h"
  25. #include "libavutil/parseutils.h"
  26. #include "libavutil/timestamp.h"
  27. #include "avformat.h"
  28. #include "internal.h"
  29. #include "url.h"
  30.  
  31. typedef enum ConcatMatchMode {
  32.     MATCH_ONE_TO_ONE,
  33.     MATCH_EXACT_ID,
  34. } ConcatMatchMode;
  35.  
  36. typedef struct ConcatStream {
  37.     AVBitStreamFilterContext *bsf;
  38.     int out_stream_index;
  39. } ConcatStream;
  40.  
  41. typedef struct {
  42.     char *url;
  43.     int64_t start_time;
  44.     int64_t file_start_time;
  45.     int64_t file_inpoint;
  46.     int64_t duration;
  47.     ConcatStream *streams;
  48.     int64_t inpoint;
  49.     int64_t outpoint;
  50.     AVDictionary *metadata;
  51.     int nb_streams;
  52. } ConcatFile;
  53.  
  54. typedef struct {
  55.     AVClass *class;
  56.     ConcatFile *files;
  57.     ConcatFile *cur_file;
  58.     unsigned nb_files;
  59.     AVFormatContext *avf;
  60.     int safe;
  61.     int seekable;
  62.     int eof;
  63.     ConcatMatchMode stream_match_mode;
  64.     unsigned auto_convert;
  65. } ConcatContext;
  66.  
  67. static int concat_probe(AVProbeData *probe)
  68. {
  69.     return memcmp(probe->buf, "ffconcat version 1.0", 20) ?
  70.            0 : AVPROBE_SCORE_MAX;
  71. }
  72.  
  73. static char *get_keyword(uint8_t **cursor)
  74. {
  75.     char *ret = *cursor += strspn(*cursor, SPACE_CHARS);
  76.     *cursor += strcspn(*cursor, SPACE_CHARS);
  77.     if (**cursor) {
  78.         *((*cursor)++) = 0;
  79.         *cursor += strspn(*cursor, SPACE_CHARS);
  80.     }
  81.     return ret;
  82. }
  83.  
  84. static int safe_filename(const char *f)
  85. {
  86.     const char *start = f;
  87.  
  88.     for (; *f; f++) {
  89.         /* A-Za-z0-9_- */
  90.         if (!((unsigned)((*f | 32) - 'a') < 26 ||
  91.               (unsigned)(*f - '0') < 10 || *f == '_' || *f == '-')) {
  92.             if (f == start)
  93.                 return 0;
  94.             else if (*f == '/')
  95.                 start = f + 1;
  96.             else if (*f != '.')
  97.                 return 0;
  98.         }
  99.     }
  100.     return 1;
  101. }
  102.  
  103. #define FAIL(retcode) do { ret = (retcode); goto fail; } while(0)
  104.  
  105. static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile,
  106.                     unsigned *nb_files_alloc)
  107. {
  108.     ConcatContext *cat = avf->priv_data;
  109.     ConcatFile *file;
  110.     char *url = NULL;
  111.     const char *proto;
  112.     size_t url_len, proto_len;
  113.     int ret;
  114.  
  115.     if (cat->safe > 0 && !safe_filename(filename)) {
  116.         av_log(avf, AV_LOG_ERROR, "Unsafe file name '%s'\n", filename);
  117.         FAIL(AVERROR(EPERM));
  118.     }
  119.  
  120.     proto = avio_find_protocol_name(filename);
  121.     proto_len = proto ? strlen(proto) : 0;
  122.     if (!memcmp(filename, proto, proto_len) &&
  123.         (filename[proto_len] == ':' || filename[proto_len] == ',')) {
  124.         url = filename;
  125.         filename = NULL;
  126.     } else {
  127.         url_len = strlen(avf->filename) + strlen(filename) + 16;
  128.         if (!(url = av_malloc(url_len)))
  129.             FAIL(AVERROR(ENOMEM));
  130.         ff_make_absolute_url(url, url_len, avf->filename, filename);
  131.         av_freep(&filename);
  132.     }
  133.  
  134.     if (cat->nb_files >= *nb_files_alloc) {
  135.         size_t n = FFMAX(*nb_files_alloc * 2, 16);
  136.         ConcatFile *new_files;
  137.         if (n <= cat->nb_files || n > SIZE_MAX / sizeof(*cat->files) ||
  138.             !(new_files = av_realloc(cat->files, n * sizeof(*cat->files))))
  139.             FAIL(AVERROR(ENOMEM));
  140.         cat->files = new_files;
  141.         *nb_files_alloc = n;
  142.     }
  143.  
  144.     file = &cat->files[cat->nb_files++];
  145.     memset(file, 0, sizeof(*file));
  146.     *rfile = file;
  147.  
  148.     file->url        = url;
  149.     file->start_time = AV_NOPTS_VALUE;
  150.     file->duration   = AV_NOPTS_VALUE;
  151.     file->inpoint    = AV_NOPTS_VALUE;
  152.     file->outpoint   = AV_NOPTS_VALUE;
  153.  
  154.     return 0;
  155.  
  156. fail:
  157.     av_free(url);
  158.     av_free(filename);
  159.     return ret;
  160. }
  161.  
  162. static int copy_stream_props(AVStream *st, AVStream *source_st)
  163. {
  164.     int ret;
  165.  
  166.     if (st->codec->codec_id || !source_st->codec->codec_id) {
  167.         if (st->codec->extradata_size < source_st->codec->extradata_size) {
  168.             ret = ff_alloc_extradata(st->codec,
  169.                                      source_st->codec->extradata_size);
  170.             if (ret < 0)
  171.                 return ret;
  172.         }
  173.         memcpy(st->codec->extradata, source_st->codec->extradata,
  174.                source_st->codec->extradata_size);
  175.         return 0;
  176.     }
  177.     if ((ret = avcodec_copy_context(st->codec, source_st->codec)) < 0)
  178.         return ret;
  179.     st->r_frame_rate        = source_st->r_frame_rate;
  180.     st->avg_frame_rate      = source_st->avg_frame_rate;
  181.     st->time_base           = source_st->time_base;
  182.     st->sample_aspect_ratio = source_st->sample_aspect_ratio;
  183.  
  184.     av_dict_copy(&st->metadata, source_st->metadata, 0);
  185.     return 0;
  186. }
  187.  
  188. static int detect_stream_specific(AVFormatContext *avf, int idx)
  189. {
  190.     ConcatContext *cat = avf->priv_data;
  191.     AVStream *st = cat->avf->streams[idx];
  192.     ConcatStream *cs = &cat->cur_file->streams[idx];
  193.     AVBitStreamFilterContext *bsf;
  194.  
  195.     if (cat->auto_convert && st->codec->codec_id == AV_CODEC_ID_H264 &&
  196.         (st->codec->extradata_size < 4 || AV_RB32(st->codec->extradata) != 1)) {
  197.         av_log(cat->avf, AV_LOG_INFO,
  198.                "Auto-inserting h264_mp4toannexb bitstream filter\n");
  199.         if (!(bsf = av_bitstream_filter_init("h264_mp4toannexb"))) {
  200.             av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb bitstream filter "
  201.                    "required for H.264 streams\n");
  202.             return AVERROR_BSF_NOT_FOUND;
  203.         }
  204.         cs->bsf = bsf;
  205.     }
  206.     return 0;
  207. }
  208.  
  209. static int match_streams_one_to_one(AVFormatContext *avf)
  210. {
  211.     ConcatContext *cat = avf->priv_data;
  212.     AVStream *st;
  213.     int i, ret;
  214.  
  215.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
  216.         if (i < avf->nb_streams) {
  217.             st = avf->streams[i];
  218.         } else {
  219.             if (!(st = avformat_new_stream(avf, NULL)))
  220.                 return AVERROR(ENOMEM);
  221.         }
  222.         if ((ret = copy_stream_props(st, cat->avf->streams[i])) < 0)
  223.             return ret;
  224.         cat->cur_file->streams[i].out_stream_index = i;
  225.     }
  226.     return 0;
  227. }
  228.  
  229. static int match_streams_exact_id(AVFormatContext *avf)
  230. {
  231.     ConcatContext *cat = avf->priv_data;
  232.     AVStream *st;
  233.     int i, j, ret;
  234.  
  235.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
  236.         st = cat->avf->streams[i];
  237.         for (j = 0; j < avf->nb_streams; j++) {
  238.             if (avf->streams[j]->id == st->id) {
  239.                 av_log(avf, AV_LOG_VERBOSE,
  240.                        "Match slave stream #%d with stream #%d id 0x%x\n",
  241.                        i, j, st->id);
  242.                 if ((ret = copy_stream_props(avf->streams[j], st)) < 0)
  243.                     return ret;
  244.                 cat->cur_file->streams[i].out_stream_index = j;
  245.             }
  246.         }
  247.     }
  248.     return 0;
  249. }
  250.  
  251. static int match_streams(AVFormatContext *avf)
  252. {
  253.     ConcatContext *cat = avf->priv_data;
  254.     ConcatStream *map;
  255.     int i, ret;
  256.  
  257.     if (cat->cur_file->nb_streams >= cat->avf->nb_streams)
  258.         return 0;
  259.     map = av_realloc(cat->cur_file->streams,
  260.                      cat->avf->nb_streams * sizeof(*map));
  261.     if (!map)
  262.         return AVERROR(ENOMEM);
  263.     cat->cur_file->streams = map;
  264.     memset(map + cat->cur_file->nb_streams, 0,
  265.            (cat->avf->nb_streams - cat->cur_file->nb_streams) * sizeof(*map));
  266.  
  267.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++)
  268.         map[i].out_stream_index = -1;
  269.     switch (cat->stream_match_mode) {
  270.     case MATCH_ONE_TO_ONE:
  271.         ret = match_streams_one_to_one(avf);
  272.         break;
  273.     case MATCH_EXACT_ID:
  274.         ret = match_streams_exact_id(avf);
  275.         break;
  276.     default:
  277.         ret = AVERROR_BUG;
  278.     }
  279.     if (ret < 0)
  280.         return ret;
  281.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++)
  282.         if ((ret = detect_stream_specific(avf, i)) < 0)
  283.             return ret;
  284.     cat->cur_file->nb_streams = cat->avf->nb_streams;
  285.     return 0;
  286. }
  287.  
  288. static int open_file(AVFormatContext *avf, unsigned fileno)
  289. {
  290.     ConcatContext *cat = avf->priv_data;
  291.     ConcatFile *file = &cat->files[fileno];
  292.     int ret;
  293.  
  294.     if (cat->avf)
  295.         avformat_close_input(&cat->avf);
  296.  
  297.     cat->avf = avformat_alloc_context();
  298.     if (!cat->avf)
  299.         return AVERROR(ENOMEM);
  300.  
  301.     cat->avf->interrupt_callback = avf->interrupt_callback;
  302.  
  303.     if ((ret = ff_copy_whitelists(cat->avf, avf)) < 0)
  304.         return ret;
  305.  
  306.     if ((ret = avformat_open_input(&cat->avf, file->url, NULL, NULL)) < 0 ||
  307.         (ret = avformat_find_stream_info(cat->avf, NULL)) < 0) {
  308.         av_log(avf, AV_LOG_ERROR, "Impossible to open '%s'\n", file->url);
  309.         avformat_close_input(&cat->avf);
  310.         return ret;
  311.     }
  312.     cat->cur_file = file;
  313.     if (file->start_time == AV_NOPTS_VALUE)
  314.         file->start_time = !fileno ? 0 :
  315.                            cat->files[fileno - 1].start_time +
  316.                            cat->files[fileno - 1].duration;
  317.     file->file_start_time = (cat->avf->start_time == AV_NOPTS_VALUE) ? 0 : cat->avf->start_time;
  318.     file->file_inpoint = (file->inpoint == AV_NOPTS_VALUE) ? file->file_start_time : file->inpoint;
  319.     if ((ret = match_streams(avf)) < 0)
  320.         return ret;
  321.     if (file->inpoint != AV_NOPTS_VALUE) {
  322.        if ((ret = avformat_seek_file(cat->avf, -1, INT64_MIN, file->inpoint, file->inpoint, 0)) < 0)
  323.            return ret;
  324.     }
  325.     return 0;
  326. }
  327.  
  328. static int concat_read_close(AVFormatContext *avf)
  329. {
  330.     ConcatContext *cat = avf->priv_data;
  331.     unsigned i;
  332.  
  333.     if (cat->avf)
  334.         avformat_close_input(&cat->avf);
  335.     for (i = 0; i < cat->nb_files; i++) {
  336.         av_freep(&cat->files[i].url);
  337.         av_freep(&cat->files[i].streams);
  338.         av_dict_free(&cat->files[i].metadata);
  339.     }
  340.     av_freep(&cat->files);
  341.     return 0;
  342. }
  343.  
  344. static int concat_read_header(AVFormatContext *avf)
  345. {
  346.     ConcatContext *cat = avf->priv_data;
  347.     uint8_t buf[4096];
  348.     uint8_t *cursor, *keyword;
  349.     int ret, line = 0, i;
  350.     unsigned nb_files_alloc = 0;
  351.     ConcatFile *file = NULL;
  352.     int64_t time = 0;
  353.  
  354.     while (1) {
  355.         if ((ret = ff_get_line(avf->pb, buf, sizeof(buf))) <= 0)
  356.             break;
  357.         line++;
  358.         cursor = buf;
  359.         keyword = get_keyword(&cursor);
  360.         if (!*keyword || *keyword == '#')
  361.             continue;
  362.  
  363.         if (!strcmp(keyword, "file")) {
  364.             char *filename = av_get_token((const char **)&cursor, SPACE_CHARS);
  365.             if (!filename) {
  366.                 av_log(avf, AV_LOG_ERROR, "Line %d: filename required\n", line);
  367.                 FAIL(AVERROR_INVALIDDATA);
  368.             }
  369.             if ((ret = add_file(avf, filename, &file, &nb_files_alloc)) < 0)
  370.                 goto fail;
  371.         } else if (!strcmp(keyword, "duration") || !strcmp(keyword, "inpoint") || !strcmp(keyword, "outpoint")) {
  372.             char *dur_str = get_keyword(&cursor);
  373.             int64_t dur;
  374.             if (!file) {
  375.                 av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",
  376.                        line, keyword);
  377.                 FAIL(AVERROR_INVALIDDATA);
  378.             }
  379.             if ((ret = av_parse_time(&dur, dur_str, 1)) < 0) {
  380.                 av_log(avf, AV_LOG_ERROR, "Line %d: invalid %s '%s'\n",
  381.                        line, keyword, dur_str);
  382.                 goto fail;
  383.             }
  384.             if (!strcmp(keyword, "duration"))
  385.                 file->duration = dur;
  386.             else if (!strcmp(keyword, "inpoint"))
  387.                 file->inpoint = dur;
  388.             else if (!strcmp(keyword, "outpoint"))
  389.                 file->outpoint = dur;
  390.         } else if (!strcmp(keyword, "file_packet_metadata")) {
  391.             char *metadata;
  392.             metadata = av_get_token((const char **)&cursor, SPACE_CHARS);
  393.             if (!metadata) {
  394.                 av_log(avf, AV_LOG_ERROR, "Line %d: packet metadata required\n", line);
  395.                 FAIL(AVERROR_INVALIDDATA);
  396.             }
  397.             if (!file) {
  398.                 av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",
  399.                        line, keyword);
  400.                 FAIL(AVERROR_INVALIDDATA);
  401.             }
  402.             if ((ret = av_dict_parse_string(&file->metadata, metadata, "=", "", 0)) < 0) {
  403.                 av_log(avf, AV_LOG_ERROR, "Line %d: failed to parse metadata string\n", line);
  404.                 av_freep(&metadata);
  405.                 FAIL(AVERROR_INVALIDDATA);
  406.             }
  407.             av_freep(&metadata);
  408.         } else if (!strcmp(keyword, "stream")) {
  409.             if (!avformat_new_stream(avf, NULL))
  410.                 FAIL(AVERROR(ENOMEM));
  411.         } else if (!strcmp(keyword, "exact_stream_id")) {
  412.             if (!avf->nb_streams) {
  413.                 av_log(avf, AV_LOG_ERROR, "Line %d: exact_stream_id without stream\n",
  414.                        line);
  415.                 FAIL(AVERROR_INVALIDDATA);
  416.             }
  417.             avf->streams[avf->nb_streams - 1]->id =
  418.                 strtol(get_keyword(&cursor), NULL, 0);
  419.         } else if (!strcmp(keyword, "ffconcat")) {
  420.             char *ver_kw  = get_keyword(&cursor);
  421.             char *ver_val = get_keyword(&cursor);
  422.             if (strcmp(ver_kw, "version") || strcmp(ver_val, "1.0")) {
  423.                 av_log(avf, AV_LOG_ERROR, "Line %d: invalid version\n", line);
  424.                 FAIL(AVERROR_INVALIDDATA);
  425.             }
  426.             if (cat->safe < 0)
  427.                 cat->safe = 1;
  428.         } else {
  429.             av_log(avf, AV_LOG_ERROR, "Line %d: unknown keyword '%s'\n",
  430.                    line, keyword);
  431.             FAIL(AVERROR_INVALIDDATA);
  432.         }
  433.     }
  434.     if (ret < 0)
  435.         goto fail;
  436.     if (!cat->nb_files)
  437.         FAIL(AVERROR_INVALIDDATA);
  438.  
  439.     for (i = 0; i < cat->nb_files; i++) {
  440.         if (cat->files[i].start_time == AV_NOPTS_VALUE)
  441.             cat->files[i].start_time = time;
  442.         else
  443.             time = cat->files[i].start_time;
  444.         if (cat->files[i].duration == AV_NOPTS_VALUE) {
  445.             if (cat->files[i].inpoint == AV_NOPTS_VALUE || cat->files[i].outpoint == AV_NOPTS_VALUE)
  446.                 break;
  447.             cat->files[i].duration = cat->files[i].outpoint - cat->files[i].inpoint;
  448.         }
  449.         time += cat->files[i].duration;
  450.     }
  451.     if (i == cat->nb_files) {
  452.         avf->duration = time;
  453.         cat->seekable = 1;
  454.     }
  455.  
  456.     cat->stream_match_mode = avf->nb_streams ? MATCH_EXACT_ID :
  457.                                                MATCH_ONE_TO_ONE;
  458.     if ((ret = open_file(avf, 0)) < 0)
  459.         goto fail;
  460.     return 0;
  461.  
  462. fail:
  463.     concat_read_close(avf);
  464.     return ret;
  465. }
  466.  
  467. static int open_next_file(AVFormatContext *avf)
  468. {
  469.     ConcatContext *cat = avf->priv_data;
  470.     unsigned fileno = cat->cur_file - cat->files;
  471.  
  472.     if (cat->cur_file->duration == AV_NOPTS_VALUE) {
  473.         cat->cur_file->duration = cat->avf->duration;
  474.         if (cat->cur_file->inpoint != AV_NOPTS_VALUE)
  475.             cat->cur_file->duration -= (cat->cur_file->inpoint - cat->cur_file->file_start_time);
  476.         if (cat->cur_file->outpoint != AV_NOPTS_VALUE)
  477.             cat->cur_file->duration -= cat->avf->duration - (cat->cur_file->outpoint - cat->cur_file->file_start_time);
  478.     }
  479.  
  480.     if (++fileno >= cat->nb_files) {
  481.         cat->eof = 1;
  482.         return AVERROR_EOF;
  483.     }
  484.     return open_file(avf, fileno);
  485. }
  486.  
  487. static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)
  488. {
  489.     AVStream *st = avf->streams[cs->out_stream_index];
  490.     AVBitStreamFilterContext *bsf;
  491.     AVPacket pkt2;
  492.     int ret;
  493.  
  494.     av_assert0(cs->out_stream_index >= 0);
  495.     for (bsf = cs->bsf; bsf; bsf = bsf->next) {
  496.         pkt2 = *pkt;
  497.         ret = av_bitstream_filter_filter(bsf, st->codec, NULL,
  498.                                          &pkt2.data, &pkt2.size,
  499.                                          pkt->data, pkt->size,
  500.                                          !!(pkt->flags & AV_PKT_FLAG_KEY));
  501.         if (ret < 0) {
  502.             av_packet_unref(pkt);
  503.             return ret;
  504.         }
  505.         av_assert0(pkt2.buf);
  506.         if (ret == 0 && pkt2.data != pkt->data) {
  507.             if ((ret = av_copy_packet(&pkt2, pkt)) < 0) {
  508.                 av_free(pkt2.data);
  509.                 return ret;
  510.             }
  511.             ret = 1;
  512.         }
  513.         if (ret > 0) {
  514.             av_free_packet(pkt);
  515.             pkt2.buf = av_buffer_create(pkt2.data, pkt2.size,
  516.                                         av_buffer_default_free, NULL, 0);
  517.             if (!pkt2.buf) {
  518.                 av_free(pkt2.data);
  519.                 return AVERROR(ENOMEM);
  520.             }
  521.         }
  522.         *pkt = pkt2;
  523.     }
  524.     return 0;
  525. }
  526.  
  527. /* Returns true if the packet dts is greater or equal to the specified outpoint. */
  528. static int packet_after_outpoint(ConcatContext *cat, AVPacket *pkt)
  529. {
  530.     if (cat->cur_file->outpoint != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE) {
  531.         return av_compare_ts(pkt->dts, cat->avf->streams[pkt->stream_index]->time_base,
  532.                              cat->cur_file->outpoint, AV_TIME_BASE_Q) >= 0;
  533.     }
  534.     return 0;
  535. }
  536.  
  537. static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)
  538. {
  539.     ConcatContext *cat = avf->priv_data;
  540.     int ret;
  541.     int64_t delta;
  542.     ConcatStream *cs;
  543.     AVStream *st;
  544.  
  545.     if (cat->eof)
  546.         return AVERROR_EOF;
  547.  
  548.     if (!cat->avf)
  549.         return AVERROR(EIO);
  550.  
  551.     while (1) {
  552.         ret = av_read_frame(cat->avf, pkt);
  553.         if (ret == AVERROR_EOF || packet_after_outpoint(cat, pkt)) {
  554.             if (ret == 0)
  555.                 av_packet_unref(pkt);
  556.             if ((ret = open_next_file(avf)) < 0)
  557.                 return ret;
  558.             continue;
  559.         }
  560.         if (ret < 0)
  561.             return ret;
  562.         if ((ret = match_streams(avf)) < 0) {
  563.             av_packet_unref(pkt);
  564.             return ret;
  565.         }
  566.         cs = &cat->cur_file->streams[pkt->stream_index];
  567.         if (cs->out_stream_index < 0) {
  568.             av_packet_unref(pkt);
  569.             continue;
  570.         }
  571.         pkt->stream_index = cs->out_stream_index;
  572.         break;
  573.     }
  574.     if ((ret = filter_packet(avf, cs, pkt)))
  575.         return ret;
  576.  
  577.     st = cat->avf->streams[pkt->stream_index];
  578.     av_log(avf, AV_LOG_DEBUG, "file:%d stream:%d pts:%s pts_time:%s dts:%s dts_time:%s",
  579.            (unsigned)(cat->cur_file - cat->files), pkt->stream_index,
  580.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
  581.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
  582.  
  583.     delta = av_rescale_q(cat->cur_file->start_time - cat->cur_file->file_inpoint,
  584.                          AV_TIME_BASE_Q,
  585.                          cat->avf->streams[pkt->stream_index]->time_base);
  586.     if (pkt->pts != AV_NOPTS_VALUE)
  587.         pkt->pts += delta;
  588.     if (pkt->dts != AV_NOPTS_VALUE)
  589.         pkt->dts += delta;
  590.     av_log(avf, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
  591.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
  592.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
  593.     if (cat->cur_file->metadata) {
  594.         uint8_t* metadata;
  595.         int metadata_len;
  596.         char* packed_metadata = av_packet_pack_dictionary(cat->cur_file->metadata, &metadata_len);
  597.         if (!packed_metadata)
  598.             return AVERROR(ENOMEM);
  599.         if (!(metadata = av_packet_new_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, metadata_len))) {
  600.             av_freep(&packed_metadata);
  601.             return AVERROR(ENOMEM);
  602.         }
  603.         memcpy(metadata, packed_metadata, metadata_len);
  604.         av_freep(&packed_metadata);
  605.     }
  606.     return ret;
  607. }
  608.  
  609. static void rescale_interval(AVRational tb_in, AVRational tb_out,
  610.                              int64_t *min_ts, int64_t *ts, int64_t *max_ts)
  611. {
  612.     *ts     = av_rescale_q    (*    ts, tb_in, tb_out);
  613.     *min_ts = av_rescale_q_rnd(*min_ts, tb_in, tb_out,
  614.                                AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
  615.     *max_ts = av_rescale_q_rnd(*max_ts, tb_in, tb_out,
  616.                                AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
  617. }
  618.  
  619. static int try_seek(AVFormatContext *avf, int stream,
  620.                     int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
  621. {
  622.     ConcatContext *cat = avf->priv_data;
  623.     int64_t t0 = cat->cur_file->start_time - cat->cur_file->file_inpoint;
  624.  
  625.     ts -= t0;
  626.     min_ts = min_ts == INT64_MIN ? INT64_MIN : min_ts - t0;
  627.     max_ts = max_ts == INT64_MAX ? INT64_MAX : max_ts - t0;
  628.     if (stream >= 0) {
  629.         if (stream >= cat->avf->nb_streams)
  630.             return AVERROR(EIO);
  631.         rescale_interval(AV_TIME_BASE_Q, cat->avf->streams[stream]->time_base,
  632.                          &min_ts, &ts, &max_ts);
  633.     }
  634.     return avformat_seek_file(cat->avf, stream, min_ts, ts, max_ts, flags);
  635. }
  636.  
  637. static int real_seek(AVFormatContext *avf, int stream,
  638.                      int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
  639. {
  640.     ConcatContext *cat = avf->priv_data;
  641.     int ret, left, right;
  642.  
  643.     if (stream >= 0) {
  644.         if (stream >= avf->nb_streams)
  645.             return AVERROR(EINVAL);
  646.         rescale_interval(avf->streams[stream]->time_base, AV_TIME_BASE_Q,
  647.                          &min_ts, &ts, &max_ts);
  648.     }
  649.  
  650.     left  = 0;
  651.     right = cat->nb_files;
  652.     while (right - left > 1) {
  653.         int mid = (left + right) / 2;
  654.         if (ts < cat->files[mid].start_time)
  655.             right = mid;
  656.         else
  657.             left  = mid;
  658.     }
  659.  
  660.     if ((ret = open_file(avf, left)) < 0)
  661.         return ret;
  662.  
  663.     ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);
  664.     if (ret < 0 &&
  665.         left < cat->nb_files - 1 &&
  666.         cat->files[left + 1].start_time < max_ts) {
  667.         if ((ret = open_file(avf, left + 1)) < 0)
  668.             return ret;
  669.         ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);
  670.     }
  671.     return ret;
  672. }
  673.  
  674. static int concat_seek(AVFormatContext *avf, int stream,
  675.                        int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
  676. {
  677.     ConcatContext *cat = avf->priv_data;
  678.     ConcatFile *cur_file_saved = cat->cur_file;
  679.     AVFormatContext *cur_avf_saved = cat->avf;
  680.     int ret;
  681.  
  682.     if (!cat->seekable)
  683.         return AVERROR(ESPIPE); /* XXX: can we use it? */
  684.     if (flags & (AVSEEK_FLAG_BYTE | AVSEEK_FLAG_FRAME))
  685.         return AVERROR(ENOSYS);
  686.     cat->avf = NULL;
  687.     if ((ret = real_seek(avf, stream, min_ts, ts, max_ts, flags)) < 0) {
  688.         if (cat->avf)
  689.             avformat_close_input(&cat->avf);
  690.         cat->avf      = cur_avf_saved;
  691.         cat->cur_file = cur_file_saved;
  692.     } else {
  693.         avformat_close_input(&cur_avf_saved);
  694.         cat->eof = 0;
  695.     }
  696.     return ret;
  697. }
  698.  
  699. #define OFFSET(x) offsetof(ConcatContext, x)
  700. #define DEC AV_OPT_FLAG_DECODING_PARAM
  701.  
  702. static const AVOption options[] = {
  703.     { "safe", "enable safe mode",
  704.       OFFSET(safe), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, DEC },
  705.     { "auto_convert", "automatically convert bitstream format",
  706.       OFFSET(auto_convert), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, DEC },
  707.     { NULL }
  708. };
  709.  
  710. static const AVClass concat_class = {
  711.     .class_name = "concat demuxer",
  712.     .item_name  = av_default_item_name,
  713.     .option     = options,
  714.     .version    = LIBAVUTIL_VERSION_INT,
  715. };
  716.  
  717.  
  718. AVInputFormat ff_concat_demuxer = {
  719.     .name           = "concat",
  720.     .long_name      = NULL_IF_CONFIG_SMALL("Virtual concatenation script"),
  721.     .priv_data_size = sizeof(ConcatContext),
  722.     .read_probe     = concat_probe,
  723.     .read_header    = concat_read_header,
  724.     .read_packet    = concat_read_packet,
  725.     .read_close     = concat_read_close,
  726.     .read_seek2     = concat_seek,
  727.     .priv_class     = &concat_class,
  728. };
  729.