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>
|
2011-02-23 15:57:08 +00:00
|
|
|
#include <assert.h>
|
|
|
|
#include <dirent.h>
|
2011-10-04 00:41:18 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2011-02-14 07:34:39 +00:00
|
|
|
#include <libavutil/common.h>
|
|
|
|
|
2012-02-03 07:05:11 +00:00
|
|
|
#include "osdep/io.h"
|
|
|
|
|
2011-02-14 07:34:39 +00:00
|
|
|
#include "talloc.h"
|
|
|
|
|
2013-08-06 20:41:30 +00:00
|
|
|
#include "mpvcore/mp_core.h"
|
|
|
|
#include "mpvcore/mp_msg.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "demux/demux.h"
|
2013-08-06 20:41:30 +00:00
|
|
|
#include "mpvcore/path.h"
|
|
|
|
#include "mpvcore/bstr.h"
|
|
|
|
#include "mpvcore/mp_common.h"
|
2011-08-19 02:36:27 +00:00
|
|
|
#include "stream/stream.h"
|
|
|
|
|
2011-10-04 00:41:18 +00:00
|
|
|
struct find_entry {
|
|
|
|
char *name;
|
|
|
|
int matchlen;
|
2012-02-28 22:01:13 +00:00
|
|
|
off_t size;
|
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
|
2012-02-28 22:01:13 +00:00
|
|
|
off_t sizediff = a->size - b->size;
|
2011-10-04 00:41:18 +00:00
|
|
|
if (sizediff)
|
|
|
|
return FFSIGN(sizediff);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-02-23 15:57:08 +00:00
|
|
|
|
|
|
|
static char **find_files(const char *original_file, const char *suffix)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2011-10-04 00:41:18 +00:00
|
|
|
struct find_entry *entries = NULL;
|
2011-02-23 15:57:08 +00:00
|
|
|
struct dirent *ep;
|
|
|
|
int num_results = 0;
|
|
|
|
while ((ep = readdir(dp))) {
|
|
|
|
int suffix_offset = strlen(ep->d_name) - strlen(suffix);
|
|
|
|
// name must end with suffix
|
|
|
|
if (suffix_offset < 0 || strcmp(ep->d_name + suffix_offset, suffix))
|
|
|
|
continue;
|
|
|
|
// don't list the original name
|
|
|
|
if (!strcmp(ep->d_name, basename))
|
|
|
|
continue;
|
|
|
|
|
2012-07-28 21:47:42 +00:00
|
|
|
char *name = mp_path_join(results, directory, bstr0(ep->d_name));
|
2011-02-23 15:57:08 +00:00
|
|
|
char *s1 = ep->d_name;
|
|
|
|
char *s2 = basename;
|
|
|
|
int matchlen = 0;
|
|
|
|
while (*s1 && *s1++ == *s2++)
|
|
|
|
matchlen++;
|
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;
|
2012-02-28 22:01:13 +00:00
|
|
|
off_t size = statbuf.st_size;
|
2011-10-04 00:41:18 +00:00
|
|
|
|
2012-08-19 15:58:58 +00:00
|
|
|
entries = talloc_realloc(tmpmem, entries, struct find_entry,
|
2011-10-04 00:41:18 +00:00
|
|
|
num_results + 1);
|
2012-02-28 22:01:13 +00:00
|
|
|
entries[num_results] = (struct find_entry) { name, matchlen, size };
|
2011-02-23 15:57:08 +00:00
|
|
|
num_results++;
|
|
|
|
}
|
|
|
|
closedir(dp);
|
2011-10-04 00:41:18 +00:00
|
|
|
// NOTE: maybe should make it compare pointers instead
|
2012-10-31 23:24:08 +00:00
|
|
|
if (entries)
|
|
|
|
qsort(entries, num_results, sizeof(struct find_entry), cmp_entry);
|
2011-02-23 15:57:08 +00:00
|
|
|
results = talloc_realloc(NULL, results, char *, num_results);
|
2011-10-04 00:41:18 +00:00
|
|
|
for (int i = 0; i < num_results; i++) {
|
|
|
|
results[i] = entries[i].name;
|
2011-02-23 15:57:08 +00:00
|
|
|
}
|
|
|
|
talloc_free(tmpmem);
|
|
|
|
return results;
|
|
|
|
}
|
2011-02-14 07:34:39 +00:00
|
|
|
|
2012-08-19 13:31:38 +00:00
|
|
|
static int enable_cache(struct MPContext *mpctx, struct stream **stream,
|
2013-04-14 00:49:07 +00:00
|
|
|
struct demuxer **demuxer, struct demuxer_params *params)
|
2012-08-19 13:31:38 +00:00
|
|
|
{
|
2013-07-27 19:24:54 +00:00
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2012-08-19 13:31:38 +00:00
|
|
|
|
2013-07-10 13:03:54 +00:00
|
|
|
if (opts->stream_cache_size <= 0)
|
2012-08-19 13:31:38 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
char *filename = talloc_strdup(NULL, (*demuxer)->filename);
|
|
|
|
free_demuxer(*demuxer);
|
|
|
|
free_stream(*stream);
|
|
|
|
|
2013-07-27 19:24:54 +00:00
|
|
|
*stream = stream_open(filename, opts);
|
2012-08-19 13:31:38 +00:00
|
|
|
if (!*stream) {
|
|
|
|
talloc_free(filename);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 16:49:09 +00:00
|
|
|
stream_enable_cache_percent(stream,
|
2012-08-19 13:31:38 +00:00
|
|
|
opts->stream_cache_size,
|
2013-07-10 13:03:54 +00:00
|
|
|
opts->stream_cache_def_size,
|
2012-08-19 13:31:38 +00:00
|
|
|
opts->stream_cache_min_percent,
|
|
|
|
opts->stream_cache_seek_min_percent);
|
|
|
|
|
2013-07-27 19:24:54 +00:00
|
|
|
*demuxer = demux_open(*stream, "mkv", params, opts);
|
2012-08-19 13:31:38 +00:00
|
|
|
if (!*demuxer) {
|
|
|
|
talloc_free(filename);
|
|
|
|
free_stream(*stream);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
talloc_free(filename);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-04-14 00:49:07 +00:00
|
|
|
// segment = get Nth segment of a multi-segment file
|
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,
|
2013-04-14 00:49:07 +00:00
|
|
|
char *filename, int segment)
|
|
|
|
{
|
|
|
|
bool was_valid = false;
|
|
|
|
struct demuxer_params params = {
|
2013-10-05 07:01:49 +00:00
|
|
|
.matroska_num_wanted_uids = *num_sources,
|
|
|
|
.matroska_wanted_uids = *uids,
|
2013-04-14 00:49:07 +00:00
|
|
|
.matroska_wanted_segment = segment,
|
|
|
|
.matroska_was_valid = &was_valid,
|
|
|
|
};
|
2013-07-27 19:24:54 +00:00
|
|
|
struct stream *s = stream_open(filename, mpctx->opts);
|
2013-04-14 00:49:07 +00:00
|
|
|
if (!s)
|
|
|
|
return false;
|
2013-07-27 19:24:54 +00:00
|
|
|
struct demuxer *d = demux_open(s, "mkv", ¶ms, mpctx->opts);
|
2013-04-14 00:49:07 +00:00
|
|
|
|
|
|
|
if (!d) {
|
|
|
|
free_stream(s);
|
|
|
|
return was_valid;
|
|
|
|
}
|
2013-07-12 19:58:11 +00:00
|
|
|
if (d->type == DEMUXER_TYPE_MATROSKA) {
|
2013-10-07 00:49:12 +00:00
|
|
|
struct matroska_data *m = &d->matroska_data;
|
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])
|
2013-04-14 00:49:07 +00:00
|
|
|
continue;
|
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) &&
|
|
|
|
(!uid->edition || uid->edition == m->uid.edition)) {
|
2013-04-14 00:49:07 +00:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "Match for source %d: %s\n",
|
|
|
|
i, d->filename);
|
|
|
|
|
|
|
|
if (enable_cache(mpctx, &s, &d, ¶ms) < 0)
|
|
|
|
continue;
|
|
|
|
|
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;
|
|
|
|
|
2013-10-08 04:33:42 +00:00
|
|
|
if (has_source_request(*uids, *num_sources, &c->uid))
|
|
|
|
continue;
|
|
|
|
|
2013-10-05 07:01:49 +00:00
|
|
|
/* Set the requested segment. */
|
|
|
|
MP_TARRAY_GROW(NULL, *uids, *num_sources);
|
|
|
|
memcpy((*uids) + *num_sources, &c->uid, sizeof(c->uid));
|
|
|
|
|
|
|
|
/* Add a new source slot. */
|
|
|
|
MP_TARRAY_APPEND(NULL, *sources, *num_sources, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
(*sources)[i] = d;
|
2013-04-14 00:49:07 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_demuxer(d);
|
|
|
|
free_stream(s);
|
|
|
|
return was_valid;
|
|
|
|
}
|
|
|
|
|
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,
|
2013-04-14 00:49:07 +00:00
|
|
|
char *filename, int first)
|
|
|
|
{
|
|
|
|
for (int segment = first; ; segment++) {
|
2013-10-07 00:49:12 +00:00
|
|
|
if (!check_file_seg(mpctx, sources, num_sources,
|
|
|
|
uids, filename, segment))
|
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;
|
|
|
|
}
|
|
|
|
|
2011-02-14 07:34:39 +00:00
|
|
|
static int find_ordered_chapter_sources(struct MPContext *mpctx,
|
2013-10-05 07:01:49 +00:00
|
|
|
struct demuxer ***sources,
|
|
|
|
int *num_sources,
|
|
|
|
struct matroska_segment_uid **uids)
|
2011-02-14 07:34:39 +00:00
|
|
|
{
|
|
|
|
int num_filenames = 0;
|
|
|
|
char **filenames = NULL;
|
2013-10-05 07:01:49 +00:00
|
|
|
if (*num_sources > 1) {
|
2013-04-14 00:49:07 +00:00
|
|
|
char *main_filename = mpctx->demuxer->filename;
|
2011-02-14 07:34:39 +00:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "This file references data from "
|
|
|
|
"other sources.\n");
|
cache: make the stream cache a proper stream that wraps other streams
Before this commit, the cache was franken-hacked on top of the stream
API. You had to use special functions (like cache_stream_fill_buffer()
instead of stream_fill_buffer()), which would access the stream in a
cached manner.
The whole idea about the previous design was that the cache runs in a
thread or in a forked process, while the cache awa functions made sure
the stream instance looked consistent to the user. If you used the
normal functions instead of the special ones while the cache was
running, you were out of luck.
Make it a bit more reasonable by turning the cache into a stream on its
own. This makes it behave exactly like a normal stream. The stream
callbacks call into the original (uncached) stream to do work. No
special cache functions or redirections are needed. The only different
thing about cache streams is that they are created by special functions,
instead of being part of the auto_open_streams[] array.
To make things simpler, remove the threading implementation, which was
messed into the code. The threading code could perhaps be kept, but I
don't really want to have to worry about this special case. A proper
threaded implementation will be added later.
Remove the cache enabling code from stream_radio.c. Since enabling the
cache involves replacing the old stream with a new one, the code as-is
can't be kept. It would be easily possible to enable the cache by
requesting a cache size (which is also much simpler). But nobody uses
stream_radio.c and I can't even test this thing, and the cache is
probably not really important for it either.
2013-05-24 16:49:09 +00:00
|
|
|
if (mpctx->demuxer->stream->uncached_type != STREAMTYPE_FILE) {
|
2011-02-14 07:34:39 +00:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_WARN, "Playback source is not a "
|
|
|
|
"normal disk file. Will not search for related files.\n");
|
|
|
|
} else {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "Will scan other files in the "
|
|
|
|
"same directory to find referenced sources.\n");
|
2013-04-14 00:49:07 +00:00
|
|
|
filenames = find_files(main_filename, ".mkv");
|
2011-02-23 15:57:08 +00:00
|
|
|
num_filenames = MP_TALLOC_ELEMS(filenames);
|
2011-02-14 07:34:39 +00:00
|
|
|
}
|
2013-04-14 00:49:07 +00:00
|
|
|
// Possibly get further segments appended to the first segment
|
2013-10-07 00:49:12 +00:00
|
|
|
check_file(mpctx, sources, num_sources, uids, main_filename, 1);
|
2011-02-14 07:34:39 +00:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "Checking file %s\n", filenames[i]);
|
|
|
|
check_file(mpctx, sources, num_sources, uids, filenames[i], 0);
|
|
|
|
}
|
|
|
|
/* Loop while we have new sources to look for. */
|
|
|
|
} while (old_source_count != *num_sources);
|
2013-04-14 00:49:07 +00:00
|
|
|
|
2011-02-14 07:34:39 +00:00
|
|
|
talloc_free(filenames);
|
2013-10-05 07:01:49 +00:00
|
|
|
if (missing(*sources, *num_sources)) {
|
2011-02-14 07:34:39 +00:00
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_ERR, "Failed to find ordered chapter part!\n"
|
|
|
|
"There will be parts MISSING from the video!\n");
|
2013-04-14 00:49:07 +00:00
|
|
|
int j = 1;
|
2013-10-05 07:01:49 +00:00
|
|
|
for (int i = 1; i < *num_sources; i++)
|
|
|
|
if ((*sources)[i]) {
|
|
|
|
struct matroska_segment_uid *source_uid = *uids + i;
|
|
|
|
struct matroska_segment_uid *target_uid = *uids + j;
|
|
|
|
(*sources)[j] = (*sources)[i];
|
2013-10-08 04:35:04 +00:00
|
|
|
memmove(target_uid, source_uid, sizeof(*source_uid));
|
2011-02-14 07:34:39 +00:00
|
|
|
j++;
|
|
|
|
}
|
2013-10-05 07:01:49 +00:00
|
|
|
*num_sources = j;
|
2011-02-14 07:34:39 +00:00
|
|
|
}
|
2013-10-05 07:01:49 +00:00
|
|
|
return *num_sources;
|
2011-02-14 07:34:39 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 01:42:30 +00:00
|
|
|
static void add_timeline_part(struct MPOpts *opts,
|
|
|
|
struct demuxer *source,
|
|
|
|
struct timeline_part **timeline,
|
|
|
|
int *part_count,
|
|
|
|
uint64_t start,
|
|
|
|
uint64_t *last_end_time,
|
|
|
|
uint64_t *starttime)
|
|
|
|
{
|
|
|
|
/* Only add a separate part if the time or file actually changes.
|
|
|
|
* Matroska files have chapter divisions that are redundant from
|
|
|
|
* timeline point of view because the same chapter structure is used
|
|
|
|
* both to specify the timeline and for normal chapter information.
|
|
|
|
* Removing a missing inserted external chapter can also cause this.
|
|
|
|
* 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. */
|
|
|
|
int64_t join_diff = start - *last_end_time;
|
|
|
|
if (*part_count == 0
|
|
|
|
|| FFABS(join_diff) > opts->chapter_merge_threshold * 1e6
|
|
|
|
|| source != (*timeline)[*part_count - 1].source) {
|
|
|
|
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) {
|
|
|
|
/* Chapter was merged at an inexact boundary;
|
|
|
|
* adjust timestamps to match. */
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_V, "Merging timeline part %d with "
|
|
|
|
"offset %g ms.\n", *part_count, join_diff / 1e6);
|
|
|
|
*starttime += join_diff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void build_timeline_loop(struct MPOpts *opts,
|
|
|
|
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,
|
|
|
|
struct chapter *chapters,
|
2013-10-07 03:22:19 +00:00
|
|
|
int *part_count,
|
|
|
|
uint64_t skip,
|
|
|
|
uint64_t limit)
|
2013-10-07 01:42:30 +00:00
|
|
|
{
|
2013-10-07 03:22:19 +00:00
|
|
|
uint64_t local_starttime = 0;
|
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;
|
|
|
|
|
2013-10-07 03:22:19 +00:00
|
|
|
/* Fill in the uid with the current one if one isn't requested. */
|
2013-10-07 01:42:30 +00:00
|
|
|
if (!c->has_segment_uid)
|
|
|
|
memcpy(&c->uid, &m->uid, sizeof(c->uid));
|
|
|
|
|
2013-10-07 03:22:19 +00:00
|
|
|
/* "Seek" to the end of the chapter. */
|
|
|
|
local_starttime += chapter_length;
|
|
|
|
|
|
|
|
/* If we're before the start time for the chapter, skip to the next
|
|
|
|
* one. */
|
|
|
|
if (local_starttime <= skip)
|
|
|
|
continue;
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* Skip if the segment or edition isn't acceptable. */
|
|
|
|
if (!demux_matroska_uid_cmp(&c->uid, &linked_m->uid))
|
|
|
|
continue;
|
|
|
|
|
2013-10-07 03:22:19 +00:00
|
|
|
/* TODO: Add option to support recursive chapters when loading
|
|
|
|
* recursive ordered chapter editions? If so, more code will be
|
|
|
|
* needed to add chapters for external non-ordered segment loading
|
|
|
|
* as well since that part is not recursive. */
|
|
|
|
if (!limit) {
|
|
|
|
chapters[i].start = *starttime / 1e9;
|
|
|
|
chapters[i].name = talloc_strdup(chapters, c->name);
|
|
|
|
}
|
2013-10-07 01:42:30 +00:00
|
|
|
|
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) {
|
|
|
|
add_timeline_part(opts, linked_source, timeline, part_count,
|
|
|
|
c->start, last_end_time, starttime);
|
|
|
|
/* Otherwise, 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. */
|
|
|
|
} else {
|
|
|
|
build_timeline_loop(opts, sources, num_sources, j, starttime,
|
|
|
|
missing_time, last_end_time, timeline,
|
|
|
|
chapters, part_count, c->start, c->end);
|
|
|
|
/* The loop call has added time as needed (we can't add it here
|
|
|
|
* due to 'join_diff' in the add_timeline_part function. Since
|
|
|
|
* the time has already been added as needed, the chapter has
|
|
|
|
* an effective 0 length at this point. */
|
|
|
|
chapter_length = 0;
|
|
|
|
}
|
2013-10-07 01:42:30 +00:00
|
|
|
*last_end_time = c->end;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We're missing a part of the chapter, so add it to the accounting. */
|
|
|
|
*missing_time += chapter_length;
|
|
|
|
found:;
|
|
|
|
*starttime += chapter_length;
|
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;
|
|
|
|
}
|
2013-10-07 01:42:30 +00:00
|
|
|
}
|
2013-10-07 03:22:19 +00:00
|
|
|
|
|
|
|
/* If we stopped before the limit, add up the missing time. */
|
|
|
|
if (local_starttime < limit)
|
|
|
|
*missing_time += limit - local_starttime;
|
2013-10-07 01:42:30 +00:00
|
|
|
}
|
|
|
|
|
2011-02-14 07:34:39 +00:00
|
|
|
void build_ordered_chapter_timeline(struct MPContext *mpctx)
|
|
|
|
{
|
2013-07-27 19:24:54 +00:00
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2011-02-14 07:34:39 +00:00
|
|
|
|
|
|
|
if (!opts->ordered_chapters) {
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "File uses ordered chapters, but "
|
|
|
|
"you have disabled support for them. Ignoring.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_INFO, "File uses ordered chapters, will build "
|
|
|
|
"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
|
2012-08-19 15:58:58 +00:00
|
|
|
struct demuxer **sources = talloc_array_ptrtype(NULL, sources,
|
|
|
|
m->num_ordered_chapters+1);
|
|
|
|
sources[0] = mpctx->demuxer;
|
2013-10-07 00:49:12 +00:00
|
|
|
struct matroska_segment_uid *uids = talloc_array_ptrtype(NULL, uids,
|
|
|
|
m->num_ordered_chapters + 1);
|
2011-02-14 07:34:39 +00:00
|
|
|
int num_sources = 1;
|
2013-10-07 00:49:12 +00:00
|
|
|
memcpy(uids[0].segment, m->uid.segment, 16);
|
|
|
|
uids[0].edition = 0;
|
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;
|
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;
|
|
|
|
|
2013-10-08 04:33:42 +00:00
|
|
|
if (has_source_request(uids, num_sources, &c->uid))
|
|
|
|
continue;
|
|
|
|
|
2013-10-07 00:49:12 +00:00
|
|
|
memcpy(uids + num_sources, &c->uid, sizeof(c->uid));
|
2012-08-19 15:58:58 +00:00
|
|
|
sources[num_sources] = NULL;
|
2011-02-14 07:34:39 +00:00
|
|
|
num_sources++;
|
|
|
|
}
|
|
|
|
|
2013-10-05 07:01:49 +00:00
|
|
|
num_sources = find_ordered_chapter_sources(mpctx, &sources, &num_sources,
|
|
|
|
&uids);
|
2013-10-07 01:42:30 +00:00
|
|
|
talloc_free(uids);
|
2011-02-14 07:34:39 +00:00
|
|
|
|
2013-10-07 01:42:30 +00:00
|
|
|
struct timeline_part *timeline = talloc_array_ptrtype(NULL, timeline, 0);
|
|
|
|
struct chapter *chapters = talloc_array_ptrtype(NULL, chapters, m->num_ordered_chapters);
|
2011-02-14 07:34:39 +00:00
|
|
|
uint64_t starttime = 0;
|
|
|
|
uint64_t missing_time = 0;
|
2013-10-07 01:42:30 +00:00
|
|
|
uint64_t last_end_time = 0;
|
2011-02-14 07:34:39 +00:00
|
|
|
int part_count = 0;
|
2013-10-07 01:42:30 +00:00
|
|
|
build_timeline_loop(opts, sources, num_sources, 0, &starttime,
|
|
|
|
&missing_time, &last_end_time, &timeline,
|
2013-10-07 03:22:19 +00:00
|
|
|
chapters, &part_count, 0, 0);
|
2011-02-14 07:34:39 +00:00
|
|
|
|
|
|
|
if (!part_count) {
|
|
|
|
// None of the parts come from the file itself???
|
|
|
|
talloc_free(sources);
|
|
|
|
talloc_free(timeline);
|
|
|
|
talloc_free(chapters);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-07 01:42:30 +00:00
|
|
|
struct timeline_part new = {
|
|
|
|
.start = starttime / 1e9,
|
|
|
|
};
|
|
|
|
MP_TARRAY_APPEND(NULL, timeline, part_count, new);
|
|
|
|
|
2011-02-14 07:34:39 +00:00
|
|
|
if (missing_time)
|
|
|
|
mp_msg(MSGT_CPLAYER, MSGL_ERR, "There are %.3f seconds missing "
|
|
|
|
"from the timeline!\n", missing_time / 1e9);
|
2013-09-08 03:17:05 +00:00
|
|
|
talloc_free(mpctx->sources);
|
2011-02-14 07:34:39 +00:00
|
|
|
mpctx->sources = sources;
|
|
|
|
mpctx->num_sources = num_sources;
|
|
|
|
mpctx->timeline = timeline;
|
2013-10-07 01:42:30 +00:00
|
|
|
mpctx->num_timeline_parts = part_count - 1;
|
|
|
|
mpctx->num_chapters = m->num_ordered_chapters;
|
2011-02-14 07:34:39 +00:00
|
|
|
mpctx->chapters = chapters;
|
|
|
|
}
|