RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/player/timeline/tl_matroska.c

583 lines
21 KiB
C
Raw Normal View History

core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
#include <assert.h>
#include <dirent.h>
matroska: look for all known matroska file extensions For segment linking (this mechanism matches file extensions to avoid opening files which are most likely not Matroska files in order to speed up scanning).
2014-10-06 20:33:21 +00:00
#include <string.h>
#include <strings.h>
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
#include <libavutil/common.h>
windows support: unicode filenames Windows uses a legacy codepage for char* / runtime functions accepting char *. Using UTF-8 as the codepage with setlocale() is explicitly forbidden. Work this around by overriding the MSVCRT functions with wrapper macros, that assume UTF-8 and use "proper" API calls like _wopen etc. to deal with unicode filenames. All code that uses standard functions that take or return filenames must now include osdep/io.h. stat() can't be overridden, because MinGW-w64 itself defines "stat" as a macro. Change code to use use mp_stat() instead. This is not perfectly clean, but still somewhat sane, and much better than littering the rest of the mplayer code with MinGW specific hacks. It's also a bit fragile, but that's actually little different from the previous situation. Also, MinGW is unlikely to ever include a nice way of dealing with this.
2012-02-03 07:05:11 +00:00
#include "osdep/io.h"
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
#include "talloc.h"
Rename mp_core.h to core.h Get rid of the mp_ prefix.
2013-12-17 00:08:53 +00:00
#include "player/core.h"
Split mpvcore/ into common/, misc/, bstr/
2013-12-17 01:39:45 +00:00
#include "common/msg.h"
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "demux/demux.h"
Move options/config related files from mpvcore/ to options/ Since m_option.h and options.h are extremely often included, a lot of files have to be changed. Moving path.c/h to options/ is a bit questionable, but since this is mainly about access to config files (which are also handled in options/), it's probably ok.
2013-12-17 01:02:25 +00:00
#include "options/path.h"
Move compat/ and bstr/ directory contents somewhere else bstr.c doesn't really deserve its own directory, and compat had just a few files, most of which may as well be in osdep. There isn't really any justification for these extra directories, so get rid of them. The compat/libav.h was empty - just delete it. We changed our approach to API compatibility, and will likely not need it anymore.
2014-08-29 10:09:04 +00:00
#include "misc/bstr.h"
Split mpvcore/ into common/, misc/, bstr/
2013-12-17 01:39:45 +00:00
#include "common/common.h"
#include "common/playlist.h"
demuxer.h: avoid including stream.h Drop the unnecessary include and add a missing direct include in some files. This also revealed that demux_rtp_internal.h was missing a config.h include, fix that too.
2011-08-19 02:36:27 +00:00
#include "stream/stream.h"
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
struct find_entry {
char *name;
int matchlen;
struct stat.st_blocks is not available on MinGW
2012-02-28 22:01:13 +00:00
off_t size;
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
};
static int cmp_entry(const void *pa, const void *pb)
{
const struct find_entry *a = pa, *b = pb;
// check "similar" filenames first
int matchdiff = b->matchlen - a->matchlen;
if (matchdiff)
return FFSIGN(matchdiff);
// check small files first
struct stat.st_blocks is not available on MinGW
2012-02-28 22:01:13 +00:00
off_t sizediff = a->size - b->size;
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
if (sizediff)
return FFSIGN(sizediff);
return 0;
}
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
matroska: look for all known matroska file extensions For segment linking (this mechanism matches file extensions to avoid opening files which are most likely not Matroska files in order to speed up scanning).
2014-10-06 20:33:21 +00:00
static bool test_matroska_ext(const char *filename)
{
static const char *const exts[] = {".mkv", ".mka", ".mks", ".mk3d", NULL};
for (int n = 0; exts[n]; n++) {
const char *suffix = exts[n];
int offset = strlen(filename) - strlen(suffix);
// name must end with suffix
if (offset > 0 && strcasecmp(filename + offset, suffix) == 0)
return true;
}
return false;
}
static char **find_files(const char *original_file)
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
{
void *tmpmem = talloc_new(NULL);
char *basename = mp_basename(original_file);
struct bstr directory = mp_dirname(original_file);
char **results = talloc_size(NULL, 0);
char *dir_zero = bstrdup0(tmpmem, directory);
DIR *dp = opendir(dir_zero);
if (!dp) {
talloc_free(tmpmem);
return results;
}
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
struct find_entry *entries = NULL;
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
struct dirent *ep;
int num_results = 0;
while ((ep = readdir(dp))) {
matroska: look for all known matroska file extensions For segment linking (this mechanism matches file extensions to avoid opening files which are most likely not Matroska files in order to speed up scanning).
2014-10-06 20:33:21 +00:00
if (!test_matroska_ext(ep->d_name))
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
continue;
// don't list the original name
if (!strcmp(ep->d_name, basename))
continue;
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
char *name = mp_path_join(results, directory, bstr0(ep->d_name));
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
char *s1 = ep->d_name;
char *s2 = basename;
int matchlen = 0;
while (*s1 && *s1++ == *s2++)
matchlen++;
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
// be a bit more fuzzy about matching the filename
matchlen = (matchlen + 3) / 5;
struct stat statbuf;
if (stat(name, &statbuf) != 0)
continue;
struct stat.st_blocks is not available on MinGW
2012-02-28 22:01:13 +00:00
off_t size = statbuf.st_size;
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
core, timeline: don't keep separate stream field The timeline code kept pairs of stream and demuxer references around. The reference to the stream is redundant, because it can be accessed through the demuxer. Simplify the code by removing the redundant stream reference. Also, set mpctx->stream to the current segment when using timeline. Fix a small memory leak in tl_matroska.c introduced earlier.
2012-08-19 15:58:58 +00:00
entries = talloc_realloc(tmpmem, entries, struct find_entry,
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
num_results + 1);
struct stat.st_blocks is not available on MinGW
2012-02-28 22:01:13 +00:00
entries[num_results] = (struct find_entry) { name, matchlen, size };
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
num_results++;
}
closedir(dp);
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
// NOTE: maybe should make it compare pointers instead
tl_matroska: fix NULL pointer issue Found by clang analyzer. Probably doesn't matter in practice, because the number of entries was 0 when entries was NULL.
2012-10-31 23:24:08 +00:00
if (entries)
qsort(entries, num_results, sizeof(struct find_entry), cmp_entry);
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
results = talloc_realloc(NULL, results, char *, num_results);
matroska: speed up ordered chapters scanning with improved heuristics Try to be a bit more clever when scanning for linked mkv files (ordered chapters feature). Instead of just preferring filenames with a closer prefix match, consider file sizes as well. The assumption is that it is better to scan small files first. Achieve this by sorting by prefix first, and then by file size. In order to make this new behavior trigger more often, be a more "fuzzy" about the prefix matching: consider all matches in a certain range as equal. This will speed up the following case: title_01.mkv title_02.mkv title_03.mkv title_op.mkv (title0*.mkv link to it) Playing title_01.mkv, the old code would first scan title_0*, and then title_op.mkv, as "title_0" is the largest prefix. The new code would reduce the common prefix to "title", and then sort the resulting files by size, causing title_op.mkv to be scanned first. The total number of scanned files is reduced.
2011-10-04 00:41:18 +00:00
for (int i = 0; i < num_results; i++) {
results[i] = entries[i].name;
tl_matroska.c: move the find_files() function here Move the find_files() function from findfiles.c to tl_matroska.c. Delete the findfiles.c file. Add a check against opendir() failure in find_files().
2011-02-23 15:57:08 +00:00
}
talloc_free(tmpmem);
return results;
}
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
static int enable_cache(struct MPContext *mpctx, struct stream **stream,
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
struct demuxer **demuxer, struct demuxer_params *params)
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
{
core: make mpctx->opts a pointer Prevents some awkwardness in a later commit, and makes the code more uniform with other places where MPOpts is accessed. This is a pretty annoying commit (touches tons of lines all over the place), but it hurts only once.
2013-07-27 19:24:54 +00:00
struct MPOpts *opts = mpctx->opts;
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
cache: redo options and default settings Some options change from percentages to number of kilobytes; there are no cache options using percentages anymore. Raise the default values. The cache is now 25000 kilobytes, although if your connection is slow enough, the maximum is probably never reached. (Although all the memory will still be used as seekback-cache.) Remove the separate --audio-file-cache option, and use the cache default settings for it.
2014-05-19 21:27:09 +00:00
if (!stream_wants_cache(*stream, &opts->stream_cache))
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
return 0;
char *filename = talloc_strdup(NULL, (*demuxer)->filename);
free_demuxer(*demuxer);
free_stream(*stream);
stream: mp_msg conversions We also drop some slave mode stuff from stream_vcd.
2013-12-21 19:36:45 +00:00
*stream = stream_open(filename, mpctx->global);
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
if (!*stream) {
talloc_free(filename);
return -1;
}
cache: redo options and default settings Some options change from percentages to number of kilobytes; there are no cache options using percentages anymore. Raise the default values. The cache is now 25000 kilobytes, although if your connection is slow enough, the maximum is probably never reached. (Although all the memory will still be used as seekback-cache.) Remove the separate --audio-file-cache option, and use the cache default settings for it.
2014-05-19 21:27:09 +00:00
stream_enable_cache(stream, &opts->stream_cache);
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
demux: mp_msg conversions The TV code pretends to be part of stream/, but it's actually demuxer code too. The audio_in code is shared between the TV code and stream_radio.c, so stream_radio.c needs a small hack until stream.c is converted.
2013-12-21 19:24:20 +00:00
*demuxer = demux_open(*stream, "mkv", params, mpctx->global);
core, timeline: cache external ordered chapter files too Previously, Matroska source files other than the initially opened one were always accessed without caching. Enable cache for extra files too. A separate cache process/thread is started for each file, which is less than optimal but probably better than no caching if the user explicitly enabled cache. This commit only implements caching for Matroska ordered chapters (not for EDL timeline). To build the timeline we need to demux the files in the current directory to look for segments with matching uuid. This first demux is done with no cache since we don't need to read a lot of the stream. If the file is recognized as one of the needed sources it's reopened with cache enabled. Also move the stream_cache_size global variable to the options struct. Conflicts: cfg-mplayer.h mplayer.c stream/stream.h timeline/tl_matroska.c
2012-08-19 13:31:38 +00:00
if (!*demuxer) {
talloc_free(filename);
free_stream(*stream);
return -1;
}
talloc_free(filename);
return 1;
}
matroska: avoid requesting the same source multiple times
2013-10-08 04:33:42 +00:00
static bool has_source_request(struct matroska_segment_uid *uids,
int num_sources,
struct matroska_segment_uid *new_uid)
{
for (int i = 0; i < num_sources; ++i) {
if (demux_matroska_uid_cmp(uids + i, new_uid))
return true;
}
return false;
}
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
// segment = get Nth segment of a multi-segment file
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
static bool check_file_seg(struct MPContext *mpctx, struct demuxer ***sources,
int *num_sources, struct matroska_segment_uid **uids,
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
char *filename, int segment)
{
bool was_valid = false;
struct demuxer_params params = {
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
.matroska_num_wanted_uids = *num_sources,
.matroska_wanted_uids = *uids,
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
.matroska_wanted_segment = segment,
.matroska_was_valid = &was_valid,
};
stream: mp_msg conversions We also drop some slave mode stuff from stream_vcd.
2013-12-21 19:36:45 +00:00
struct stream *s = stream_open(filename, mpctx->global);
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
if (!s)
return false;
demux: mp_msg conversions The TV code pretends to be part of stream/, but it's actually demuxer code too. The audio_in code is shared between the TV code and stream_radio.c, so stream_radio.c needs a small hack until stream.c is converted.
2013-12-21 19:24:20 +00:00
struct demuxer *d = demux_open(s, "mkv", &params, mpctx->global);
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
if (!d) {
free_stream(s);
return was_valid;
}
demux: rewrite probing and demuxer initialization Get rid of the strange and messy reliance on DEMUXER_TYPE_ constants. Instead of having two open functions for the demuxer callbacks (which somehow are both optional, but you can also decide to implement both...), just have one function. This function takes a parameter that tells the demuxer how strictly it should check for the file headers. This is a nice simplification and allows more flexibility. Remove the file extension code. This literally did nothing (anymore). Change demux_lavf so that we check our other builtin demuxers first before libavformat tries to guess by file extension.
2013-07-12 19:58:11 +00:00
if (d->type == DEMUXER_TYPE_MATROSKA) {
matroska: store segment/edition uids in a single structure To support edition references in matroska chapters, editions need to be remembered for each chapter and source. To facilitate easier management of these now-paired uids, a single structure is used.
2013-10-07 00:49:12 +00:00
struct matroska_data *m = &d->matroska_data;
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
for (int i = 1; i < *num_sources; i++) {
struct matroska_segment_uid *uid = *uids + i;
if ((*sources)[i])
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
continue;
matroska: select the edition using the requested edition uid
2013-09-26 06:53:54 +00:00
/* Accept the source if the segment uid matches and the edition
* either matches or isn't specified. */
if (!memcmp(uid->segment, m->uid.segment, 16) &&
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
(!uid->edition || uid->edition == m->uid.edition))
{
MP_INFO(mpctx, "Match for source %d: %s\n", i, d->filename);
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
for (int j = 0; j < m->num_ordered_chapters; j++) {
struct matroska_chapter *c = m->ordered_chapters + j;
if (!c->has_segment_uid)
continue;
matroska: avoid requesting the same source multiple times
2013-10-08 04:33:42 +00:00
if (has_source_request(*uids, *num_sources, &c->uid))
continue;
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
/* Set the requested segment. */
MP_TARRAY_GROW(NULL, *uids, *num_sources);
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
(*uids)[*num_sources] = c->uid;
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
/* Add a new source slot. */
MP_TARRAY_APPEND(NULL, *sources, *num_sources, NULL);
}
tl_matroska: fix use-after-free with --cache If cache was enabled, using ordered chapters could easily crash. The reason is that enable_cache() reopens the demuxer and closes the old one. The code after that (reading m->ordered_chapters etc.) then accessed freed data. This commit also avoids enabling cache for files which are not used (which would make opening much slower).
2013-10-19 20:58:02 +00:00
if (enable_cache(mpctx, &s, &d, &params) < 0)
continue;
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
(*sources)[i] = d;
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
return true;
}
}
}
free_demuxer(d);
free_stream(s);
return was_valid;
}
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
static void check_file(struct MPContext *mpctx, struct demuxer ***sources,
int *num_sources, struct matroska_segment_uid **uids,
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
char *filename, int first)
{
for (int segment = first; ; segment++) {
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
if (!check_file_seg(mpctx, sources, num_sources, uids, filename, segment))
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
break;
}
}
static bool missing(struct demuxer **sources, int num_sources)
{
for (int i = 0; i < num_sources; i++) {
if (!sources[i])
return true;
}
return false;
}
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
static int find_ordered_chapter_sources(struct MPContext *mpctx,
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
struct demuxer ***sources,
int *num_sources,
struct matroska_segment_uid **uids)
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
{
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
struct MPOpts *opts = mpctx->opts;
void *tmp = talloc_new(NULL);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
int num_filenames = 0;
char **filenames = NULL;
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
if (*num_sources > 1) {
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
char *main_filename = mpctx->demuxer->filename;
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
MP_INFO(mpctx, "This file references data from other sources.\n");
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
if (opts->ordered_chapters_files && opts->ordered_chapters_files[0]) {
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
MP_INFO(mpctx, "Loading references from '%s'.\n",
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
opts->ordered_chapters_files);
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
struct playlist *pl =
demux: mp_msg conversions The TV code pretends to be part of stream/, but it's actually demuxer code too. The audio_in code is shared between the TV code and stream_radio.c, so stream_radio.c needs a small hack until stream.c is converted.
2013-12-21 19:24:20 +00:00
playlist_parse_file(opts->ordered_chapters_files, mpctx->global);
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
talloc_steal(tmp, pl);
for (struct playlist_entry *e = pl->first; e; e = e->next)
MP_TARRAY_APPEND(tmp, filenames, num_filenames, e->filename);
} else if (mpctx->demuxer->stream->uncached_type != STREAMTYPE_FILE) {
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
MP_WARN(mpctx, "Playback source is not a "
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
"normal disk file. Will not search for related files.\n");
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
} else {
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
MP_INFO(mpctx, "Will scan other files in the "
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
"same directory to find referenced sources.\n");
matroska: look for all known matroska file extensions For segment linking (this mechanism matches file extensions to avoid opening files which are most likely not Matroska files in order to speed up scanning).
2014-10-06 20:33:21 +00:00
filenames = find_files(main_filename);
ta: rename MP_TALLOC_ELEMS to MP_TALLOC_AVAIL The macro actually returns the *available* space in the array, not how much is actually filled in.
2015-01-26 18:16:27 +00:00
num_filenames = MP_TALLOC_AVAIL(filenames);
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
talloc_steal(tmp, filenames);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
// Possibly get further segments appended to the first segment
matroska: store segment/edition uids in a single structure To support edition references in matroska chapters, editions need to be remembered for each chapter and source. To facilitate easier management of these now-paired uids, a single structure is used.
2013-10-07 00:49:12 +00:00
check_file(mpctx, sources, num_sources, uids, main_filename, 1);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
int old_source_count;
do {
old_source_count = *num_sources;
for (int i = 0; i < num_filenames; i++) {
if (!missing(*sources, *num_sources))
break;
player: demote matroska ordered chapter scanning messages to Verbose Causes a lot of terminal spam on large folders and is not actually useful except maybe for debugging.
2015-01-28 02:41:01 +00:00
MP_VERBOSE(mpctx, "Checking file %s\n", filenames[i]);
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
check_file(mpctx, sources, num_sources, uids, filenames[i], 0);
}
} while (old_source_count != *num_sources);
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
if (missing(*sources, *num_sources)) {
player: ordered chapters: bullshit reduction Nobody cares about these redundant messages, they make the code even more complicated than it has to be, and also they're annoying.
2014-12-26 18:44:53 +00:00
MP_ERR(mpctx, "Failed to find ordered chapter part!\n");
core: matroska: support concatenated segments Matroska files can contain multiple segments, which are literally further Matroska files appended to the main file. They can be referenced by segment linking. While this is an extraordinarily useless and dumb feature, we support it for the hell of it. This is implemented by adding a further demuxer parameter for skipping segments. When scanning for linked segments, each file is opened multiple times, until there are no further segments found. Each segment will have a separate demuxer instance (with a separate file handle etc.). It appears the Matroska spec. has an even worse feature for segments: live streaming can completely reconfigure the stream by starting a new segment. We won't add support for it, because there are 0 people on this earth who think Matroska life streaming is a good idea. (As opposed to serving Matroska/WebM files via HTTP.)
2013-04-14 00:49:07 +00:00
int j = 1;
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
for (int i = 1; i < *num_sources; i++) {
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
if ((*sources)[i]) {
struct matroska_segment_uid *source_uid = *uids + i;
struct matroska_segment_uid *target_uid = *uids + j;
(*sources)[j] = (*sources)[i];
matroska: use memmove when collapsing the source list down
2013-10-08 04:35:04 +00:00
memmove(target_uid, source_uid, sizeof(*source_uid));
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
j++;
}
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
}
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
*num_sources = j;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}
matroska: add --ordered-chapters-files option This option takes a playlist. The playlist will then be used as list of potential segment files for use with ordered chapters.
2013-12-14 20:52:37 +00:00
talloc_free(tmp);
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
return *num_sources;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
static int64_t add_timeline_part(struct MPContext *mpctx,
matroska: modify chapter limits by join_diff When adding or removing frames to avoid 1-frame seeks on chapter boundaries, the end of the chapter needs to be pushed or pulled by the same amount to keep the intended end frame the same.
2013-10-14 22:51:03 +00:00
struct demuxer *source,
struct timeline_part **timeline,
int *part_count,
uint64_t start,
uint64_t *last_end_time,
uint64_t *starttime)
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
{
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
/* Merge directly adjacent parts. We allow for a configurable fudge factor
* because of files which specify chapter end times that are one frame too
* early; we don't want to try seeking over a one frame gap. */
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
int64_t join_diff = start - *last_end_time;
if (*part_count == 0
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
|| FFABS(join_diff) > mpctx->opts->chapter_merge_threshold * 1e6
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
|| source != (*timeline)[*part_count - 1].source)
{
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
struct timeline_part new = {
.start = *starttime / 1e9,
.source_start = start / 1e9,
.source = source,
};
MP_TARRAY_APPEND(NULL, *timeline, *part_count, new);
} else if (*part_count > 0 && join_diff) {
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
// Chapter was merged at an inexact boundary; adjust timestamps to match.
MP_VERBOSE(mpctx, "Merging timeline part %d with offset %g ms.\n",
*part_count, join_diff / 1e6);
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
*starttime += join_diff;
matroska: modify chapter limits by join_diff When adding or removing frames to avoid 1-frame seeks on chapter boundaries, the end of the chapter needs to be pushed or pulled by the same amount to keep the intended end frame the same.
2013-10-14 22:51:03 +00:00
return join_diff;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
}
matroska: modify chapter limits by join_diff When adding or removing frames to avoid 1-frame seeks on chapter boundaries, the end of the chapter needs to be pushed or pulled by the same amount to keep the intended end frame the same.
2013-10-14 22:51:03 +00:00
return 0;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
}
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
static void build_timeline_loop(struct MPContext *mpctx,
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
struct demuxer **sources,
int num_sources,
int current_source,
uint64_t *starttime,
uint64_t *missing_time,
uint64_t *last_end_time,
struct timeline_part **timeline,
player: always use demux_chapter Instead of defining a separate data structure in the core. For some odd reason, demux_chapter exported the chapter time in nano-seconds. Change that to the usual timestamps (rename the field to make any code relying on this to fail compilation), and also remove the unused chapter end time.
2014-11-02 16:20:04 +00:00
struct demux_chapter *chapters,
tl_matroska: check chapter bounds I have no idea what this does, but it's without doubt a sufficient fix for the issue at hand. Fixes #1445.
2015-01-09 00:47:48 +00:00
int num_chapters,
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
int *part_count,
uint64_t skip,
uint64_t limit)
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
{
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
uint64_t local_starttime = 0;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
struct demuxer *source = sources[current_source];
struct matroska_data *m = &source->matroska_data;
for (int i = 0; i < m->num_ordered_chapters; i++) {
struct matroska_chapter *c = m->ordered_chapters + i;
uint64_t chapter_length = c->end - c->start;
if (!c->has_segment_uid)
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
c->uid = m->uid;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
local_starttime += chapter_length;
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
// If we're before the start time for the chapter, skip to the next one.
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
if (local_starttime <= skip)
continue;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
/* Look for the source for this chapter. */
for (int j = 0; j < num_sources; j++) {
struct demuxer *linked_source = sources[j];
struct matroska_data *linked_m = &linked_source->matroska_data;
if (!demux_matroska_uid_cmp(&c->uid, &linked_m->uid))
continue;
tl_matroska: check chapter bounds I have no idea what this does, but it's without doubt a sufficient fix for the issue at hand. Fixes #1445.
2015-01-09 00:47:48 +00:00
if (i >= num_chapters)
break; // probably needed only for broken sources
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
if (!limit) {
player: always use demux_chapter Instead of defining a separate data structure in the core. For some odd reason, demux_chapter exported the chapter time in nano-seconds. Change that to the usual timestamps (rename the field to make any code relying on this to fail compilation), and also remove the unused chapter end time.
2014-11-02 16:20:04 +00:00
chapters[i].pts = *starttime / 1e9;
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
chapters[i].name = talloc_strdup(chapters, c->name);
}
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
/* If we're the source or it's a non-ordered edition reference,
* just add a timeline part from the source. */
if (current_source == j || !linked_m->num_ordered_chapters) {
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
uint64_t source_full_length =
demuxer_get_time_length(linked_source) * 1e9;
matroska: account for missing information from short sources If a source is shorter than the requested chapter length, account for the time missing.
2013-10-14 23:28:47 +00:00
uint64_t source_length = source_full_length - c->start;
int64_t join_diff = 0;
/* If the chapter starts after the end of a source, there's
* nothing we can get from it. Instead, mark the entire chapter
* as missing and make the chapter length 0. */
if (source_full_length <= c->start) {
player: ordered chapters: bullshit reduction Nobody cares about these redundant messages, they make the code even more complicated than it has to be, and also they're annoying.
2014-12-26 18:44:53 +00:00
*missing_time += chapter_length;
matroska: account for missing information from short sources If a source is shorter than the requested chapter length, account for the time missing.
2013-10-14 23:28:47 +00:00
chapter_length = 0;
goto found;
}
/* If the source length starting at the chapter start is
* shorter than the chapter it is supposed to fill, add the gap
* to missing_time. Also, modify the chapter length to be what
* we actually have to avoid playing off the end of the file
* and not switching to the next source. */
if (source_length < chapter_length) {
player: ordered chapters: bullshit reduction Nobody cares about these redundant messages, they make the code even more complicated than it has to be, and also they're annoying.
2014-12-26 18:44:53 +00:00
*missing_time += chapter_length - source_length;
matroska: account for missing information from short sources If a source is shorter than the requested chapter length, account for the time missing.
2013-10-14 23:28:47 +00:00
chapter_length = source_length;
}
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
join_diff = add_timeline_part(mpctx, linked_source, timeline, part_count,
matroska: account for missing information from short sources If a source is shorter than the requested chapter length, account for the time missing.
2013-10-14 23:28:47 +00:00
c->start, last_end_time, starttime);
matroska: modify chapter limits by join_diff When adding or removing frames to avoid 1-frame seeks on chapter boundaries, the end of the chapter needs to be pushed or pulled by the same amount to keep the intended end frame the same.
2013-10-14 22:51:03 +00:00
/* If we merged two chapters into a single part due to them
* being off by a few frames, we need to change the limit to
* avoid chopping the end of the intended chapter (the adding
* frames case) or showing extra content (the removing frames
* case). Also update chapter_length to incorporate the extra
* time. */
if (limit) {
limit += join_diff;
chapter_length += join_diff;
}
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
} else {
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
/* We have an ordered edition as the source. Since this
* can jump around all over the place, we need to build up the
* timeline parts for each of its chapters, but not add them as
* chapters. */
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
build_timeline_loop(mpctx, sources, num_sources, j, starttime,
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
missing_time, last_end_time, timeline,
tl_matroska: check chapter bounds I have no idea what this does, but it's without doubt a sufficient fix for the issue at hand. Fixes #1445.
2015-01-09 00:47:48 +00:00
chapters, num_chapters, part_count,
c->start, c->end);
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
// Already handled by the loop call.
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
chapter_length = 0;
}
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
*last_end_time = c->end;
goto found;
}
player: ordered chapters: bullshit reduction Nobody cares about these redundant messages, they make the code even more complicated than it has to be, and also they're annoying.
2014-12-26 18:44:53 +00:00
*missing_time += chapter_length;
matroska: don't add time for chapters without a source
2013-10-16 01:16:05 +00:00
chapter_length = 0;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
found:;
*starttime += chapter_length;
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
/* If we're after the limit on this chapter, stop here. */
if (limit && local_starttime >= limit) {
/* Back up the global start time by the overflow. */
*starttime -= local_starttime - limit;
break;
}
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
}
matroska: support chapter references to ordered editions Since ordered editions can reference external files, when an ordered chapter references another ordered edition, we have to go and figure out what is is referencing as well.
2013-10-07 03:22:19 +00:00
/* If we stopped before the limit, add up the missing time. */
if (local_starttime < limit)
player: ordered chapters: bullshit reduction Nobody cares about these redundant messages, they make the code even more complicated than it has to be, and also they're annoying.
2014-12-26 18:44:53 +00:00
*missing_time += limit - local_starttime;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
}
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
void build_ordered_chapter_timeline(struct MPContext *mpctx)
{
core: make mpctx->opts a pointer Prevents some awkwardness in a later commit, and makes the code more uniform with other places where MPOpts is accessed. This is a pretty annoying commit (touches tons of lines all over the place), but it hurts only once.
2013-07-27 19:24:54 +00:00
struct MPOpts *opts = mpctx->opts;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
if (!opts->ordered_chapters) {
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
MP_INFO(mpctx, "File uses ordered chapters, but "
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
"you have disabled support for them. Ignoring.\n");
return;
}
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
MP_INFO(mpctx, "File uses ordered chapters, will build "
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
"edit timeline.\n");
struct demuxer *demuxer = mpctx->demuxer;
struct matroska_data *m = &demuxer->matroska_data;
// +1 because sources/uid_map[0] is original file even if all chapters
// actually use other sources and need separate entries
tl_matroska: initialize segment related arrays with 0 mpv crashed when linked files were not found. The reason was that the chapters array contained some uninitialized data. I have no idea how this code works (after the merge). The old code actually seems to remove missing chapters, while the new code just leaves them unintiialized. Work around the crash by initializing the chapters array (and a bunch of other things) with 0, which means the missing chapter will be located at 00:00:00 and have no name. There is a regression since commit af0306d.
2013-11-01 16:20:56 +00:00
struct demuxer **sources = talloc_zero_array(NULL, struct demuxer *,
core, timeline: don't keep separate stream field The timeline code kept pairs of stream and demuxer references around. The reference to the stream is redundant, because it can be accessed through the demuxer. Simplify the code by removing the redundant stream reference. Also, set mpctx->stream to the current segment when using timeline. Fix a small memory leak in tl_matroska.c introduced earlier.
2012-08-19 15:58:58 +00:00
m->num_ordered_chapters+1);
sources[0] = mpctx->demuxer;
tl_matroska: initialize segment related arrays with 0 mpv crashed when linked files were not found. The reason was that the chapters array contained some uninitialized data. I have no idea how this code works (after the merge). The old code actually seems to remove missing chapters, while the new code just leaves them unintiialized. Work around the crash by initializing the chapters array (and a bunch of other things) with 0, which means the missing chapter will be located at 00:00:00 and have no name. There is a regression since commit af0306d.
2013-11-01 16:20:56 +00:00
struct matroska_segment_uid *uids =
talloc_zero_array(NULL, struct matroska_segment_uid,
m->num_ordered_chapters + 1);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
int num_sources = 1;
matroska: store segment/edition uids in a single structure To support edition references in matroska chapters, editions need to be remembered for each chapter and source. To facilitate easier management of these now-paired uids, a single structure is used.
2013-10-07 00:49:12 +00:00
memcpy(uids[0].segment, m->uid.segment, 16);
uids[0].edition = 0;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
for (int i = 0; i < m->num_ordered_chapters; i++) {
struct matroska_chapter *c = m->ordered_chapters + i;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
/* If there isn't a segment uid, we are the source. If the segment uid
* is our segment uid and the edition matches. We can't accept the
* "don't care" edition value of 0 since the user may have requested a
* non-default edition. */
if (!c->has_segment_uid || demux_matroska_uid_cmp(&c->uid, &m->uid))
continue;
matroska: avoid requesting the same source multiple times
2013-10-08 04:33:42 +00:00
if (has_source_request(uids, num_sources, &c->uid))
continue;
matroska: store segment/edition uids in a single structure To support edition references in matroska chapters, editions need to be remembered for each chapter and source. To facilitate easier management of these now-paired uids, a single structure is used.
2013-10-07 00:49:12 +00:00
memcpy(uids + num_sources, &c->uid, sizeof(c->uid));
core, timeline: don't keep separate stream field The timeline code kept pairs of stream and demuxer references around. The reference to the stream is redundant, because it can be accessed through the demuxer. Simplify the code by removing the redundant stream reference. Also, set mpctx->stream to the current segment when using timeline. Fix a small memory leak in tl_matroska.c introduced earlier.
2012-08-19 15:58:58 +00:00
sources[num_sources] = NULL;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
num_sources++;
}
matroska: recursively search for referenced segments When playing a Matroska file with ordered chapters, it may reference another file by edition uid. When this edition is also ordered, it may reference other files. When this occurs, the new segment/edition pair is added to the list of sources to search for.
2013-10-05 07:01:49 +00:00
num_sources = find_ordered_chapter_sources(mpctx, &sources, &num_sources,
&uids);
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
talloc_free(uids);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
struct timeline_part *timeline = talloc_array_ptrtype(NULL, timeline, 0);
player: always use demux_chapter Instead of defining a separate data structure in the core. For some odd reason, demux_chapter exported the chapter time in nano-seconds. Change that to the usual timestamps (rename the field to make any code relying on this to fail compilation), and also remove the unused chapter end time.
2014-11-02 16:20:04 +00:00
struct demux_chapter *chapters =
talloc_zero_array(NULL, struct demux_chapter, m->num_ordered_chapters);
player: ordered chapters: filter missing chapters Ever since someone (not me) added some Matroska features which nobody ever uses (ordered edition or some bullshit), I haven't had a fucking clue what the fuck is going on in this fucking file. (Still agreed to it, so it's my fault.) mplayer2 handled missing chapters correctly (and I suppose in a somewhat clean/simple manner), but the changed code doesn't. Since I can't even follow this code because it's so arcanely complicated, just add a hack that has the same effect.
2014-12-26 18:42:03 +00:00
// Stupid hack, because fuck everything.
for (int n = 0; n < m->num_ordered_chapters; n++)
chapters[n].pts = -1;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
uint64_t starttime = 0;
uint64_t missing_time = 0;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
uint64_t last_end_time = 0;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
int part_count = 0;
player/timeline: mp_msg conversions
2013-12-21 17:59:32 +00:00
build_timeline_loop(mpctx, sources, num_sources, 0, &starttime,
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
&missing_time, &last_end_time, &timeline,
tl_matroska: check chapter bounds I have no idea what this does, but it's without doubt a sufficient fix for the issue at hand. Fixes #1445.
2015-01-09 00:47:48 +00:00
chapters, m->num_ordered_chapters, &part_count, 0, 0);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
player: ordered chapters: filter missing chapters Ever since someone (not me) added some Matroska features which nobody ever uses (ordered edition or some bullshit), I haven't had a fucking clue what the fuck is going on in this fucking file. (Still agreed to it, so it's my fault.) mplayer2 handled missing chapters correctly (and I suppose in a somewhat clean/simple manner), but the changed code doesn't. Since I can't even follow this code because it's so arcanely complicated, just add a hack that has the same effect.
2014-12-26 18:42:03 +00:00
// Fuck everything (2): filter out all "unset" chapters.
for (int n = m->num_ordered_chapters - 1; n >= 0; n--) {
if (chapters[n].pts == -1)
MP_TARRAY_REMOVE_AT(chapters, m->num_ordered_chapters, n);
}
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
if (!part_count) {
tl_matroska: fix minor memory leak in error case Going the way of least resistance. Fixes #1460.
2015-01-12 12:20:56 +00:00
// None of the parts come from the file itself???
// Broken file, but we need at least 1 valid timeline part - add a dummy.
MP_WARN(mpctx, "Ordered chapters file with no parts?\n");
struct timeline_part new = {
.source = demuxer,
};
MP_TARRAY_APPEND(NULL, timeline, part_count, new);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
struct timeline_part new = {
.start = starttime / 1e9,
};
MP_TARRAY_APPEND(NULL, timeline, part_count, new);
matroska: only error if at least a millisecond is missing
2013-10-14 23:29:42 +00:00
/* Ignore anything less than a millisecond when reporting missing time. If
* users really notice less than a millisecond missing, maybe this can be
* revisited. */
player: ordered chapters: cosmetics Drop some meaningless comments, fix codingstyle, fix some formatting victims of the mp_msg refactoring, replace some memcpys with assignments.
2014-12-26 18:58:50 +00:00
if (missing_time >= 1e6) {
MP_ERR(mpctx, "There are %.3f seconds missing from the timeline!\n",
missing_time / 1e9);
}
core: remove a minor memory leak
2013-09-08 03:17:05 +00:00
talloc_free(mpctx->sources);
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
mpctx->sources = sources;
mpctx->num_sources = num_sources;
mpctx->timeline = timeline;
matroska: refactor ordered chapter timeline building This will need to be recursive to support chapters referencing ordered editions in other files.
2013-10-07 01:42:30 +00:00
mpctx->num_timeline_parts = part_count - 1;
mpctx->num_chapters = m->num_ordered_chapters;
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
mpctx->chapters = chapters;
player: move timeline specific handling to timeline loaders In particular, gets rid of the Matroska specifics from the common code.
2015-02-04 20:20:41 +00:00
// With Matroska, the "master" file usually dictates track layout etc.,
// except maybe with playlist-like files.
mpctx->track_layout = mpctx->timeline[0].source;
for (int n = 0; n < mpctx->num_timeline_parts; n++) {
if (mpctx->timeline[n].source == mpctx->demuxer) {
mpctx->track_layout = mpctx->demuxer;
break;
}
}
core: ordered chapters: move timeline creation to timeline/ Add new file timeline/tl_matroska.c. Move the code that parses ordered chapter information from Matroska files and creates the timeline structure based on that to the new file. Initialize the format parameter given to open_stream() in the moved code. The previous uninitialized value shouldn't have caused any visible effects.
2011-02-14 07:34:39 +00:00
}