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

297 lines
9.2 KiB
C
Raw Blame History

/*
* Original author: Uoti Urpala
*
* This file is part of mpv.
*
* mpv is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* mpv 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <inttypes.h>
#include "osdep/io.h"
#include "mpv_talloc.h"
#include "misc/bstr.h"
#include "misc/charset_conv.h"
#include "common/msg.h"
#include "demux/demux.h"
#include "options/m_config.h"
#include "options/m_option.h"
#include "options/path.h"
#include "common/common.h"
#include "stream/stream.h"
#include "timeline.h"
#include "cue.h"
#define PROBE_SIZE 512
struct priv {
struct cue_file *f;
};
static void add_source(struct timeline *tl, struct demuxer *d)
{
MP_TARRAY_APPEND(tl, tl->sources, tl->num_sources, d);
}
static bool try_open(struct timeline *tl, char *filename)
{
struct bstr bfilename = bstr0(filename);
// Avoid trying to open itself or another .cue file. Best would be
// to check the result of demuxer auto-detection, but the demuxer
// API doesn't allow this without opening a full demuxer.
if (bstr_case_endswith(bfilename, bstr0(".cue"))
|| bstrcasecmp(bstr0(tl->demuxer->filename), bfilename) == 0)
return false;
struct demuxer_params p = {
.stream_flags = tl->stream_origin,
};
struct demuxer *d = demux_open_url(filename, &p, tl->cancel, tl->global);
// Since .bin files are raw PCM data with no headers, we have to explicitly
// open them. Also, try to avoid to open files that are most likely not .bin
// files, as that would only play noise. Checking the file extension is
// fragile, but it's about the only way we have.
// TODO: maybe also could check if the .bin file is a multiple of the Audio
// CD sector size (2352 bytes)
if (!d && bstr_case_endswith(bfilename, bstr0(".bin"))) {
MP_WARN(tl, "CUE: Opening as BIN file!\n");
p.force_format = "rawaudio";
d = demux_open_url(filename, &p, tl->cancel, tl->global);
}
if (d) {
add_source(tl, d);
return true;
}
MP_ERR(tl, "Could not open source '%s'!\n", filename);
return false;
}
static bool open_source(struct timeline *tl, char *filename)
{
void *ctx = talloc_new(NULL);
bool res = false;
struct bstr dirname = mp_dirname(tl->demuxer->filename);
struct bstr base_filename = bstr0(mp_basename(filename));
if (!base_filename.len) {
MP_WARN(tl, "CUE: Invalid audio filename in .cue file!\n");
} else {
char *fullname = mp_path_join_bstr(ctx, dirname, base_filename);
if (try_open(tl, fullname)) {
res = true;
goto out;
}
}
// Try an audio file with the same name as the .cue file (but different
// extension).
// Rationale: this situation happens easily if the audio file or both files
// are renamed.
struct bstr cuefile =
bstr_strip_ext(bstr0(mp_basename(tl->demuxer->filename)));
DIR *d = opendir(bstrdup0(ctx, dirname));
if (!d)
goto out;
struct dirent *de;
while ((de = readdir(d))) {
char *dename0 = de->d_name;
struct bstr dename = bstr0(dename0);
if (bstr_case_startswith(dename, cuefile)) {
MP_WARN(tl, "CUE: No useful audio filename "
"in .cue file found, trying with '%s' instead!\n",
dename0);
if (try_open(tl, mp_path_join_bstr(ctx, dirname, dename))) {
res = true;
break;
}
}
}
closedir(d);
out:
talloc_free(ctx);
if (!res)
MP_ERR(tl, "CUE: Could not open audio file!\n");
return res;
}
static void build_timeline(struct timeline *tl)
{
struct priv *p = tl->demuxer->priv;
void *ctx = talloc_new(NULL);
add_source(tl, tl->demuxer);
struct cue_track *tracks = NULL;
size_t track_count = 0;
for (size_t n = 0; n < p->f->num_tracks; n++) {
struct cue_track *track = &p->f->tracks[n];
if (track->filename) {
MP_TARRAY_APPEND(ctx, tracks, track_count, *track);
} else {
MP_WARN(tl->demuxer, "No file specified for track entry %zd. "
"It will be removed\n", n + 1);
}
}
if (track_count == 0) {
MP_ERR(tl, "CUE: no tracks found!\n");
goto out;
}
// Remove duplicate file entries. This might be too sophisticated, since
// CUE files usually use either separate files for every single track, or
// only one file for all tracks.
char **files = 0;
size_t file_count = 0;
for (size_t n = 0; n < track_count; n++) {
struct cue_track *track = &tracks[n];
track->source = -1;
for (size_t file = 0; file < file_count; file++) {
if (strcmp(files[file], track->filename) == 0) {
track->source = file;
break;
}
}
if (track->source == -1) {
file_count++;
files = talloc_realloc(ctx, files, char *, file_count);
files[file_count - 1] = track->filename;
track->source = file_count - 1;
}
}
for (size_t i = 0; i < file_count; i++) {
if (!open_source(tl, files[i]))
goto out;
}
struct timeline_part *timeline = talloc_array_ptrtype(tl, timeline,
track_count + 1);
struct demux_chapter *chapters = talloc_array_ptrtype(tl, chapters,
track_count);
double starttime = 0;
for (int i = 0; i < track_count; i++) {
struct demuxer *source = tl->sources[1 + tracks[i].source];
double duration;
if (i + 1 < track_count && tracks[i].source == tracks[i + 1].source) {
duration = tracks[i + 1].start - tracks[i].start;
} else {
duration = source->duration;
// Two cases: 1) last track of a single-file cue, or 2) any track of
// a multi-file cue. We need to do this for 1) only because the
// timeline needs to be terminated with the length of the last
// track.
duration -= tracks[i].start;
}
if (duration < 0) {
MP_WARN(tl, "CUE: Can't get duration of source file!\n");
// xxx: do something more reasonable
duration = 0.0;
}
timeline[i] = (struct timeline_part) {
.start = starttime,
.end = starttime + duration,
.source_start = tracks[i].start,
.source = source,
};
chapters[i] = (struct demux_chapter) {
.pts = timeline[i].start,
.metadata = mp_tags_dup(tl, tracks[i].tags),
};
starttime = timeline[i].end;
}
struct timeline_par *par = talloc_ptrtype(tl, par);
*par = (struct timeline_par){
.parts = timeline,
.num_parts = track_count,
.track_layout = timeline[0].source,
};
tl->chapters = chapters;
tl->num_chapters = track_count;
MP_TARRAY_APPEND(tl, tl->pars, tl->num_pars, par);
tl->meta = par->track_layout;
tl->format = "cue";
out:
talloc_free(ctx);
}
static int try_open_file(struct demuxer *demuxer, enum demux_check check)
{
if (!demuxer->access_references)
return -1;
struct stream *s = demuxer->stream;
if (check >= DEMUX_CHECK_UNSAFE) {
char probe[PROBE_SIZE];
int len = stream_read_peek(s, probe, sizeof(probe));
if (len < 1 || !mp_probe_cue((bstr){probe, len}))
return -1;
}
struct priv *p = talloc_zero(demuxer, struct priv);
demuxer->priv = p;
demuxer->fully_read = true;
bstr data = stream_read_complete(s, p, 1000000);
if (data.start == NULL)
return -1;
struct demux_opts *opts = mp_get_config_group(p, demuxer->global, &demux_conf);
const char *charset = mp_charset_guess(p, demuxer->log, data, opts->meta_cp, 0);
if (charset && !mp_charset_is_utf8(charset)) {
MP_INFO(demuxer, "Using CUE charset: %s\n", charset);
bstr utf8 = mp_iconv_to_utf8(demuxer->log, data, charset, MP_ICONV_VERBOSE);
if (utf8.start && utf8.start != data.start) {
ta_steal(data.start, utf8.start);
data = utf8;
}
}
talloc_free(opts);
p->f = mp_parse_cue(data);
talloc_steal(p, p->f);
if (!p->f) {
MP_ERR(demuxer, "error parsing input file!\n");
return -1;
}
demux_close_stream(demuxer);
mp_tags_merge(demuxer->metadata, p->f->tags);
return 0;
}
const struct demuxer_desc demuxer_desc_cue = {
.name = "cue",
.desc = "CUE sheet",
.open = try_open_file,
.load_timeline = build_timeline,
};
Reference in New Issue View Git Blame Copy Permalink