2004-01-19 19:16:10 +00:00
|
|
|
/*
|
2009-05-08 21:51:13 +00:00
|
|
|
* Matroska demuxer
|
|
|
|
* Copyright (C) 2004 Aurelien Jacobs <aurel@gnuage.org>
|
2004-01-19 19:16:10 +00:00
|
|
|
* Based on the one written by Ronald Bultje for gstreamer
|
2009-05-08 21:51:13 +00:00
|
|
|
* and on demux_mkv.cpp from Moritz Bunkus.
|
|
|
|
*
|
|
|
|
* 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.
|
2004-01-19 19:16:10 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <ctype.h>
|
2006-06-04 22:41:27 +00:00
|
|
|
#include <inttypes.h>
|
2009-03-16 21:30:48 +00:00
|
|
|
#include <stdbool.h>
|
demux_mkv: improve robustness against broken files
Fixes test7.mkv from the Matroska test file collection, as well as some
real broken files I've found in the wild. (Unfortunately, true recovery
requires resetting the decoders and playback state with a manual seek,
but it's still better than just exiting.)
If there are broken EBML elements, try harder to skip them correctly.
Do this by searching for the next cluster element. The cluster element
intentionally has a long ID, so it's a suitable element for
resynchronizing (mkvmerge does something similar).
We know that data is corrupt if the ID or length fields of an element
are malformed. Additionally, if skipping an unknown element goes past
the end of the file, we assume it's corrupt and undo the seek. Do this
because it often happens that corrupt data is interpreted as correct
EBML elements. Since these elements will have a ridiculous values in
their length fields due to the large value range that is possible
(0-2^56-2), they will go past the end of the file. So instead of
skipping them (which would result in playback termination), try to
find the next cluster instead. (We still skip unknown elements that
are within the file, as this is needed for correct operation. Also, we
first execute the seek, because we don't really know where the file
ends. Doing it this way is better for unseekable streams too, because
it will still work in the non-error case.)
This is done as special case in the packet reading function only. On
the other hand, that's the only part of the file that's read after
initialization is done.
2013-03-27 23:01:17 +00:00
|
|
|
#include <assert.h>
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-02-01 18:01:16 +00:00
|
|
|
#include <libavutil/common.h>
|
|
|
|
#include <libavutil/lzo.h>
|
|
|
|
#include <libavutil/intreadwrite.h>
|
|
|
|
#include <libavutil/avstring.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#if CONFIG_ZLIB
|
|
|
|
#include <zlib.h>
|
|
|
|
#endif
|
|
|
|
|
2009-03-16 21:30:48 +00:00
|
|
|
#include "talloc.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/options.h"
|
|
|
|
#include "core/bstr.h"
|
2007-03-15 18:36:36 +00:00
|
|
|
#include "stream/stream.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "demux.h"
|
2004-01-19 19:16:10 +00:00
|
|
|
#include "stheader.h"
|
|
|
|
#include "ebml.h"
|
|
|
|
#include "matroska.h"
|
2012-08-18 09:13:58 +00:00
|
|
|
//#include "demux_real.h"
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/mp_msg.h"
|
2006-11-05 13:53:27 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static const unsigned char sipr_swaps[38][2] = {
|
2006-04-03 19:41:17 +00:00
|
|
|
{0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
|
|
|
|
{13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
|
|
|
|
{25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
|
|
|
|
{42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
|
2009-12-29 19:06:21 +00:00
|
|
|
{77,80}
|
|
|
|
};
|
2006-04-03 19:41:17 +00:00
|
|
|
|
|
|
|
// Map flavour to bytes per second
|
|
|
|
#define SIPR_FLAVORS 4
|
|
|
|
#define ATRC_FLAVORS 8
|
|
|
|
#define COOK_FLAVORS 34
|
2009-12-29 19:06:21 +00:00
|
|
|
static const int sipr_fl2bps[SIPR_FLAVORS] = { 813, 1062, 625, 2000 };
|
2010-05-29 14:15:55 +00:00
|
|
|
static const int atrc_fl2bps[ATRC_FLAVORS] = {
|
|
|
|
8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100 };
|
2008-04-12 15:51:11 +00:00
|
|
|
static const int cook_fl2bps[COOK_FLAVORS] = {
|
|
|
|
1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
|
|
|
|
4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
|
|
|
|
4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
|
2009-12-29 19:06:21 +00:00
|
|
|
12016, 16408, 22911, 33506
|
|
|
|
};
|
2006-04-03 19:41:17 +00:00
|
|
|
|
2010-01-26 14:05:49 +00:00
|
|
|
typedef struct mkv_content_encoding {
|
|
|
|
uint64_t order, type, scope;
|
|
|
|
uint64_t comp_algo;
|
2009-12-29 19:06:21 +00:00
|
|
|
uint8_t *comp_settings;
|
|
|
|
int comp_settings_len;
|
2004-01-19 19:16:10 +00:00
|
|
|
} mkv_content_encoding_t;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
typedef struct mkv_track {
|
|
|
|
int tnum;
|
|
|
|
char *name;
|
2010-05-22 07:14:41 +00:00
|
|
|
int id; // -aid / -sid / -vid option value
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
char *codec_id;
|
|
|
|
int ms_compat;
|
|
|
|
char *language;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
int type;
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
uint32_t v_width, v_height, v_dwidth, v_dheight;
|
2013-04-03 23:20:06 +00:00
|
|
|
bool v_dwidth_set, v_dheight_set;
|
2009-12-29 19:06:21 +00:00
|
|
|
double v_frate;
|
2013-01-24 15:57:21 +00:00
|
|
|
uint32_t colorspace;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
uint32_t a_formattag;
|
|
|
|
uint32_t a_channels, a_bps;
|
|
|
|
float a_sfreq;
|
2010-11-21 12:52:08 +00:00
|
|
|
float a_osfreq;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
double default_duration;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
int default_track;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
unsigned char *private_data;
|
|
|
|
unsigned int private_size;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
/* stuff for realmedia */
|
|
|
|
int realmedia;
|
|
|
|
int64_t rv_kf_base;
|
|
|
|
int rv_kf_pts;
|
|
|
|
double rv_pts; /* previous video timestamp */
|
|
|
|
double ra_pts; /* previous audio timestamp */
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2006-04-03 19:41:17 +00:00
|
|
|
/** realaudio descrambling */
|
2009-12-29 19:06:21 +00:00
|
|
|
int sub_packet_size; ///< sub packet size, per stream
|
|
|
|
int sub_packet_h; ///< number of coded frames per block
|
|
|
|
int coded_framesize; ///< coded frame size, per stream
|
|
|
|
int audiopk_size; ///< audio packet size
|
|
|
|
unsigned char *audio_buf; ///< place to store reordered audio data
|
|
|
|
double *audio_timestamp; ///< timestamp for each audio packet
|
|
|
|
int sub_packet_cnt; ///< number of subpacket already received
|
|
|
|
int audio_filepos; ///< file position of first audio packet in block
|
|
|
|
|
|
|
|
/* stuff for quicktime */
|
|
|
|
int fix_i_bps;
|
|
|
|
double qt_last_a_pts;
|
|
|
|
|
|
|
|
int subtitle_type;
|
|
|
|
|
|
|
|
/* generic content encoding support */
|
|
|
|
mkv_content_encoding_t *encodings;
|
|
|
|
int num_encodings;
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
/* latest added index entry for this track */
|
|
|
|
int last_index_entry;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
/* For VobSubs and SSA/ASS */
|
|
|
|
sh_sub_t *sh_sub;
|
2004-01-19 19:16:10 +00:00
|
|
|
} mkv_track_t;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
typedef struct mkv_index {
|
|
|
|
int tnum;
|
|
|
|
uint64_t timecode, filepos;
|
2004-01-19 19:16:10 +00:00
|
|
|
} mkv_index_t;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
typedef struct mkv_demuxer {
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t segment_start;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
double duration, last_pts;
|
|
|
|
uint64_t last_filepos;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_track_t **tracks;
|
|
|
|
int num_tracks;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
uint64_t tc_scale, cluster_tc;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-01 16:42:52 +00:00
|
|
|
uint64_t cluster_start;
|
2013-04-11 18:31:58 +00:00
|
|
|
uint64_t cluster_end;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_index_t *indexes;
|
|
|
|
int num_indexes;
|
2013-04-11 15:40:23 +00:00
|
|
|
bool index_complete;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t *parsed_pos;
|
2010-01-25 10:37:42 +00:00
|
|
|
int num_parsed_pos;
|
|
|
|
bool parsed_info;
|
|
|
|
bool parsed_tracks;
|
|
|
|
bool parsed_tags;
|
|
|
|
bool parsed_chapters;
|
|
|
|
bool parsed_attachments;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2011-01-23 22:29:01 +00:00
|
|
|
uint64_t skip_to_timecode;
|
2009-12-29 19:06:21 +00:00
|
|
|
int v_skip_to_keyframe, a_skip_to_keyframe;
|
2013-04-03 23:43:14 +00:00
|
|
|
bool subtitle_preroll;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-05-22 07:14:41 +00:00
|
|
|
int num_audio_tracks;
|
2011-04-07 23:33:57 +00:00
|
|
|
int num_video_tracks;
|
2004-01-19 19:16:10 +00:00
|
|
|
} mkv_demuxer_t;
|
|
|
|
|
2007-05-28 18:13:33 +00:00
|
|
|
#define REALHEADER_SIZE 16
|
|
|
|
#define RVPROPERTIES_SIZE 34
|
|
|
|
#define RAPROPERTIES4_SIZE 56
|
|
|
|
#define RAPROPERTIES5_SIZE 70
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2006-10-10 15:01:11 +00:00
|
|
|
/**
|
|
|
|
* \brief ensures there is space for at least one additional element
|
|
|
|
* \param array array to grow
|
|
|
|
* \param nelem current number of elements in array
|
|
|
|
* \param elsize size of one array element
|
|
|
|
*/
|
2009-12-29 19:06:21 +00:00
|
|
|
static void *grow_array(void *array, int nelem, size_t elsize)
|
|
|
|
{
|
|
|
|
if (!(nelem & 31))
|
|
|
|
array = realloc(array, (nelem + 32) * elsize);
|
|
|
|
return array;
|
2006-10-10 15:01:11 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-11-18 19:46:12 +00:00
|
|
|
static bool is_parsed_header(struct mkv_demuxer *mkv_d, int64_t pos)
|
2010-01-25 10:37:42 +00:00
|
|
|
{
|
|
|
|
int low = 0;
|
|
|
|
int high = mkv_d->num_parsed_pos;
|
|
|
|
while (high > low + 1) {
|
|
|
|
int mid = high + low >> 1;
|
|
|
|
if (mkv_d->parsed_pos[mid] > pos)
|
|
|
|
high = mid;
|
|
|
|
else
|
|
|
|
low = mid;
|
|
|
|
}
|
|
|
|
if (mkv_d->num_parsed_pos && mkv_d->parsed_pos[low] == pos)
|
|
|
|
return true;
|
|
|
|
if (!(mkv_d->num_parsed_pos & 31))
|
2012-11-18 19:46:12 +00:00
|
|
|
mkv_d->parsed_pos = talloc_realloc(mkv_d, mkv_d->parsed_pos, int64_t,
|
2010-01-25 10:37:42 +00:00
|
|
|
mkv_d->num_parsed_pos + 32);
|
|
|
|
mkv_d->num_parsed_pos++;
|
|
|
|
for (int i = mkv_d->num_parsed_pos - 1; i > low; i--)
|
|
|
|
mkv_d->parsed_pos[i] = mkv_d->parsed_pos[i - 1];
|
|
|
|
mkv_d->parsed_pos[low] = pos;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-05-22 07:14:41 +00:00
|
|
|
static mkv_track_t *find_track_by_num(struct mkv_demuxer *d, int n, int type)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-05-22 07:14:41 +00:00
|
|
|
for (int i = 0; i < d->num_tracks; i++)
|
2009-12-29 19:06:21 +00:00
|
|
|
if (d->tracks[i] != NULL && d->tracks[i]->type == type)
|
2010-05-22 07:14:41 +00:00
|
|
|
if (d->tracks[i]->id == n)
|
2009-12-29 19:06:21 +00:00
|
|
|
return d->tracks[i];
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
return NULL;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define AAC_SYNC_EXTENSION_TYPE 0x02b7
|
2009-12-29 19:06:21 +00:00
|
|
|
static int aac_get_sample_rate_index(uint32_t sample_rate)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
static const int srates[] = {
|
|
|
|
92017, 75132, 55426, 46009, 37566, 27713,
|
|
|
|
23004, 18783, 13856, 11502, 9391, 0
|
|
|
|
};
|
|
|
|
int i = 0;
|
|
|
|
while (sample_rate < srates[i])
|
|
|
|
i++;
|
|
|
|
return i;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:07 +00:00
|
|
|
static void demux_mkv_decode(mkv_track_t *track, uint8_t *src,
|
|
|
|
uint8_t **dest, uint32_t *size, uint32_t type)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-01-26 17:40:07 +00:00
|
|
|
uint8_t *orig_src = src;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
*dest = src;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 17:40:07 +00:00
|
|
|
for (int i = 0; i < track->num_encodings; i++) {
|
|
|
|
struct mkv_content_encoding *enc = track->encodings + i;
|
|
|
|
if (!(enc->scope & type))
|
2009-12-29 19:06:21 +00:00
|
|
|
continue;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 17:40:07 +00:00
|
|
|
if (src != *dest && src != orig_src)
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(src);
|
2010-01-26 17:40:07 +00:00
|
|
|
src = *dest; // output from last iteration is new source
|
|
|
|
|
|
|
|
if (enc->comp_algo == 0) {
|
2009-02-07 15:23:55 +00:00
|
|
|
#if CONFIG_ZLIB
|
2009-12-29 19:06:21 +00:00
|
|
|
/* zlib encoded track */
|
2010-01-26 14:38:39 +00:00
|
|
|
|
|
|
|
if (*size == 0)
|
|
|
|
continue;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
z_stream zstream;
|
|
|
|
|
|
|
|
zstream.zalloc = (alloc_func) 0;
|
|
|
|
zstream.zfree = (free_func) 0;
|
|
|
|
zstream.opaque = (voidpf) 0;
|
|
|
|
if (inflateInit(&zstream) != Z_OK) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] zlib initialization failed.\n");
|
2010-01-26 17:40:07 +00:00
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
}
|
|
|
|
zstream.next_in = (Bytef *) src;
|
|
|
|
zstream.avail_in = *size;
|
|
|
|
|
|
|
|
*dest = NULL;
|
|
|
|
zstream.avail_out = *size;
|
2010-01-26 17:40:07 +00:00
|
|
|
int result;
|
2009-12-29 19:06:21 +00:00
|
|
|
do {
|
|
|
|
*size += 4000;
|
2010-03-21 16:36:47 +00:00
|
|
|
*dest = talloc_realloc_size(NULL, *dest, *size);
|
2009-12-29 19:06:21 +00:00
|
|
|
zstream.next_out = (Bytef *) (*dest + zstream.total_out);
|
|
|
|
result = inflate(&zstream, Z_NO_FLUSH);
|
|
|
|
if (result != Z_OK && result != Z_STREAM_END) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] zlib decompression failed.\n");
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(*dest);
|
2009-12-29 19:06:21 +00:00
|
|
|
*dest = NULL;
|
|
|
|
inflateEnd(&zstream);
|
2010-01-26 17:40:07 +00:00
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
}
|
|
|
|
zstream.avail_out += 4000;
|
|
|
|
} while (zstream.avail_out == 4000 && zstream.avail_in != 0
|
|
|
|
&& result != Z_STREAM_END);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
*size = zstream.total_out;
|
|
|
|
inflateEnd(&zstream);
|
2004-01-19 19:16:10 +00:00
|
|
|
#endif
|
2010-01-26 17:40:07 +00:00
|
|
|
} else if (enc->comp_algo == 2) {
|
2009-12-29 19:06:21 +00:00
|
|
|
/* lzo encoded track */
|
2010-09-18 17:24:39 +00:00
|
|
|
int out_avail;
|
2009-12-29 19:06:21 +00:00
|
|
|
int dstlen = *size * 3;
|
|
|
|
|
|
|
|
*dest = NULL;
|
|
|
|
while (1) {
|
|
|
|
int srclen = *size;
|
2010-03-21 16:36:47 +00:00
|
|
|
*dest = talloc_realloc_size(NULL, *dest,
|
|
|
|
dstlen + AV_LZO_OUTPUT_PADDING);
|
2010-09-18 17:24:39 +00:00
|
|
|
out_avail = dstlen;
|
|
|
|
int result = av_lzo1x_decode(*dest, &out_avail, src, &srclen);
|
2009-12-29 19:06:21 +00:00
|
|
|
if (result == 0)
|
|
|
|
break;
|
|
|
|
if (!(result & AV_LZO_OUTPUT_FULL)) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] lzo decompression failed.\n");
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(*dest);
|
2009-12-29 19:06:21 +00:00
|
|
|
*dest = NULL;
|
2010-01-26 17:40:07 +00:00
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_DBG2,
|
|
|
|
"[mkv] lzo decompression buffer too small.\n");
|
|
|
|
dstlen *= 2;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-09-18 17:24:39 +00:00
|
|
|
*size = dstlen - out_avail;
|
2010-01-26 17:40:07 +00:00
|
|
|
} else if (enc->comp_algo == 3) {
|
2010-03-21 16:36:47 +00:00
|
|
|
*dest = talloc_size(NULL, *size + enc->comp_settings_len);
|
2010-01-26 17:40:07 +00:00
|
|
|
memcpy(*dest, enc->comp_settings, enc->comp_settings_len);
|
|
|
|
memcpy(*dest + enc->comp_settings_len, src, *size);
|
|
|
|
*size += enc->comp_settings_len;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-26 17:40:07 +00:00
|
|
|
error:
|
|
|
|
if (src != *dest && src != orig_src)
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(src);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-03-13 01:26:32 +00:00
|
|
|
static int demux_mkv_read_info(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-03-13 01:26:32 +00:00
|
|
|
mkv_demuxer_t *mkv_d = demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
2011-08-04 05:38:39 +00:00
|
|
|
int res = 0;
|
2009-03-16 21:30:48 +00:00
|
|
|
|
2010-01-26 12:06:49 +00:00
|
|
|
mkv_d->tc_scale = 1000000;
|
|
|
|
mkv_d->duration = 0;
|
|
|
|
|
|
|
|
struct ebml_info info = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &info, &ebml_info_desc) < 0)
|
2011-08-04 05:38:39 +00:00
|
|
|
return -1;
|
2010-01-26 12:06:49 +00:00
|
|
|
if (info.n_timecode_scale) {
|
|
|
|
mkv_d->tc_scale = info.timecode_scale;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] | + timecode scale: %" PRIu64 "\n", mkv_d->tc_scale);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-26 12:06:49 +00:00
|
|
|
if (info.n_duration) {
|
|
|
|
mkv_d->duration = info.duration * mkv_d->tc_scale / 1e9;
|
2009-03-13 01:26:32 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3fs\n",
|
|
|
|
mkv_d->duration);
|
2010-01-26 12:06:49 +00:00
|
|
|
}
|
|
|
|
if (info.n_segment_uid) {
|
|
|
|
int len = info.segment_uid.len;
|
|
|
|
if (len != sizeof(demuxer->matroska_data.segment_uid)) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_INFO,
|
|
|
|
"[mkv] segment uid invalid length %d\n", len);
|
|
|
|
} else {
|
|
|
|
memcpy(demuxer->matroska_data.segment_uid, info.segment_uid.start,
|
|
|
|
len);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + segment uid");
|
|
|
|
for (int i = 0; i < len; i++)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, " %02x",
|
|
|
|
demuxer->matroska_data.segment_uid[i]);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "\n");
|
|
|
|
}
|
|
|
|
}
|
2011-08-04 05:38:39 +00:00
|
|
|
if (demuxer->params && demuxer->params->matroska_wanted_uids) {
|
|
|
|
unsigned char (*uids)[16] = demuxer->params->matroska_wanted_uids;
|
|
|
|
if (!info.n_segment_uid)
|
|
|
|
uids = NULL;
|
|
|
|
for (int i = 0; i < MP_TALLOC_ELEMS(uids); i++) {
|
|
|
|
if (!memcmp(info.segment_uid.start, uids[i], 16))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_INFO,
|
|
|
|
"[mkv] This is not one of the wanted files. "
|
|
|
|
"Stopping attempt to open.\n");
|
|
|
|
res = -2;
|
|
|
|
}
|
|
|
|
out:
|
2010-01-26 12:06:49 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2011-08-04 05:38:39 +00:00
|
|
|
return res;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
static void parse_trackencodings(struct demuxer *demuxer,
|
|
|
|
struct mkv_track *track,
|
|
|
|
struct ebml_content_encodings *encodings)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-01-26 14:05:49 +00:00
|
|
|
// initial allocation to be a non-NULL context before realloc
|
|
|
|
mkv_content_encoding_t *ce = talloc_size(track, 1);
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
for (int n_enc = 0; n_enc < encodings->n_content_encoding; n_enc++) {
|
|
|
|
struct ebml_content_encoding *enc = encodings->content_encoding + n_enc;
|
2010-01-26 14:05:49 +00:00
|
|
|
struct mkv_content_encoding e = {};
|
|
|
|
e.order = enc->content_encoding_order;
|
|
|
|
if (enc->n_content_encoding_scope)
|
|
|
|
e.scope = enc->content_encoding_scope;
|
|
|
|
else
|
2004-01-19 19:16:10 +00:00
|
|
|
e.scope = 1;
|
2010-01-26 14:05:49 +00:00
|
|
|
e.type = enc->content_encoding_type;
|
|
|
|
|
|
|
|
if (enc->n_content_compression) {
|
|
|
|
struct ebml_content_compression *z = &enc->content_compression;
|
|
|
|
e.comp_algo = z->content_comp_algo;
|
|
|
|
if (z->n_content_comp_settings) {
|
|
|
|
int sz = z->content_comp_settings.len;
|
|
|
|
e.comp_settings = talloc_size(ce, sz);
|
|
|
|
memcpy(e.comp_settings, z->content_comp_settings.start, sz);
|
|
|
|
e.comp_settings_len = sz;
|
2009-12-29 19:06:21 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 14:05:49 +00:00
|
|
|
if (e.type == 1) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Track "
|
|
|
|
"number %u has been encrypted and "
|
|
|
|
"decryption has not yet been\n"
|
|
|
|
"[mkv] implemented. Skipping track.\n",
|
|
|
|
track->tnum);
|
|
|
|
} else if (e.type != 0) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] Unknown content encoding type for "
|
|
|
|
"track %u. Skipping track.\n",
|
|
|
|
track->tnum);
|
2010-01-28 15:17:54 +00:00
|
|
|
} else if (e.comp_algo != 0 && e.comp_algo != 2 && e.comp_algo != 3) {
|
2010-01-26 14:05:49 +00:00
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] Track %u has been compressed with "
|
|
|
|
"an unknown/unsupported compression\n"
|
|
|
|
"[mkv] algorithm (%" PRIu64 "). Skipping track.\n",
|
|
|
|
track->tnum, e.comp_algo);
|
|
|
|
}
|
|
|
|
#if !CONFIG_ZLIB
|
|
|
|
else if (e.comp_algo == 0) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN,
|
|
|
|
"[mkv] Track %u was compressed with zlib "
|
2012-10-11 00:04:08 +00:00
|
|
|
"but mpv has not been compiled\n"
|
2010-01-26 14:05:49 +00:00
|
|
|
"[mkv] with support for zlib compression. "
|
|
|
|
"Skipping track.\n",
|
|
|
|
track->tnum);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < n_enc; i++)
|
2010-01-26 17:40:07 +00:00
|
|
|
if (e.order >= ce[i].order)
|
2010-01-26 14:05:49 +00:00
|
|
|
break;
|
|
|
|
ce = talloc_realloc_size(track, ce, (n_enc + 1) * sizeof(*ce));
|
|
|
|
memmove(ce + i + 1, ce + i, (n_enc - i) * sizeof(*ce));
|
|
|
|
memcpy(ce + i, &e, sizeof(e));
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
track->encodings = ce;
|
2010-01-26 16:15:02 +00:00
|
|
|
track->num_encodings = encodings->n_content_encoding;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
static void parse_trackaudio(struct demuxer *demuxer, struct mkv_track *track,
|
|
|
|
struct ebml_audio *audio)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-01-26 16:15:02 +00:00
|
|
|
if (audio->n_sampling_frequency) {
|
|
|
|
track->a_sfreq = audio->sampling_frequency;
|
2010-01-26 12:41:07 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] | + Sampling frequency: %f\n", track->a_sfreq);
|
|
|
|
} else
|
|
|
|
track->a_sfreq = 8000;
|
2010-11-21 12:52:08 +00:00
|
|
|
if (audio->n_output_sampling_frequency) {
|
|
|
|
track->a_osfreq = audio->output_sampling_frequency;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] | + Output sampling frequency: %f\n", track->a_osfreq);
|
|
|
|
} else
|
|
|
|
track->a_osfreq = track->a_sfreq;
|
2012-12-16 09:02:42 +00:00
|
|
|
// Something creates files with osfreq incorrectly set
|
|
|
|
if (track->a_sfreq == 44100 && track->a_osfreq == 96000) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Audio track has codec frequency "
|
|
|
|
"%.1f and playback frequency %.1f.\n[mkv] This looks wrong. "
|
|
|
|
"Assuming this file is corrupt and ignoring the latter.\n",
|
|
|
|
track->a_sfreq, track->a_osfreq);
|
|
|
|
track->a_osfreq = track->a_sfreq;
|
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (audio->n_bit_depth) {
|
|
|
|
track->a_bps = audio->bit_depth;
|
2010-01-26 12:41:07 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Bit depth: %u\n",
|
|
|
|
track->a_bps);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (audio->n_channels) {
|
|
|
|
track->a_channels = audio->channels;
|
2010-01-26 12:41:07 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Channels: %u\n",
|
|
|
|
track->a_channels);
|
|
|
|
} else
|
|
|
|
track->a_channels = 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
static void parse_trackvideo(struct demuxer *demuxer, struct mkv_track *track,
|
|
|
|
struct ebml_video *video)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-01-26 16:15:02 +00:00
|
|
|
if (video->n_frame_rate) {
|
|
|
|
track->v_frate = video->frame_rate;
|
2010-01-26 12:55:06 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Frame rate: %f\n",
|
|
|
|
track->v_frate);
|
|
|
|
if (track->v_frate > 0)
|
|
|
|
track->default_duration = 1 / track->v_frate;
|
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (video->n_display_width) {
|
|
|
|
track->v_dwidth = video->display_width;
|
2013-04-03 23:20:06 +00:00
|
|
|
track->v_dwidth_set = true;
|
2010-01-26 12:55:06 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Display width: %u\n",
|
|
|
|
track->v_dwidth);
|
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (video->n_display_height) {
|
|
|
|
track->v_dheight = video->display_height;
|
2013-04-03 23:20:06 +00:00
|
|
|
track->v_dheight_set = true;
|
2010-01-26 12:55:06 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Display height: %u\n",
|
|
|
|
track->v_dheight);
|
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (video->n_pixel_width) {
|
|
|
|
track->v_width = video->pixel_width;
|
2010-01-26 12:55:06 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel width: %u\n",
|
|
|
|
track->v_width);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
if (video->n_pixel_height) {
|
|
|
|
track->v_height = video->pixel_height;
|
2010-01-26 12:55:06 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel height: %u\n",
|
|
|
|
track->v_height);
|
|
|
|
}
|
2013-01-24 15:57:21 +00:00
|
|
|
if (video->n_colour_space && video->colour_space.len == 4) {
|
|
|
|
uint8_t *d = (uint8_t *)&video->colour_space.start[0];
|
|
|
|
track->colorspace = d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Colorspace: %#x\n",
|
|
|
|
(unsigned int)track->colorspace);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2006-10-09 18:48:55 +00:00
|
|
|
/**
|
|
|
|
* \brief free any data associated with given track
|
|
|
|
* \param track track of which to free data
|
|
|
|
*/
|
2009-12-29 19:06:21 +00:00
|
|
|
static void demux_mkv_free_trackentry(mkv_track_t *track)
|
|
|
|
{
|
|
|
|
free(track->audio_buf);
|
|
|
|
free(track->audio_timestamp);
|
2010-01-26 14:05:49 +00:00
|
|
|
talloc_free(track);
|
2006-10-09 18:48:55 +00:00
|
|
|
}
|
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
static void parse_trackentry(struct demuxer *demuxer,
|
|
|
|
struct ebml_track_entry *entry)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
2010-01-26 16:15:02 +00:00
|
|
|
struct mkv_track *track = talloc_zero_size(NULL, sizeof(*track));
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
track->last_index_entry = -1;
|
2010-01-26 16:15:02 +00:00
|
|
|
|
|
|
|
track->tnum = entry->track_number;
|
|
|
|
if (track->tnum)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track number: %u\n",
|
|
|
|
track->tnum);
|
|
|
|
else
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Missing track number!\n");
|
|
|
|
|
|
|
|
if (entry->n_name) {
|
|
|
|
track->name = talloc_strndup(track, entry->name.start,
|
|
|
|
entry->name.len);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Name: %s\n",
|
|
|
|
track->name);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
track->type = entry->track_type;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track type: ");
|
|
|
|
switch (track->type) {
|
|
|
|
case MATROSKA_TRACK_AUDIO:
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "Audio\n");
|
|
|
|
break;
|
|
|
|
case MATROSKA_TRACK_VIDEO:
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "Video\n");
|
|
|
|
break;
|
|
|
|
case MATROSKA_TRACK_SUBTITLE:
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "Subtitle\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "unknown\n");
|
|
|
|
break;
|
|
|
|
}
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_audio) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Audio track\n");
|
|
|
|
parse_trackaudio(demuxer, track, &entry->audio);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_video) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Video track\n");
|
|
|
|
parse_trackvideo(demuxer, track, &entry->video);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_codec_id) {
|
|
|
|
track->codec_id = talloc_strndup(track, entry->codec_id.start,
|
|
|
|
entry->codec_id.len);
|
|
|
|
if (!strcmp(track->codec_id, MKV_V_MSCOMP)
|
|
|
|
|| !strcmp(track->codec_id, MKV_A_ACM))
|
|
|
|
track->ms_compat = 1;
|
|
|
|
else if (!strcmp(track->codec_id, MKV_S_VOBSUB))
|
2011-03-31 00:23:55 +00:00
|
|
|
track->subtitle_type = 'v';
|
2010-01-26 16:15:02 +00:00
|
|
|
else if (!strcmp(track->codec_id, MKV_S_TEXTSSA)
|
|
|
|
|| !strcmp(track->codec_id, MKV_S_TEXTASS)
|
|
|
|
|| !strcmp(track->codec_id, MKV_S_SSA)
|
2011-03-31 00:23:55 +00:00
|
|
|
|| !strcmp(track->codec_id, MKV_S_ASS))
|
|
|
|
track->subtitle_type = 'a';
|
|
|
|
else if (!strcmp(track->codec_id, MKV_S_TEXTASCII)
|
|
|
|
|| !strcmp(track->codec_id, MKV_S_TEXTUTF8))
|
|
|
|
track->subtitle_type = 't';
|
2011-03-31 00:31:46 +00:00
|
|
|
else if (!strcmp(track->codec_id, MKV_S_PGS))
|
|
|
|
track->subtitle_type = 'p';
|
2010-01-26 16:15:02 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Codec ID: %s\n",
|
|
|
|
track->codec_id);
|
|
|
|
} else
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Missing codec ID!\n");
|
|
|
|
|
|
|
|
if (entry->n_codec_private) {
|
|
|
|
int len = entry->codec_private.len;
|
|
|
|
track->private_data = talloc_size(track, len + AV_LZO_INPUT_PADDING);
|
|
|
|
memcpy(track->private_data, entry->codec_private.start, len);
|
|
|
|
track->private_size = len;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + CodecPrivate, length %u\n",
|
|
|
|
track->private_size);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_language) {
|
|
|
|
track->language = talloc_strndup(track, entry->language.start,
|
|
|
|
entry->language.len);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Language: %s\n",
|
|
|
|
track->language);
|
|
|
|
} else
|
|
|
|
track->language = talloc_strdup(track, "eng");
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_flag_default) {
|
|
|
|
track->default_track = entry->flag_default;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Default flag: %u\n",
|
|
|
|
track->default_track);
|
|
|
|
} else
|
|
|
|
track->default_track = 1;
|
|
|
|
|
|
|
|
if (entry->n_default_duration) {
|
|
|
|
track->default_duration = entry->default_duration / 1e9;
|
|
|
|
if (entry->default_duration == 0)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: 0");
|
|
|
|
else {
|
|
|
|
if (!track->v_frate)
|
|
|
|
track->v_frate = 1e9 / entry->default_duration;
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
2010-01-26 16:15:02 +00:00
|
|
|
"[mkv] | + Default duration: %.3fms ( = %.3f fps)\n",
|
|
|
|
entry->default_duration / 1000000.0, track->v_frate);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
if (entry->n_content_encodings)
|
|
|
|
parse_trackencodings(demuxer, track, &entry->content_encodings);
|
2006-10-09 18:48:55 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
mkv_d->tracks[mkv_d->num_tracks++] = track;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_tracks(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 16:15:02 +00:00
|
|
|
struct ebml_tracks tracks = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &tracks, &ebml_tracks_desc) < 0)
|
2011-08-20 18:45:42 +00:00
|
|
|
return -1;
|
2010-01-26 16:15:02 +00:00
|
|
|
|
|
|
|
mkv_d->tracks = talloc_size(mkv_d,
|
|
|
|
tracks.n_track_entry * sizeof(*mkv_d->tracks));
|
|
|
|
for (int i = 0; i < tracks.n_track_entry; i++) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + a track...\n");
|
|
|
|
parse_trackentry(demuxer, &tracks.track_entry[i]);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-26 16:15:02 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
static void cue_index_add(demuxer_t *demuxer, int track_id, uint64_t filepos,
|
|
|
|
uint64_t timecode)
|
|
|
|
{
|
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
|
|
|
|
mkv_d->indexes = grow_array(mkv_d->indexes, mkv_d->num_indexes,
|
|
|
|
sizeof(mkv_index_t));
|
|
|
|
mkv_d->indexes[mkv_d->num_indexes].tnum = track_id;
|
|
|
|
mkv_d->indexes[mkv_d->num_indexes].timecode = timecode;
|
|
|
|
mkv_d->indexes[mkv_d->num_indexes].filepos = filepos;
|
|
|
|
mkv_d->num_indexes++;
|
|
|
|
}
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
static void add_block_position(demuxer_t *demuxer, struct mkv_track *track,
|
|
|
|
uint64_t filepos, uint64_t timecode)
|
2013-04-11 15:40:23 +00:00
|
|
|
{
|
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
if (mkv_d->index_complete || !track)
|
2013-04-11 15:40:23 +00:00
|
|
|
return;
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
if (track->last_index_entry >= 0) {
|
|
|
|
mkv_index_t *index = &mkv_d->indexes[track->last_index_entry];
|
|
|
|
// filepos is always the cluster position, which can contain multiple
|
|
|
|
// blocks with different timecodes - one is enough.
|
|
|
|
// Also, never add block which are already covered by the index.
|
|
|
|
if (index->filepos == filepos || index->timecode >= timecode)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cue_index_add(demuxer, track->tnum, filepos, timecode);
|
|
|
|
track->last_index_entry = mkv_d->num_indexes - 1;
|
2013-04-11 15:40:23 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_cues(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
|
|
|
|
2009-12-31 05:05:11 +00:00
|
|
|
if (index_mode == 0 || index_mode == 2) {
|
2009-12-29 19:06:21 +00:00
|
|
|
ebml_read_skip(s, NULL);
|
2004-01-19 19:16:10 +00:00
|
|
|
return 0;
|
2009-12-29 19:06:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n");
|
2010-01-25 11:19:09 +00:00
|
|
|
struct ebml_cues cues = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &cues, &ebml_cues_desc) < 0)
|
2011-08-20 18:45:42 +00:00
|
|
|
return -1;
|
2010-01-25 11:19:09 +00:00
|
|
|
for (int i = 0; i < cues.n_cue_point; i++) {
|
|
|
|
struct ebml_cue_point *cuepoint = &cues.cue_point[i];
|
|
|
|
if (cuepoint->n_cue_time != 1 || !cuepoint->n_cue_track_positions) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Malformed CuePoint element\n");
|
|
|
|
continue;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-25 11:19:09 +00:00
|
|
|
uint64_t time = cuepoint->cue_time;
|
|
|
|
for (int i = 0; i < cuepoint->n_cue_track_positions; i++) {
|
|
|
|
struct ebml_cue_track_positions *trackpos =
|
|
|
|
&cuepoint->cue_track_positions[i];
|
2013-04-11 15:40:23 +00:00
|
|
|
uint64_t pos = mkv_d->segment_start + trackpos->cue_cluster_position;
|
|
|
|
cue_index_add(demuxer, trackpos->cue_track, pos, time);
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_DBG2,
|
2010-01-25 11:19:09 +00:00
|
|
|
"[mkv] |+ found cue point for track %" PRIu64
|
2013-04-11 15:40:23 +00:00
|
|
|
": timecode %" PRIu64 ", filepos: %" PRIu64 "\n",
|
|
|
|
trackpos->cue_track, time, pos);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
// Do not attempt to create index on the fly.
|
|
|
|
mkv_d->index_complete = true;
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n");
|
2010-01-25 11:19:09 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-03-13 01:26:32 +00:00
|
|
|
static int demux_mkv_read_chapters(struct demuxer *demuxer)
|
|
|
|
{
|
2009-12-01 12:28:34 +00:00
|
|
|
struct MPOpts *opts = demuxer->opts;
|
2009-03-13 01:26:32 +00:00
|
|
|
stream_t *s = demuxer->stream;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-03-13 01:26:32 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing chapters ] ---------\n");
|
2010-01-26 11:39:33 +00:00
|
|
|
struct ebml_chapters file_chapters = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &file_chapters,
|
|
|
|
&ebml_chapters_desc) < 0)
|
2011-08-20 18:45:42 +00:00
|
|
|
return -1;
|
2009-03-13 01:26:32 +00:00
|
|
|
|
2010-01-26 11:39:33 +00:00
|
|
|
int selected_edition = 0;
|
|
|
|
int num_editions = file_chapters.n_edition_entry;
|
|
|
|
struct ebml_edition_entry *editions = file_chapters.edition_entry;
|
|
|
|
if (opts->edition_id >= 0 && opts->edition_id < num_editions) {
|
|
|
|
selected_edition = opts->edition_id;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] User-specified edition: %d\n",
|
|
|
|
selected_edition);
|
|
|
|
} else
|
|
|
|
for (int i = 0; i < num_editions; i++)
|
|
|
|
if (editions[i].edition_flag_default) {
|
|
|
|
selected_edition = i;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition: %d\n", i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
struct matroska_chapter *m_chapters = NULL;
|
|
|
|
if (editions[selected_edition].edition_flag_ordered) {
|
|
|
|
int count = editions[selected_edition].n_chapter_atom;
|
|
|
|
m_chapters = talloc_array_ptrtype(demuxer, m_chapters, count);
|
|
|
|
demuxer->matroska_data.ordered_chapters = m_chapters;
|
|
|
|
demuxer->matroska_data.num_ordered_chapters = count;
|
|
|
|
}
|
2009-03-16 21:30:48 +00:00
|
|
|
|
2010-01-26 11:39:33 +00:00
|
|
|
for (int idx = 0; idx < num_editions; idx++) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] New edition %d\n", idx);
|
|
|
|
int warn_level = idx == selected_edition ? MSGL_WARN : MSGL_V;
|
|
|
|
if (editions[idx].n_edition_flag_default)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition flag: %"PRIu64
|
|
|
|
"\n", editions[idx].edition_flag_default);
|
|
|
|
if (editions[idx].n_edition_flag_ordered)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Ordered chapter flag: %"PRIu64
|
|
|
|
"\n", editions[idx].edition_flag_ordered);
|
|
|
|
for (int i = 0; i < editions[idx].n_chapter_atom; i++) {
|
|
|
|
struct ebml_chapter_atom *ca = editions[idx].chapter_atom + i;
|
|
|
|
struct matroska_chapter chapter = { };
|
|
|
|
struct bstr name = { "(unnamed)", 9 };
|
|
|
|
|
|
|
|
if (!ca->n_chapter_time_start)
|
|
|
|
mp_msg(MSGT_DEMUX, warn_level,
|
|
|
|
"[mkv] Chapter lacks start time\n");
|
2011-01-23 22:29:01 +00:00
|
|
|
chapter.start = ca->chapter_time_start;
|
|
|
|
chapter.end = ca->chapter_time_end;
|
2010-01-26 11:39:33 +00:00
|
|
|
|
|
|
|
if (ca->n_chapter_display) {
|
|
|
|
if (ca->n_chapter_display > 1)
|
|
|
|
mp_msg(MSGT_DEMUX, warn_level, "[mkv] Multiple chapter "
|
|
|
|
"names not supported, picking first\n");
|
|
|
|
if (!ca->chapter_display[0].n_chap_string)
|
|
|
|
mp_msg(MSGT_DEMUX, warn_level, "[mkv] Malformed chapter "
|
|
|
|
"name entry\n");
|
|
|
|
else
|
|
|
|
name = ca->chapter_display[0].chap_string;
|
2009-03-13 01:26:32 +00:00
|
|
|
}
|
2010-01-26 11:39:33 +00:00
|
|
|
|
|
|
|
if (ca->n_chapter_segment_uid) {
|
|
|
|
chapter.has_segment_uid = true;
|
|
|
|
int len = ca->chapter_segment_uid.len;
|
|
|
|
if (len != sizeof(chapter.segment_uid))
|
|
|
|
mp_msg(MSGT_DEMUX, warn_level,
|
|
|
|
"[mkv] Chapter segment uid bad length %d\n", len);
|
|
|
|
else if (ca->n_chapter_segment_edition_uid) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, warn_level, "[mkv] Warning: "
|
|
|
|
"unsupported edition recursion in chapter; "
|
|
|
|
"will skip on playback!\n");
|
|
|
|
} else {
|
|
|
|
memcpy(chapter.segment_uid, ca->chapter_segment_uid.start,
|
|
|
|
len);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Chapter segment uid ");
|
|
|
|
for (int i = 0; i < len; i++)
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "%02x ",
|
|
|
|
chapter.segment_uid[i]);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "\n");
|
|
|
|
}
|
2009-03-16 21:30:48 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-26 11:39:33 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] Chapter %u from %02d:%02d:%02d.%03d "
|
2010-04-24 17:28:09 +00:00
|
|
|
"to %02d:%02d:%02d.%03d, %.*s\n", i,
|
2011-01-23 22:29:01 +00:00
|
|
|
(int) (chapter.start / 60 / 60 / 1000000000),
|
|
|
|
(int) ((chapter.start / 60 / 1000000000) % 60),
|
|
|
|
(int) ((chapter.start / 1000000000) % 60),
|
|
|
|
(int) (chapter.start % 1000000000),
|
|
|
|
(int) (chapter.end / 60 / 60 / 1000000000),
|
|
|
|
(int) ((chapter.end / 60 / 1000000000) % 60),
|
|
|
|
(int) ((chapter.end / 1000000000) % 60),
|
|
|
|
(int) (chapter.end % 1000000000),
|
2010-05-20 20:50:18 +00:00
|
|
|
BSTR_P(name));
|
2010-01-26 11:39:33 +00:00
|
|
|
|
|
|
|
if (idx == selected_edition){
|
2010-05-19 10:44:37 +00:00
|
|
|
demuxer_add_chapter(demuxer, name, chapter.start, chapter.end);
|
2010-01-26 11:39:33 +00:00
|
|
|
if (editions[idx].edition_flag_ordered) {
|
|
|
|
chapter.name = talloc_strndup(m_chapters, name.start,
|
|
|
|
name.len);
|
|
|
|
m_chapters[i] = chapter;
|
|
|
|
}
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-26 11:39:33 +00:00
|
|
|
if (num_editions > 1)
|
2009-12-01 12:28:34 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_INFO,
|
|
|
|
"[mkv] Found %d editions, will play #%d (first is 0).\n",
|
2010-01-26 11:39:33 +00:00
|
|
|
num_editions, selected_edition);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-08-25 23:19:42 +00:00
|
|
|
demuxer->num_editions = num_editions;
|
|
|
|
demuxer->edition = selected_edition;
|
|
|
|
|
2010-01-26 11:39:33 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] \\---- [ parsing chapters ] ---------\n");
|
2009-03-13 01:26:32 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_tags(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-03-28 12:21:42 +00:00
|
|
|
stream_t *s = demuxer->stream;
|
|
|
|
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
struct ebml_tags tags = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &tags, &ebml_tags_desc) < 0)
|
2011-08-20 18:45:42 +00:00
|
|
|
return -1;
|
2010-03-28 12:21:42 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < tags.n_tag; i++) {
|
|
|
|
struct ebml_tag tag = tags.tag[i];
|
|
|
|
if (tag.targets.target_track_uid || tag.targets.target_edition_uid ||
|
|
|
|
tag.targets.target_chapter_uid || tag.targets.target_attachment_uid)
|
|
|
|
continue;
|
|
|
|
|
2011-04-02 16:50:36 +00:00
|
|
|
for (int j = 0; j < tag.n_simple_tag; j++)
|
2010-03-28 12:21:42 +00:00
|
|
|
demux_info_add_bstr(demuxer, tag.simple_tag[j].tag_name, tag.simple_tag[j].tag_string);
|
|
|
|
}
|
|
|
|
|
2012-08-29 11:15:39 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_attachments(demuxer_t *demuxer)
|
2006-07-07 18:26:51 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
stream_t *s = demuxer->stream;
|
|
|
|
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] /---- [ parsing attachments ] ---------\n");
|
2006-07-07 18:26:51 +00:00
|
|
|
|
2010-01-25 17:42:37 +00:00
|
|
|
struct ebml_attachments attachments = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &attachments,
|
|
|
|
&ebml_attachments_desc) < 0)
|
2011-08-20 18:45:42 +00:00
|
|
|
return -1;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2010-01-25 17:42:37 +00:00
|
|
|
for (int i = 0; i < attachments.n_attached_file; i++) {
|
|
|
|
struct ebml_attached_file *attachment = &attachments.attached_file[i];
|
|
|
|
if (!attachment->n_file_name || !attachment->n_file_mime_type
|
|
|
|
|| !attachment->n_file_data) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Malformed attachment\n");
|
|
|
|
continue;
|
2006-07-07 18:26:51 +00:00
|
|
|
}
|
2010-01-25 17:42:37 +00:00
|
|
|
struct bstr name = attachment->file_name;
|
|
|
|
struct bstr mime = attachment->file_mime_type;
|
2010-05-19 10:44:37 +00:00
|
|
|
demuxer_add_attachment(demuxer, name, mime, attachment->file_data);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Attachment: %.*s, %.*s, %zu bytes\n",
|
|
|
|
BSTR_P(name), BSTR_P(mime), attachment->file_data.len);
|
2006-07-07 18:26:51 +00:00
|
|
|
}
|
|
|
|
|
2010-01-25 17:42:37 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] \\---- [ parsing attachments ] ---------\n");
|
|
|
|
return 0;
|
2006-07-07 18:26:51 +00:00
|
|
|
}
|
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
static int read_header_element(struct demuxer *demuxer, uint32_t id,
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t at_filepos);
|
2010-01-25 10:37:42 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_seekhead(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-01-25 10:37:42 +00:00
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
struct stream *s = demuxer->stream;
|
|
|
|
int res = 0;
|
|
|
|
struct ebml_seek_head seekhead = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = {};
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] /---- [ parsing seek head ] ---------\n");
|
2010-01-25 10:37:42 +00:00
|
|
|
if (ebml_read_element(s, &parse_ctx, &seekhead, &ebml_seek_head_desc) < 0) {
|
2011-08-04 05:38:39 +00:00
|
|
|
res = -1;
|
2010-01-25 10:37:42 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
/* off now holds the position of the next element after the seek head. */
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t off = stream_tell(s);
|
2010-01-25 10:37:42 +00:00
|
|
|
for (int i = 0; i < seekhead.n_seek; i++) {
|
|
|
|
struct ebml_seek *seek = &seekhead.seek[i];
|
|
|
|
if (seek->n_seek_id != 1 || seek->n_seek_position != 1) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Invalid SeekHead entry\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
uint64_t pos = seek->seek_position + mkv_d->segment_start;
|
|
|
|
if (pos >= demuxer->movi_end) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] SeekHead position beyond "
|
|
|
|
"end of file - incomplete file?\n");
|
|
|
|
continue;
|
|
|
|
}
|
2011-08-04 05:38:39 +00:00
|
|
|
int r = read_header_element(demuxer, seek->seek_id, pos);
|
|
|
|
if (r <= -2) {
|
|
|
|
res = r;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-01-25 10:37:42 +00:00
|
|
|
}
|
|
|
|
if (!stream_seek(s, off)) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Couldn't seek back after "
|
|
|
|
"SeekHead??\n");
|
2011-08-04 05:38:39 +00:00
|
|
|
res = -1;
|
2010-01-25 10:37:42 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] \\---- [ parsing seek head ] ---------\n");
|
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
|
|
|
return res;
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2012-11-18 19:46:12 +00:00
|
|
|
static bool seek_pos_id(struct stream *s, int64_t pos, uint32_t id)
|
2010-01-25 10:37:42 +00:00
|
|
|
{
|
|
|
|
if (!stream_seek(s, pos)) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Failed to seek in file\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (ebml_read_id(s, NULL) != id) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Expected element not found\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
static int read_header_element(struct demuxer *demuxer, uint32_t id,
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t at_filepos)
|
2010-01-25 10:37:42 +00:00
|
|
|
{
|
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
2012-11-18 19:46:12 +00:00
|
|
|
int64_t pos = stream_tell(s) - 4;
|
2011-08-20 18:45:42 +00:00
|
|
|
int res = 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
switch(id) {
|
|
|
|
case MATROSKA_ID_INFO:
|
|
|
|
if (mkv_d->parsed_info)
|
2004-01-19 19:16:10 +00:00
|
|
|
break;
|
2010-01-25 10:37:42 +00:00
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n");
|
|
|
|
mkv_d->parsed_info = true;
|
2011-08-04 05:38:39 +00:00
|
|
|
return demux_mkv_read_info(demuxer);
|
2010-01-25 10:37:42 +00:00
|
|
|
|
|
|
|
case MATROSKA_ID_TRACKS:
|
|
|
|
if (mkv_d->parsed_tracks)
|
2004-01-19 19:16:10 +00:00
|
|
|
break;
|
2010-01-25 10:37:42 +00:00
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
|
|
|
mkv_d->parsed_tracks = true;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n");
|
2011-08-20 18:45:42 +00:00
|
|
|
return demux_mkv_read_tracks(demuxer);
|
2010-01-25 10:37:42 +00:00
|
|
|
|
|
|
|
case MATROSKA_ID_CUES:
|
|
|
|
if (is_parsed_header(mkv_d, pos))
|
|
|
|
break;
|
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
2011-08-20 18:45:42 +00:00
|
|
|
return demux_mkv_read_cues(demuxer);
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
case MATROSKA_ID_TAGS:
|
|
|
|
if (mkv_d->parsed_tags)
|
|
|
|
break;
|
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
|
|
|
mkv_d->parsed_tags = true;
|
2011-08-20 18:45:42 +00:00
|
|
|
return demux_mkv_read_tags(demuxer);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
case MATROSKA_ID_SEEKHEAD:
|
|
|
|
if (is_parsed_header(mkv_d, pos))
|
|
|
|
break;
|
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
2011-08-04 05:38:39 +00:00
|
|
|
return demux_mkv_read_seekhead(demuxer);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
case MATROSKA_ID_CHAPTERS:
|
|
|
|
if (mkv_d->parsed_chapters)
|
|
|
|
break;
|
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
|
|
|
mkv_d->parsed_chapters = true;
|
2011-08-20 18:45:42 +00:00
|
|
|
return demux_mkv_read_chapters(demuxer);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
case MATROSKA_ID_ATTACHMENTS:
|
|
|
|
if (mkv_d->parsed_attachments)
|
|
|
|
break;
|
|
|
|
if (at_filepos && !seek_pos_id(s, at_filepos, id))
|
|
|
|
return -1;
|
|
|
|
mkv_d->parsed_attachments = true;
|
2011-08-20 18:45:42 +00:00
|
|
|
return demux_mkv_read_attachments(demuxer);
|
|
|
|
|
|
|
|
case EBML_ID_VOID:
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
default:
|
2011-08-20 18:45:42 +00:00
|
|
|
res = 2;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
demux_mkv: fix skipping broken header elements
Fixes test4.mkv from the Matroska test file collection.
demux_mkv_open() contains a loop that reads header elements. It starts
by reading the EBML element ID with ebml_read_id(). If there is broken
data in the header, ebml_read_id() might return EBML_ID_INVALID.
However, that is not handled specially, and the code for handling
unknown tags is invoked. This reads the EBML element length in order to
skip data, which, if the EBML ID is broken, is entirely random. This
caused a seek beyond the end of the file, making the demuxer fail.
So don't skip any data if the EBML ID was invalid, and simply try to
read the next element. ebml_read_id() reads at least one byte, so the
parsing loop won't get stuck.
All in all this is rather questionable, but since this affects error
situations only, makes behavior a bit more robust (no random seeks), and
actually fixes at least one sample, it's ok.
libavformat's demuxer handled this.
2013-03-27 23:00:39 +00:00
|
|
|
if (!at_filepos && id != EBML_ID_INVALID)
|
2010-01-25 10:37:42 +00:00
|
|
|
ebml_read_skip(s, NULL);
|
2011-08-20 18:45:42 +00:00
|
|
|
return res;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int vid);
|
|
|
|
static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int aid);
|
|
|
|
static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int sid);
|
2006-08-26 19:17:04 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static void display_create_tracks(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
int i, vid = 0, aid = 0, sid = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < mkv_d->num_tracks; i++) {
|
|
|
|
char *type = "unknown", str[32];
|
|
|
|
*str = '\0';
|
|
|
|
switch (mkv_d->tracks[i]->type) {
|
2004-01-19 19:16:10 +00:00
|
|
|
case MATROSKA_TRACK_VIDEO:
|
2009-12-29 19:06:21 +00:00
|
|
|
type = "video";
|
2010-05-22 07:14:41 +00:00
|
|
|
mkv_d->tracks[i]->id = -1;
|
|
|
|
if (vid == MAX_V_STREAMS)
|
|
|
|
break;
|
|
|
|
mkv_d->tracks[i]->id = vid;
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
|
|
|
|
if (mkv_d->tracks[i]->name)
|
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", vid,
|
|
|
|
mkv_d->tracks[i]->name);
|
|
|
|
sprintf(str, "-vid %u", vid++);
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
case MATROSKA_TRACK_AUDIO:
|
2009-12-29 19:06:21 +00:00
|
|
|
type = "audio";
|
2010-05-22 07:14:41 +00:00
|
|
|
mkv_d->tracks[i]->id = -1;
|
|
|
|
if (aid == MAX_A_STREAMS)
|
|
|
|
break;
|
|
|
|
mkv_d->tracks[i]->id = aid;
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
|
|
|
|
if (mkv_d->tracks[i]->name)
|
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", aid,
|
|
|
|
mkv_d->tracks[i]->name);
|
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid,
|
|
|
|
mkv_d->tracks[i]->language);
|
|
|
|
sprintf(str, "-aid %u, -alang %.5s", aid++,
|
|
|
|
mkv_d->tracks[i]->language);
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
case MATROSKA_TRACK_SUBTITLE:
|
2009-12-29 19:06:21 +00:00
|
|
|
type = "subtitles";
|
2010-05-22 07:14:41 +00:00
|
|
|
mkv_d->tracks[i]->id = -1;
|
|
|
|
if (sid == MAX_S_STREAMS)
|
|
|
|
break;
|
|
|
|
mkv_d->tracks[i]->id = sid;
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
|
|
|
|
if (mkv_d->tracks[i]->name)
|
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", sid,
|
|
|
|
mkv_d->tracks[i]->name);
|
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid,
|
|
|
|
mkv_d->tracks[i]->language);
|
|
|
|
sprintf(str, "-sid %u, -slang %.5s", sid++,
|
|
|
|
mkv_d->tracks[i]->language);
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
if (mkv_d->tracks[i]->name)
|
2012-07-29 19:04:57 +00:00
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_V,
|
2009-12-29 19:06:21 +00:00
|
|
|
"[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
|
|
|
|
mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
|
|
|
|
mkv_d->tracks[i]->name, str);
|
|
|
|
else
|
2012-07-29 19:04:57 +00:00
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_V, "[mkv] Track ID %u: %s (%s), %s\n",
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
|
|
|
|
str);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-05-22 07:14:41 +00:00
|
|
|
mkv_d->num_audio_tracks = aid;
|
2011-04-07 23:33:57 +00:00
|
|
|
mkv_d->num_video_tracks = vid;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2007-05-10 13:58:57 +00:00
|
|
|
typedef struct {
|
2009-12-29 19:06:21 +00:00
|
|
|
char *id;
|
|
|
|
int fourcc;
|
|
|
|
int extradata;
|
2007-05-10 13:58:57 +00:00
|
|
|
} videocodec_info_t;
|
|
|
|
|
|
|
|
static const videocodec_info_t vinfo[] = {
|
2010-10-26 22:46:05 +00:00
|
|
|
{MKV_V_MJPEG, mmioFOURCC('m', 'j', 'p', 'g'), 1},
|
2009-12-29 19:06:21 +00:00
|
|
|
{MKV_V_MPEG1, mmioFOURCC('m', 'p', 'g', '1'), 0},
|
|
|
|
{MKV_V_MPEG2, mmioFOURCC('m', 'p', 'g', '2'), 0},
|
|
|
|
{MKV_V_MPEG4_SP, mmioFOURCC('m', 'p', '4', 'v'), 1},
|
|
|
|
{MKV_V_MPEG4_ASP, mmioFOURCC('m', 'p', '4', 'v'), 1},
|
|
|
|
{MKV_V_MPEG4_AP, mmioFOURCC('m', 'p', '4', 'v'), 1},
|
|
|
|
{MKV_V_MPEG4_AVC, mmioFOURCC('a', 'v', 'c', '1'), 1},
|
|
|
|
{MKV_V_THEORA, mmioFOURCC('t', 'h', 'e', 'o'), 1},
|
2010-05-30 14:21:59 +00:00
|
|
|
{MKV_V_VP8, mmioFOURCC('V', 'P', '8', '0'), 0},
|
2009-12-29 19:06:21 +00:00
|
|
|
{NULL, 0, 0}
|
2007-05-10 13:58:57 +00:00
|
|
|
};
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int vid)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
BITMAPINFOHEADER *bih;
|
|
|
|
sh_video_t *sh_v;
|
2013-01-29 23:57:07 +00:00
|
|
|
bool raw = false;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (track->ms_compat) { /* MS compatibility mode */
|
|
|
|
BITMAPINFOHEADER *src;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (track->private_data == NULL
|
2010-09-12 11:44:42 +00:00
|
|
|
|| track->private_size < sizeof(*bih))
|
2009-12-29 19:06:21 +00:00
|
|
|
return 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
src = (BITMAPINFOHEADER *) track->private_data;
|
|
|
|
bih = calloc(1, track->private_size);
|
|
|
|
bih->biSize = le2me_32(src->biSize);
|
|
|
|
bih->biWidth = le2me_32(src->biWidth);
|
|
|
|
bih->biHeight = le2me_32(src->biHeight);
|
|
|
|
bih->biPlanes = le2me_16(src->biPlanes);
|
|
|
|
bih->biBitCount = le2me_16(src->biBitCount);
|
|
|
|
bih->biCompression = le2me_32(src->biCompression);
|
|
|
|
bih->biSizeImage = le2me_32(src->biSizeImage);
|
|
|
|
bih->biXPelsPerMeter = le2me_32(src->biXPelsPerMeter);
|
|
|
|
bih->biYPelsPerMeter = le2me_32(src->biYPelsPerMeter);
|
|
|
|
bih->biClrUsed = le2me_32(src->biClrUsed);
|
|
|
|
bih->biClrImportant = le2me_32(src->biClrImportant);
|
2010-09-12 11:44:42 +00:00
|
|
|
memcpy(bih + 1,
|
|
|
|
src + 1,
|
|
|
|
track->private_size - sizeof(*bih));
|
2009-12-29 19:06:21 +00:00
|
|
|
|
|
|
|
if (track->v_width == 0)
|
|
|
|
track->v_width = bih->biWidth;
|
|
|
|
if (track->v_height == 0)
|
|
|
|
track->v_height = bih->biHeight;
|
|
|
|
} else {
|
2010-09-12 11:44:42 +00:00
|
|
|
bih = calloc(1, sizeof(*bih));
|
|
|
|
bih->biSize = sizeof(*bih);
|
2009-12-29 19:06:21 +00:00
|
|
|
bih->biWidth = track->v_width;
|
|
|
|
bih->biHeight = track->v_height;
|
|
|
|
bih->biBitCount = 24;
|
|
|
|
bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount / 8;
|
|
|
|
|
|
|
|
if (track->private_size >= RVPROPERTIES_SIZE
|
|
|
|
&& (!strcmp(track->codec_id, MKV_V_REALV10)
|
|
|
|
|| !strcmp(track->codec_id, MKV_V_REALV20)
|
|
|
|
|| !strcmp(track->codec_id, MKV_V_REALV30)
|
|
|
|
|| !strcmp(track->codec_id, MKV_V_REALV40))) {
|
|
|
|
unsigned char *dst, *src;
|
|
|
|
uint32_t type2;
|
|
|
|
unsigned int cnt;
|
|
|
|
|
|
|
|
src = (uint8_t *) track->private_data + RVPROPERTIES_SIZE;
|
|
|
|
|
|
|
|
cnt = track->private_size - RVPROPERTIES_SIZE;
|
2010-09-12 11:44:42 +00:00
|
|
|
bih = realloc(bih, sizeof(*bih) + 8 + cnt);
|
2009-12-29 19:06:21 +00:00
|
|
|
bih->biSize = 48 + cnt;
|
|
|
|
bih->biPlanes = 1;
|
|
|
|
type2 = AV_RB32(src - 4);
|
|
|
|
if (type2 == 0x10003000 || type2 == 0x10003001)
|
|
|
|
bih->biCompression = mmioFOURCC('R', 'V', '1', '3');
|
|
|
|
else
|
|
|
|
bih->biCompression =
|
|
|
|
mmioFOURCC('R', 'V', track->codec_id[9], '0');
|
|
|
|
dst = (unsigned char *) (bih + 1);
|
|
|
|
// copy type1 and type2 info from rv properties
|
2010-05-26 05:32:40 +00:00
|
|
|
memcpy(dst, src - 8, 8 + cnt);
|
2009-12-29 19:06:21 +00:00
|
|
|
track->realmedia = 1;
|
2013-01-24 15:57:21 +00:00
|
|
|
} else if (strcmp(track->codec_id, MKV_V_UNCOMPRESSED) == 0) {
|
|
|
|
// raw video, "like AVI" - this is a FourCC
|
|
|
|
bih->biCompression = track->colorspace;
|
2013-01-29 23:57:07 +00:00
|
|
|
raw = true;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else {
|
|
|
|
const videocodec_info_t *vi = vinfo;
|
|
|
|
while (vi->id && strcmp(vi->id, track->codec_id))
|
|
|
|
vi++;
|
|
|
|
bih->biCompression = vi->fourcc;
|
|
|
|
if (vi->extradata && track->private_data
|
|
|
|
&& (track->private_size > 0)) {
|
|
|
|
bih->biSize += track->private_size;
|
|
|
|
bih = realloc(bih, bih->biSize);
|
|
|
|
memcpy(bih + 1, track->private_data, track->private_size);
|
|
|
|
}
|
|
|
|
if (!vi->id) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported "
|
|
|
|
"CodecID (%s) or missing/bad CodecPrivate\n"
|
|
|
|
"[mkv] data (track %u).\n",
|
|
|
|
track->codec_id, track->tnum);
|
|
|
|
free(bih);
|
|
|
|
return 1;
|
2005-01-11 08:30:56 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-22 07:14:41 +00:00
|
|
|
sh_v = new_sh_video(demuxer, vid);
|
2012-08-03 10:24:55 +00:00
|
|
|
sh_v->gsh->demuxer_id = track->tnum;
|
|
|
|
sh_v->gsh->title = talloc_strdup(sh_v, track->name);
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_v->bih = bih;
|
|
|
|
sh_v->format = sh_v->bih->biCompression;
|
2013-01-29 23:57:07 +00:00
|
|
|
if (raw) {
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
sh_v->gsh->codec = "rawvideo";
|
|
|
|
} else {
|
|
|
|
mp_set_video_codec_from_tag(sh_v);
|
|
|
|
sh_v->format = mp_video_fourcc_alias(sh_v->format);
|
2013-01-29 23:57:07 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
if (track->v_frate == 0.0)
|
|
|
|
track->v_frate = 25.0;
|
|
|
|
sh_v->fps = track->v_frate;
|
|
|
|
sh_v->frametime = 1 / track->v_frate;
|
|
|
|
sh_v->aspect = 0;
|
|
|
|
if (!track->realmedia) {
|
|
|
|
sh_v->disp_w = track->v_width;
|
|
|
|
sh_v->disp_h = track->v_height;
|
2013-04-03 23:20:06 +00:00
|
|
|
uint32_t dw = track->v_dwidth_set ? track->v_dwidth : track->v_width;
|
|
|
|
uint32_t dh = track->v_dheight_set ? track->v_dheight : track->v_height;
|
2013-03-27 23:00:04 +00:00
|
|
|
if (dw && dh)
|
|
|
|
sh_v->aspect = (double) dw / dh;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else {
|
|
|
|
// vd_realvid.c will set aspect to disp_w/disp_h and rederive
|
|
|
|
// disp_w and disp_h from the RealVideo stream contents returned
|
|
|
|
// by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
|
|
|
|
// the Matroska file then it has already been set to PixelWidth/Height
|
|
|
|
// by check_track_information.
|
|
|
|
sh_v->disp_w = track->v_dwidth;
|
|
|
|
sh_v->disp_h = track->v_dheight;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Aspect: %f\n", sh_v->aspect);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_v->ds = demuxer->video;
|
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2011-08-20 02:54:27 +00:00
|
|
|
static struct mkv_audio_tag {
|
|
|
|
char *id; bool prefix; uint32_t formattag;
|
|
|
|
} mkv_audio_tags[] = {
|
|
|
|
{ MKV_A_MP2, 0, 0x0055 },
|
|
|
|
{ MKV_A_MP3, 0, 0x0055 },
|
|
|
|
{ MKV_A_AC3, 1, 0x2000 },
|
|
|
|
{ MKV_A_EAC3, 1, mmioFOURCC('E', 'A', 'C', '3') },
|
|
|
|
{ MKV_A_DTS, 0, 0x2001 },
|
|
|
|
{ MKV_A_PCM, 0, 0x0001 },
|
|
|
|
{ MKV_A_PCM_BE, 0, 0x0001 },
|
|
|
|
{ MKV_A_AAC_2MAIN, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_2LC, 1, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_2SSR, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_4MAIN, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_4LC, 1, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_4SSR, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC_4LTP, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_AAC, 0, mmioFOURCC('M', 'P', '4', 'A') },
|
|
|
|
{ MKV_A_VORBIS, 0, mmioFOURCC('v', 'r', 'b', 's') },
|
2013-02-14 12:23:26 +00:00
|
|
|
{ MKV_A_OPUS, 0, mmioFOURCC('O', 'p', 'u', 's') },
|
|
|
|
{ MKV_A_OPUS_EXP, 0, mmioFOURCC('O', 'p', 'u', 's') },
|
2011-08-20 02:54:27 +00:00
|
|
|
{ MKV_A_QDMC, 0, mmioFOURCC('Q', 'D', 'M', 'C') },
|
|
|
|
{ MKV_A_QDMC2, 0, mmioFOURCC('Q', 'D', 'M', '2') },
|
|
|
|
{ MKV_A_WAVPACK, 0, mmioFOURCC('W', 'V', 'P', 'K') },
|
|
|
|
{ MKV_A_TRUEHD, 0, mmioFOURCC('T', 'R', 'H', 'D') },
|
|
|
|
{ MKV_A_FLAC, 0, mmioFOURCC('f', 'L', 'a', 'C') },
|
2013-03-15 06:49:47 +00:00
|
|
|
{ MKV_A_ALAC, 0, mmioFOURCC('a', 'L', 'a', 'C') },
|
2011-08-20 02:54:27 +00:00
|
|
|
{ MKV_A_REAL28, 0, mmioFOURCC('2', '8', '_', '8') },
|
|
|
|
{ MKV_A_REALATRC, 0, mmioFOURCC('a', 't', 'r', 'c') },
|
|
|
|
{ MKV_A_REALCOOK, 0, mmioFOURCC('c', 'o', 'o', 'k') },
|
|
|
|
{ MKV_A_REALDNET, 0, mmioFOURCC('d', 'n', 'e', 't') },
|
|
|
|
{ MKV_A_REALSIPR, 0, mmioFOURCC('s', 'i', 'p', 'r') },
|
2010-04-02 13:00:42 +00:00
|
|
|
{ MKV_A_TTA1, 0, mmioFOURCC('T', 'T', 'A', '1') },
|
2011-08-20 02:54:27 +00:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int aid)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-05-22 07:14:41 +00:00
|
|
|
sh_audio_t *sh_a = new_sh_audio(demuxer, aid);
|
2009-12-29 19:06:21 +00:00
|
|
|
if (!sh_a)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (track->language && (strcmp(track->language, "und") != 0))
|
2013-02-09 14:15:28 +00:00
|
|
|
sh_a->gsh->lang = talloc_strdup(sh_a, track->language);
|
2012-08-03 10:24:55 +00:00
|
|
|
sh_a->gsh->demuxer_id = track->tnum;
|
|
|
|
sh_a->gsh->title = talloc_strdup(sh_a, track->name);
|
|
|
|
sh_a->gsh->default_track = track->default_track;
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->ds = demuxer->audio;
|
2011-08-20 02:54:27 +00:00
|
|
|
if (track->ms_compat) {
|
|
|
|
if (track->private_size < sizeof(*sh_a->wf))
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
WAVEFORMATEX *wf = (WAVEFORMATEX *) track->private_data;
|
2011-08-20 02:54:27 +00:00
|
|
|
sh_a->wf = calloc(1, track->private_size);
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->wFormatTag = le2me_16(wf->wFormatTag);
|
|
|
|
sh_a->wf->nChannels = le2me_16(wf->nChannels);
|
|
|
|
sh_a->wf->nSamplesPerSec = le2me_32(wf->nSamplesPerSec);
|
|
|
|
sh_a->wf->nAvgBytesPerSec = le2me_32(wf->nAvgBytesPerSec);
|
|
|
|
sh_a->wf->nBlockAlign = le2me_16(wf->nBlockAlign);
|
|
|
|
sh_a->wf->wBitsPerSample = le2me_16(wf->wBitsPerSample);
|
2010-09-12 11:44:42 +00:00
|
|
|
sh_a->wf->cbSize = track->private_size - sizeof(*sh_a->wf);
|
2009-12-29 19:06:21 +00:00
|
|
|
memcpy(sh_a->wf + 1, wf + 1,
|
2010-09-12 11:44:42 +00:00
|
|
|
track->private_size - sizeof(*sh_a->wf));
|
2009-12-29 19:06:21 +00:00
|
|
|
if (track->a_sfreq == 0.0)
|
|
|
|
track->a_sfreq = sh_a->wf->nSamplesPerSec;
|
|
|
|
if (track->a_channels == 0)
|
|
|
|
track->a_channels = sh_a->wf->nChannels;
|
|
|
|
if (track->a_bps == 0)
|
|
|
|
track->a_bps = sh_a->wf->wBitsPerSample;
|
|
|
|
track->a_formattag = sh_a->wf->wFormatTag;
|
|
|
|
} else {
|
2011-08-20 02:54:27 +00:00
|
|
|
sh_a->wf = calloc(1, sizeof(*sh_a->wf));
|
|
|
|
for (int i = 0; ; i++) {
|
|
|
|
struct mkv_audio_tag *t = mkv_audio_tags + i;
|
|
|
|
if (t->id == NULL)
|
|
|
|
goto error;
|
|
|
|
if (t->prefix) {
|
2012-07-28 21:47:42 +00:00
|
|
|
if (!bstr_startswith0(bstr0(track->codec_id), t->id))
|
2011-08-20 02:54:27 +00:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if (strcmp(track->codec_id, t->id))
|
|
|
|
continue;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2011-08-20 02:54:27 +00:00
|
|
|
track->a_formattag = t->formattag;
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->format = track->a_formattag;
|
|
|
|
sh_a->wf->wFormatTag = track->a_formattag;
|
|
|
|
sh_a->channels = track->a_channels;
|
|
|
|
sh_a->wf->nChannels = track->a_channels;
|
|
|
|
sh_a->samplerate = (uint32_t) track->a_sfreq;
|
2010-11-21 12:52:08 +00:00
|
|
|
sh_a->container_out_samplerate = track->a_osfreq;
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
|
2012-11-26 02:47:29 +00:00
|
|
|
if (track->a_bps == 0)
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->wBitsPerSample = 16;
|
2012-11-26 02:47:29 +00:00
|
|
|
else
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->wBitsPerSample = track->a_bps;
|
|
|
|
if (track->a_formattag == 0x0055) { /* MP3 || MP2 */
|
|
|
|
sh_a->wf->nAvgBytesPerSec = 16000;
|
|
|
|
sh_a->wf->nBlockAlign = 1152;
|
|
|
|
} else if ((track->a_formattag == 0x2000) /* AC3 */
|
2011-03-30 23:20:02 +00:00
|
|
|
|| track->a_formattag == mmioFOURCC('E', 'A', 'C', '3')
|
2009-12-29 19:06:21 +00:00
|
|
|
|| (track->a_formattag == 0x2001)) { /* DTS */
|
|
|
|
free(sh_a->wf);
|
|
|
|
sh_a->wf = NULL;
|
|
|
|
} else if (track->a_formattag == 0x0001) { /* PCM || PCM_BE */
|
|
|
|
sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate * 2;
|
|
|
|
sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
|
|
|
|
if (!strcmp(track->codec_id, MKV_A_PCM_BE))
|
|
|
|
sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
|
|
|
|
} else if (!strcmp(track->codec_id, MKV_A_QDMC)
|
|
|
|
|| !strcmp(track->codec_id, MKV_A_QDMC2)) {
|
|
|
|
sh_a->wf->nAvgBytesPerSec = 16000;
|
|
|
|
sh_a->wf->nBlockAlign = 1486;
|
|
|
|
track->fix_i_bps = 1;
|
|
|
|
track->qt_last_a_pts = 0.0;
|
2011-08-20 03:00:57 +00:00
|
|
|
goto copy_private_data;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A')) {
|
|
|
|
int profile, srate_idx;
|
|
|
|
|
|
|
|
sh_a->wf->nAvgBytesPerSec = 16000;
|
|
|
|
sh_a->wf->nBlockAlign = 1024;
|
|
|
|
|
2011-08-20 03:00:57 +00:00
|
|
|
if (!strcmp(track->codec_id, MKV_A_AAC) && track->private_data)
|
|
|
|
goto copy_private_data;
|
2005-10-22 10:13:28 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
/* Recreate the 'private data' */
|
|
|
|
/* which faad2 uses in its initialization */
|
|
|
|
srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
|
|
|
|
if (!strncmp(&track->codec_id[12], "MAIN", 4))
|
|
|
|
profile = 0;
|
|
|
|
else if (!strncmp(&track->codec_id[12], "LC", 2))
|
|
|
|
profile = 1;
|
|
|
|
else if (!strncmp(&track->codec_id[12], "SSR", 3))
|
|
|
|
profile = 2;
|
|
|
|
else
|
|
|
|
profile = 3;
|
|
|
|
sh_a->codecdata = malloc(5);
|
|
|
|
sh_a->codecdata[0] = ((profile + 1) << 3) | ((srate_idx & 0xE) >> 1);
|
|
|
|
sh_a->codecdata[1] =
|
|
|
|
((srate_idx & 0x1) << 7) | (track->a_channels << 3);
|
|
|
|
|
|
|
|
if (strstr(track->codec_id, "SBR") != NULL) {
|
|
|
|
/* HE-AAC (aka SBR AAC) */
|
|
|
|
sh_a->codecdata_len = 5;
|
|
|
|
|
|
|
|
sh_a->samplerate *= 2;
|
|
|
|
sh_a->wf->nSamplesPerSec *= 2;
|
|
|
|
srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
|
|
|
|
sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
|
|
|
|
sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
|
|
|
|
sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
|
|
|
|
track->default_duration = 1024.0 / (sh_a->samplerate / 2);
|
|
|
|
} else {
|
|
|
|
sh_a->codecdata_len = 2;
|
|
|
|
track->default_duration = 1024.0 / sh_a->samplerate;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2011-08-20 02:54:27 +00:00
|
|
|
} else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's')) {
|
|
|
|
/* VORBIS */
|
|
|
|
if (track->private_size == 0 || track->ms_compat && !sh_a->wf->cbSize)
|
|
|
|
goto error;
|
|
|
|
if (!track->ms_compat) {
|
|
|
|
sh_a->wf->cbSize = track->private_size;
|
|
|
|
sh_a->wf = realloc(sh_a->wf, sizeof(*sh_a->wf) + sh_a->wf->cbSize);
|
|
|
|
memcpy((unsigned char *) (sh_a->wf + 1), track->private_data,
|
|
|
|
sh_a->wf->cbSize);
|
|
|
|
}
|
2013-02-14 12:23:26 +00:00
|
|
|
} else if (!strcmp(track->codec_id, MKV_A_OPUS)
|
|
|
|
|| !strcmp(track->codec_id, MKV_A_OPUS_EXP)) {
|
|
|
|
sh_a->format = mmioFOURCC('O', 'p', 'u', 's');
|
2011-08-20 02:54:27 +00:00
|
|
|
} else if (!strncmp(track->codec_id, MKV_A_REALATRC, 7)) {
|
|
|
|
if (track->private_size < RAPROPERTIES4_SIZE)
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
/* Common initialization for all RealAudio codecs */
|
|
|
|
unsigned char *src = track->private_data;
|
|
|
|
int codecdata_length, version;
|
|
|
|
int flavor;
|
|
|
|
|
|
|
|
sh_a->wf->nAvgBytesPerSec = 0; /* FIXME !? */
|
|
|
|
|
|
|
|
version = AV_RB16(src + 4);
|
|
|
|
flavor = AV_RB16(src + 22);
|
|
|
|
track->coded_framesize = AV_RB32(src + 24);
|
|
|
|
track->sub_packet_h = AV_RB16(src + 40);
|
|
|
|
sh_a->wf->nBlockAlign = track->audiopk_size = AV_RB16(src + 42);
|
|
|
|
track->sub_packet_size = AV_RB16(src + 44);
|
|
|
|
if (version == 4) {
|
|
|
|
src += RAPROPERTIES4_SIZE;
|
|
|
|
src += src[0] + 1;
|
|
|
|
src += src[0] + 1;
|
|
|
|
} else
|
|
|
|
src += RAPROPERTIES5_SIZE;
|
|
|
|
|
|
|
|
src += 3;
|
|
|
|
if (version == 5)
|
|
|
|
src++;
|
|
|
|
codecdata_length = AV_RB32(src);
|
|
|
|
src += 4;
|
|
|
|
sh_a->wf->cbSize = codecdata_length;
|
2010-09-12 11:44:42 +00:00
|
|
|
sh_a->wf = realloc(sh_a->wf, sizeof(*sh_a->wf) + sh_a->wf->cbSize);
|
2009-12-29 19:06:21 +00:00
|
|
|
memcpy(((char *) (sh_a->wf + 1)), src, codecdata_length);
|
|
|
|
|
|
|
|
switch (track->a_formattag) {
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('a', 't', 'r', 'c'):
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[flavor];
|
|
|
|
sh_a->wf->nBlockAlign = track->sub_packet_size;
|
2011-08-20 02:54:27 +00:00
|
|
|
goto audiobuf;
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('c', 'o', 'o', 'k'):
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->nAvgBytesPerSec = cook_fl2bps[flavor];
|
|
|
|
sh_a->wf->nBlockAlign = track->sub_packet_size;
|
2011-08-20 02:54:27 +00:00
|
|
|
goto audiobuf;
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('s', 'i', 'p', 'r'):
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[flavor];
|
|
|
|
sh_a->wf->nBlockAlign = track->coded_framesize;
|
2011-08-20 02:54:27 +00:00
|
|
|
goto audiobuf;
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('2', '8', '_', '8'):
|
2009-12-29 19:06:21 +00:00
|
|
|
sh_a->wf->nAvgBytesPerSec = 3600;
|
|
|
|
sh_a->wf->nBlockAlign = track->coded_framesize;
|
2011-08-20 02:54:27 +00:00
|
|
|
audiobuf:
|
2009-12-29 19:06:21 +00:00
|
|
|
track->audio_buf =
|
|
|
|
malloc(track->sub_packet_h * track->audiopk_size);
|
|
|
|
track->audio_timestamp =
|
|
|
|
malloc(track->sub_packet_h * sizeof(double));
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
|
|
|
|
track->realmedia = 1;
|
|
|
|
} else if (!strcmp(track->codec_id, MKV_A_FLAC)
|
|
|
|
|| (track->a_formattag == 0xf1ac)) {
|
|
|
|
unsigned char *ptr;
|
|
|
|
int size;
|
|
|
|
free(sh_a->wf);
|
|
|
|
sh_a->wf = NULL;
|
|
|
|
|
2011-08-20 02:54:27 +00:00
|
|
|
if (!track->ms_compat) {
|
2009-12-29 19:06:21 +00:00
|
|
|
ptr = track->private_data;
|
|
|
|
size = track->private_size;
|
|
|
|
} else {
|
|
|
|
sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
|
2010-09-12 11:44:42 +00:00
|
|
|
ptr = track->private_data + sizeof(*sh_a->wf);
|
|
|
|
size = track->private_size - sizeof(*sh_a->wf);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' || ptr[2] != 'a'
|
|
|
|
|| ptr[3] != 'C') {
|
2009-10-17 17:30:49 +00:00
|
|
|
sh_a->codecdata = malloc(4);
|
|
|
|
sh_a->codecdata_len = 4;
|
|
|
|
memcpy(sh_a->codecdata, "fLaC", 4);
|
2009-12-29 19:06:21 +00:00
|
|
|
} else {
|
2009-10-17 17:30:49 +00:00
|
|
|
sh_a->codecdata = malloc(size);
|
|
|
|
sh_a->codecdata_len = size;
|
|
|
|
memcpy(sh_a->codecdata, ptr, size);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2013-03-15 06:49:47 +00:00
|
|
|
} else if (!strcmp(track->codec_id, MKV_A_ALAC)) {
|
|
|
|
if (track->private_size && track->private_size < 10000000) {
|
|
|
|
sh_a->codecdata_len = track->private_size + 12;
|
|
|
|
sh_a->codecdata = malloc(sh_a->codecdata_len);
|
|
|
|
char *data = sh_a->codecdata;
|
|
|
|
AV_WB32(data + 0, sh_a->codecdata_len);
|
|
|
|
memcpy(data + 4, "alac", 4);
|
|
|
|
AV_WB32(data + 8, 0);
|
|
|
|
memcpy(data + 12, track->private_data, track->private_size);
|
|
|
|
}
|
2011-08-20 03:00:57 +00:00
|
|
|
} else if (track->a_formattag == mmioFOURCC('W', 'V', 'P', 'K') ||
|
|
|
|
track->a_formattag == mmioFOURCC('T', 'R', 'H', 'D')) {
|
|
|
|
copy_private_data:
|
|
|
|
if (!track->ms_compat && track->private_size) {
|
|
|
|
sh_a->codecdata = malloc(track->private_size);
|
|
|
|
sh_a->codecdata_len = track->private_size;
|
|
|
|
memcpy(sh_a->codecdata, track->private_data, track->private_size);
|
|
|
|
}
|
2010-04-02 13:00:42 +00:00
|
|
|
} else if (track->a_formattag == mmioFOURCC('T', 'T', 'A', '1')) {
|
|
|
|
sh_a->codecdata_len = 30;
|
|
|
|
sh_a->codecdata = calloc(1, sh_a->codecdata_len);
|
|
|
|
if (!sh_a->codecdata)
|
|
|
|
goto error;
|
|
|
|
char *data = sh_a->codecdata;
|
|
|
|
memcpy(data + 0, "TTA1", 4);
|
|
|
|
AV_WL16(data + 4, 1);
|
|
|
|
AV_WL16(data + 6, sh_a->channels);
|
|
|
|
AV_WL16(data + 8, sh_a->wf->wBitsPerSample);
|
|
|
|
AV_WL32(data + 10, sh_a->samplerate);
|
|
|
|
// Bogus: last frame won't be played.
|
|
|
|
AV_WL32(data + 14, 0);
|
2011-08-20 02:54:27 +00:00
|
|
|
} else if (!track->ms_compat) {
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
mp_set_audio_codec_from_tag(sh_a);
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2011-08-20 02:54:27 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported audio "
|
|
|
|
"codec ID '%s' for track %u or missing/faulty\n[mkv] "
|
|
|
|
"private codec data.\n", track->codec_id, track->tnum);
|
|
|
|
return 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
|
|
|
|
int sid)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2011-03-31 00:23:55 +00:00
|
|
|
if (track->subtitle_type) {
|
2010-01-26 17:40:07 +00:00
|
|
|
int size;
|
2009-12-29 19:06:21 +00:00
|
|
|
uint8_t *buffer;
|
2010-05-22 07:14:41 +00:00
|
|
|
sh_sub_t *sh = new_sh_sub(demuxer, sid);
|
2012-08-03 10:24:55 +00:00
|
|
|
sh->gsh->demuxer_id = track->tnum;
|
2009-12-29 19:06:21 +00:00
|
|
|
track->sh_sub = sh;
|
2011-03-31 00:23:55 +00:00
|
|
|
sh->type = track->subtitle_type;
|
2009-12-29 19:06:21 +00:00
|
|
|
size = track->private_size;
|
2010-01-26 17:40:07 +00:00
|
|
|
demux_mkv_decode(track, track->private_data, &buffer, &size, 2);
|
|
|
|
if (buffer && buffer != track->private_data) {
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(track->private_data);
|
|
|
|
talloc_steal(track, buffer);
|
2009-12-29 19:06:21 +00:00
|
|
|
track->private_data = buffer;
|
|
|
|
track->private_size = size;
|
2008-01-11 21:45:08 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
sh->extradata = malloc(track->private_size);
|
|
|
|
memcpy(sh->extradata, track->private_data, track->private_size);
|
|
|
|
sh->extradata_len = track->private_size;
|
|
|
|
if (track->language && (strcmp(track->language, "und") != 0))
|
2013-02-09 14:15:28 +00:00
|
|
|
sh->gsh->lang = talloc_strdup(sh, track->language);
|
2012-08-03 10:24:55 +00:00
|
|
|
sh->gsh->title = talloc_strdup(sh, track->name);
|
|
|
|
sh->gsh->default_track = track->default_track;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_ERR,
|
|
|
|
"[mkv] Subtitle type '%s' is not supported.\n",
|
|
|
|
track->codec_id);
|
|
|
|
return 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2011-08-04 05:38:39 +00:00
|
|
|
static void mkv_free(struct demuxer *demuxer)
|
|
|
|
{
|
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
if (!mkv_d)
|
|
|
|
return;
|
|
|
|
for (int i = 0; i < mkv_d->num_tracks; i++)
|
|
|
|
demux_mkv_free_trackentry(mkv_d->tracks[i]);
|
|
|
|
free(mkv_d->indexes);
|
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_open(demuxer_t *demuxer)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
stream_t *s = demuxer->stream;
|
|
|
|
mkv_demuxer_t *mkv_d;
|
|
|
|
mkv_track_t *track;
|
|
|
|
|
|
|
|
stream_seek(s, s->start_pos);
|
2010-01-25 00:43:27 +00:00
|
|
|
if (ebml_read_id(s, NULL) != EBML_ID_EBML)
|
|
|
|
return 0;
|
|
|
|
struct ebml_ebml ebml_master = {};
|
|
|
|
struct ebml_parse_ctx parse_ctx = { .no_error_messages = true };
|
|
|
|
if (ebml_read_element(s, &parse_ctx, &ebml_master, &ebml_ebml_desc) < 0)
|
|
|
|
return 0;
|
2010-10-21 19:58:51 +00:00
|
|
|
if (ebml_master.doc_type.start == NULL) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] File has EBML header but no doctype."
|
|
|
|
" Assuming \"matroska\".\n");
|
2012-07-28 21:47:42 +00:00
|
|
|
} else if (bstrcmp(ebml_master.doc_type, bstr0("matroska")) != 0
|
|
|
|
&& bstrcmp(ebml_master.doc_type, bstr0("webm")) != 0) {
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] no head found\n");
|
2010-01-25 00:43:27 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (ebml_master.doc_type_read_version > 2) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
|
|
|
|
"but we don't support format version %"PRIu64"\n",
|
|
|
|
ebml_master.doc_type_read_version);
|
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if ((ebml_master.n_ebml_read_version
|
|
|
|
&& ebml_master.ebml_read_version != EBML_VERSION)
|
|
|
|
|| (ebml_master.n_ebml_max_size_length
|
|
|
|
&& ebml_master.ebml_max_size_length > 8)
|
|
|
|
|| (ebml_master.n_ebml_max_id_length
|
|
|
|
&& ebml_master.ebml_max_id_length != 4)) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
|
|
|
|
"but the header has bad parameters\n");
|
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2009-12-29 19:06:21 +00:00
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2010-01-25 00:43:27 +00:00
|
|
|
talloc_free(parse_ctx.talloc_ctx);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n");
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (ebml_read_id(s, NULL) != MATROSKA_ID_SEGMENT) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n");
|
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
ebml_read_length(s, NULL); /* return bytes number until EOF */
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n");
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-01-25 10:37:42 +00:00
|
|
|
mkv_d = talloc_zero(demuxer, struct mkv_demuxer);
|
2009-12-29 19:06:21 +00:00
|
|
|
demuxer->priv = mkv_d;
|
|
|
|
mkv_d->tc_scale = 1000000;
|
|
|
|
mkv_d->segment_start = stream_tell(s);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2011-08-04 05:38:39 +00:00
|
|
|
while (1) {
|
2010-01-25 10:37:42 +00:00
|
|
|
uint32_t id = ebml_read_id(s, NULL);
|
2011-09-25 15:35:09 +00:00
|
|
|
if (s->eof) {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "[mkv] Unexpected end of file\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2011-08-20 18:45:42 +00:00
|
|
|
if (id == MATROSKA_ID_CLUSTER) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ found cluster, headers are "
|
2009-12-29 19:06:21 +00:00
|
|
|
"parsed completely :)\n");
|
2009-12-31 06:08:50 +00:00
|
|
|
stream_seek(s, stream_tell(s) - 4);
|
2009-12-29 19:06:21 +00:00
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2011-08-20 18:45:42 +00:00
|
|
|
int res = read_header_element(demuxer, id, 0);
|
|
|
|
if (res <= -2)
|
|
|
|
return 0;
|
|
|
|
if (res < 0)
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
display_create_tracks(demuxer);
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
/* select video track */
|
|
|
|
track = NULL;
|
|
|
|
if (demuxer->video->id == -1) { /* automatically select a video track */
|
|
|
|
/* search for a video track that has the 'default' flag set */
|
2011-08-04 05:38:39 +00:00
|
|
|
for (int i = 0; i < mkv_d->num_tracks; i++)
|
2009-12-29 19:06:21 +00:00
|
|
|
if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
|
|
|
|
&& mkv_d->tracks[i]->default_track) {
|
|
|
|
track = mkv_d->tracks[i];
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
|
|
|
|
if (track == NULL)
|
|
|
|
/* no track has the 'default' flag set */
|
|
|
|
/* let's take the first video track */
|
2011-08-04 05:38:39 +00:00
|
|
|
for (int i = 0; i < mkv_d->num_tracks; i++)
|
2010-05-22 07:14:41 +00:00
|
|
|
if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
|
2010-05-24 05:01:04 +00:00
|
|
|
&& mkv_d->tracks[i]->id >= 0) {
|
2009-12-29 19:06:21 +00:00
|
|
|
track = mkv_d->tracks[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (demuxer->video->id != -2) /* -2 = no video at all */
|
2010-05-22 07:14:41 +00:00
|
|
|
track = find_track_by_num(mkv_d, demuxer->video->id,
|
|
|
|
MATROSKA_TRACK_VIDEO);
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2010-05-22 07:14:41 +00:00
|
|
|
if (track && demuxer->v_streams[track->id]) {
|
2012-07-29 19:04:57 +00:00
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_V, "[mkv] Will play video track %u.\n",
|
2009-12-29 19:06:21 +00:00
|
|
|
track->tnum);
|
2010-05-22 07:14:41 +00:00
|
|
|
demuxer->video->id = track->id;
|
|
|
|
demuxer->video->sh = demuxer->v_streams[track->id];
|
2009-12-29 19:06:21 +00:00
|
|
|
} else {
|
|
|
|
mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] No video track found/wanted.\n");
|
|
|
|
demuxer->video->id = -2;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2011-04-02 19:39:01 +00:00
|
|
|
demuxer->audio->id = -2; // wait for higher-level code to select track
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-06-02 16:30:40 +00:00
|
|
|
if (s->end_pos == 0)
|
2009-12-29 19:06:21 +00:00
|
|
|
demuxer->seekable = 0;
|
|
|
|
else {
|
|
|
|
demuxer->movi_start = s->start_pos;
|
|
|
|
demuxer->movi_end = s->end_pos;
|
|
|
|
demuxer->seekable = 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
demuxer->accurate_seek = true;
|
2009-03-19 03:25:12 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
return DEMUXER_TYPE_MATROSKA;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_read_block_lacing(uint8_t *buffer, uint64_t *size,
|
|
|
|
uint8_t *laces,
|
|
|
|
uint32_t **all_lace_sizes)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-10-31 03:14:50 +00:00
|
|
|
uint32_t total = 0;
|
|
|
|
uint32_t *lace_size = NULL;
|
2009-12-29 19:06:21 +00:00
|
|
|
uint8_t flags;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*all_lace_sizes = NULL;
|
|
|
|
/* lacing flags */
|
2010-10-31 03:14:50 +00:00
|
|
|
if (*size < 1)
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
flags = *buffer++;
|
|
|
|
(*size)--;
|
|
|
|
|
|
|
|
switch ((flags & 0x06) >> 1) {
|
|
|
|
case 0: /* no lacing */
|
|
|
|
*laces = 1;
|
|
|
|
lace_size = calloc(*laces, sizeof(uint32_t));
|
|
|
|
lace_size[0] = *size;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1: /* xiph lacing */
|
|
|
|
case 2: /* fixed-size lacing */
|
|
|
|
case 3: /* EBML lacing */
|
2010-10-31 03:14:50 +00:00
|
|
|
if (*size < 1)
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
*laces = *buffer++;
|
|
|
|
(*size)--;
|
|
|
|
(*laces)++;
|
|
|
|
lace_size = calloc(*laces, sizeof(uint32_t));
|
|
|
|
|
|
|
|
switch ((flags & 0x06) >> 1) {
|
|
|
|
case 1: /* xiph lacing */
|
|
|
|
for (i = 0; i < *laces - 1; i++) {
|
|
|
|
lace_size[i] = 0;
|
|
|
|
do {
|
2010-10-31 03:14:50 +00:00
|
|
|
if (!*size)
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
lace_size[i] += *buffer;
|
|
|
|
(*size)--;
|
2004-01-19 19:16:10 +00:00
|
|
|
} while (*buffer++ == 0xFF);
|
2010-10-31 03:14:50 +00:00
|
|
|
if (lace_size[i] > *size - total || total > *size)
|
|
|
|
goto error;
|
2009-12-29 19:06:21 +00:00
|
|
|
total += lace_size[i];
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
lace_size[i] = *size - total;
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
case 2: /* fixed-size lacing */
|
|
|
|
for (i = 0; i < *laces; i++)
|
|
|
|
lace_size[i] = *size / *laces;
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
case 3:; /* EBML lacing */
|
2004-01-19 19:16:10 +00:00
|
|
|
int l;
|
2009-12-29 19:06:21 +00:00
|
|
|
uint64_t num = ebml_read_vlen_uint(buffer, &l);
|
2010-10-31 03:14:50 +00:00
|
|
|
if (num == EBML_UINT_INVALID)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
buffer += l;
|
2010-10-31 03:14:50 +00:00
|
|
|
if (*size < l)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
*size -= l;
|
2010-10-31 03:14:50 +00:00
|
|
|
if (num > *size)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
|
|
|
total = lace_size[0] = num;
|
2009-12-29 19:06:21 +00:00
|
|
|
for (i = 1; i < *laces - 1; i++) {
|
2010-10-31 03:14:50 +00:00
|
|
|
int64_t snum = ebml_read_vlen_int(buffer, &l);
|
|
|
|
if (snum == EBML_INT_INVALID)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
buffer += l;
|
2010-10-31 03:14:50 +00:00
|
|
|
if (*size < l)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
*size -= l;
|
2009-12-29 19:06:21 +00:00
|
|
|
lace_size[i] = lace_size[i - 1] + snum;
|
2010-10-31 03:14:50 +00:00
|
|
|
if (lace_size[i] > *size - total || total > *size)
|
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
total += lace_size[i];
|
2009-12-29 19:06:21 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
lace_size[i] = *size - total;
|
|
|
|
break;
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
*all_lace_sizes = lace_size;
|
|
|
|
return 0;
|
2010-10-31 03:14:50 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
free(lace_size);
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Bad input [lacing]\n");
|
|
|
|
return 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2012-08-18 09:13:58 +00:00
|
|
|
#define SKIP_BITS(n) buffer<<=n
|
|
|
|
#define SHOW_BITS(n) ((buffer)>>(32-(n)))
|
|
|
|
|
|
|
|
static double real_fix_timestamp(unsigned char *buf, unsigned int timestamp, unsigned int format, int64_t *kf_base, int *kf_pts, double *pts){
|
|
|
|
double v_pts;
|
|
|
|
unsigned char *s = buf + 1 + (*buf+1)*8;
|
|
|
|
uint32_t buffer= (s[0]<<24) + (s[1]<<16) + (s[2]<<8) + s[3];
|
|
|
|
unsigned int kf=timestamp;
|
|
|
|
int pict_type;
|
|
|
|
|
|
|
|
if(format==mmioFOURCC('R','V','3','0') || format==mmioFOURCC('R','V','4','0')){
|
|
|
|
if(format==mmioFOURCC('R','V','3','0')){
|
|
|
|
SKIP_BITS(3);
|
|
|
|
pict_type= SHOW_BITS(2);
|
|
|
|
SKIP_BITS(2 + 7);
|
|
|
|
}else{
|
|
|
|
SKIP_BITS(1);
|
|
|
|
pict_type= SHOW_BITS(2);
|
|
|
|
SKIP_BITS(2 + 7 + 3);
|
|
|
|
}
|
|
|
|
kf= SHOW_BITS(13); // kf= 2*SHOW_BITS(12);
|
|
|
|
// if(pict_type==0)
|
|
|
|
if(pict_type<=1){
|
|
|
|
// I frame, sync timestamps:
|
|
|
|
*kf_base=(int64_t)timestamp-kf;
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_DBG2,"\nTS: base=%08"PRIX64"\n",*kf_base);
|
|
|
|
kf=timestamp;
|
|
|
|
} else {
|
|
|
|
// P/B frame, merge timestamps:
|
|
|
|
int64_t tmp=(int64_t)timestamp-*kf_base;
|
|
|
|
kf|=tmp&(~0x1fff); // combine with packet timestamp
|
|
|
|
if(kf<tmp-4096) kf+=8192; else // workaround wrap-around problems
|
|
|
|
if(kf>tmp+4096) kf-=8192;
|
|
|
|
kf+=*kf_base;
|
|
|
|
}
|
|
|
|
if(pict_type != 3){ // P || I frame -> swap timestamps
|
|
|
|
unsigned int tmp=kf;
|
|
|
|
kf=*kf_pts;
|
|
|
|
*kf_pts=tmp;
|
|
|
|
// if(kf<=tmp) kf=0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
v_pts=kf*0.001f;
|
|
|
|
// if(pts && (v_pts<*pts || !kf)) v_pts=*pts+frametime;
|
|
|
|
if(pts) *pts=v_pts;
|
|
|
|
return v_pts;
|
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static void handle_realvideo(demuxer_t *demuxer, mkv_track_t *track,
|
2012-07-24 21:23:27 +00:00
|
|
|
uint8_t *buffer, uint32_t size, bool keyframe)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
demux_packet_t *dp;
|
|
|
|
uint32_t timestamp = mkv_d->last_pts * 1000;
|
|
|
|
|
|
|
|
dp = new_demux_packet(size);
|
|
|
|
memcpy(dp->buffer, buffer, size);
|
|
|
|
|
|
|
|
if (mkv_d->v_skip_to_keyframe) {
|
|
|
|
dp->pts = mkv_d->last_pts;
|
|
|
|
track->rv_kf_base = 0;
|
|
|
|
track->rv_kf_pts = timestamp;
|
|
|
|
} else
|
|
|
|
dp->pts =
|
|
|
|
real_fix_timestamp(dp->buffer, timestamp,
|
|
|
|
((sh_video_t *) demuxer->video->sh)->bih->
|
|
|
|
biCompression, &track->rv_kf_base,
|
|
|
|
&track->rv_kf_pts, NULL);
|
|
|
|
dp->pos = demuxer->filepos;
|
2012-07-24 21:23:27 +00:00
|
|
|
dp->keyframe = keyframe;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
|
|
|
ds_add_packet(demuxer->video, dp);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static void handle_realaudio(demuxer_t *demuxer, mkv_track_t *track,
|
2012-07-24 21:23:27 +00:00
|
|
|
uint8_t *buffer, uint32_t size, bool keyframe)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
int sps = track->sub_packet_size;
|
|
|
|
int sph = track->sub_packet_h;
|
|
|
|
int cfs = track->coded_framesize;
|
|
|
|
int w = track->audiopk_size;
|
|
|
|
int spc = track->sub_packet_cnt;
|
|
|
|
demux_packet_t *dp;
|
|
|
|
int x;
|
|
|
|
|
|
|
|
if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8'))
|
|
|
|
|| (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k'))
|
|
|
|
|| (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c'))
|
|
|
|
|| (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r'))) {
|
2006-04-03 19:41:17 +00:00
|
|
|
// if(!block_bref)
|
|
|
|
// spc = track->sub_packet_cnt = 0;
|
2009-12-29 19:06:21 +00:00
|
|
|
switch (track->a_formattag) {
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('2', '8', '_', '8'):
|
2009-12-29 19:06:21 +00:00
|
|
|
for (x = 0; x < sph / 2; x++)
|
|
|
|
memcpy(track->audio_buf + x * 2 * w + spc * cfs,
|
|
|
|
buffer + cfs * x, cfs);
|
|
|
|
break;
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('c', 'o', 'o', 'k'):
|
|
|
|
case mmioFOURCC('a', 't', 'r', 'c'):
|
2009-12-29 19:06:21 +00:00
|
|
|
for (x = 0; x < w / sps; x++)
|
|
|
|
memcpy(track->audio_buf +
|
|
|
|
sps * (sph * x + ((sph + 1) / 2) * (spc & 1) +
|
|
|
|
(spc >> 1)), buffer + sps * x, sps);
|
|
|
|
break;
|
2006-04-03 19:41:17 +00:00
|
|
|
case mmioFOURCC('s', 'i', 'p', 'r'):
|
2009-12-29 19:06:21 +00:00
|
|
|
memcpy(track->audio_buf + spc * w, buffer, w);
|
|
|
|
if (spc == sph - 1) {
|
|
|
|
int n;
|
|
|
|
int bs = sph * w * 2 / 96; // nibbles per subpacket
|
|
|
|
// Perform reordering
|
|
|
|
for (n = 0; n < 38; n++) {
|
|
|
|
int j;
|
|
|
|
int i = bs * sipr_swaps[n][0];
|
|
|
|
int o = bs * sipr_swaps[n][1];
|
|
|
|
// swap nibbles of block 'i' with 'o' TODO: optimize
|
|
|
|
for (j = 0; j < bs; j++) {
|
|
|
|
int x = (i & 1) ?
|
|
|
|
(track->audio_buf[i >> 1] >> 4) :
|
|
|
|
(track->audio_buf[i >> 1] & 0x0F);
|
|
|
|
int y = (o & 1) ?
|
|
|
|
(track->audio_buf[o >> 1] >> 4) :
|
|
|
|
(track->audio_buf[o >> 1] & 0x0F);
|
|
|
|
if (o & 1)
|
|
|
|
track->audio_buf[o >> 1] =
|
|
|
|
(track->audio_buf[o >> 1] & 0x0F) | (x << 4);
|
|
|
|
else
|
|
|
|
track->audio_buf[o >> 1] =
|
|
|
|
(track->audio_buf[o >> 1] & 0xF0) | x;
|
|
|
|
if (i & 1)
|
|
|
|
track->audio_buf[i >> 1] =
|
|
|
|
(track->audio_buf[i >> 1] & 0x0F) | (y << 4);
|
|
|
|
else
|
|
|
|
track->audio_buf[i >> 1] =
|
|
|
|
(track->audio_buf[i >> 1] & 0xF0) | y;
|
|
|
|
++i;
|
|
|
|
++o;
|
2006-04-03 19:41:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
track->audio_timestamp[track->sub_packet_cnt] =
|
|
|
|
(track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
|
|
|
|
track->ra_pts = mkv_d->last_pts;
|
|
|
|
if (track->sub_packet_cnt == 0)
|
|
|
|
track->audio_filepos = demuxer->filepos;
|
|
|
|
if (++(track->sub_packet_cnt) == sph) {
|
|
|
|
int apk_usize =
|
2010-09-12 11:44:42 +00:00
|
|
|
((sh_audio_t *) demuxer->audio->sh)->wf->nBlockAlign;
|
2009-12-29 19:06:21 +00:00
|
|
|
track->sub_packet_cnt = 0;
|
|
|
|
// Release all the audio packets
|
|
|
|
for (x = 0; x < sph * w / apk_usize; x++) {
|
|
|
|
dp = new_demux_packet(apk_usize);
|
|
|
|
memcpy(dp->buffer, track->audio_buf + x * apk_usize,
|
|
|
|
apk_usize);
|
|
|
|
/* Put timestamp only on packets that correspond to original
|
|
|
|
* audio packets in file */
|
|
|
|
dp->pts = (x * apk_usize % w) ? 0 :
|
|
|
|
track->audio_timestamp[x * apk_usize / w];
|
|
|
|
dp->pos = track->audio_filepos; // all equal
|
2012-07-24 21:23:27 +00:00
|
|
|
dp->keyframe = !x; // Mark first packet as keyframe
|
2009-12-29 19:06:21 +00:00
|
|
|
ds_add_packet(demuxer->audio, dp);
|
|
|
|
}
|
2006-04-03 19:41:17 +00:00
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
} else { // Not a codec that require reordering
|
|
|
|
dp = new_demux_packet(size);
|
|
|
|
memcpy(dp->buffer, buffer, size);
|
|
|
|
if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
|
|
|
|
dp->pts = 0;
|
|
|
|
else
|
|
|
|
dp->pts = mkv_d->last_pts;
|
|
|
|
track->ra_pts = mkv_d->last_pts;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
dp->pos = demuxer->filepos;
|
2012-07-24 21:23:27 +00:00
|
|
|
dp->keyframe = keyframe;
|
2009-12-29 19:06:21 +00:00
|
|
|
ds_add_packet(demuxer->audio, dp);
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2013-04-11 19:42:46 +00:00
|
|
|
struct block_info {
|
|
|
|
uint64_t length;
|
|
|
|
uint64_t duration;
|
|
|
|
bool simple, keyframe;
|
2013-04-11 23:26:02 +00:00
|
|
|
uint64_t timecode;
|
|
|
|
mkv_track_t *track;
|
2013-04-11 19:42:46 +00:00
|
|
|
uint8_t *data;
|
2013-04-11 23:26:02 +00:00
|
|
|
void *alloc;
|
2013-04-11 19:42:46 +00:00
|
|
|
};
|
|
|
|
|
2013-04-11 22:43:34 +00:00
|
|
|
static void free_block(struct block_info *block)
|
2013-04-11 19:42:46 +00:00
|
|
|
{
|
2013-04-11 23:26:02 +00:00
|
|
|
free(block->alloc);
|
|
|
|
block->data = block->alloc = NULL;
|
2013-04-11 19:42:46 +00:00
|
|
|
}
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
static void index_block(demuxer_t *demuxer, struct block_info *block)
|
|
|
|
{
|
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
if (block->keyframe) {
|
|
|
|
add_block_position(demuxer, block->track, mkv_d->cluster_start,
|
|
|
|
block->timecode / mkv_d->tc_scale);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-11 19:42:46 +00:00
|
|
|
static int read_block(demuxer_t *demuxer, struct block_info *block)
|
|
|
|
{
|
2013-04-11 23:26:02 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
2013-04-11 19:42:46 +00:00
|
|
|
stream_t *s = demuxer->stream;
|
2013-04-11 23:26:02 +00:00
|
|
|
int tmp, num;
|
|
|
|
int16_t time;
|
|
|
|
int res = -1;
|
2013-04-11 19:42:46 +00:00
|
|
|
|
2013-04-11 22:43:34 +00:00
|
|
|
free_block(block);
|
2013-04-11 19:42:46 +00:00
|
|
|
block->length = ebml_read_length(s, NULL);
|
|
|
|
if (block->length > 500000000)
|
2013-04-11 23:26:02 +00:00
|
|
|
goto exit;
|
|
|
|
block->data = block->alloc = malloc(block->length + AV_LZO_INPUT_PADDING);
|
2013-04-11 19:42:46 +00:00
|
|
|
demuxer->filepos = stream_tell(s);
|
|
|
|
if (stream_read(s, block->data, block->length) != (int) block->length)
|
2013-04-11 23:26:02 +00:00
|
|
|
goto exit;
|
2013-04-11 22:43:34 +00:00
|
|
|
|
2013-04-11 23:26:02 +00:00
|
|
|
// Parse header of the Block element
|
|
|
|
/* first byte(s): track num */
|
|
|
|
num = ebml_read_vlen_uint(block->data, &tmp);
|
|
|
|
block->data += tmp;
|
|
|
|
/* time (relative to cluster time) */
|
|
|
|
time = block->data[0] << 8 | block->data[1];
|
|
|
|
block->data += 2;
|
|
|
|
block->length -= tmp + 2;
|
|
|
|
if (block->simple)
|
|
|
|
block->keyframe = block->data[0] & 0x80;
|
|
|
|
block->timecode = time * mkv_d->tc_scale + mkv_d->cluster_tc;
|
|
|
|
for (int i = 0; i < mkv_d->num_tracks; i++) {
|
|
|
|
if (mkv_d->tracks[i]->tnum == num) {
|
|
|
|
block->track = mkv_d->tracks[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!block->track) {
|
|
|
|
res = 0;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = 1;
|
|
|
|
exit:
|
|
|
|
if (res <= 0)
|
|
|
|
free_block(block);
|
|
|
|
return res;
|
2013-04-11 19:42:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int handle_block(demuxer_t *demuxer, struct block_info *block_info)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
demux_stream_t *ds = NULL;
|
|
|
|
uint64_t old_length;
|
|
|
|
uint32_t *lace_size;
|
2013-04-11 23:26:02 +00:00
|
|
|
uint8_t laces;
|
|
|
|
int i, use_this_block = 1;
|
2009-12-29 19:06:21 +00:00
|
|
|
double current_pts;
|
2013-04-11 19:42:46 +00:00
|
|
|
uint8_t *block = block_info->data;
|
|
|
|
uint64_t length = block_info->length;
|
|
|
|
bool keyframe = block_info->keyframe;
|
|
|
|
uint64_t block_duration = block_info->duration;
|
2013-04-11 23:26:02 +00:00
|
|
|
uint64_t tc = block_info->timecode;
|
|
|
|
mkv_track_t *track = block_info->track;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
|
|
|
old_length = length;
|
|
|
|
if (demux_mkv_read_block_lacing(block, &length, &laces, &lace_size))
|
|
|
|
return 0;
|
|
|
|
block += old_length - length;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2011-01-23 22:29:01 +00:00
|
|
|
current_pts = tc / 1e9;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-05-22 07:14:41 +00:00
|
|
|
if (track->type == MATROSKA_TRACK_AUDIO
|
|
|
|
&& track->id == demuxer->audio->id) {
|
2009-12-29 19:06:21 +00:00
|
|
|
ds = demuxer->audio;
|
|
|
|
|
2012-07-24 21:23:27 +00:00
|
|
|
if (mkv_d->a_skip_to_keyframe)
|
|
|
|
use_this_block = keyframe;
|
2010-11-15 16:18:21 +00:00
|
|
|
if (mkv_d->v_skip_to_keyframe)
|
2006-09-25 21:17:43 +00:00
|
|
|
use_this_block = 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (track->fix_i_bps && use_this_block) {
|
|
|
|
sh_audio_t *sh = (sh_audio_t *) ds->sh;
|
|
|
|
|
|
|
|
if (block_duration != 0) {
|
2011-01-23 22:29:01 +00:00
|
|
|
sh->i_bps = length * 1e9 / block_duration;
|
2009-12-29 19:06:21 +00:00
|
|
|
track->fix_i_bps = 0;
|
|
|
|
} else if (track->qt_last_a_pts == 0.0)
|
|
|
|
track->qt_last_a_pts = current_pts;
|
|
|
|
else if (track->qt_last_a_pts != current_pts) {
|
|
|
|
sh->i_bps = length / (current_pts - track->qt_last_a_pts);
|
|
|
|
track->fix_i_bps = 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
2013-04-03 23:43:14 +00:00
|
|
|
} else if (track->type == MATROSKA_TRACK_SUBTITLE
|
|
|
|
&& track->id == demuxer->sub->id) {
|
|
|
|
if (tc < mkv_d->skip_to_timecode && !mkv_d->subtitle_preroll)
|
|
|
|
use_this_block = 0;
|
|
|
|
if (use_this_block) {
|
|
|
|
ds = demuxer->sub;
|
|
|
|
if (laces > 1) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Subtitles use Matroska "
|
|
|
|
"lacing. This is abnormal and not supported.\n");
|
|
|
|
use_this_block = 0;
|
|
|
|
}
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
} else if (tc < mkv_d->skip_to_timecode)
|
|
|
|
use_this_block = 0;
|
2010-05-22 07:14:41 +00:00
|
|
|
else if (track->type == MATROSKA_TRACK_VIDEO
|
|
|
|
&& track->id == demuxer->video->id) {
|
2009-12-29 19:06:21 +00:00
|
|
|
ds = demuxer->video;
|
2012-07-24 21:23:27 +00:00
|
|
|
if (mkv_d->v_skip_to_keyframe)
|
|
|
|
use_this_block = keyframe;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else
|
|
|
|
use_this_block = 0;
|
|
|
|
|
|
|
|
if (use_this_block) {
|
|
|
|
mkv_d->last_pts = current_pts;
|
|
|
|
mkv_d->last_filepos = demuxer->filepos;
|
|
|
|
|
|
|
|
for (i = 0; i < laces; i++) {
|
|
|
|
if (ds == demuxer->video && track->realmedia)
|
|
|
|
handle_realvideo(demuxer, track, block, lace_size[i],
|
2012-07-24 21:23:27 +00:00
|
|
|
keyframe);
|
2009-12-29 19:06:21 +00:00
|
|
|
else if (ds == demuxer->audio && track->realmedia)
|
|
|
|
handle_realaudio(demuxer, track, block, lace_size[i],
|
2012-07-24 21:23:27 +00:00
|
|
|
keyframe);
|
2009-12-29 19:06:21 +00:00
|
|
|
else {
|
2010-01-26 17:40:07 +00:00
|
|
|
int size = lace_size[i];
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_packet_t *dp;
|
|
|
|
uint8_t *buffer;
|
2010-01-26 17:40:07 +00:00
|
|
|
demux_mkv_decode(track, block, &buffer, &size, 1);
|
2009-12-29 19:06:21 +00:00
|
|
|
if (buffer) {
|
|
|
|
dp = new_demux_packet(size);
|
|
|
|
memcpy(dp->buffer, buffer, size);
|
2010-01-26 17:40:07 +00:00
|
|
|
if (buffer != block)
|
2010-03-21 16:36:47 +00:00
|
|
|
talloc_free(buffer);
|
2012-07-24 21:23:27 +00:00
|
|
|
dp->keyframe = keyframe;
|
2009-12-29 19:06:21 +00:00
|
|
|
/* If default_duration is 0, assume no pts value is known
|
|
|
|
* for packets after the first one (rather than all pts
|
|
|
|
* values being the same) */
|
|
|
|
if (i == 0 || track->default_duration)
|
|
|
|
dp->pts =
|
|
|
|
mkv_d->last_pts + i * track->default_duration;
|
2011-03-31 00:06:21 +00:00
|
|
|
dp->duration = block_duration / 1e9;
|
2009-12-29 19:06:21 +00:00
|
|
|
ds_add_packet(ds, dp);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
block += lace_size[i];
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (ds == demuxer->video) {
|
|
|
|
mkv_d->v_skip_to_keyframe = 0;
|
|
|
|
mkv_d->skip_to_timecode = 0;
|
2013-04-03 23:43:14 +00:00
|
|
|
mkv_d->subtitle_preroll = false;
|
2009-12-29 19:06:21 +00:00
|
|
|
} else if (ds == demuxer->audio)
|
|
|
|
mkv_d->a_skip_to_keyframe = 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
free(lace_size);
|
|
|
|
return 1;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
free(lace_size);
|
|
|
|
return 0;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
static int read_block_group(demuxer_t *demuxer, int64_t end,
|
|
|
|
struct block_info *block)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
2013-04-11 22:43:34 +00:00
|
|
|
*block = (struct block_info){ .keyframe = true };
|
2013-04-11 21:33:42 +00:00
|
|
|
|
|
|
|
while (stream_tell(s) < end) {
|
|
|
|
switch (ebml_read_id(s, NULL)) {
|
|
|
|
case MATROSKA_ID_BLOCKDURATION:
|
|
|
|
block->duration = ebml_read_uint(s, NULL);
|
|
|
|
if (block->duration == EBML_UINT_INVALID)
|
2013-04-11 22:43:34 +00:00
|
|
|
goto error;
|
2013-04-11 21:33:42 +00:00
|
|
|
block->duration *= mkv_d->tc_scale;
|
|
|
|
break;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
case MATROSKA_ID_BLOCK:
|
|
|
|
if (read_block(demuxer, block) < 0)
|
2013-04-11 22:43:34 +00:00
|
|
|
goto error;
|
2013-04-11 21:33:42 +00:00
|
|
|
break;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
case MATROSKA_ID_REFERENCEBLOCK:;
|
|
|
|
int64_t num = ebml_read_int(s, NULL);
|
|
|
|
if (num == EBML_INT_INVALID)
|
2013-04-11 22:43:34 +00:00
|
|
|
goto error;
|
2013-04-11 21:33:42 +00:00
|
|
|
if (num)
|
|
|
|
block->keyframe = false;
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
case EBML_ID_INVALID:
|
2013-04-11 22:43:34 +00:00
|
|
|
goto error;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
default:
|
|
|
|
if (ebml_read_skip_or_resync_cluster(s, NULL) != 0)
|
2013-04-11 22:43:34 +00:00
|
|
|
goto error;
|
2013-04-11 21:33:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-11 22:43:34 +00:00
|
|
|
return block->data ? 1 : 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
free_block(block);
|
|
|
|
return -1;
|
2013-04-11 21:33:42 +00:00
|
|
|
}
|
2004-02-09 19:21:08 +00:00
|
|
|
|
2013-04-11 22:43:34 +00:00
|
|
|
static int read_next_block(demuxer_t *demuxer, struct block_info *block)
|
2013-04-11 21:33:42 +00:00
|
|
|
{
|
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
|
|
|
stream_t *s = demuxer->stream;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
while (1) {
|
|
|
|
while (stream_tell(s) < mkv_d->cluster_end) {
|
2013-04-12 12:57:06 +00:00
|
|
|
int64_t start_filepos = stream_tell(s);
|
|
|
|
switch (ebml_read_id(s, NULL)) {
|
|
|
|
case MATROSKA_ID_TIMECODE: {
|
|
|
|
uint64_t num = ebml_read_uint(s, NULL);
|
|
|
|
if (num == EBML_UINT_INVALID)
|
|
|
|
goto find_next_cluster;
|
|
|
|
mkv_d->cluster_tc = num * mkv_d->tc_scale;
|
|
|
|
break;
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-12 12:57:06 +00:00
|
|
|
case MATROSKA_ID_BLOCKGROUP: {
|
|
|
|
int64_t end = ebml_read_length(s, NULL);
|
|
|
|
end += stream_tell(s);
|
|
|
|
int res = read_block_group(demuxer, end, block);
|
|
|
|
if (res < 0)
|
|
|
|
goto find_next_cluster;
|
|
|
|
if (res > 0)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-12 12:57:06 +00:00
|
|
|
case MATROSKA_ID_SIMPLEBLOCK: {
|
|
|
|
*block = (struct block_info){ .simple = true };
|
|
|
|
int res = read_block(demuxer, block);
|
|
|
|
if (res < 0)
|
|
|
|
goto find_next_cluster;
|
|
|
|
if (res > 0)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
}
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2013-04-12 12:57:06 +00:00
|
|
|
case MATROSKA_ID_CLUSTER:
|
|
|
|
mkv_d->cluster_start = start_filepos;
|
|
|
|
goto next_cluster;
|
2013-04-11 21:28:27 +00:00
|
|
|
|
2013-04-12 12:57:06 +00:00
|
|
|
case EBML_ID_INVALID:
|
|
|
|
goto find_next_cluster;
|
2004-02-09 19:21:08 +00:00
|
|
|
|
2013-04-12 12:57:06 +00:00
|
|
|
default: ;
|
|
|
|
if (ebml_read_skip_or_resync_cluster(s, NULL) != 0)
|
|
|
|
goto find_next_cluster;
|
|
|
|
break;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
demux_mkv: improve robustness against broken files
Fixes test7.mkv from the Matroska test file collection, as well as some
real broken files I've found in the wild. (Unfortunately, true recovery
requires resetting the decoders and playback state with a manual seek,
but it's still better than just exiting.)
If there are broken EBML elements, try harder to skip them correctly.
Do this by searching for the next cluster element. The cluster element
intentionally has a long ID, so it's a suitable element for
resynchronizing (mkvmerge does something similar).
We know that data is corrupt if the ID or length fields of an element
are malformed. Additionally, if skipping an unknown element goes past
the end of the file, we assume it's corrupt and undo the seek. Do this
because it often happens that corrupt data is interpreted as correct
EBML elements. Since these elements will have a ridiculous values in
their length fields due to the large value range that is possible
(0-2^56-2), they will go past the end of the file. So instead of
skipping them (which would result in playback termination), try to
find the next cluster instead. (We still skip unknown elements that
are within the file, as this is needed for correct operation. Also, we
first execute the seek, because we don't really know where the file
ends. Doing it this way is better for unseekable streams too, because
it will still work in the non-error case.)
This is done as special case in the packet reading function only. On
the other hand, that's the only part of the file that's read after
initialization is done.
2013-03-27 23:01:17 +00:00
|
|
|
find_next_cluster:
|
2013-04-11 21:33:42 +00:00
|
|
|
mkv_d->cluster_end = 0;
|
demux_mkv: improve robustness against broken files
Fixes test7.mkv from the Matroska test file collection, as well as some
real broken files I've found in the wild. (Unfortunately, true recovery
requires resetting the decoders and playback state with a manual seek,
but it's still better than just exiting.)
If there are broken EBML elements, try harder to skip them correctly.
Do this by searching for the next cluster element. The cluster element
intentionally has a long ID, so it's a suitable element for
resynchronizing (mkvmerge does something similar).
We know that data is corrupt if the ID or length fields of an element
are malformed. Additionally, if skipping an unknown element goes past
the end of the file, we assume it's corrupt and undo the seek. Do this
because it often happens that corrupt data is interpreted as correct
EBML elements. Since these elements will have a ridiculous values in
their length fields due to the large value range that is possible
(0-2^56-2), they will go past the end of the file. So instead of
skipping them (which would result in playback termination), try to
find the next cluster instead. (We still skip unknown elements that
are within the file, as this is needed for correct operation. Also, we
first execute the seek, because we don't really know where the file
ends. Doing it this way is better for unseekable streams too, because
it will still work in the non-error case.)
This is done as special case in the packet reading function only. On
the other hand, that's the only part of the file that's read after
initialization is done.
2013-03-27 23:01:17 +00:00
|
|
|
for (;;) {
|
2013-04-11 18:31:58 +00:00
|
|
|
mkv_d->cluster_start = stream_tell(s);
|
|
|
|
uint32_t id = ebml_read_id(s, NULL);
|
demux_mkv: improve robustness against broken files
Fixes test7.mkv from the Matroska test file collection, as well as some
real broken files I've found in the wild. (Unfortunately, true recovery
requires resetting the decoders and playback state with a manual seek,
but it's still better than just exiting.)
If there are broken EBML elements, try harder to skip them correctly.
Do this by searching for the next cluster element. The cluster element
intentionally has a long ID, so it's a suitable element for
resynchronizing (mkvmerge does something similar).
We know that data is corrupt if the ID or length fields of an element
are malformed. Additionally, if skipping an unknown element goes past
the end of the file, we assume it's corrupt and undo the seek. Do this
because it often happens that corrupt data is interpreted as correct
EBML elements. Since these elements will have a ridiculous values in
their length fields due to the large value range that is possible
(0-2^56-2), they will go past the end of the file. So instead of
skipping them (which would result in playback termination), try to
find the next cluster instead. (We still skip unknown elements that
are within the file, as this is needed for correct operation. Also, we
first execute the seek, because we don't really know where the file
ends. Doing it this way is better for unseekable streams too, because
it will still work in the non-error case.)
This is done as special case in the packet reading function only. On
the other hand, that's the only part of the file that's read after
initialization is done.
2013-03-27 23:01:17 +00:00
|
|
|
if (id == MATROSKA_ID_CLUSTER)
|
|
|
|
break;
|
2010-01-25 11:27:35 +00:00
|
|
|
if (s->eof)
|
2013-04-11 22:43:34 +00:00
|
|
|
return -1;
|
2013-03-30 19:43:06 +00:00
|
|
|
ebml_read_skip_or_resync_cluster(s, NULL);
|
2010-01-25 11:27:35 +00:00
|
|
|
}
|
2013-04-11 21:28:27 +00:00
|
|
|
next_cluster:
|
2013-04-11 18:31:58 +00:00
|
|
|
mkv_d->cluster_end = ebml_read_length(s, NULL);
|
2013-04-11 21:28:27 +00:00
|
|
|
// mkv files for "streaming" can have this legally
|
|
|
|
if (mkv_d->cluster_end != EBML_UINT_INVALID)
|
|
|
|
mkv_d->cluster_end += stream_tell(s);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
2013-04-11 22:43:34 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2013-04-11 22:43:34 +00:00
|
|
|
static int demux_mkv_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
|
|
|
|
{
|
|
|
|
for (;;) {
|
|
|
|
int res;
|
|
|
|
struct block_info block;
|
|
|
|
res = read_next_block(demuxer, &block);
|
|
|
|
if (res < 0)
|
|
|
|
return 0;
|
|
|
|
if (res > 0) {
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
index_block(demuxer, &block);
|
2013-04-11 22:43:34 +00:00
|
|
|
res = handle_block(demuxer, &block);
|
|
|
|
free_block(&block);
|
|
|
|
if (res > 0)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
static mkv_index_t *get_highest_index_entry(struct demuxer *demuxer)
|
|
|
|
{
|
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
assert(!mkv_d->index_complete); // would require separate code
|
|
|
|
|
|
|
|
mkv_index_t *index = NULL;
|
|
|
|
for (int n = 0; n < mkv_d->num_tracks; n++) {
|
|
|
|
int n_index = mkv_d->tracks[n]->last_index_entry;
|
|
|
|
if (n_index >= 0) {
|
|
|
|
mkv_index_t *index2 = &mkv_d->indexes[n_index];
|
|
|
|
if (!index || index2->filepos > index->filepos)
|
|
|
|
index = index2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
static int create_index_until(struct demuxer *demuxer, uint64_t timecode)
|
2010-11-08 02:27:09 +00:00
|
|
|
{
|
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
struct stream *s = demuxer->stream;
|
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
if (mkv_d->index_complete)
|
|
|
|
return 0;
|
|
|
|
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
mkv_index_t *index = get_highest_index_entry(demuxer);
|
|
|
|
|
|
|
|
if (!index || index->timecode * mkv_d->tc_scale < timecode) {
|
|
|
|
int64_t old_filepos = stream_tell(s);
|
|
|
|
int64_t old_cluster_start = mkv_d->cluster_start;
|
|
|
|
int64_t old_cluster_end = mkv_d->cluster_end;
|
|
|
|
uint64_t old_cluster_tc = mkv_d->cluster_tc;
|
|
|
|
if (index)
|
|
|
|
stream_seek(s, index->filepos);
|
2013-04-11 15:40:23 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V,
|
|
|
|
"[mkv] creating index until TC %" PRIu64 "\n", timecode);
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
for (;;) {
|
|
|
|
int res;
|
|
|
|
struct block_info block;
|
|
|
|
res = read_next_block(demuxer, &block);
|
|
|
|
if (res < 0)
|
|
|
|
break;
|
|
|
|
if (res > 0) {
|
|
|
|
index_block(demuxer, &block);
|
|
|
|
free_block(&block);
|
2010-11-08 02:27:09 +00:00
|
|
|
}
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
index = get_highest_index_entry(demuxer);
|
|
|
|
if (index && index->timecode * mkv_d->tc_scale >= timecode)
|
2010-11-08 02:43:48 +00:00
|
|
|
break;
|
2010-11-08 02:27:09 +00:00
|
|
|
}
|
demux_mkv: fix seeking with index generation
Relative seeks backwards didn't work too well with incomplete files, or
other files that are missing the seek index. The problem was that the
on-the-fly seek index generation simply added cluster positions as seek
entries. While this is perfectly fine, the seek code had no information
about the location of video key frames. For example, a 5 second long
cluster can have only 1 video key frame, which is located 4 seconds into
the cluster. Seeking backwards by one second while still located in the
same cluster would select this cluster as seek target again. Decoding
would resume with the key frame, giving the impression that seeking is
"stuck" at this frame.
Make the generated index aware of key frame and track information, so
that video can always be seeked in an idea way. This also uses the
normal block parsing code for indexing the clusters, instead of the
suspicious looking special code. (This code didn't parse the Matroska
elements correctly, but was fine for files with normal structure. Files
with corrupted clusters or clusters formatted for streaming were not
handled properly.)
Skipping is now quite a bit slower (takes about twice as long as
before), but it removes the special cased skipping code, and it's still
much faster (at least twice as fast) than libavformat. It needs to do
more I/O (no more skipping entire clusters, all data is read), and has
more CPU usage (more data needs to be parsed).
2013-04-12 00:22:23 +00:00
|
|
|
stream_seek(s, old_filepos);
|
|
|
|
mkv_d->cluster_start = old_cluster_start;
|
|
|
|
mkv_d->cluster_end = old_cluster_end;
|
|
|
|
mkv_d->cluster_tc = old_cluster_tc;
|
2010-11-08 02:27:09 +00:00
|
|
|
}
|
2013-04-11 15:40:23 +00:00
|
|
|
if (!mkv_d->indexes) {
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] no target for seek found\n");
|
2010-11-08 02:27:09 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-08 03:43:35 +00:00
|
|
|
static struct mkv_index *seek_with_cues(struct demuxer *demuxer, int seek_id,
|
|
|
|
int64_t target_timecode, int flags)
|
|
|
|
{
|
|
|
|
struct mkv_demuxer *mkv_d = demuxer->priv;
|
|
|
|
struct mkv_index *index = NULL;
|
|
|
|
|
2010-12-20 00:26:10 +00:00
|
|
|
/* Find the entry in the index closest to the target timecode in the
|
|
|
|
* give direction. If there are no such entries - we're trying to seek
|
|
|
|
* backward from a target time before the first entry or forward from a
|
|
|
|
* target time after the last entry - then still seek to the first/last
|
|
|
|
* entry if that's further in the direction wanted than mkv_d->last_pts.
|
|
|
|
*/
|
2011-01-23 22:29:01 +00:00
|
|
|
int64_t min_diff = target_timecode - (int64_t)(mkv_d->last_pts * 1e9 + 0.5);
|
2010-12-20 00:26:10 +00:00
|
|
|
if (flags & SEEK_BACKWARD)
|
|
|
|
min_diff = -min_diff;
|
|
|
|
min_diff = FFMAX(min_diff, 1);
|
2013-04-03 23:43:14 +00:00
|
|
|
|
2010-11-08 03:43:35 +00:00
|
|
|
for (int i = 0; i < mkv_d->num_indexes; i++)
|
|
|
|
if (seek_id < 0 || mkv_d->indexes[i].tnum == seek_id) {
|
2010-11-15 15:48:22 +00:00
|
|
|
int64_t diff =
|
2010-11-08 03:43:35 +00:00
|
|
|
target_timecode -
|
2011-01-23 22:29:01 +00:00
|
|
|
(int64_t) (mkv_d->indexes[i].timecode * mkv_d->tc_scale);
|
2010-12-20 00:26:10 +00:00
|
|
|
if (flags & SEEK_BACKWARD)
|
|
|
|
diff = -diff;
|
|
|
|
if (diff <= 0) {
|
|
|
|
if (min_diff <= 0 && diff <= min_diff)
|
2010-11-08 03:43:35 +00:00
|
|
|
continue;
|
2010-12-20 00:26:10 +00:00
|
|
|
} else if (diff >= min_diff)
|
|
|
|
continue;
|
2010-11-08 03:43:35 +00:00
|
|
|
min_diff = diff;
|
|
|
|
index = mkv_d->indexes + i;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index) { /* We've found an entry. */
|
2013-04-03 23:43:14 +00:00
|
|
|
uint64_t seek_pos = index->filepos;
|
2013-04-04 13:24:04 +00:00
|
|
|
if (mkv_d->subtitle_preroll) {
|
2013-04-03 23:43:14 +00:00
|
|
|
uint64_t prev_target = 0;
|
|
|
|
for (int i = 0; i < mkv_d->num_indexes; i++) {
|
|
|
|
if (seek_id < 0 || mkv_d->indexes[i].tnum == seek_id) {
|
|
|
|
uint64_t index_pos = mkv_d->indexes[i].filepos;
|
|
|
|
if (index_pos > prev_target && index_pos < seek_pos)
|
|
|
|
prev_target = index_pos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (prev_target)
|
|
|
|
seek_pos = prev_target;
|
|
|
|
}
|
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
mkv_d->cluster_end = 0;
|
2013-04-03 23:43:14 +00:00
|
|
|
stream_seek(demuxer->stream, seek_pos);
|
2010-11-08 03:43:35 +00:00
|
|
|
}
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static void demux_mkv_seek(demuxer_t *demuxer, float rel_seek_secs,
|
|
|
|
float audio_delay, int flags)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2010-05-22 07:14:41 +00:00
|
|
|
mkv_demuxer_t *mkv_d = demuxer->priv;
|
|
|
|
uint64_t v_tnum = -1;
|
|
|
|
if (demuxer->video->id >= 0)
|
|
|
|
v_tnum = find_track_by_num(mkv_d, demuxer->video->id,
|
2010-05-31 18:34:38 +00:00
|
|
|
MATROSKA_TRACK_VIDEO)->tnum;
|
2010-05-22 07:14:41 +00:00
|
|
|
uint64_t a_tnum = -1;
|
|
|
|
if (demuxer->audio->id >= 0)
|
|
|
|
a_tnum = find_track_by_num(mkv_d, demuxer->audio->id,
|
2010-05-31 18:34:38 +00:00
|
|
|
MATROSKA_TRACK_AUDIO)->tnum;
|
2013-04-04 13:24:04 +00:00
|
|
|
mkv_d->subtitle_preroll = (flags & SEEK_SUBPREROLL) && demuxer->sub->id >= 0;
|
2009-03-19 03:25:12 +00:00
|
|
|
if (!(flags & (SEEK_BACKWARD | SEEK_FORWARD))) {
|
|
|
|
if (flags & SEEK_ABSOLUTE || rel_seek_secs < 0)
|
|
|
|
flags |= SEEK_BACKWARD;
|
|
|
|
else
|
|
|
|
flags |= SEEK_FORWARD;
|
|
|
|
}
|
2009-03-31 16:30:14 +00:00
|
|
|
// Adjust the target a little bit to catch cases where the target position
|
|
|
|
// specifies a keyframe with high, but not perfect, precision.
|
2009-07-09 15:23:35 +00:00
|
|
|
rel_seek_secs += flags & SEEK_FORWARD ? -0.005 : 0.005;
|
2009-03-31 16:30:14 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (!(flags & SEEK_FACTOR)) { /* time in secs */
|
|
|
|
mkv_index_t *index = NULL;
|
|
|
|
|
|
|
|
if (!(flags & SEEK_ABSOLUTE)) /* relative seek */
|
2010-11-08 03:18:48 +00:00
|
|
|
rel_seek_secs += mkv_d->last_pts;
|
2011-01-23 22:29:01 +00:00
|
|
|
rel_seek_secs = FFMAX(rel_seek_secs, 0);
|
|
|
|
int64_t target_timecode = rel_seek_secs * 1e9 + 0.5;
|
2009-12-29 19:06:21 +00:00
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
if (create_index_until(demuxer, target_timecode) >= 0) {
|
2009-12-29 19:06:21 +00:00
|
|
|
int seek_id = (demuxer->video->id < 0) ?
|
2010-05-22 07:14:41 +00:00
|
|
|
a_tnum : v_tnum;
|
2010-11-08 03:43:35 +00:00
|
|
|
index = seek_with_cues(demuxer, seek_id, target_timecode, flags);
|
|
|
|
if (!index)
|
|
|
|
index = seek_with_cues(demuxer, -1, target_timecode, flags);
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (demuxer->video->id >= 0)
|
|
|
|
mkv_d->v_skip_to_keyframe = 1;
|
|
|
|
if (flags & SEEK_FORWARD)
|
|
|
|
mkv_d->skip_to_timecode = target_timecode;
|
|
|
|
else
|
2011-01-23 22:29:01 +00:00
|
|
|
mkv_d->skip_to_timecode = index ? index->timecode * mkv_d->tc_scale
|
|
|
|
: 0;
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_d->a_skip_to_keyframe = 1;
|
|
|
|
|
|
|
|
demux_mkv_fill_buffer(demuxer, NULL);
|
|
|
|
} else if ((demuxer->movi_end <= 0) || !(flags & SEEK_ABSOLUTE))
|
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
|
|
|
|
else {
|
|
|
|
stream_t *s = demuxer->stream;
|
|
|
|
uint64_t target_filepos;
|
|
|
|
mkv_index_t *index = NULL;
|
|
|
|
int i;
|
|
|
|
|
2013-04-11 15:40:23 +00:00
|
|
|
if (!mkv_d->index_complete) { /* not implemented without index */
|
2009-12-29 19:06:21 +00:00
|
|
|
mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
|
|
|
|
return;
|
2004-03-26 19:45:06 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
target_filepos = (uint64_t) (demuxer->movi_end * rel_seek_secs);
|
|
|
|
for (i = 0; i < mkv_d->num_indexes; i++)
|
2010-05-22 07:14:41 +00:00
|
|
|
if (mkv_d->indexes[i].tnum == v_tnum)
|
2009-12-29 19:06:21 +00:00
|
|
|
if ((index == NULL)
|
|
|
|
|| ((mkv_d->indexes[i].filepos >= target_filepos)
|
|
|
|
&& ((index->filepos < target_filepos)
|
|
|
|
|| (mkv_d->indexes[i].filepos < index->filepos))))
|
|
|
|
index = &mkv_d->indexes[i];
|
2004-03-26 19:45:06 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (!index)
|
|
|
|
return;
|
2004-03-26 19:45:06 +00:00
|
|
|
|
2013-04-11 21:33:42 +00:00
|
|
|
mkv_d->cluster_end = 0;
|
2009-12-29 19:06:21 +00:00
|
|
|
stream_seek(s, index->filepos);
|
2004-03-26 19:45:06 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
if (demuxer->video->id >= 0)
|
|
|
|
mkv_d->v_skip_to_keyframe = 1;
|
2011-01-23 22:29:01 +00:00
|
|
|
mkv_d->skip_to_timecode = index->timecode * mkv_d->tc_scale;
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_d->a_skip_to_keyframe = 1;
|
2004-03-26 19:45:06 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_mkv_fill_buffer(demuxer, NULL);
|
2004-03-26 19:45:06 +00:00
|
|
|
}
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
static int demux_mkv_control(demuxer_t *demuxer, int cmd, void *arg)
|
2004-01-19 19:16:10 +00:00
|
|
|
{
|
2009-12-29 19:06:21 +00:00
|
|
|
mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
switch (cmd) {
|
2008-02-03 12:14:29 +00:00
|
|
|
case DEMUXER_CTRL_CORRECT_PTS:
|
2009-12-29 19:06:21 +00:00
|
|
|
return DEMUXER_CTRL_OK;
|
2004-01-19 19:16:10 +00:00
|
|
|
case DEMUXER_CTRL_GET_TIME_LENGTH:
|
2009-12-29 19:06:21 +00:00
|
|
|
if (mkv_d->duration == 0)
|
|
|
|
return DEMUXER_CTRL_DONTKNOW;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2009-12-29 19:06:21 +00:00
|
|
|
*((double *) arg) = (double) mkv_d->duration;
|
|
|
|
return DEMUXER_CTRL_OK;
|
2004-01-19 19:16:10 +00:00
|
|
|
|
2010-05-22 07:38:55 +00:00
|
|
|
case DEMUXER_CTRL_SWITCH_AUDIO:;
|
|
|
|
int new_aid = *(int *) arg;
|
|
|
|
int current_aid = demuxer->audio->id;
|
|
|
|
if (current_aid < 0)
|
|
|
|
current_aid = -1;
|
2011-08-19 23:43:51 +00:00
|
|
|
if (new_aid == -1) { // cycle to next
|
|
|
|
new_aid = current_aid;
|
|
|
|
while (1) {
|
|
|
|
new_aid = (new_aid + 2) % (mkv_d->num_audio_tracks + 1) - 1;
|
|
|
|
if (new_aid == -1 || demuxer->a_streams[new_aid])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (new_aid < 0 || new_aid >= mkv_d->num_audio_tracks ||
|
|
|
|
!demuxer->a_streams[new_aid])
|
2010-05-22 07:38:55 +00:00
|
|
|
new_aid = -2;
|
|
|
|
*(int *) arg = new_aid;
|
|
|
|
if (current_aid != new_aid)
|
|
|
|
ds_free_packs(demuxer->audio);
|
|
|
|
demuxer->audio->id = new_aid;
|
2009-12-29 19:06:21 +00:00
|
|
|
return DEMUXER_CTRL_OK;
|
2005-04-13 22:33:19 +00:00
|
|
|
|
2011-04-07 23:33:57 +00:00
|
|
|
case DEMUXER_CTRL_SWITCH_VIDEO:;
|
|
|
|
int new_vid = *(int *) arg;
|
|
|
|
int current_vid = demuxer->video->id;
|
|
|
|
if (current_vid < 0)
|
|
|
|
current_vid = -1;
|
2011-08-19 23:43:51 +00:00
|
|
|
if (new_vid == -1) { // cycle to next
|
|
|
|
new_vid = current_vid;
|
|
|
|
while (1) {
|
|
|
|
new_vid = (new_vid + 2) % (mkv_d->num_video_tracks + 1) - 1;
|
|
|
|
if (new_vid == -1 || demuxer->v_streams[new_vid])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (new_vid < 0 || new_vid >= mkv_d->num_video_tracks ||
|
|
|
|
!demuxer->v_streams[new_vid])
|
2011-04-07 23:33:57 +00:00
|
|
|
new_vid = -2;
|
|
|
|
*(int *) arg = new_vid;
|
|
|
|
if (current_vid != new_vid)
|
|
|
|
ds_free_packs(demuxer->video);
|
|
|
|
demuxer->video->id = new_vid;
|
|
|
|
return DEMUXER_CTRL_OK;
|
|
|
|
|
2004-01-19 19:16:10 +00:00
|
|
|
default:
|
2009-12-29 19:06:21 +00:00
|
|
|
return DEMUXER_CTRL_NOTIMPL;
|
2004-01-19 19:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-13 16:00:39 +00:00
|
|
|
const demuxer_desc_t demuxer_desc_matroska = {
|
2009-12-29 19:06:21 +00:00
|
|
|
"Matroska demuxer",
|
|
|
|
"mkv",
|
|
|
|
"Matroska",
|
|
|
|
"Aurelien Jacobs",
|
|
|
|
"",
|
|
|
|
DEMUXER_TYPE_MATROSKA,
|
|
|
|
1, // safe autodetect
|
|
|
|
demux_mkv_open,
|
|
|
|
demux_mkv_fill_buffer,
|
|
|
|
NULL,
|
2011-08-04 05:38:39 +00:00
|
|
|
mkv_free,
|
2009-12-29 19:06:21 +00:00
|
|
|
demux_mkv_seek,
|
|
|
|
demux_mkv_control
|
2005-08-05 19:57:47 +00:00
|
|
|
};
|