falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
89662 Commits
32 Branches
385MB
Tree: e45f7bca73
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e45f7bca73'
${ noResults }
FFmpeg/libavformat/concatdec.c

781 lines
25KB
Raw Blame History 

  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.     AVBSFContext *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.     int64_t next_dts;

  48.     ConcatStream *streams;

  49.     int64_t inpoint;

  50.     int64_t outpoint;

  51.     AVDictionary *metadata;

  52.     int nb_streams;

  53. } ConcatFile;

  54. 

  55. typedef struct {

  56.     AVClass *class;

  57.     ConcatFile *files;

  58.     ConcatFile *cur_file;

  59.     unsigned nb_files;

  60.     AVFormatContext *avf;

  61.     int safe;

  62.     int seekable;

  63.     int eof;

  64.     ConcatMatchMode stream_match_mode;

  65.     unsigned auto_convert;

  66.     int segment_time_metadata;

  67. } ConcatContext;

  68. 

  69. static int concat_probe(AVProbeData *probe)

  70. {

  71.     return memcmp(probe->buf, "ffconcat version 1.0", 20) ?

  72.            0 : AVPROBE_SCORE_MAX;

  73. }

  74. 

  75. static char *get_keyword(uint8_t **cursor)

  76. {

  77.     char *ret = *cursor += strspn(*cursor, SPACE_CHARS);

  78.     *cursor += strcspn(*cursor, SPACE_CHARS);

  79.     if (**cursor) {

  80.         *((*cursor)++) = 0;

  81.         *cursor += strspn(*cursor, SPACE_CHARS);

  82.     }

  83.     return ret;

  84. }

  85. 

  86. static int safe_filename(const char *f)

  87. {

  88.     const char *start = f;

  89. 

  90.     for (; *f; f++) {

  91.         /* A-Za-z0-9_- */

  92.         if (!((unsigned)((*f | 32) - 'a') < 26 ||

  93.               (unsigned)(*f - '0') < 10 || *f == '_' || *f == '-')) {

  94.             if (f == start)

  95.                 return 0;

  96.             else if (*f == '/')

  97.                 start = f + 1;

  98.             else if (*f != '.')

  99.                 return 0;

  100.         }

  101.     }

  102.     return 1;

  103. }

  104. 

  105. #define FAIL(retcode) do { ret = (retcode); goto fail; } while(0)

  106. 

  107. static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile,

  108.                     unsigned *nb_files_alloc)

  109. {

  110.     ConcatContext *cat = avf->priv_data;

  111.     ConcatFile *file;

  112.     char *url = NULL;

  113.     const char *proto;

  114.     size_t url_len, proto_len;

  115.     int ret;

  116. 

  117.     if (cat->safe > 0 && !safe_filename(filename)) {

  118.         av_log(avf, AV_LOG_ERROR, "Unsafe file name '%s'\n", filename);

  119.         FAIL(AVERROR(EPERM));

  120.     }

  121. 

  122.     proto = avio_find_protocol_name(filename);

  123.     proto_len = proto ? strlen(proto) : 0;

  124.     if (proto && !memcmp(filename, proto, proto_len) &&

  125.         (filename[proto_len] == ':' || filename[proto_len] == ',')) {

  126.         url = filename;

  127.         filename = NULL;

  128.     } else {

  129.         url_len = strlen(avf->filename) + strlen(filename) + 16;

  130.         if (!(url = av_malloc(url_len)))

  131.             FAIL(AVERROR(ENOMEM));

  132.         ff_make_absolute_url(url, url_len, avf->filename, filename);

  133.         av_freep(&filename);

  134.     }

  135. 

  136.     if (cat->nb_files >= *nb_files_alloc) {

  137.         size_t n = FFMAX(*nb_files_alloc * 2, 16);

  138.         ConcatFile *new_files;

  139.         if (n <= cat->nb_files || n > SIZE_MAX / sizeof(*cat->files) ||

  140.             !(new_files = av_realloc(cat->files, n * sizeof(*cat->files))))

  141.             FAIL(AVERROR(ENOMEM));

  142.         cat->files = new_files;

  143.         *nb_files_alloc = n;

  144.     }

  145. 

  146.     file = &cat->files[cat->nb_files++];

  147.     memset(file, 0, sizeof(*file));

  148.     *rfile = file;

  149. 

  150.     file->url        = url;

  151.     file->start_time = AV_NOPTS_VALUE;

  152.     file->duration   = AV_NOPTS_VALUE;

  153.     file->next_dts   = AV_NOPTS_VALUE;

  154.     file->inpoint    = AV_NOPTS_VALUE;

  155.     file->outpoint   = AV_NOPTS_VALUE;

  156. 

  157.     return 0;

  158. 

  159. fail:

  160.     av_free(url);

  161.     av_free(filename);

  162.     return ret;

  163. }

  164. 

  165. static int copy_stream_props(AVStream *st, AVStream *source_st)

  166. {

  167.     int ret;

  168. 

  169.     if (st->codecpar->codec_id || !source_st->codecpar->codec_id) {

  170.         if (st->codecpar->extradata_size < source_st->codecpar->extradata_size) {

  171.             if (st->codecpar->extradata) {

  172.                 av_freep(&st->codecpar->extradata);

  173.                 st->codecpar->extradata_size = 0;

  174.             }

  175.             ret = ff_alloc_extradata(st->codecpar,

  176.                                      source_st->codecpar->extradata_size);

  177.             if (ret < 0)

  178.                 return ret;

  179.         }

  180.         memcpy(st->codecpar->extradata, source_st->codecpar->extradata,

  181.                source_st->codecpar->extradata_size);

  182.         return 0;

  183.     }

  184.     if ((ret = avcodec_parameters_copy(st->codecpar, source_st->codecpar)) < 0)

  185.         return ret;

  186.     st->r_frame_rate        = source_st->r_frame_rate;

  187.     st->avg_frame_rate      = source_st->avg_frame_rate;

  188.     st->sample_aspect_ratio = source_st->sample_aspect_ratio;

  189.     avpriv_set_pts_info(st, 64, source_st->time_base.num, source_st->time_base.den);

  190. 

  191.     av_dict_copy(&st->metadata, source_st->metadata, 0);

  192.     return 0;

  193. }

  194. 

  195. static int detect_stream_specific(AVFormatContext *avf, int idx)

  196. {

  197.     ConcatContext *cat = avf->priv_data;

  198.     AVStream *st = cat->avf->streams[idx];

  199.     ConcatStream *cs = &cat->cur_file->streams[idx];

  200.     const AVBitStreamFilter *filter;

  201.     AVBSFContext *bsf;

  202.     int ret;

  203. 

  204.     if (cat->auto_convert && st->codecpar->codec_id == AV_CODEC_ID_H264) {

  205.         if (!st->codecpar->extradata_size                                                ||

  206.             (st->codecpar->extradata_size >= 3 && AV_RB24(st->codecpar->extradata) == 1) ||

  207.             (st->codecpar->extradata_size >= 4 && AV_RB32(st->codecpar->extradata) == 1))

  208.             return 0;

  209.         av_log(cat->avf, AV_LOG_INFO,

  210.                "Auto-inserting h264_mp4toannexb bitstream filter\n");

  211.         filter = av_bsf_get_by_name("h264_mp4toannexb");

  212.         if (!filter) {

  213.             av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb bitstream filter "

  214.                    "required for H.264 streams\n");

  215.             return AVERROR_BSF_NOT_FOUND;

  216.         }

  217.         ret = av_bsf_alloc(filter, &bsf);

  218.         if (ret < 0)

  219.             return ret;

  220.         cs->bsf = bsf;

  221. 

  222.         ret = avcodec_parameters_copy(bsf->par_in, st->codecpar);

  223.         if (ret < 0)

  224.            return ret;

  225. 

  226.         ret = av_bsf_init(bsf);

  227.         if (ret < 0)

  228.             return ret;

  229. 

  230.         ret = avcodec_parameters_copy(st->codecpar, bsf->par_out);

  231.         if (ret < 0)

  232.             return ret;

  233.     }

  234.     return 0;

  235. }

  236. 

  237. static int match_streams_one_to_one(AVFormatContext *avf)

  238. {

  239.     ConcatContext *cat = avf->priv_data;

  240.     AVStream *st;

  241.     int i, ret;

  242. 

  243.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {

  244.         if (i < avf->nb_streams) {

  245.             st = avf->streams[i];

  246.         } else {

  247.             if (!(st = avformat_new_stream(avf, NULL)))

  248.                 return AVERROR(ENOMEM);

  249.         }

  250.         if ((ret = copy_stream_props(st, cat->avf->streams[i])) < 0)

  251.             return ret;

  252.         cat->cur_file->streams[i].out_stream_index = i;

  253.     }

  254.     return 0;

  255. }

  256. 

  257. static int match_streams_exact_id(AVFormatContext *avf)

  258. {

  259.     ConcatContext *cat = avf->priv_data;

  260.     AVStream *st;

  261.     int i, j, ret;

  262. 

  263.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {

  264.         st = cat->avf->streams[i];

  265.         for (j = 0; j < avf->nb_streams; j++) {

  266.             if (avf->streams[j]->id == st->id) {

  267.                 av_log(avf, AV_LOG_VERBOSE,

  268.                        "Match slave stream #%d with stream #%d id 0x%x\n",

  269.                        i, j, st->id);

  270.                 if ((ret = copy_stream_props(avf->streams[j], st)) < 0)

  271.                     return ret;

  272.                 cat->cur_file->streams[i].out_stream_index = j;

  273.             }

  274.         }

  275.     }

  276.     return 0;

  277. }

  278. 

  279. static int match_streams(AVFormatContext *avf)

  280. {

  281.     ConcatContext *cat = avf->priv_data;

  282.     ConcatStream *map;

  283.     int i, ret;

  284. 

  285.     if (cat->cur_file->nb_streams >= cat->avf->nb_streams)

  286.         return 0;

  287.     map = av_realloc(cat->cur_file->streams,

  288.                      cat->avf->nb_streams * sizeof(*map));

  289.     if (!map)

  290.         return AVERROR(ENOMEM);

  291.     cat->cur_file->streams = map;

  292.     memset(map + cat->cur_file->nb_streams, 0,

  293.            (cat->avf->nb_streams - cat->cur_file->nb_streams) * sizeof(*map));

  294. 

  295.     for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {

  296.         map[i].out_stream_index = -1;

  297.         if ((ret = detect_stream_specific(avf, i)) < 0)

  298.             return ret;

  299.     }

  300.     switch (cat->stream_match_mode) {

  301.     case MATCH_ONE_TO_ONE:

  302.         ret = match_streams_one_to_one(avf);

  303.         break;

  304.     case MATCH_EXACT_ID:

  305.         ret = match_streams_exact_id(avf);

  306.         break;

  307.     default:

  308.         ret = AVERROR_BUG;

  309.     }

  310.     if (ret < 0)

  311.         return ret;

  312.     cat->cur_file->nb_streams = cat->avf->nb_streams;

  313.     return 0;

  314. }

  315. 

  316. static int open_file(AVFormatContext *avf, unsigned fileno)

  317. {

  318.     ConcatContext *cat = avf->priv_data;

  319.     ConcatFile *file = &cat->files[fileno];

  320.     int ret;

  321. 

  322.     if (cat->avf)

  323.         avformat_close_input(&cat->avf);

  324. 

  325.     cat->avf = avformat_alloc_context();

  326.     if (!cat->avf)

  327.         return AVERROR(ENOMEM);

  328. 

  329.     cat->avf->flags |= avf->flags & ~AVFMT_FLAG_CUSTOM_IO;

  330.     cat->avf->interrupt_callback = avf->interrupt_callback;

  331. 

  332.     if ((ret = ff_copy_whiteblacklists(cat->avf, avf)) < 0)

  333.         return ret;

  334. 

  335.     if ((ret = avformat_open_input(&cat->avf, file->url, NULL, NULL)) < 0 ||

  336.         (ret = avformat_find_stream_info(cat->avf, NULL)) < 0) {

  337.         av_log(avf, AV_LOG_ERROR, "Impossible to open '%s'\n", file->url);

  338.         avformat_close_input(&cat->avf);

  339.         return ret;

  340.     }

  341.     cat->cur_file = file;

  342.     if (file->start_time == AV_NOPTS_VALUE)

  343.         file->start_time = !fileno ? 0 :

  344.                            cat->files[fileno - 1].start_time +

  345.                            cat->files[fileno - 1].duration;

  346.     file->file_start_time = (cat->avf->start_time == AV_NOPTS_VALUE) ? 0 : cat->avf->start_time;

  347.     file->file_inpoint = (file->inpoint == AV_NOPTS_VALUE) ? file->file_start_time : file->inpoint;

  348.     if (file->duration == AV_NOPTS_VALUE && file->outpoint != AV_NOPTS_VALUE)

  349.         file->duration = file->outpoint - file->file_inpoint;

  350. 

  351.     if (cat->segment_time_metadata) {

  352.         av_dict_set_int(&file->metadata, "lavf.concatdec.start_time", file->start_time, 0);

  353.         if (file->duration != AV_NOPTS_VALUE)

  354.             av_dict_set_int(&file->metadata, "lavf.concatdec.duration", file->duration, 0);

  355.     }

  356. 

  357.     if ((ret = match_streams(avf)) < 0)

  358.         return ret;

  359.     if (file->inpoint != AV_NOPTS_VALUE) {

  360.        if ((ret = avformat_seek_file(cat->avf, -1, INT64_MIN, file->inpoint, file->inpoint, 0)) < 0)

  361.            return ret;

  362.     }

  363.     return 0;

  364. }

  365. 

  366. static int concat_read_close(AVFormatContext *avf)

  367. {

  368.     ConcatContext *cat = avf->priv_data;

  369.     unsigned i, j;

  370. 

  371.     for (i = 0; i < cat->nb_files; i++) {

  372.         av_freep(&cat->files[i].url);

  373.         for (j = 0; j < cat->files[i].nb_streams; j++) {

  374.             if (cat->files[i].streams[j].bsf)

  375.                 av_bsf_free(&cat->files[i].streams[j].bsf);

  376.         }

  377.         av_freep(&cat->files[i].streams);

  378.         av_dict_free(&cat->files[i].metadata);

  379.     }

  380.     if (cat->avf)

  381.         avformat_close_input(&cat->avf);

  382.     av_freep(&cat->files);

  383.     return 0;

  384. }

  385. 

  386. static int concat_read_header(AVFormatContext *avf)

  387. {

  388.     ConcatContext *cat = avf->priv_data;

  389.     uint8_t buf[4096];

  390.     uint8_t *cursor, *keyword;

  391.     int ret, line = 0, i;

  392.     unsigned nb_files_alloc = 0;

  393.     ConcatFile *file = NULL;

  394.     int64_t time = 0;

  395. 

  396.     while (1) {

  397.         if ((ret = ff_get_line(avf->pb, buf, sizeof(buf))) <= 0)

  398.             break;

  399.         line++;

  400.         cursor = buf;

  401.         keyword = get_keyword(&cursor);

  402.         if (!*keyword || *keyword == '#')

  403.             continue;

  404. 

  405.         if (!strcmp(keyword, "file")) {

  406.             char *filename = av_get_token((const char **)&cursor, SPACE_CHARS);

  407.             if (!filename) {

  408.                 av_log(avf, AV_LOG_ERROR, "Line %d: filename required\n", line);

  409.                 FAIL(AVERROR_INVALIDDATA);

  410.             }

  411.             if ((ret = add_file(avf, filename, &file, &nb_files_alloc)) < 0)

  412.                 goto fail;

  413.         } else if (!strcmp(keyword, "duration") || !strcmp(keyword, "inpoint") || !strcmp(keyword, "outpoint")) {

  414.             char *dur_str = get_keyword(&cursor);

  415.             int64_t dur;

  416.             if (!file) {

  417.                 av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",

  418.                        line, keyword);

  419.                 FAIL(AVERROR_INVALIDDATA);

  420.             }

  421.             if ((ret = av_parse_time(&dur, dur_str, 1)) < 0) {

  422.                 av_log(avf, AV_LOG_ERROR, "Line %d: invalid %s '%s'\n",

  423.                        line, keyword, dur_str);

  424.                 goto fail;

  425.             }

  426.             if (!strcmp(keyword, "duration"))

  427.                 file->duration = dur;

  428.             else if (!strcmp(keyword, "inpoint"))

  429.                 file->inpoint = dur;

  430.             else if (!strcmp(keyword, "outpoint"))

  431.                 file->outpoint = dur;

  432.         } else if (!strcmp(keyword, "file_packet_metadata")) {

  433.             char *metadata;

  434.             if (!file) {

  435.                 av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",

  436.                        line, keyword);

  437.                 FAIL(AVERROR_INVALIDDATA);

  438.             }

  439.             metadata = av_get_token((const char **)&cursor, SPACE_CHARS);

  440.             if (!metadata) {

  441.                 av_log(avf, AV_LOG_ERROR, "Line %d: packet metadata required\n", line);

  442.                 FAIL(AVERROR_INVALIDDATA);

  443.             }

  444.             if ((ret = av_dict_parse_string(&file->metadata, metadata, "=", "", 0)) < 0) {

  445.                 av_log(avf, AV_LOG_ERROR, "Line %d: failed to parse metadata string\n", line);

  446.                 av_freep(&metadata);

  447.                 FAIL(AVERROR_INVALIDDATA);

  448.             }

  449.             av_freep(&metadata);

  450.         } else if (!strcmp(keyword, "stream")) {

  451.             if (!avformat_new_stream(avf, NULL))

  452.                 FAIL(AVERROR(ENOMEM));

  453.         } else if (!strcmp(keyword, "exact_stream_id")) {

  454.             if (!avf->nb_streams) {

  455.                 av_log(avf, AV_LOG_ERROR, "Line %d: exact_stream_id without stream\n",

  456.                        line);

  457.                 FAIL(AVERROR_INVALIDDATA);

  458.             }

  459.             avf->streams[avf->nb_streams - 1]->id =

  460.                 strtol(get_keyword(&cursor), NULL, 0);

  461.         } else if (!strcmp(keyword, "ffconcat")) {

  462.             char *ver_kw  = get_keyword(&cursor);

  463.             char *ver_val = get_keyword(&cursor);

  464.             if (strcmp(ver_kw, "version") || strcmp(ver_val, "1.0")) {

  465.                 av_log(avf, AV_LOG_ERROR, "Line %d: invalid version\n", line);

  466.                 FAIL(AVERROR_INVALIDDATA);

  467.             }

  468.             if (cat->safe < 0)

  469.                 cat->safe = 1;

  470.         } else {

  471.             av_log(avf, AV_LOG_ERROR, "Line %d: unknown keyword '%s'\n",

  472.                    line, keyword);

  473.             FAIL(AVERROR_INVALIDDATA);

  474.         }

  475.     }

  476.     if (ret < 0)

  477.         goto fail;

  478.     if (!cat->nb_files)

  479.         FAIL(AVERROR_INVALIDDATA);

  480. 

  481.     for (i = 0; i < cat->nb_files; i++) {

  482.         if (cat->files[i].start_time == AV_NOPTS_VALUE)

  483.             cat->files[i].start_time = time;

  484.         else

  485.             time = cat->files[i].start_time;

  486.         if (cat->files[i].duration == AV_NOPTS_VALUE) {

  487.             if (cat->files[i].inpoint == AV_NOPTS_VALUE || cat->files[i].outpoint == AV_NOPTS_VALUE)

  488.                 break;

  489.             cat->files[i].duration = cat->files[i].outpoint - cat->files[i].inpoint;

  490.         }

  491.         time += cat->files[i].duration;

  492.     }

  493.     if (i == cat->nb_files) {

  494.         avf->duration = time;

  495.         cat->seekable = 1;

  496.     }

  497. 

  498.     cat->stream_match_mode = avf->nb_streams ? MATCH_EXACT_ID :

  499.                                                MATCH_ONE_TO_ONE;

  500.     if ((ret = open_file(avf, 0)) < 0)

  501.         goto fail;

  502.     return 0;

  503. 

  504. fail:

  505.     concat_read_close(avf);

  506.     return ret;

  507. }

  508. 

  509. static int open_next_file(AVFormatContext *avf)

  510. {

  511.     ConcatContext *cat = avf->priv_data;

  512.     unsigned fileno = cat->cur_file - cat->files;

  513. 

  514.     if (cat->cur_file->duration == AV_NOPTS_VALUE) {

  515.         if (cat->avf->duration > 0 || cat->cur_file->next_dts == AV_NOPTS_VALUE) {

  516.             cat->cur_file->duration = cat->avf->duration;

  517.         } else {

  518.             cat->cur_file->duration = cat->cur_file->next_dts;

  519.         }

  520.         cat->cur_file->duration -= (cat->cur_file->file_inpoint - cat->cur_file->file_start_time);

  521.     }

  522. 

  523.     if (++fileno >= cat->nb_files) {

  524.         cat->eof = 1;

  525.         return AVERROR_EOF;

  526.     }

  527.     return open_file(avf, fileno);

  528. }

  529. 

  530. static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)

  531. {

  532.     int ret;

  533. 

  534.     if (cs->bsf) {

  535.         ret = av_bsf_send_packet(cs->bsf, pkt);

  536.         if (ret < 0) {

  537.             av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "

  538.                    "failed to send input packet\n");

  539.             av_packet_unref(pkt);

  540.             return ret;

  541.         }

  542. 

  543.         while (!ret)

  544.             ret = av_bsf_receive_packet(cs->bsf, pkt);

  545. 

  546.         if (ret < 0 && (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)) {

  547.             av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "

  548.                    "failed to receive output packet\n");

  549.             return ret;

  550.         }

  551.     }

  552.     return 0;

  553. }

  554. 

  555. /* Returns true if the packet dts is greater or equal to the specified outpoint. */

  556. static int packet_after_outpoint(ConcatContext *cat, AVPacket *pkt)

  557. {

  558.     if (cat->cur_file->outpoint != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE) {

  559.         return av_compare_ts(pkt->dts, cat->avf->streams[pkt->stream_index]->time_base,

  560.                              cat->cur_file->outpoint, AV_TIME_BASE_Q) >= 0;

  561.     }

  562.     return 0;

  563. }

  564. 

  565. static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)

  566. {

  567.     ConcatContext *cat = avf->priv_data;

  568.     int ret;

  569.     int64_t delta;

  570.     ConcatStream *cs;

  571.     AVStream *st;

  572. 

  573.     if (cat->eof)

  574.         return AVERROR_EOF;

  575. 

  576.     if (!cat->avf)

  577.         return AVERROR(EIO);

  578. 

  579.     while (1) {

  580.         ret = av_read_frame(cat->avf, pkt);

  581.         if (ret == AVERROR_EOF) {

  582.             if ((ret = open_next_file(avf)) < 0)

  583.                 return ret;

  584.             continue;

  585.         }

  586.         if (ret < 0)

  587.             return ret;

  588.         if ((ret = match_streams(avf)) < 0) {

  589.             av_packet_unref(pkt);

  590.             return ret;

  591.         }

  592.         if (packet_after_outpoint(cat, pkt)) {

  593.             av_packet_unref(pkt);

  594.             if ((ret = open_next_file(avf)) < 0)

  595.                 return ret;

  596.             continue;

  597.         }

  598.         cs = &cat->cur_file->streams[pkt->stream_index];

  599.         if (cs->out_stream_index < 0) {

  600.             av_packet_unref(pkt);

  601.             continue;

  602.         }

  603.         pkt->stream_index = cs->out_stream_index;

  604.         break;

  605.     }

  606.     if ((ret = filter_packet(avf, cs, pkt)))

  607.         return ret;

  608. 

  609.     st = cat->avf->streams[pkt->stream_index];

  610.     av_log(avf, AV_LOG_DEBUG, "file:%d stream:%d pts:%s pts_time:%s dts:%s dts_time:%s",

  611.            (unsigned)(cat->cur_file - cat->files), pkt->stream_index,

  612.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),

  613.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));

  614. 

  615.     delta = av_rescale_q(cat->cur_file->start_time - cat->cur_file->file_inpoint,

  616.                          AV_TIME_BASE_Q,

  617.                          cat->avf->streams[pkt->stream_index]->time_base);

  618.     if (pkt->pts != AV_NOPTS_VALUE)

  619.         pkt->pts += delta;

  620.     if (pkt->dts != AV_NOPTS_VALUE)

  621.         pkt->dts += delta;

  622.     av_log(avf, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",

  623.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),

  624.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));

  625.     if (cat->cur_file->metadata) {

  626.         uint8_t* metadata;

  627.         int metadata_len;

  628.         char* packed_metadata = av_packet_pack_dictionary(cat->cur_file->metadata, &metadata_len);

  629.         if (!packed_metadata)

  630.             return AVERROR(ENOMEM);

  631.         if (!(metadata = av_packet_new_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, metadata_len))) {

  632.             av_freep(&packed_metadata);

  633.             return AVERROR(ENOMEM);

  634.         }

  635.         memcpy(metadata, packed_metadata, metadata_len);

  636.         av_freep(&packed_metadata);

  637.     }

  638. 

  639.     if (cat->cur_file->duration == AV_NOPTS_VALUE && st->cur_dts != AV_NOPTS_VALUE) {

  640.         int64_t next_dts = av_rescale_q(st->cur_dts, st->time_base, AV_TIME_BASE_Q);

  641.         if (cat->cur_file->next_dts == AV_NOPTS_VALUE || next_dts > cat->cur_file->next_dts) {

  642.             cat->cur_file->next_dts = next_dts;

  643.         }

  644.     }

  645. 

  646.     return ret;

  647. }

  648. 

  649. static void rescale_interval(AVRational tb_in, AVRational tb_out,

  650.                              int64_t *min_ts, int64_t *ts, int64_t *max_ts)

  651. {

  652.     *ts     = av_rescale_q    (*    ts, tb_in, tb_out);

  653.     *min_ts = av_rescale_q_rnd(*min_ts, tb_in, tb_out,

  654.                                AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);

  655.     *max_ts = av_rescale_q_rnd(*max_ts, tb_in, tb_out,

  656.                                AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

  657. }

  658. 

  659. static int try_seek(AVFormatContext *avf, int stream,

  660.                     int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

  661. {

  662.     ConcatContext *cat = avf->priv_data;

  663.     int64_t t0 = cat->cur_file->start_time - cat->cur_file->file_inpoint;

  664. 

  665.     ts -= t0;

  666.     min_ts = min_ts == INT64_MIN ? INT64_MIN : min_ts - t0;

  667.     max_ts = max_ts == INT64_MAX ? INT64_MAX : max_ts - t0;

  668.     if (stream >= 0) {

  669.         if (stream >= cat->avf->nb_streams)

  670.             return AVERROR(EIO);

  671.         rescale_interval(AV_TIME_BASE_Q, cat->avf->streams[stream]->time_base,

  672.                          &min_ts, &ts, &max_ts);

  673.     }

  674.     return avformat_seek_file(cat->avf, stream, min_ts, ts, max_ts, flags);

  675. }

  676. 

  677. static int real_seek(AVFormatContext *avf, int stream,

  678.                      int64_t min_ts, int64_t ts, int64_t max_ts, int flags, AVFormatContext *cur_avf)

  679. {

  680.     ConcatContext *cat = avf->priv_data;

  681.     int ret, left, right;

  682. 

  683.     if (stream >= 0) {

  684.         if (stream >= avf->nb_streams)

  685.             return AVERROR(EINVAL);

  686.         rescale_interval(avf->streams[stream]->time_base, AV_TIME_BASE_Q,

  687.                          &min_ts, &ts, &max_ts);

  688.     }

  689. 

  690.     left  = 0;

  691.     right = cat->nb_files;

  692.     while (right - left > 1) {

  693.         int mid = (left + right) / 2;

  694.         if (ts < cat->files[mid].start_time)

  695.             right = mid;

  696.         else

  697.             left  = mid;

  698.     }

  699. 

  700.     if (cat->cur_file != &cat->files[left]) {

  701.         if ((ret = open_file(avf, left)) < 0)

  702.             return ret;

  703.     } else {

  704.         cat->avf = cur_avf;

  705.     }

  706. 

  707.     ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);

  708.     if (ret < 0 &&

  709.         left < cat->nb_files - 1 &&

  710.         cat->files[left + 1].start_time < max_ts) {

  711.         if (cat->cur_file == &cat->files[left])

  712.             cat->avf = NULL;

  713.         if ((ret = open_file(avf, left + 1)) < 0)

  714.             return ret;

  715.         ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);

  716.     }

  717.     return ret;

  718. }

  719. 

  720. static int concat_seek(AVFormatContext *avf, int stream,

  721.                        int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

  722. {

  723.     ConcatContext *cat = avf->priv_data;

  724.     ConcatFile *cur_file_saved = cat->cur_file;

  725.     AVFormatContext *cur_avf_saved = cat->avf;

  726.     int ret;

  727. 

  728.     if (!cat->seekable)

  729.         return AVERROR(ESPIPE); /* XXX: can we use it? */

  730.     if (flags & (AVSEEK_FLAG_BYTE | AVSEEK_FLAG_FRAME))

  731.         return AVERROR(ENOSYS);

  732.     cat->avf = NULL;

  733.     if ((ret = real_seek(avf, stream, min_ts, ts, max_ts, flags, cur_avf_saved)) < 0) {

  734.         if (cat->cur_file != cur_file_saved) {

  735.             if (cat->avf)

  736.                 avformat_close_input(&cat->avf);

  737.         }

  738.         cat->avf      = cur_avf_saved;

  739.         cat->cur_file = cur_file_saved;

  740.     } else {

  741.         if (cat->cur_file != cur_file_saved) {

  742.             avformat_close_input(&cur_avf_saved);

  743.         }

  744.         cat->eof = 0;

  745.     }

  746.     return ret;

  747. }

  748. 

  749. #define OFFSET(x) offsetof(ConcatContext, x)

  750. #define DEC AV_OPT_FLAG_DECODING_PARAM

  751. 

  752. static const AVOption options[] = {

  753.     { "safe", "enable safe mode",

  754.       OFFSET(safe), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, DEC },

  755.     { "auto_convert", "automatically convert bitstream format",

  756.       OFFSET(auto_convert), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DEC },

  757.     { "segment_time_metadata", "output file segment start time and duration as packet metadata",

  758.       OFFSET(segment_time_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

  759.     { NULL }

  760. };

  761. 

  762. static const AVClass concat_class = {

  763.     .class_name = "concat demuxer",

  764.     .item_name  = av_default_item_name,

  765.     .option     = options,

  766.     .version    = LIBAVUTIL_VERSION_INT,

  767. };

  768. 

  769. 

  770. AVInputFormat ff_concat_demuxer = {

  771.     .name           = "concat",

  772.     .long_name      = NULL_IF_CONFIG_SMALL("Virtual concatenation script"),

  773.     .priv_data_size = sizeof(ConcatContext),

  774.     .read_probe     = concat_probe,

  775.     .read_header    = concat_read_header,

  776.     .read_packet    = concat_read_packet,

  777.     .read_close     = concat_read_close,

  778.     .read_seek2     = concat_seek,

  779.     .priv_class     = &concat_class,

  780. };