mpv/stream/stream_rar.c

219 lines
6.2 KiB
C
Raw Normal View History

// Major parts based on:
/*****************************************************************************
* access.c: uncompressed RAR access
*****************************************************************************
* Copyright (C) 2008-2010 Laurent Aimar
* $Id: dcd973529e0029abe326d31f8d58cd13bbcc276c $
*
* Author: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
*
* This program 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.
*
* This program 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 this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#include "config.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include "osdep/io.h"
#include "common/msg.h"
#include "stream.h"
#include "options/m_option.h"
#include "rar.h"
/*
This works as follows:
- stream_open() with file01.rar
- is opened as normal file (stream_file.c or others) first
- stream_info_rar_filter stream filter applies
- leads to rar_filter_open()
- if multi-part, opens file02.rar, file03.rar, etc. as actual streams
(recursive opening is prevented with the STREAM_NO_FILTERS flag)
- read accesses return a m3u playlist with entries like:
rar://bla01.rar|subfile.mkv
(one such entry for each file contained in the rar)
- stream_open() with the playlist entry, e.g. rar://bla01.rar|subfile.mkv
- leads to rar_entry_open()
- opens bla01.rar etc. again as actual streams
(again, STREAM_NO_FILTERS to open the actual files)
- read accesses go into subfile.mkv contained in the rar file(s)
*/
static int rar_entry_fill_buffer(stream_t *s, char *buffer, int max_len)
{
rar_file_t *rar_file = s->priv;
return RarRead(rar_file, buffer, max_len);
}
static int rar_entry_seek(stream_t *s, int64_t newpos)
{
rar_file_t *rar_file = s->priv;
return RarSeek(rar_file, newpos);
}
static void rar_entry_close(stream_t *s)
{
rar_file_t *rar_file = s->priv;
RarFileDelete(rar_file);
}
static int rar_entry_control(stream_t *s, int cmd, void *arg)
{
rar_file_t *rar_file = s->priv;
switch (cmd) {
case STREAM_CTRL_GET_BASE_FILENAME:
*(char **)arg = talloc_strdup(NULL, rar_file->s->url);
return STREAM_OK;
case STREAM_CTRL_GET_SIZE:
*(int64_t *)arg = rar_file->size;
return STREAM_OK;
}
return STREAM_UNSUPPORTED;
}
static int rar_entry_open(stream_t *stream)
{
if (!strchr(stream->path, '|'))
return STREAM_ERROR;
char *base = talloc_strdup(stream, stream->path);
char *name = strchr(base, '|');
*name++ = '\0';
mp_url_unescape_inplace(base);
stream: redo playback abort handling This mechanism originates from MPlayer's way of dealing with blocking network, but it's still useful. On opening and closing, mpv waits for network synchronously, and also some obscure commands and use-cases can lead to such blocking. In these situations, the stream is asynchronously forced to stop by "interrupting" it. The old design interrupting I/O was a bit broken: polling with a callback, instead of actively interrupting it. Change the direction of this. There is no callback anymore, and the player calls mp_cancel_trigger() to force the stream to return. libavformat (via stream_lavf.c) has the old broken design, and fixing it would require fixing libavformat, which won't happen so quickly. So we have to keep that part. But everything above the stream layer is prepared for a better design, and more sophisticated methods than mp_cancel_test() could be easily introduced. There's still one problem: commands are still run in the central playback loop, which we assume can block on I/O in the worst case. That's not a problem yet, because we simply mark some commands as being able to stop playback of the current file ("quit" etc.), so input.c could abort playback as soon as such a command is queued. But there are also commands abort playback only conditionally, and the logic for that is in the playback core and thus "unreachable". For example, "playlist_next" aborts playback only if there's a next file. We don't want it to always abort playback. As a quite ugly hack, abort playback only if at least 2 abort commands are queued - this pretty much happens only if the core is frozen and doesn't react to input.
2014-09-13 12:23:08 +00:00
struct stream *rar = stream_create(base, STREAM_READ | STREAM_NO_FILTERS,
stream->cancel, stream->global);
if (!rar)
return STREAM_ERROR;
int count;
rar_file_t **files;
if (RarProbe(rar) || RarParse(rar, &count, &files)) {
free_stream(rar);
return STREAM_ERROR;
}
rar_file_t *file = NULL;
for (int i = 0; i < count; i++) {
if (!file && strcmp(files[i]->name, name) == 0)
file = files[i];
else
RarFileDelete(files[i]);
}
talloc_free(files);
if (!file) {
free_stream(rar);
return STREAM_ERROR;
}
rar_file_chunk_t dummy = {
.mrl = base,
};
file->current_chunk = &dummy;
file->s = rar; // transfer ownership
stream: redo playback abort handling This mechanism originates from MPlayer's way of dealing with blocking network, but it's still useful. On opening and closing, mpv waits for network synchronously, and also some obscure commands and use-cases can lead to such blocking. In these situations, the stream is asynchronously forced to stop by "interrupting" it. The old design interrupting I/O was a bit broken: polling with a callback, instead of actively interrupting it. Change the direction of this. There is no callback anymore, and the player calls mp_cancel_trigger() to force the stream to return. libavformat (via stream_lavf.c) has the old broken design, and fixing it would require fixing libavformat, which won't happen so quickly. So we have to keep that part. But everything above the stream layer is prepared for a better design, and more sophisticated methods than mp_cancel_test() could be easily introduced. There's still one problem: commands are still run in the central playback loop, which we assume can block on I/O in the worst case. That's not a problem yet, because we simply mark some commands as being able to stop playback of the current file ("quit" etc.), so input.c could abort playback as soon as such a command is queued. But there are also commands abort playback only conditionally, and the logic for that is in the playback core and thus "unreachable". For example, "playlist_next" aborts playback only if there's a next file. We don't want it to always abort playback. As a quite ugly hack, abort playback only if at least 2 abort commands are queued - this pretty much happens only if the core is frozen and doesn't react to input.
2014-09-13 12:23:08 +00:00
file->cancel = stream->cancel;
file->global = stream->global;
RarSeek(file, 0);
stream->priv = file;
stream->fill_buffer = rar_entry_fill_buffer;
stream->seek = rar_entry_seek;
stream->seekable = true;
stream->close = rar_entry_close;
stream->control = rar_entry_control;
return STREAM_OK;
}
static int rar_filter_fill_buffer(stream_t *s, char *buffer, int max_len)
{
struct stream *m = s->priv;
return stream_read_partial(m, buffer, max_len);
}
static int rar_filter_seek(stream_t *s, int64_t newpos)
{
struct stream *m = s->priv;
return stream_seek(m, newpos);
}
static void rar_filter_close(stream_t *s)
{
struct stream *m = s->priv;
free_stream(m);
}
static int rar_filter_control(stream_t *s, int cmd, void *arg)
{
struct stream *m = s->priv;
return stream_control(m, cmd, arg);
}
static int rar_filter_open(stream_t *stream)
{
struct stream *rar = stream->source;
if (!rar)
return STREAM_UNSUPPORTED;
int count;
rar_file_t **files;
if (!rar || RarProbe(rar) || RarParse(rar, &count, &files))
return STREAM_UNSUPPORTED;
void *tmp = talloc_new(NULL);
// Create a playlist containing all entries of the .rar file. The URLs
// link to rar_entry_open().
char *prefix = mp_url_escape(tmp, stream->url, "~|");
char *pl = talloc_strdup(tmp, "#EXTM3U\n");
for (int n = 0; n < count; n++) {
pl = talloc_asprintf_append_buffer(pl, "rar://%s|%s\n",
prefix, files[n]->name);
RarFileDelete(files[n]);
}
talloc_free(files);
struct stream *m = open_memory_stream(pl, strlen(pl));
stream->priv = m;
stream->fill_buffer = rar_filter_fill_buffer;
stream->seek = rar_filter_seek;
stream->seekable = true;
stream->close = rar_filter_close;
stream->control = rar_filter_control;
stream->safe_origin = true;
talloc_free(tmp);
return STREAM_OK;
}
const stream_info_t stream_info_rar_entry = {
.name = "rar_entry",
.open = rar_entry_open,
.protocols = (const char*const[]){ "rar", NULL },
};
const stream_info_t stream_info_rar_filter = {
.name = "rar_filter",
.open = rar_filter_open,
.stream_filter = true,
};