2007-06-05 00:10:54 +02:00
|
|
|
/*
|
2008-08-05 02:42:43 +02:00
|
|
|
* Matroska file demuxer
|
2008-08-05 10:28:57 +02:00
|
|
|
* Copyright (c) 2003-2008 The FFmpeg Project
|
2007-06-05 00:10:54 +02:00
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2010-04-20 16:45:34 +02:00
|
|
|
* @file
|
2007-06-05 00:10:54 +02:00
|
|
|
* Matroska file demuxer
|
2011-10-30 19:10:50 +01:00
|
|
|
* @author Ronald Bultje <rbultje@ronald.bitfreak.net>
|
|
|
|
* @author with a little help from Moritz Bunkus <moritz@bunkus.org>
|
|
|
|
* @author totally reworked by Aurelien Jacobs <aurel@gnuage.org>
|
|
|
|
* @see specs available on the Matroska project page: http://www.matroska.org/
|
2007-06-05 00:10:54 +02:00
|
|
|
*/
|
|
|
|
|
2008-09-05 01:26:12 +02:00
|
|
|
#include <stdio.h>
|
2007-06-05 00:10:54 +02:00
|
|
|
#include "avformat.h"
|
2010-04-11 23:44:23 +02:00
|
|
|
#include "internal.h"
|
2011-02-20 11:04:13 +01:00
|
|
|
#include "avio_internal.h"
|
2009-06-23 01:09:34 +02:00
|
|
|
/* For ff_codec_get_id(). */
|
2007-06-05 00:10:54 +02:00
|
|
|
#include "riff.h"
|
2008-07-27 17:11:04 +02:00
|
|
|
#include "isom.h"
|
2010-03-13 00:49:06 +01:00
|
|
|
#include "rm.h"
|
2007-06-05 00:10:54 +02:00
|
|
|
#include "matroska.h"
|
2008-04-02 23:41:48 +02:00
|
|
|
#include "libavcodec/mpeg4audio.h"
|
2011-11-27 15:04:16 +01:00
|
|
|
#include "libavutil/intfloat.h"
|
2009-01-11 23:19:48 +01:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2008-08-05 02:39:47 +02:00
|
|
|
#include "libavutil/avstring.h"
|
2008-05-09 03:53:59 +02:00
|
|
|
#include "libavutil/lzo.h"
|
2011-05-22 12:46:29 +02:00
|
|
|
#include "libavutil/dict.h"
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_ZLIB
|
2008-05-14 01:32:13 +02:00
|
|
|
#include <zlib.h>
|
|
|
|
#endif
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_BZLIB
|
2008-05-16 01:12:41 +02:00
|
|
|
#include <bzlib.h>
|
|
|
|
#endif
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:00 +02:00
|
|
|
typedef enum {
|
|
|
|
EBML_NONE,
|
|
|
|
EBML_UINT,
|
|
|
|
EBML_FLOAT,
|
|
|
|
EBML_STR,
|
|
|
|
EBML_UTF8,
|
|
|
|
EBML_BIN,
|
|
|
|
EBML_NEST,
|
|
|
|
EBML_PASS,
|
|
|
|
EBML_STOP,
|
2011-02-06 11:32:03 +01:00
|
|
|
EBML_TYPE_COUNT
|
2008-08-05 02:40:00 +02:00
|
|
|
} EbmlType;
|
|
|
|
|
|
|
|
typedef const struct EbmlSyntax {
|
|
|
|
uint32_t id;
|
|
|
|
EbmlType type;
|
|
|
|
int list_elem_size;
|
|
|
|
int data_offset;
|
|
|
|
union {
|
|
|
|
uint64_t u;
|
|
|
|
double f;
|
|
|
|
const char *s;
|
|
|
|
const struct EbmlSyntax *n;
|
|
|
|
} def;
|
|
|
|
} EbmlSyntax;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int nb_elem;
|
|
|
|
void *elem;
|
|
|
|
} EbmlList;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int size;
|
|
|
|
uint8_t *data;
|
|
|
|
int64_t pos;
|
|
|
|
} EbmlBin;
|
|
|
|
|
2008-08-05 02:40:02 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t version;
|
|
|
|
uint64_t max_size;
|
|
|
|
uint64_t id_length;
|
|
|
|
char *doctype;
|
|
|
|
uint64_t doctype_version;
|
|
|
|
} Ebml;
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t algo;
|
|
|
|
EbmlBin settings;
|
|
|
|
} MatroskaTrackCompression;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t scope;
|
|
|
|
uint64_t type;
|
|
|
|
MatroskaTrackCompression compression;
|
|
|
|
} MatroskaTrackEncoding;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
typedef struct {
|
|
|
|
double frame_rate;
|
|
|
|
uint64_t display_width;
|
|
|
|
uint64_t display_height;
|
|
|
|
uint64_t pixel_width;
|
|
|
|
uint64_t pixel_height;
|
2011-06-14 02:00:06 +02:00
|
|
|
EbmlBin color_space;
|
2011-05-24 01:09:24 +02:00
|
|
|
uint64_t stereo_mode;
|
2008-08-05 02:40:31 +02:00
|
|
|
} MatroskaTrackVideo;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
typedef struct {
|
|
|
|
double samplerate;
|
|
|
|
double out_samplerate;
|
|
|
|
uint64_t bitdepth;
|
|
|
|
uint64_t channels;
|
|
|
|
|
|
|
|
/* real audio header (extracted from extradata) */
|
|
|
|
int coded_framesize;
|
|
|
|
int sub_packet_h;
|
|
|
|
int frame_size;
|
|
|
|
int sub_packet_size;
|
|
|
|
int sub_packet_cnt;
|
|
|
|
int pkt_cnt;
|
2011-02-26 12:52:01 +01:00
|
|
|
uint64_t buf_timecode;
|
2008-08-05 02:40:31 +02:00
|
|
|
uint8_t *buf;
|
|
|
|
} MatroskaTrackAudio;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-05-21 17:14:14 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t uid;
|
|
|
|
uint64_t type;
|
|
|
|
} MatroskaTrackPlane;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
EbmlList combine_planes;
|
|
|
|
} MatroskaTrackOperation;
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t num;
|
2009-02-15 16:34:22 +01:00
|
|
|
uint64_t uid;
|
2008-08-05 02:40:31 +02:00
|
|
|
uint64_t type;
|
2009-02-15 16:29:09 +01:00
|
|
|
char *name;
|
2008-08-05 02:40:31 +02:00
|
|
|
char *codec_id;
|
|
|
|
EbmlBin codec_priv;
|
|
|
|
char *language;
|
2008-06-01 15:54:11 +02:00
|
|
|
double time_scale;
|
2007-06-05 00:10:54 +02:00
|
|
|
uint64_t default_duration;
|
2008-08-05 02:39:53 +02:00
|
|
|
uint64_t flag_default;
|
2010-07-02 18:38:44 +02:00
|
|
|
uint64_t flag_forced;
|
2008-08-05 02:40:31 +02:00
|
|
|
MatroskaTrackVideo video;
|
|
|
|
MatroskaTrackAudio audio;
|
2011-05-21 17:14:14 +02:00
|
|
|
MatroskaTrackOperation operation;
|
2008-08-05 02:40:31 +02:00
|
|
|
EbmlList encodings;
|
2008-08-05 02:40:06 +02:00
|
|
|
|
|
|
|
AVStream *stream;
|
2008-09-09 14:07:10 +02:00
|
|
|
int64_t end_timecode;
|
2010-03-03 22:46:43 +01:00
|
|
|
int ms_compat;
|
2007-06-05 00:10:54 +02:00
|
|
|
} MatroskaTrack;
|
|
|
|
|
2008-08-05 02:40:24 +02:00
|
|
|
typedef struct {
|
2009-02-15 16:34:22 +01:00
|
|
|
uint64_t uid;
|
2008-08-05 02:40:24 +02:00
|
|
|
char *filename;
|
|
|
|
char *mime;
|
|
|
|
EbmlBin bin;
|
2009-02-15 16:53:55 +01:00
|
|
|
|
|
|
|
AVStream *stream;
|
2008-08-05 02:40:24 +02:00
|
|
|
} MatroskaAttachement;
|
|
|
|
|
2008-08-05 02:40:21 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t start;
|
|
|
|
uint64_t end;
|
|
|
|
uint64_t uid;
|
|
|
|
char *title;
|
2009-02-15 16:25:14 +01:00
|
|
|
|
|
|
|
AVChapter *chapter;
|
2008-08-05 02:40:21 +02:00
|
|
|
} MatroskaChapter;
|
|
|
|
|
2008-08-05 02:40:15 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t track;
|
|
|
|
uint64_t pos;
|
|
|
|
} MatroskaIndexPos;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint64_t time;
|
|
|
|
EbmlList pos;
|
|
|
|
} MatroskaIndex;
|
|
|
|
|
2008-08-09 01:50:38 +02:00
|
|
|
typedef struct {
|
|
|
|
char *name;
|
|
|
|
char *string;
|
2009-02-15 17:05:37 +01:00
|
|
|
char *lang;
|
|
|
|
uint64_t def;
|
2008-08-09 01:50:38 +02:00
|
|
|
EbmlList sub;
|
|
|
|
} MatroskaTag;
|
|
|
|
|
2009-02-15 16:53:55 +01:00
|
|
|
typedef struct {
|
|
|
|
char *type;
|
|
|
|
uint64_t typevalue;
|
|
|
|
uint64_t trackuid;
|
|
|
|
uint64_t chapteruid;
|
|
|
|
uint64_t attachuid;
|
|
|
|
} MatroskaTagTarget;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
MatroskaTagTarget target;
|
|
|
|
EbmlList tag;
|
|
|
|
} MatroskaTags;
|
|
|
|
|
2008-08-05 02:40:36 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t id;
|
|
|
|
uint64_t pos;
|
|
|
|
} MatroskaSeekhead;
|
|
|
|
|
2008-08-05 02:41:19 +02:00
|
|
|
typedef struct {
|
2007-06-05 00:35:16 +02:00
|
|
|
uint64_t start;
|
|
|
|
uint64_t length;
|
2007-06-05 00:10:54 +02:00
|
|
|
} MatroskaLevel;
|
|
|
|
|
2012-04-19 20:12:24 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t timecode;
|
|
|
|
EbmlList blocks;
|
|
|
|
} MatroskaCluster;
|
|
|
|
|
2008-08-05 02:41:19 +02:00
|
|
|
typedef struct {
|
2007-06-05 00:10:54 +02:00
|
|
|
AVFormatContext *ctx;
|
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* EBML stuff */
|
2007-06-05 00:10:54 +02:00
|
|
|
int num_levels;
|
|
|
|
MatroskaLevel levels[EBML_MAX_DEPTH];
|
|
|
|
int level_up;
|
2010-06-11 18:34:01 +02:00
|
|
|
uint32_t current_id;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:27 +02:00
|
|
|
uint64_t time_scale;
|
|
|
|
double duration;
|
|
|
|
char *title;
|
2012-03-05 19:02:48 +01:00
|
|
|
EbmlBin date_utc;
|
2008-08-05 02:40:31 +02:00
|
|
|
EbmlList tracks;
|
2008-08-05 02:40:24 +02:00
|
|
|
EbmlList attachments;
|
2008-08-05 02:40:21 +02:00
|
|
|
EbmlList chapters;
|
2008-08-05 02:40:15 +02:00
|
|
|
EbmlList index;
|
2008-08-09 01:50:38 +02:00
|
|
|
EbmlList tags;
|
2008-08-05 02:40:36 +02:00
|
|
|
EbmlList seekhead;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
/* byte position of the segment inside the stream */
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t segment_start;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* the packet queue */
|
2007-06-05 00:10:54 +02:00
|
|
|
AVPacket **packets;
|
|
|
|
int num_packets;
|
2008-09-29 01:06:25 +02:00
|
|
|
AVPacket *prev_pkt;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2007-06-05 00:35:16 +02:00
|
|
|
int done;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
/* What to skip before effectively reading a packet. */
|
|
|
|
int skip_to_keyframe;
|
2008-09-09 14:01:51 +02:00
|
|
|
uint64_t skip_to_timecode;
|
2011-07-09 07:48:43 +02:00
|
|
|
|
|
|
|
/* File has a CUES element, but we defer parsing until it is needed. */
|
|
|
|
int cues_parsing_deferred;
|
2012-04-19 20:12:24 +02:00
|
|
|
|
|
|
|
int current_cluster_num_blocks;
|
|
|
|
int64_t current_cluster_pos;
|
|
|
|
MatroskaCluster current_cluster;
|
|
|
|
|
|
|
|
/* File has SSA subtitles which prevent incremental cluster parsing. */
|
|
|
|
int contains_ssa;
|
2007-06-05 00:10:54 +02:00
|
|
|
} MatroskaDemuxContext;
|
|
|
|
|
2008-08-05 02:41:05 +02:00
|
|
|
typedef struct {
|
|
|
|
uint64_t duration;
|
|
|
|
int64_t reference;
|
2009-08-10 20:06:14 +02:00
|
|
|
uint64_t non_simple;
|
2008-08-05 02:41:05 +02:00
|
|
|
EbmlBin bin;
|
|
|
|
} MatroskaBlock;
|
|
|
|
|
2008-08-05 02:40:02 +02:00
|
|
|
static EbmlSyntax ebml_header[] = {
|
|
|
|
{ EBML_ID_EBMLREADVERSION, EBML_UINT, 0, offsetof(Ebml,version), {.u=EBML_VERSION} },
|
|
|
|
{ EBML_ID_EBMLMAXSIZELENGTH, EBML_UINT, 0, offsetof(Ebml,max_size), {.u=8} },
|
|
|
|
{ EBML_ID_EBMLMAXIDLENGTH, EBML_UINT, 0, offsetof(Ebml,id_length), {.u=4} },
|
|
|
|
{ EBML_ID_DOCTYPE, EBML_STR, 0, offsetof(Ebml,doctype), {.s="(none)"} },
|
|
|
|
{ EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, offsetof(Ebml,doctype_version), {.u=1} },
|
|
|
|
{ EBML_ID_EBMLVERSION, EBML_NONE },
|
|
|
|
{ EBML_ID_DOCTYPEVERSION, EBML_NONE },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax ebml_syntax[] = {
|
|
|
|
{ EBML_ID_HEADER, EBML_NEST, 0, 0, {.n=ebml_header} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:27 +02:00
|
|
|
static EbmlSyntax matroska_info[] = {
|
|
|
|
{ MATROSKA_ID_TIMECODESCALE, EBML_UINT, 0, offsetof(MatroskaDemuxContext,time_scale), {.u=1000000} },
|
|
|
|
{ MATROSKA_ID_DURATION, EBML_FLOAT, 0, offsetof(MatroskaDemuxContext,duration) },
|
|
|
|
{ MATROSKA_ID_TITLE, EBML_UTF8, 0, offsetof(MatroskaDemuxContext,title) },
|
|
|
|
{ MATROSKA_ID_WRITINGAPP, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_MUXINGAPP, EBML_NONE },
|
2012-03-05 19:02:48 +01:00
|
|
|
{ MATROSKA_ID_DATEUTC, EBML_BIN, 0, offsetof(MatroskaDemuxContext,date_utc) },
|
2008-08-05 02:40:27 +02:00
|
|
|
{ MATROSKA_ID_SEGMENTUID, EBML_NONE },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
static EbmlSyntax matroska_track_video[] = {
|
|
|
|
{ MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT,0, offsetof(MatroskaTrackVideo,frame_rate) },
|
|
|
|
{ MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_width) },
|
|
|
|
{ MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_height) },
|
|
|
|
{ MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_width) },
|
|
|
|
{ MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_height) },
|
2011-06-14 02:00:06 +02:00
|
|
|
{ MATROSKA_ID_VIDEOCOLORSPACE, EBML_BIN, 0, offsetof(MatroskaTrackVideo,color_space) },
|
2011-05-24 01:09:24 +02:00
|
|
|
{ MATROSKA_ID_VIDEOSTEREOMODE, EBML_UINT, 0, offsetof(MatroskaTrackVideo,stereo_mode) },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_VIDEOPIXELCROPB, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_VIDEOPIXELCROPT, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_VIDEOPIXELCROPL, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_VIDEOPIXELCROPR, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_VIDEODISPLAYUNIT, EBML_NONE },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ MATROSKA_ID_VIDEOFLAGINTERLACED,EBML_NONE },
|
|
|
|
{ MATROSKA_ID_VIDEOASPECTRATIO, EBML_NONE },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_audio[] = {
|
|
|
|
{ MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT,0, offsetof(MatroskaTrackAudio,samplerate), {.f=8000.0} },
|
|
|
|
{ MATROSKA_ID_AUDIOOUTSAMPLINGFREQ,EBML_FLOAT,0,offsetof(MatroskaTrackAudio,out_samplerate) },
|
|
|
|
{ MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, offsetof(MatroskaTrackAudio,bitdepth) },
|
|
|
|
{ MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, offsetof(MatroskaTrackAudio,channels), {.u=1} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_encoding_compression[] = {
|
|
|
|
{ MATROSKA_ID_ENCODINGCOMPALGO, EBML_UINT, 0, offsetof(MatroskaTrackCompression,algo), {.u=0} },
|
|
|
|
{ MATROSKA_ID_ENCODINGCOMPSETTINGS,EBML_BIN, 0, offsetof(MatroskaTrackCompression,settings) },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_encoding[] = {
|
|
|
|
{ MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding,scope), {.u=1} },
|
|
|
|
{ MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding,type), {.u=0} },
|
|
|
|
{ MATROSKA_ID_ENCODINGCOMPRESSION,EBML_NEST, 0, offsetof(MatroskaTrackEncoding,compression), {.n=matroska_track_encoding_compression} },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_ENCODINGORDER, EBML_NONE },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_encodings[] = {
|
|
|
|
{ MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack,encodings), {.n=matroska_track_encoding} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2011-05-21 17:14:14 +02:00
|
|
|
static EbmlSyntax matroska_track_plane[] = {
|
|
|
|
{ MATROSKA_ID_TRACKPLANEUID, EBML_UINT, 0, offsetof(MatroskaTrackPlane,uid) },
|
|
|
|
{ MATROSKA_ID_TRACKPLANETYPE, EBML_UINT, 0, offsetof(MatroskaTrackPlane,type) },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_combine_planes[] = {
|
|
|
|
{ MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n=matroska_track_plane} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_track_operation[] = {
|
|
|
|
{ MATROSKA_ID_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n=matroska_track_combine_planes} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
static EbmlSyntax matroska_track[] = {
|
|
|
|
{ MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, offsetof(MatroskaTrack,num) },
|
2009-02-15 16:29:09 +01:00
|
|
|
{ MATROSKA_ID_TRACKNAME, EBML_UTF8, 0, offsetof(MatroskaTrack,name) },
|
2009-02-15 16:34:22 +01:00
|
|
|
{ MATROSKA_ID_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTrack,uid) },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ MATROSKA_ID_TRACKTYPE, EBML_UINT, 0, offsetof(MatroskaTrack,type) },
|
|
|
|
{ MATROSKA_ID_CODECID, EBML_STR, 0, offsetof(MatroskaTrack,codec_id) },
|
|
|
|
{ MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, offsetof(MatroskaTrack,codec_priv) },
|
|
|
|
{ MATROSKA_ID_TRACKLANGUAGE, EBML_UTF8, 0, offsetof(MatroskaTrack,language), {.s="eng"} },
|
|
|
|
{ MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack,default_duration) },
|
|
|
|
{ MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT,0, offsetof(MatroskaTrack,time_scale), {.f=1.0} },
|
|
|
|
{ MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTrack,flag_default), {.u=1} },
|
2010-07-02 18:38:44 +02:00
|
|
|
{ MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, offsetof(MatroskaTrack,flag_forced), {.u=0} },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, offsetof(MatroskaTrack,video), {.n=matroska_track_video} },
|
|
|
|
{ MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, offsetof(MatroskaTrack,audio), {.n=matroska_track_audio} },
|
2011-05-21 17:14:14 +02:00
|
|
|
{ MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, offsetof(MatroskaTrack,operation), {.n=matroska_track_operation} },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ MATROSKA_ID_TRACKCONTENTENCODINGS,EBML_NEST, 0, 0, {.n=matroska_track_encodings} },
|
|
|
|
{ MATROSKA_ID_TRACKFLAGENABLED, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TRACKFLAGLACING, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CODECNAME, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CODECDECODEALL, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CODECINFOURL, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CODECDOWNLOADURL, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TRACKMINCACHE, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TRACKMAXCACHE, EBML_NONE },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_TRACKMAXBLKADDID, EBML_NONE },
|
2008-08-05 02:40:31 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_tracks[] = {
|
|
|
|
{ MATROSKA_ID_TRACKENTRY, EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext,tracks), {.n=matroska_track} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:24 +02:00
|
|
|
static EbmlSyntax matroska_attachment[] = {
|
2009-02-15 16:34:22 +01:00
|
|
|
{ MATROSKA_ID_FILEUID, EBML_UINT, 0, offsetof(MatroskaAttachement,uid) },
|
2008-08-05 02:40:24 +02:00
|
|
|
{ MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) },
|
|
|
|
{ MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachement,mime) },
|
|
|
|
{ MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachement,bin) },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_FILEDESC, EBML_NONE },
|
2008-08-05 02:40:24 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_attachments[] = {
|
|
|
|
{ MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachement), offsetof(MatroskaDemuxContext,attachments), {.n=matroska_attachment} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:21 +02:00
|
|
|
static EbmlSyntax matroska_chapter_display[] = {
|
|
|
|
{ MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, offsetof(MatroskaChapter,title) },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_CHAPLANG, EBML_NONE },
|
2008-08-05 02:40:21 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_chapter_entry[] = {
|
|
|
|
{ MATROSKA_ID_CHAPTERTIMESTART, EBML_UINT, 0, offsetof(MatroskaChapter,start), {.u=AV_NOPTS_VALUE} },
|
|
|
|
{ MATROSKA_ID_CHAPTERTIMEEND, EBML_UINT, 0, offsetof(MatroskaChapter,end), {.u=AV_NOPTS_VALUE} },
|
|
|
|
{ MATROSKA_ID_CHAPTERUID, EBML_UINT, 0, offsetof(MatroskaChapter,uid) },
|
|
|
|
{ MATROSKA_ID_CHAPTERDISPLAY, EBML_NEST, 0, 0, {.n=matroska_chapter_display} },
|
|
|
|
{ MATROSKA_ID_CHAPTERFLAGHIDDEN, EBML_NONE },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_CHAPTERFLAGENABLED, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CHAPTERPHYSEQUIV, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CHAPTERATOM, EBML_NONE },
|
2008-08-05 02:40:21 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_chapter[] = {
|
|
|
|
{ MATROSKA_ID_CHAPTERATOM, EBML_NEST, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext,chapters), {.n=matroska_chapter_entry} },
|
|
|
|
{ MATROSKA_ID_EDITIONUID, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_EDITIONFLAGHIDDEN, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_EDITIONFLAGDEFAULT, EBML_NONE },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_EDITIONFLAGORDERED, EBML_NONE },
|
2008-08-05 02:40:21 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_chapters[] = {
|
|
|
|
{ MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, {.n=matroska_chapter} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:15 +02:00
|
|
|
static EbmlSyntax matroska_index_pos[] = {
|
|
|
|
{ MATROSKA_ID_CUETRACK, EBML_UINT, 0, offsetof(MatroskaIndexPos,track) },
|
|
|
|
{ MATROSKA_ID_CUECLUSTERPOSITION, EBML_UINT, 0, offsetof(MatroskaIndexPos,pos) },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_CUEBLOCKNUMBER, EBML_NONE },
|
2008-08-05 02:40:15 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_index_entry[] = {
|
|
|
|
{ MATROSKA_ID_CUETIME, EBML_UINT, 0, offsetof(MatroskaIndex,time) },
|
|
|
|
{ MATROSKA_ID_CUETRACKPOSITION, EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex,pos), {.n=matroska_index_pos} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_index[] = {
|
|
|
|
{ MATROSKA_ID_POINTENTRY, EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext,index), {.n=matroska_index_entry} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-09 01:50:38 +02:00
|
|
|
static EbmlSyntax matroska_simpletag[] = {
|
|
|
|
{ MATROSKA_ID_TAGNAME, EBML_UTF8, 0, offsetof(MatroskaTag,name) },
|
|
|
|
{ MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, offsetof(MatroskaTag,string) },
|
2009-02-15 17:05:37 +01:00
|
|
|
{ MATROSKA_ID_TAGLANG, EBML_STR, 0, offsetof(MatroskaTag,lang), {.s="und"} },
|
|
|
|
{ MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTag,def) },
|
2010-06-08 21:28:22 +02:00
|
|
|
{ MATROSKA_ID_TAGDEFAULT_BUG, EBML_UINT, 0, offsetof(MatroskaTag,def) },
|
2008-08-09 01:50:38 +02:00
|
|
|
{ MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag,sub), {.n=matroska_simpletag} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2009-02-15 16:53:55 +01:00
|
|
|
static EbmlSyntax matroska_tagtargets[] = {
|
|
|
|
{ MATROSKA_ID_TAGTARGETS_TYPE, EBML_STR, 0, offsetof(MatroskaTagTarget,type) },
|
|
|
|
{ MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, offsetof(MatroskaTagTarget,typevalue), {.u=50} },
|
|
|
|
{ MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTagTarget,trackuid) },
|
|
|
|
{ MATROSKA_ID_TAGTARGETS_CHAPTERUID,EBML_UINT, 0, offsetof(MatroskaTagTarget,chapteruid) },
|
|
|
|
{ MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, offsetof(MatroskaTagTarget,attachuid) },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-09 01:50:38 +02:00
|
|
|
static EbmlSyntax matroska_tag[] = {
|
2009-02-15 16:53:55 +01:00
|
|
|
{ MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTags,tag), {.n=matroska_simpletag} },
|
|
|
|
{ MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, offsetof(MatroskaTags,target), {.n=matroska_tagtargets} },
|
2008-08-09 01:50:38 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:18 +02:00
|
|
|
static EbmlSyntax matroska_tags[] = {
|
2009-02-15 16:53:55 +01:00
|
|
|
{ MATROSKA_ID_TAG, EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext,tags), {.n=matroska_tag} },
|
2008-08-05 02:40:18 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:36 +02:00
|
|
|
static EbmlSyntax matroska_seekhead_entry[] = {
|
|
|
|
{ MATROSKA_ID_SEEKID, EBML_UINT, 0, offsetof(MatroskaSeekhead,id) },
|
|
|
|
{ MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, offsetof(MatroskaSeekhead,pos), {.u=-1} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_seekhead[] = {
|
|
|
|
{ MATROSKA_ID_SEEKENTRY, EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext,seekhead), {.n=matroska_seekhead_entry} },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:40:58 +02:00
|
|
|
static EbmlSyntax matroska_segment[] = {
|
|
|
|
{ MATROSKA_ID_INFO, EBML_NEST, 0, 0, {.n=matroska_info } },
|
|
|
|
{ MATROSKA_ID_TRACKS, EBML_NEST, 0, 0, {.n=matroska_tracks } },
|
|
|
|
{ MATROSKA_ID_ATTACHMENTS, EBML_NEST, 0, 0, {.n=matroska_attachments} },
|
|
|
|
{ MATROSKA_ID_CHAPTERS, EBML_NEST, 0, 0, {.n=matroska_chapters } },
|
|
|
|
{ MATROSKA_ID_CUES, EBML_NEST, 0, 0, {.n=matroska_index } },
|
|
|
|
{ MATROSKA_ID_TAGS, EBML_NEST, 0, 0, {.n=matroska_tags } },
|
|
|
|
{ MATROSKA_ID_SEEKHEAD, EBML_NEST, 0, 0, {.n=matroska_seekhead } },
|
2010-06-11 18:36:51 +02:00
|
|
|
{ MATROSKA_ID_CLUSTER, EBML_STOP },
|
2008-08-05 02:40:58 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_segments[] = {
|
|
|
|
{ MATROSKA_ID_SEGMENT, EBML_NEST, 0, 0, {.n=matroska_segment } },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2008-08-05 02:41:05 +02:00
|
|
|
static EbmlSyntax matroska_blockgroup[] = {
|
|
|
|
{ MATROSKA_ID_BLOCK, EBML_BIN, 0, offsetof(MatroskaBlock,bin) },
|
|
|
|
{ MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock,bin) },
|
2011-03-16 23:37:16 +01:00
|
|
|
{ MATROSKA_ID_BLOCKDURATION, EBML_UINT, 0, offsetof(MatroskaBlock,duration) },
|
2008-08-05 02:41:05 +02:00
|
|
|
{ MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock,reference) },
|
2009-08-10 20:06:14 +02:00
|
|
|
{ 1, EBML_UINT, 0, offsetof(MatroskaBlock,non_simple), {.u=1} },
|
2008-08-05 02:41:05 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_cluster[] = {
|
|
|
|
{ MATROSKA_ID_CLUSTERTIMECODE,EBML_UINT,0, offsetof(MatroskaCluster,timecode) },
|
|
|
|
{ MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
|
|
|
|
{ MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_CLUSTERPOSITION,EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CLUSTERPREVSIZE,EBML_NONE },
|
2008-08-05 02:41:05 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_clusters[] = {
|
|
|
|
{ MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, {.n=matroska_cluster} },
|
2008-08-13 23:15:15 +02:00
|
|
|
{ MATROSKA_ID_INFO, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CUES, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TAGS, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_SEEKHEAD, EBML_NONE },
|
2008-08-05 02:41:05 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2012-04-19 20:12:24 +02:00
|
|
|
static EbmlSyntax matroska_cluster_incremental_parsing[] = {
|
|
|
|
{ MATROSKA_ID_CLUSTERTIMECODE,EBML_UINT,0, offsetof(MatroskaCluster,timecode) },
|
|
|
|
{ MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
|
|
|
|
{ MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
|
|
|
|
{ MATROSKA_ID_CLUSTERPOSITION,EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CLUSTERPREVSIZE,EBML_NONE },
|
|
|
|
{ MATROSKA_ID_INFO, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CUES, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TAGS, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_SEEKHEAD, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CLUSTER, EBML_STOP },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_cluster_incremental[] = {
|
|
|
|
{ MATROSKA_ID_CLUSTERTIMECODE,EBML_UINT,0, offsetof(MatroskaCluster,timecode) },
|
|
|
|
{ MATROSKA_ID_BLOCKGROUP, EBML_STOP },
|
|
|
|
{ MATROSKA_ID_SIMPLEBLOCK, EBML_STOP },
|
|
|
|
{ MATROSKA_ID_CLUSTERPOSITION,EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CLUSTERPREVSIZE,EBML_NONE },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static EbmlSyntax matroska_clusters_incremental[] = {
|
|
|
|
{ MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, {.n=matroska_cluster_incremental} },
|
|
|
|
{ MATROSKA_ID_INFO, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_CUES, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_TAGS, EBML_NONE },
|
|
|
|
{ MATROSKA_ID_SEEKHEAD, EBML_NONE },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
2012-02-20 09:42:33 +01:00
|
|
|
static const char *const matroska_doctypes[] = { "matroska", "webm" };
|
2010-05-22 03:41:32 +02:00
|
|
|
|
2012-02-13 23:06:19 +01:00
|
|
|
static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
|
|
|
|
{
|
|
|
|
AVIOContext *pb = matroska->ctx->pb;
|
|
|
|
uint32_t id;
|
|
|
|
matroska->current_id = 0;
|
|
|
|
matroska->num_levels = 0;
|
|
|
|
|
|
|
|
// seek to next position to resync from
|
|
|
|
if (avio_seek(pb, last_pos + 1, SEEK_SET) < 0 || avio_tell(pb) <= last_pos)
|
|
|
|
goto eof;
|
|
|
|
|
|
|
|
id = avio_rb32(pb);
|
|
|
|
|
|
|
|
// try to find a toplevel element
|
|
|
|
while (!url_feof(pb)) {
|
|
|
|
if (id == MATROSKA_ID_INFO || id == MATROSKA_ID_TRACKS ||
|
|
|
|
id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
|
|
|
|
id == MATROSKA_ID_SEEKHEAD || id == MATROSKA_ID_ATTACHMENTS ||
|
|
|
|
id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS)
|
|
|
|
{
|
|
|
|
matroska->current_id = id;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
id = (id << 8) | avio_r8(pb);
|
|
|
|
}
|
|
|
|
eof:
|
|
|
|
matroska->done = 1;
|
|
|
|
return AVERROR_EOF;
|
|
|
|
}
|
|
|
|
|
2007-06-05 00:10:54 +02:00
|
|
|
/*
|
2008-08-05 10:28:57 +02:00
|
|
|
* Return: Whether we reached the end of a level in the hierarchy or not.
|
2007-06-05 00:10:54 +02:00
|
|
|
*/
|
2008-08-05 02:42:08 +02:00
|
|
|
static int ebml_level_end(MatroskaDemuxContext *matroska)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = matroska->ctx->pb;
|
2011-03-03 20:11:45 +01:00
|
|
|
int64_t pos = avio_tell(pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:42:08 +02:00
|
|
|
if (matroska->num_levels > 0) {
|
2007-06-05 00:10:54 +02:00
|
|
|
MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
|
2010-06-11 18:43:47 +02:00
|
|
|
if (pos - level->start >= level->length || matroska->current_id) {
|
2007-06-05 00:10:54 +02:00
|
|
|
matroska->num_levels--;
|
2008-08-05 02:42:08 +02:00
|
|
|
return 1;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
}
|
2008-08-05 02:42:08 +02:00
|
|
|
return 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read: an "EBML number", which is defined as a variable-length
|
|
|
|
* array of bytes. The first byte indicates the length by giving a
|
|
|
|
* number of 0-bits followed by a one. The position of the first
|
|
|
|
* "one" bit inside the first byte indicates the length of this
|
|
|
|
* number.
|
2008-08-05 10:28:57 +02:00
|
|
|
* Returns: number of bytes read, < 0 on error
|
2007-06-05 00:10:54 +02:00
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
|
2008-08-05 02:42:05 +02:00
|
|
|
int max_size, uint64_t *number)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2010-09-02 21:17:46 +02:00
|
|
|
int read = 1, n = 1;
|
|
|
|
uint64_t total = 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-02-21 16:43:01 +01:00
|
|
|
/* The first byte tells us the length in bytes - avio_r8() can normally
|
2007-06-05 00:10:54 +02:00
|
|
|
* return 0, but since that's not a valid first ebmlID byte, we can
|
|
|
|
* use it safely here to catch EOS. */
|
2011-02-21 16:43:01 +01:00
|
|
|
if (!(total = avio_r8(pb))) {
|
2007-06-05 00:10:54 +02:00
|
|
|
/* we might encounter EOS here */
|
|
|
|
if (!url_feof(pb)) {
|
2011-03-03 20:11:45 +01:00
|
|
|
int64_t pos = avio_tell(pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
|
|
|
|
pos, pos);
|
2012-07-21 10:48:39 +02:00
|
|
|
return pb->error ? pb->error : AVERROR(EIO);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
2012-07-21 10:48:39 +02:00
|
|
|
return AVERROR_EOF;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* get the length of the EBML number */
|
2010-09-02 21:17:46 +02:00
|
|
|
read = 8 - ff_log2_tab[total];
|
2007-06-05 00:10:54 +02:00
|
|
|
if (read > max_size) {
|
2011-03-03 20:11:45 +01:00
|
|
|
int64_t pos = avio_tell(pb) - 1;
|
2007-06-05 00:10:54 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
|
|
|
|
(uint8_t) total, pos, pos);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read out length */
|
2010-09-02 21:17:46 +02:00
|
|
|
total ^= 1 << ff_log2_tab[total];
|
2007-06-05 00:10:54 +02:00
|
|
|
while (n++ < read)
|
2011-02-21 16:43:01 +01:00
|
|
|
total = (total << 8) | avio_r8(pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
*number = total;
|
|
|
|
|
|
|
|
return read;
|
|
|
|
}
|
|
|
|
|
2010-09-06 19:51:44 +02:00
|
|
|
/**
|
|
|
|
* Read a EBML length value.
|
|
|
|
* This needs special handling for the "unknown length" case which has multiple
|
|
|
|
* encodings.
|
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb,
|
2010-09-06 19:51:44 +02:00
|
|
|
uint64_t *number)
|
|
|
|
{
|
|
|
|
int res = ebml_read_num(matroska, pb, 8, number);
|
|
|
|
if (res > 0 && *number + 1 == 1ULL << (7 * res))
|
|
|
|
*number = 0xffffffffffffffULL;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2007-06-05 00:10:54 +02:00
|
|
|
/*
|
|
|
|
* Read the next element as an unsigned int.
|
|
|
|
* 0 is success, < 0 is failure.
|
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2008-08-05 02:41:55 +02:00
|
|
|
int n = 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2010-09-05 23:37:40 +02:00
|
|
|
if (size > 8)
|
2007-06-05 00:10:54 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* big-endian ordering; build up number */
|
2007-06-05 00:10:54 +02:00
|
|
|
*num = 0;
|
|
|
|
while (n++ < size)
|
2011-02-21 16:43:01 +01:00
|
|
|
*num = (*num << 8) | avio_r8(pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the next element as a float.
|
|
|
|
* 0 is success, < 0 is failure.
|
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_float(AVIOContext *pb, int size, double *num)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2010-09-05 23:37:40 +02:00
|
|
|
if (size == 0) {
|
|
|
|
*num = 0;
|
|
|
|
} else if (size == 4) {
|
2011-11-27 15:04:16 +01:00
|
|
|
*num = av_int2float(avio_rb32(pb));
|
|
|
|
} else if (size == 8){
|
|
|
|
*num = av_int2double(avio_rb64(pb));
|
2008-08-05 02:41:52 +02:00
|
|
|
} else
|
2007-06-05 00:10:54 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the next element as an ASCII string.
|
|
|
|
* 0 is success, < 0 is failure.
|
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2012-02-25 01:12:18 +01:00
|
|
|
char *res;
|
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* EBML strings are usually not 0-terminated, so we allocate one
|
2007-06-05 00:10:54 +02:00
|
|
|
* byte more, read the string and NULL-terminate it ourselves. */
|
2012-02-25 01:12:18 +01:00
|
|
|
if (!(res = av_malloc(size + 1)))
|
2007-07-19 17:21:30 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2012-02-25 01:12:18 +01:00
|
|
|
if (avio_read(pb, (uint8_t *) res, size) != size) {
|
|
|
|
av_free(res);
|
2007-07-19 17:23:32 +02:00
|
|
|
return AVERROR(EIO);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
2012-02-25 01:12:18 +01:00
|
|
|
(res)[size] = '\0';
|
|
|
|
av_free(*str);
|
|
|
|
*str = res;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
/*
|
|
|
|
* Read the next element as binary data.
|
|
|
|
* 0 is success, < 0 is failure.
|
|
|
|
*/
|
2011-02-20 11:04:12 +01:00
|
|
|
static int ebml_read_binary(AVIOContext *pb, int length, EbmlBin *bin)
|
2008-08-05 02:42:39 +02:00
|
|
|
{
|
|
|
|
av_free(bin->data);
|
|
|
|
if (!(bin->data = av_malloc(length)))
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
bin->size = length;
|
2011-03-03 20:11:45 +01:00
|
|
|
bin->pos = avio_tell(pb);
|
2011-02-21 16:43:01 +01:00
|
|
|
if (avio_read(pb, bin->data, length) != length) {
|
2010-05-18 23:21:37 +02:00
|
|
|
av_freep(&bin->data);
|
2008-08-05 02:42:39 +02:00
|
|
|
return AVERROR(EIO);
|
2010-05-18 23:21:37 +02:00
|
|
|
}
|
2008-08-05 02:42:39 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-05 00:10:54 +02:00
|
|
|
/*
|
|
|
|
* Read the next element, but only the header. The contents
|
|
|
|
* are supposed to be sub-elements which can be read separately.
|
|
|
|
* 0 is success, < 0 is failure.
|
|
|
|
*/
|
2010-06-11 19:16:43 +02:00
|
|
|
static int ebml_read_master(MatroskaDemuxContext *matroska, uint64_t length)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = matroska->ctx->pb;
|
2007-06-05 00:10:54 +02:00
|
|
|
MatroskaLevel *level;
|
|
|
|
|
|
|
|
if (matroska->num_levels >= EBML_MAX_DEPTH) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
|
2007-07-19 17:38:33 +02:00
|
|
|
return AVERROR(ENOSYS);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
level = &matroska->levels[matroska->num_levels++];
|
2011-03-03 20:11:45 +01:00
|
|
|
level->start = avio_tell(pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
level->length = length;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read signed/unsigned "EBML" numbers.
|
2008-08-05 10:28:57 +02:00
|
|
|
* Return: number of bytes processed, < 0 on error
|
2007-06-05 00:10:54 +02:00
|
|
|
*/
|
2008-08-05 02:42:52 +02:00
|
|
|
static int matroska_ebmlnum_uint(MatroskaDemuxContext *matroska,
|
|
|
|
uint8_t *data, uint32_t size, uint64_t *num)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext pb;
|
2011-02-20 11:04:13 +01:00
|
|
|
ffio_init_context(&pb, data, size, 0, NULL, NULL, NULL, NULL);
|
2010-05-18 23:21:32 +02:00
|
|
|
return ebml_read_num(matroska, &pb, FFMIN(size, 8), num);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Same as above, but signed.
|
|
|
|
*/
|
2008-08-05 02:42:52 +02:00
|
|
|
static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska,
|
|
|
|
uint8_t *data, uint32_t size, int64_t *num)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
uint64_t unum;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
/* read as unsigned number first */
|
2008-08-05 02:42:52 +02:00
|
|
|
if ((res = matroska_ebmlnum_uint(matroska, data, size, &unum)) < 0)
|
2007-06-05 00:10:54 +02:00
|
|
|
return res;
|
|
|
|
|
|
|
|
/* make signed (weird way) */
|
2008-08-05 02:42:55 +02:00
|
|
|
*num = unum - ((1LL << (7*res - 1)) - 1);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
static int ebml_parse_elem(MatroskaDemuxContext *matroska,
|
|
|
|
EbmlSyntax *syntax, void *data);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
static int ebml_parse_id(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
|
|
|
|
uint32_t id, void *data)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
int i;
|
2008-08-05 02:42:39 +02:00
|
|
|
for (i=0; syntax[i].id; i++)
|
|
|
|
if (id == syntax[i].id)
|
|
|
|
break;
|
2010-06-11 18:43:47 +02:00
|
|
|
if (!syntax[i].id && id == MATROSKA_ID_CLUSTER &&
|
|
|
|
matroska->num_levels > 0 &&
|
2010-06-11 19:16:43 +02:00
|
|
|
matroska->levels[matroska->num_levels-1].length == 0xffffffffffffff)
|
2010-06-11 18:43:47 +02:00
|
|
|
return 0; // we reached the end of an unknown size cluster
|
2012-07-07 17:15:27 +02:00
|
|
|
if (!syntax[i].id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
|
2008-08-05 02:42:39 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_INFO, "Unknown entry 0x%X\n", id);
|
2012-07-07 17:15:27 +02:00
|
|
|
if (matroska->ctx->error_recognition & AV_EF_EXPLODE)
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2008-08-05 02:42:39 +02:00
|
|
|
return ebml_parse_elem(matroska, &syntax[i], data);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
|
|
|
|
void *data)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2010-06-11 18:34:01 +02:00
|
|
|
if (!matroska->current_id) {
|
2010-06-11 18:45:38 +02:00
|
|
|
uint64_t id;
|
|
|
|
int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
matroska->current_id = id | 1 << 7*res;
|
2010-06-11 18:34:01 +02:00
|
|
|
}
|
|
|
|
return ebml_parse_id(matroska, syntax, matroska->current_id, data);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
|
|
|
|
void *data)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2008-08-05 02:42:39 +02:00
|
|
|
int i, res = 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
for (i=0; syntax[i].id; i++)
|
|
|
|
switch (syntax[i].type) {
|
|
|
|
case EBML_UINT:
|
|
|
|
*(uint64_t *)((char *)data+syntax[i].data_offset) = syntax[i].def.u;
|
|
|
|
break;
|
|
|
|
case EBML_FLOAT:
|
|
|
|
*(double *)((char *)data+syntax[i].data_offset) = syntax[i].def.f;
|
|
|
|
break;
|
|
|
|
case EBML_STR:
|
|
|
|
case EBML_UTF8:
|
|
|
|
*(char **)((char *)data+syntax[i].data_offset) = av_strdup(syntax[i].def.s);
|
|
|
|
break;
|
2007-12-29 19:32:47 +01:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
while (!res && !ebml_level_end(matroska))
|
|
|
|
res = ebml_parse(matroska, syntax, data);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
return res;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:40:00 +02:00
|
|
|
static int ebml_parse_elem(MatroskaDemuxContext *matroska,
|
|
|
|
EbmlSyntax *syntax, void *data)
|
|
|
|
{
|
2011-02-06 11:32:03 +01:00
|
|
|
static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
|
|
|
|
[EBML_UINT] = 8,
|
|
|
|
[EBML_FLOAT] = 8,
|
|
|
|
// max. 16 MB for strings
|
|
|
|
[EBML_STR] = 0x1000000,
|
|
|
|
[EBML_UTF8] = 0x1000000,
|
|
|
|
// max. 256 MB for binary data
|
|
|
|
[EBML_BIN] = 0x10000000,
|
|
|
|
// no limits for anything else
|
|
|
|
};
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = matroska->ctx->pb;
|
2008-08-05 02:40:00 +02:00
|
|
|
uint32_t id = syntax->id;
|
2008-08-05 02:41:55 +02:00
|
|
|
uint64_t length;
|
2008-08-05 02:40:00 +02:00
|
|
|
int res;
|
2011-07-28 14:59:54 +02:00
|
|
|
void *newelem;
|
2008-08-05 02:40:00 +02:00
|
|
|
|
|
|
|
data = (char *)data + syntax->data_offset;
|
|
|
|
if (syntax->list_elem_size) {
|
|
|
|
EbmlList *list = data;
|
2011-07-28 14:59:54 +02:00
|
|
|
newelem = av_realloc(list->elem, (list->nb_elem+1)*syntax->list_elem_size);
|
|
|
|
if (!newelem)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
list->elem = newelem;
|
2008-08-05 02:40:00 +02:00
|
|
|
data = (char*)list->elem + list->nb_elem*syntax->list_elem_size;
|
|
|
|
memset(data, 0, syntax->list_elem_size);
|
|
|
|
list->nb_elem++;
|
|
|
|
}
|
|
|
|
|
2010-06-11 18:34:01 +02:00
|
|
|
if (syntax->type != EBML_PASS && syntax->type != EBML_STOP) {
|
|
|
|
matroska->current_id = 0;
|
2010-09-06 19:51:44 +02:00
|
|
|
if ((res = ebml_read_length(matroska, pb, &length)) < 0)
|
2008-08-05 02:41:55 +02:00
|
|
|
return res;
|
2011-02-06 11:32:03 +01:00
|
|
|
if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Invalid length 0x%"PRIx64" > 0x%"PRIx64" for syntax element %i\n",
|
|
|
|
length, max_lengths[syntax->type], syntax->type);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2010-06-11 18:34:01 +02:00
|
|
|
}
|
2008-08-05 02:41:55 +02:00
|
|
|
|
2008-08-05 02:40:00 +02:00
|
|
|
switch (syntax->type) {
|
2008-08-05 02:41:55 +02:00
|
|
|
case EBML_UINT: res = ebml_read_uint (pb, length, data); break;
|
|
|
|
case EBML_FLOAT: res = ebml_read_float (pb, length, data); break;
|
2008-08-05 02:40:00 +02:00
|
|
|
case EBML_STR:
|
2008-08-05 02:41:55 +02:00
|
|
|
case EBML_UTF8: res = ebml_read_ascii (pb, length, data); break;
|
2008-08-05 02:41:59 +02:00
|
|
|
case EBML_BIN: res = ebml_read_binary(pb, length, data); break;
|
2008-08-05 02:41:55 +02:00
|
|
|
case EBML_NEST: if ((res=ebml_read_master(matroska, length)) < 0)
|
2008-08-05 02:40:00 +02:00
|
|
|
return res;
|
|
|
|
if (id == MATROSKA_ID_SEGMENT)
|
2011-03-03 20:11:45 +01:00
|
|
|
matroska->segment_start = avio_tell(matroska->ctx->pb);
|
2008-08-05 02:42:23 +02:00
|
|
|
return ebml_parse_nest(matroska, syntax->def.n, data);
|
2008-08-05 02:42:20 +02:00
|
|
|
case EBML_PASS: return ebml_parse_id(matroska, syntax->def.n, id, data);
|
2010-06-11 18:36:51 +02:00
|
|
|
case EBML_STOP: return 1;
|
2012-08-04 02:27:51 +02:00
|
|
|
default:
|
|
|
|
if(ffio_limit(pb, length) != length)
|
|
|
|
return AVERROR(EIO);
|
|
|
|
return avio_skip(pb,length)<0 ? AVERROR(EIO) : 0;
|
2008-08-05 02:40:00 +02:00
|
|
|
}
|
2008-08-05 02:41:52 +02:00
|
|
|
if (res == AVERROR_INVALIDDATA)
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
|
|
|
|
else if (res == AVERROR(EIO))
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
|
|
|
|
return res;
|
2008-08-05 02:40:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ebml_free(EbmlSyntax *syntax, void *data)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i=0; syntax[i].id; i++) {
|
|
|
|
void *data_off = (char *)data + syntax[i].data_offset;
|
|
|
|
switch (syntax[i].type) {
|
|
|
|
case EBML_STR:
|
|
|
|
case EBML_UTF8: av_freep(data_off); break;
|
|
|
|
case EBML_BIN: av_freep(&((EbmlBin *)data_off)->data); break;
|
|
|
|
case EBML_NEST:
|
|
|
|
if (syntax[i].list_elem_size) {
|
|
|
|
EbmlList *list = data_off;
|
|
|
|
char *ptr = list->elem;
|
|
|
|
for (j=0; j<list->nb_elem; j++, ptr+=syntax[i].list_elem_size)
|
|
|
|
ebml_free(syntax[i].def.n, ptr);
|
|
|
|
av_free(list->elem);
|
|
|
|
} else
|
|
|
|
ebml_free(syntax[i].def.n, data_off);
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Autodetecting...
|
|
|
|
*/
|
|
|
|
static int matroska_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
uint64_t total = 0;
|
2010-05-22 03:41:32 +02:00
|
|
|
int len_mask = 0x80, size = 1, n = 1, i;
|
2008-08-05 02:42:39 +02:00
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* EBML header? */
|
2008-08-05 02:42:39 +02:00
|
|
|
if (AV_RB32(p->buf) != EBML_ID_HEADER)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* length of header */
|
|
|
|
total = p->buf[4];
|
|
|
|
while (size <= 8 && !(total & len_mask)) {
|
|
|
|
size++;
|
|
|
|
len_mask >>= 1;
|
|
|
|
}
|
|
|
|
if (size > 8)
|
|
|
|
return 0;
|
|
|
|
total &= (len_mask - 1);
|
|
|
|
while (n < size)
|
|
|
|
total = (total << 8) | p->buf[4 + n++];
|
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
/* Does the probe data contain the whole header? */
|
2008-08-05 02:42:39 +02:00
|
|
|
if (p->buf_size < 4 + size + total)
|
|
|
|
return 0;
|
|
|
|
|
2010-05-22 03:41:32 +02:00
|
|
|
/* The header should contain a known document type. For now,
|
2008-08-05 02:42:39 +02:00
|
|
|
* we don't parse the whole header but simply check for the
|
|
|
|
* availability of that array of characters inside the header.
|
|
|
|
* Not fully fool-proof, but good enough. */
|
2010-05-22 03:41:32 +02:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
|
|
|
|
int probelen = strlen(matroska_doctypes[i]);
|
2011-07-20 02:51:48 +02:00
|
|
|
if (total < probelen)
|
|
|
|
continue;
|
2010-05-22 03:41:32 +02:00
|
|
|
for (n = 4+size; n <= 4+size+total-probelen; n++)
|
|
|
|
if (!memcmp(p->buf+n, matroska_doctypes[i], probelen))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
}
|
2008-08-05 02:42:39 +02:00
|
|
|
|
2010-05-22 03:41:35 +02:00
|
|
|
// probably valid EBML header but no recognized doctype
|
|
|
|
return AVPROBE_SCORE_MAX/2;
|
2008-08-05 02:42:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static MatroskaTrack *matroska_find_track_by_num(MatroskaDemuxContext *matroska,
|
|
|
|
int num)
|
|
|
|
{
|
|
|
|
MatroskaTrack *tracks = matroska->tracks.elem;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i=0; i < matroska->tracks.nb_elem; i++)
|
|
|
|
if (tracks[i].num == num)
|
|
|
|
return &tracks[i];
|
|
|
|
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_decode_buffer(uint8_t** buf, int* buf_size,
|
|
|
|
MatroskaTrack *track)
|
2008-06-22 17:49:44 +02:00
|
|
|
{
|
2008-08-05 02:40:31 +02:00
|
|
|
MatroskaTrackEncoding *encodings = track->encodings.elem;
|
2008-06-22 17:49:44 +02:00
|
|
|
uint8_t* data = *buf;
|
|
|
|
int isize = *buf_size;
|
|
|
|
uint8_t* pkt_data = NULL;
|
2012-02-12 10:58:46 +01:00
|
|
|
uint8_t av_unused *newpktdata;
|
2008-06-22 17:49:44 +02:00
|
|
|
int pkt_size = isize;
|
|
|
|
int result = 0;
|
|
|
|
int olen;
|
|
|
|
|
2012-06-15 01:29:30 +02:00
|
|
|
if (pkt_size >= 10000000U)
|
2010-08-17 16:05:23 +02:00
|
|
|
return -1;
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
switch (encodings[0].compression.algo) {
|
2008-06-22 17:49:44 +02:00
|
|
|
case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
|
2012-04-17 17:12:22 +02:00
|
|
|
if (encodings[0].compression.settings.size && !encodings[0].compression.settings.data) {
|
|
|
|
av_log(0, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2008-08-05 02:40:31 +02:00
|
|
|
return encodings[0].compression.settings.size;
|
2008-06-22 17:49:44 +02:00
|
|
|
case MATROSKA_TRACK_ENCODING_COMP_LZO:
|
|
|
|
do {
|
|
|
|
olen = pkt_size *= 3;
|
2009-02-02 22:32:11 +01:00
|
|
|
pkt_data = av_realloc(pkt_data, pkt_size+AV_LZO_OUTPUT_PADDING);
|
2009-02-02 21:16:00 +01:00
|
|
|
result = av_lzo1x_decode(pkt_data, &olen, data, &isize);
|
|
|
|
} while (result==AV_LZO_OUTPUT_FULL && pkt_size<10000000);
|
2008-06-22 17:49:44 +02:00
|
|
|
if (result)
|
|
|
|
goto failed;
|
|
|
|
pkt_size -= olen;
|
|
|
|
break;
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_ZLIB
|
2008-06-22 17:49:44 +02:00
|
|
|
case MATROSKA_TRACK_ENCODING_COMP_ZLIB: {
|
|
|
|
z_stream zstream = {0};
|
|
|
|
if (inflateInit(&zstream) != Z_OK)
|
|
|
|
return -1;
|
|
|
|
zstream.next_in = data;
|
|
|
|
zstream.avail_in = isize;
|
|
|
|
do {
|
|
|
|
pkt_size *= 3;
|
2011-07-28 14:59:54 +02:00
|
|
|
newpktdata = av_realloc(pkt_data, pkt_size);
|
|
|
|
if (!newpktdata) {
|
|
|
|
inflateEnd(&zstream);
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
pkt_data = newpktdata;
|
2008-06-22 17:49:44 +02:00
|
|
|
zstream.avail_out = pkt_size - zstream.total_out;
|
|
|
|
zstream.next_out = pkt_data + zstream.total_out;
|
2011-07-28 14:59:54 +02:00
|
|
|
if (pkt_data) {
|
|
|
|
result = inflate(&zstream, Z_NO_FLUSH);
|
|
|
|
} else
|
|
|
|
result = Z_MEM_ERROR;
|
2008-06-22 17:49:44 +02:00
|
|
|
} while (result==Z_OK && pkt_size<10000000);
|
|
|
|
pkt_size = zstream.total_out;
|
|
|
|
inflateEnd(&zstream);
|
|
|
|
if (result != Z_STREAM_END)
|
|
|
|
goto failed;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_BZLIB
|
2008-06-22 17:49:44 +02:00
|
|
|
case MATROSKA_TRACK_ENCODING_COMP_BZLIB: {
|
|
|
|
bz_stream bzstream = {0};
|
|
|
|
if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
|
|
|
|
return -1;
|
|
|
|
bzstream.next_in = data;
|
|
|
|
bzstream.avail_in = isize;
|
|
|
|
do {
|
|
|
|
pkt_size *= 3;
|
2011-07-28 14:59:54 +02:00
|
|
|
newpktdata = av_realloc(pkt_data, pkt_size);
|
|
|
|
if (!newpktdata) {
|
|
|
|
BZ2_bzDecompressEnd(&bzstream);
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
pkt_data = newpktdata;
|
2008-06-22 17:49:44 +02:00
|
|
|
bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
|
|
|
|
bzstream.next_out = pkt_data + bzstream.total_out_lo32;
|
2011-07-28 14:59:54 +02:00
|
|
|
if (pkt_data) {
|
|
|
|
result = BZ2_bzDecompress(&bzstream);
|
|
|
|
} else
|
|
|
|
result = BZ_MEM_ERROR;
|
2008-06-22 17:49:44 +02:00
|
|
|
} while (result==BZ_OK && pkt_size<10000000);
|
|
|
|
pkt_size = bzstream.total_out_lo32;
|
|
|
|
BZ2_bzDecompressEnd(&bzstream);
|
|
|
|
if (result != BZ_STREAM_END)
|
|
|
|
goto failed;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2008-08-21 01:08:07 +02:00
|
|
|
default:
|
|
|
|
return -1;
|
2008-06-22 17:49:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
*buf = pkt_data;
|
|
|
|
*buf_size = pkt_size;
|
|
|
|
return 0;
|
|
|
|
failed:
|
|
|
|
av_free(pkt_data);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-05 01:26:12 +02:00
|
|
|
static void matroska_fix_ass_packet(MatroskaDemuxContext *matroska,
|
2008-09-29 00:55:28 +02:00
|
|
|
AVPacket *pkt, uint64_t display_duration)
|
2008-09-05 01:26:12 +02:00
|
|
|
{
|
|
|
|
char *line, *layer, *ptr = pkt->data, *end = ptr+pkt->size;
|
|
|
|
for (; *ptr!=',' && ptr<end-1; ptr++);
|
|
|
|
if (*ptr == ',')
|
2011-05-29 21:02:20 +02:00
|
|
|
ptr++;
|
|
|
|
layer = ptr;
|
2008-09-05 01:26:12 +02:00
|
|
|
for (; *ptr!=',' && ptr<end-1; ptr++);
|
|
|
|
if (*ptr == ',') {
|
2008-09-29 00:55:28 +02:00
|
|
|
int64_t end_pts = pkt->pts + display_duration;
|
2008-09-05 01:26:12 +02:00
|
|
|
int sc = matroska->time_scale * pkt->pts / 10000000;
|
|
|
|
int ec = matroska->time_scale * end_pts / 10000000;
|
|
|
|
int sh, sm, ss, eh, em, es, len;
|
|
|
|
sh = sc/360000; sc -= 360000*sh;
|
|
|
|
sm = sc/ 6000; sc -= 6000*sm;
|
|
|
|
ss = sc/ 100; sc -= 100*ss;
|
|
|
|
eh = ec/360000; ec -= 360000*eh;
|
|
|
|
em = ec/ 6000; ec -= 6000*em;
|
|
|
|
es = ec/ 100; ec -= 100*es;
|
|
|
|
*ptr++ = '\0';
|
|
|
|
len = 50 + end-ptr + FF_INPUT_BUFFER_PADDING_SIZE;
|
|
|
|
if (!(line = av_malloc(len)))
|
|
|
|
return;
|
2008-09-29 01:01:07 +02:00
|
|
|
snprintf(line,len,"Dialogue: %s,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s\r\n",
|
2008-09-05 01:26:12 +02:00
|
|
|
layer, sh, sm, ss, sc, eh, em, es, ec, ptr);
|
|
|
|
av_free(pkt->data);
|
|
|
|
pkt->data = line;
|
|
|
|
pkt->size = strlen(line);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-28 14:59:54 +02:00
|
|
|
static int matroska_merge_packets(AVPacket *out, AVPacket *in)
|
2008-09-29 01:06:25 +02:00
|
|
|
{
|
2012-04-16 18:02:02 +02:00
|
|
|
int ret = av_grow_packet(out, in->size);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
memcpy(out->data + out->size - in->size, in->data, in->size);
|
2008-09-29 01:06:25 +02:00
|
|
|
av_destruct_packet(in);
|
|
|
|
av_free(in);
|
2011-07-28 14:59:54 +02:00
|
|
|
return 0;
|
2008-09-29 01:06:25 +02:00
|
|
|
}
|
|
|
|
|
2009-02-15 16:53:55 +01:00
|
|
|
static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
|
2011-05-22 12:46:29 +02:00
|
|
|
AVDictionary **metadata, char *prefix)
|
2008-08-09 01:50:38 +02:00
|
|
|
{
|
|
|
|
MatroskaTag *tags = list->elem;
|
2009-02-15 16:53:55 +01:00
|
|
|
char key[1024];
|
|
|
|
int i;
|
2008-08-09 01:50:38 +02:00
|
|
|
|
|
|
|
for (i=0; i < list->nb_elem; i++) {
|
2012-03-23 01:27:49 +01:00
|
|
|
const char *lang= (tags[i].lang && strcmp(tags[i].lang, "und")) ? tags[i].lang : NULL;
|
2010-11-03 07:29:04 +01:00
|
|
|
|
|
|
|
if (!tags[i].name) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
|
|
|
|
continue;
|
|
|
|
}
|
2009-02-15 16:53:55 +01:00
|
|
|
if (prefix) snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
|
|
|
|
else av_strlcpy(key, tags[i].name, sizeof(key));
|
2009-02-15 17:05:37 +01:00
|
|
|
if (tags[i].def || !lang) {
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(metadata, key, tags[i].string, 0);
|
2008-08-09 01:50:38 +02:00
|
|
|
if (tags[i].sub.nb_elem)
|
2009-02-15 16:53:55 +01:00
|
|
|
matroska_convert_tag(s, &tags[i].sub, metadata, key);
|
2009-02-15 17:05:37 +01:00
|
|
|
}
|
|
|
|
if (lang) {
|
|
|
|
av_strlcat(key, "-", sizeof(key));
|
|
|
|
av_strlcat(key, lang, sizeof(key));
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(metadata, key, tags[i].string, 0);
|
2009-02-15 17:05:37 +01:00
|
|
|
if (tags[i].sub.nb_elem)
|
|
|
|
matroska_convert_tag(s, &tags[i].sub, metadata, key);
|
|
|
|
}
|
2009-02-15 16:53:55 +01:00
|
|
|
}
|
2010-10-16 15:20:41 +02:00
|
|
|
ff_metadata_conv(metadata, NULL, ff_mkv_metadata_conv);
|
2009-02-15 16:53:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void matroska_convert_tags(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
MatroskaDemuxContext *matroska = s->priv_data;
|
|
|
|
MatroskaTags *tags = matroska->tags.elem;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i=0; i < matroska->tags.nb_elem; i++) {
|
|
|
|
if (tags[i].target.attachuid) {
|
|
|
|
MatroskaAttachement *attachment = matroska->attachments.elem;
|
|
|
|
for (j=0; j<matroska->attachments.nb_elem; j++)
|
2011-03-24 00:28:19 +01:00
|
|
|
if (attachment[j].uid == tags[i].target.attachuid
|
|
|
|
&& attachment[j].stream)
|
2009-02-15 16:53:55 +01:00
|
|
|
matroska_convert_tag(s, &tags[i].tag,
|
|
|
|
&attachment[j].stream->metadata, NULL);
|
|
|
|
} else if (tags[i].target.chapteruid) {
|
|
|
|
MatroskaChapter *chapter = matroska->chapters.elem;
|
|
|
|
for (j=0; j<matroska->chapters.nb_elem; j++)
|
2011-03-24 00:28:19 +01:00
|
|
|
if (chapter[j].uid == tags[i].target.chapteruid
|
|
|
|
&& chapter[j].chapter)
|
2009-02-15 16:53:55 +01:00
|
|
|
matroska_convert_tag(s, &tags[i].tag,
|
|
|
|
&chapter[j].chapter->metadata, NULL);
|
|
|
|
} else if (tags[i].target.trackuid) {
|
|
|
|
MatroskaTrack *track = matroska->tracks.elem;
|
|
|
|
for (j=0; j<matroska->tracks.nb_elem; j++)
|
2011-03-24 00:28:19 +01:00
|
|
|
if (track[j].uid == tags[i].target.trackuid && track[j].stream)
|
2009-02-15 16:53:55 +01:00
|
|
|
matroska_convert_tag(s, &tags[i].tag,
|
|
|
|
&track[j].stream->metadata, NULL);
|
|
|
|
} else {
|
2009-06-14 00:29:38 +02:00
|
|
|
matroska_convert_tag(s, &tags[i].tag, &s->metadata,
|
|
|
|
tags[i].target.type);
|
2009-02-15 16:53:55 +01:00
|
|
|
}
|
2008-08-09 01:50:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int idx)
|
2008-08-05 02:40:36 +02:00
|
|
|
{
|
|
|
|
EbmlList *seekhead_list = &matroska->seekhead;
|
|
|
|
MatroskaSeekhead *seekhead = seekhead_list->elem;
|
|
|
|
uint32_t level_up = matroska->level_up;
|
2011-03-03 20:11:45 +01:00
|
|
|
int64_t before_pos = avio_tell(matroska->ctx->pb);
|
2010-06-11 18:34:01 +02:00
|
|
|
uint32_t saved_id = matroska->current_id;
|
2008-08-05 02:40:36 +02:00
|
|
|
MatroskaLevel level;
|
2011-07-09 07:48:43 +02:00
|
|
|
int64_t offset;
|
|
|
|
int ret = 0;
|
2008-08-05 02:42:33 +02:00
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
if (idx >= seekhead_list->nb_elem
|
|
|
|
|| seekhead[idx].id == MATROSKA_ID_SEEKHEAD
|
|
|
|
|| seekhead[idx].id == MATROSKA_ID_CLUSTER)
|
|
|
|
return 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-07-09 08:11:30 +02:00
|
|
|
/* seek */
|
2011-07-09 07:48:43 +02:00
|
|
|
offset = seekhead[idx].pos + matroska->segment_start;
|
|
|
|
if (avio_seek(matroska->ctx->pb, offset, SEEK_SET) == offset) {
|
2008-08-05 10:28:57 +02:00
|
|
|
/* We don't want to lose our seekhead level, so we add
|
2008-08-05 02:40:43 +02:00
|
|
|
* a dummy. This is a crude hack. */
|
|
|
|
if (matroska->num_levels == EBML_MAX_DEPTH) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
|
|
|
"Max EBML element depth (%d) reached, "
|
|
|
|
"cannot parse further.\n", EBML_MAX_DEPTH);
|
2011-07-09 07:48:43 +02:00
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
} else {
|
2011-07-09 08:11:30 +02:00
|
|
|
level.start = 0;
|
|
|
|
level.length = (uint64_t)-1;
|
|
|
|
matroska->levels[matroska->num_levels] = level;
|
|
|
|
matroska->num_levels++;
|
|
|
|
matroska->current_id = 0;
|
|
|
|
|
2011-09-09 00:43:32 +02:00
|
|
|
ret = ebml_parse(matroska, matroska_segment, matroska);
|
2011-07-09 08:11:30 +02:00
|
|
|
|
|
|
|
/* remove dummy level */
|
|
|
|
while (matroska->num_levels) {
|
|
|
|
uint64_t length = matroska->levels[--matroska->num_levels].length;
|
|
|
|
if (length == (uint64_t)-1)
|
|
|
|
break;
|
|
|
|
}
|
2008-08-05 02:40:43 +02:00
|
|
|
}
|
2008-08-05 02:40:36 +02:00
|
|
|
}
|
2008-08-05 02:40:43 +02:00
|
|
|
/* seek back */
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
|
2008-08-05 02:40:43 +02:00
|
|
|
matroska->level_up = level_up;
|
2010-06-11 18:34:01 +02:00
|
|
|
matroska->current_id = saved_id;
|
2011-07-09 07:48:43 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
|
|
|
|
{
|
|
|
|
EbmlList *seekhead_list = &matroska->seekhead;
|
|
|
|
int64_t before_pos = avio_tell(matroska->ctx->pb);
|
2008-08-05 02:41:01 +02:00
|
|
|
int i;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2010-06-08 21:31:08 +02:00
|
|
|
// we should not do any seeking in the streaming case
|
2011-03-05 21:06:46 +01:00
|
|
|
if (!matroska->ctx->pb->seekable ||
|
2010-06-08 21:31:08 +02:00
|
|
|
(matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
|
|
|
|
return;
|
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
for (i = 0; i < seekhead_list->nb_elem; i++) {
|
2012-01-04 16:33:34 +01:00
|
|
|
MatroskaSeekhead *seekhead = seekhead_list->elem;
|
2011-07-09 07:48:43 +02:00
|
|
|
if (seekhead[i].pos <= before_pos)
|
2008-08-05 02:40:36 +02:00
|
|
|
continue;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
// defer cues parsing until we actually need cue data.
|
|
|
|
if (seekhead[i].id == MATROSKA_ID_CUES) {
|
|
|
|
matroska->cues_parsing_deferred = 1;
|
2008-08-05 02:40:43 +02:00
|
|
|
continue;
|
2011-07-09 07:48:43 +02:00
|
|
|
}
|
2008-08-05 02:40:43 +02:00
|
|
|
|
2012-02-12 14:09:03 +01:00
|
|
|
if (matroska_parse_seekhead_entry(matroska, i) < 0) {
|
|
|
|
// mark index as broken
|
|
|
|
matroska->cues_parsing_deferred = -1;
|
2008-08-05 02:40:43 +02:00
|
|
|
break;
|
2012-02-12 14:09:03 +01:00
|
|
|
}
|
2011-07-09 07:48:43 +02:00
|
|
|
}
|
|
|
|
}
|
2008-08-05 02:40:43 +02:00
|
|
|
|
2011-09-22 16:51:00 +02:00
|
|
|
static void matroska_add_index_entries(MatroskaDemuxContext *matroska) {
|
2011-07-09 07:48:43 +02:00
|
|
|
EbmlList *index_list;
|
|
|
|
MatroskaIndex *index;
|
|
|
|
int index_scale = 1;
|
|
|
|
int i, j;
|
2008-08-05 02:40:43 +02:00
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
index_list = &matroska->index;
|
|
|
|
index = index_list->elem;
|
|
|
|
if (index_list->nb_elem
|
|
|
|
&& index[0].time > 1E14/matroska->time_scale) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
|
|
|
|
index_scale = matroska->time_scale;
|
|
|
|
}
|
|
|
|
for (i = 0; i < index_list->nb_elem; i++) {
|
|
|
|
EbmlList *pos_list = &index[i].pos;
|
|
|
|
MatroskaIndexPos *pos = pos_list->elem;
|
|
|
|
for (j = 0; j < pos_list->nb_elem; j++) {
|
|
|
|
MatroskaTrack *track = matroska_find_track_by_num(matroska, pos[j].track);
|
|
|
|
if (track && track->stream)
|
|
|
|
av_add_index_entry(track->stream,
|
|
|
|
pos[j].pos + matroska->segment_start,
|
|
|
|
index[i].time/index_scale, 0, 0,
|
|
|
|
AVINDEX_KEYFRAME);
|
2008-08-05 02:40:43 +02:00
|
|
|
}
|
2008-08-05 02:40:36 +02:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2011-09-22 16:51:00 +02:00
|
|
|
static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
|
|
|
|
EbmlList *seekhead_list = &matroska->seekhead;
|
|
|
|
MatroskaSeekhead *seekhead = seekhead_list->elem;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < seekhead_list->nb_elem; i++)
|
|
|
|
if (seekhead[i].id == MATROSKA_ID_CUES)
|
|
|
|
break;
|
|
|
|
assert(i <= seekhead_list->nb_elem);
|
|
|
|
|
2012-02-12 14:09:03 +01:00
|
|
|
if (matroska_parse_seekhead_entry(matroska, i) < 0)
|
|
|
|
matroska->cues_parsing_deferred = -1;
|
2011-09-22 16:51:00 +02:00
|
|
|
matroska_add_index_entries(matroska);
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_aac_profile(char *codec_id)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2008-08-24 15:12:41 +02:00
|
|
|
static const char * const aac_profiles[] = { "MAIN", "LC", "SSR" };
|
2007-06-05 00:10:54 +02:00
|
|
|
int profile;
|
|
|
|
|
2008-10-21 23:40:24 +02:00
|
|
|
for (profile=0; profile<FF_ARRAY_ELEMS(aac_profiles); profile++)
|
2007-06-05 00:10:54 +02:00
|
|
|
if (strstr(codec_id, aac_profiles[profile]))
|
|
|
|
break;
|
|
|
|
return profile + 1;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_aac_sri(int samplerate)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
int sri;
|
|
|
|
|
2011-10-17 09:28:53 +02:00
|
|
|
for (sri=0; sri<FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
|
|
|
|
if (avpriv_mpeg4audio_sample_rates[sri] == samplerate)
|
2007-06-05 00:10:54 +02:00
|
|
|
break;
|
|
|
|
return sri;
|
|
|
|
}
|
|
|
|
|
2012-03-05 19:02:48 +01:00
|
|
|
static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
|
|
|
|
{
|
|
|
|
char buffer[32];
|
|
|
|
/* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
|
|
|
|
time_t creation_time = date_utc / 1000000000 + 978307200;
|
|
|
|
struct tm *ptm = gmtime(&creation_time);
|
|
|
|
if (!ptm) return;
|
|
|
|
strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
|
|
|
|
av_dict_set(metadata, "creation_time", buffer, 0);
|
|
|
|
}
|
|
|
|
|
2012-01-12 13:20:36 +01:00
|
|
|
static int matroska_read_header(AVFormatContext *s)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
MatroskaDemuxContext *matroska = s->priv_data;
|
2008-08-05 02:40:55 +02:00
|
|
|
EbmlList *attachements_list = &matroska->attachments;
|
|
|
|
MatroskaAttachement *attachements;
|
|
|
|
EbmlList *chapters_list = &matroska->chapters;
|
|
|
|
MatroskaChapter *chapters;
|
2008-08-05 02:40:49 +02:00
|
|
|
MatroskaTrack *tracks;
|
2009-01-15 01:42:57 +01:00
|
|
|
uint64_t max_start = 0;
|
2012-02-13 23:06:19 +01:00
|
|
|
int64_t pos;
|
2008-08-05 02:40:02 +02:00
|
|
|
Ebml ebml = { 0 };
|
2008-08-05 02:40:49 +02:00
|
|
|
AVStream *st;
|
2011-05-24 01:09:24 +02:00
|
|
|
int i, j, k, res;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
matroska->ctx = s;
|
|
|
|
|
|
|
|
/* First read the EBML header. */
|
2008-08-05 02:42:20 +02:00
|
|
|
if (ebml_parse(matroska, ebml_syntax, &ebml)
|
2008-08-05 02:40:02 +02:00
|
|
|
|| ebml.version > EBML_VERSION || ebml.max_size > sizeof(uint64_t)
|
2012-03-16 05:28:18 +01:00
|
|
|
|| ebml.id_length > sizeof(uint32_t) || ebml.doctype_version > 3 || !ebml.doctype) {
|
2007-06-05 00:10:54 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
2008-08-05 02:40:02 +02:00
|
|
|
"EBML header using unsupported features\n"
|
|
|
|
"(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
|
|
|
|
ebml.version, ebml.doctype, ebml.doctype_version);
|
2010-05-22 03:41:32 +02:00
|
|
|
ebml_free(ebml_syntax, &ebml);
|
|
|
|
return AVERROR_PATCHWELCOME;
|
2011-05-21 17:14:14 +02:00
|
|
|
} else if (ebml.doctype_version == 3) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_WARNING,
|
|
|
|
"EBML header using unsupported features\n"
|
|
|
|
"(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
|
|
|
|
ebml.version, ebml.doctype, ebml.doctype_version);
|
2010-05-22 03:41:32 +02:00
|
|
|
}
|
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
|
|
|
|
if (!strcmp(ebml.doctype, matroska_doctypes[i]))
|
|
|
|
break;
|
|
|
|
if (i >= FF_ARRAY_ELEMS(matroska_doctypes)) {
|
2010-05-22 03:41:35 +02:00
|
|
|
av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
2008-08-05 02:40:02 +02:00
|
|
|
ebml_free(ebml_syntax, &ebml);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
/* The next thing is a segment. */
|
2012-02-13 23:06:19 +01:00
|
|
|
pos = avio_tell(matroska->ctx->pb);
|
|
|
|
res = ebml_parse(matroska, matroska_segments, matroska);
|
|
|
|
// try resyncing until we find a EBML_STOP type element.
|
|
|
|
while (res != 1) {
|
|
|
|
res = matroska_resync(matroska, pos);
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
pos = avio_tell(matroska->ctx->pb);
|
|
|
|
res = ebml_parse(matroska, matroska_segment, matroska);
|
|
|
|
}
|
2008-08-05 02:40:36 +02:00
|
|
|
matroska_execute_seekhead(matroska);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2010-05-18 23:21:28 +02:00
|
|
|
if (!matroska->time_scale)
|
|
|
|
matroska->time_scale = 1000000;
|
2008-08-05 02:40:55 +02:00
|
|
|
if (matroska->duration)
|
|
|
|
matroska->ctx->duration = matroska->duration * matroska->time_scale
|
|
|
|
* 1000 / AV_TIME_BASE;
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(&s->metadata, "title", matroska->title, 0);
|
2008-08-05 02:40:55 +02:00
|
|
|
|
2012-03-05 19:02:48 +01:00
|
|
|
if (matroska->date_utc.size == 8)
|
|
|
|
matroska_metadata_creation_time(&s->metadata, AV_RB64(matroska->date_utc.data));
|
|
|
|
|
2008-08-05 02:40:52 +02:00
|
|
|
tracks = matroska->tracks.elem;
|
|
|
|
for (i=0; i < matroska->tracks.nb_elem; i++) {
|
|
|
|
MatroskaTrack *track = &tracks[i];
|
2012-08-05 11:11:04 +02:00
|
|
|
enum AVCodecID codec_id = AV_CODEC_ID_NONE;
|
2011-08-18 00:21:21 +02:00
|
|
|
EbmlList *encodings_list = &track->encodings;
|
2008-08-05 02:40:55 +02:00
|
|
|
MatroskaTrackEncoding *encodings = encodings_list->elem;
|
2008-08-05 02:40:52 +02:00
|
|
|
uint8_t *extradata = NULL;
|
|
|
|
int extradata_size = 0;
|
|
|
|
int extradata_offset = 0;
|
2011-06-14 01:58:11 +02:00
|
|
|
uint32_t fourcc = 0;
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext b;
|
2008-08-05 02:40:52 +02:00
|
|
|
|
|
|
|
/* Apply some sanity checks. */
|
2008-08-05 02:40:55 +02:00
|
|
|
if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
|
|
|
|
track->type != MATROSKA_TRACK_TYPE_AUDIO &&
|
|
|
|
track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
|
|
|
"Unknown or unsupported track type %"PRIu64"\n",
|
|
|
|
track->type);
|
|
|
|
continue;
|
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
if (track->codec_id == NULL)
|
|
|
|
continue;
|
|
|
|
|
2008-08-05 02:40:55 +02:00
|
|
|
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
|
2012-04-18 14:48:20 +02:00
|
|
|
if (!track->default_duration && track->video.frame_rate > 0)
|
2008-08-05 02:40:55 +02:00
|
|
|
track->default_duration = 1000000000/track->video.frame_rate;
|
|
|
|
if (!track->video.display_width)
|
|
|
|
track->video.display_width = track->video.pixel_width;
|
|
|
|
if (!track->video.display_height)
|
|
|
|
track->video.display_height = track->video.pixel_height;
|
2011-06-14 02:00:06 +02:00
|
|
|
if (track->video.color_space.size == 4)
|
|
|
|
fourcc = AV_RL32(track->video.color_space.data);
|
2008-08-05 02:40:55 +02:00
|
|
|
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
|
|
|
|
if (!track->audio.out_samplerate)
|
|
|
|
track->audio.out_samplerate = track->audio.samplerate;
|
|
|
|
}
|
|
|
|
if (encodings_list->nb_elem > 1) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
2011-09-15 09:34:38 +02:00
|
|
|
"Multiple combined encodings not supported");
|
2008-08-05 02:40:55 +02:00
|
|
|
} else if (encodings_list->nb_elem == 1) {
|
|
|
|
if (encodings[0].type ||
|
|
|
|
(encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_ZLIB
|
2008-08-05 02:40:55 +02:00
|
|
|
encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
|
|
|
|
#endif
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_BZLIB
|
2008-08-05 02:40:55 +02:00
|
|
|
encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
|
|
|
|
#endif
|
|
|
|
encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_LZO)) {
|
|
|
|
encodings[0].scope = 0;
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Unsupported encoding type");
|
|
|
|
} else if (track->codec_priv.size && encodings[0].scope&2) {
|
|
|
|
uint8_t *codec_priv = track->codec_priv.data;
|
|
|
|
int offset = matroska_decode_buffer(&track->codec_priv.data,
|
|
|
|
&track->codec_priv.size,
|
|
|
|
track);
|
|
|
|
if (offset < 0) {
|
|
|
|
track->codec_priv.data = NULL;
|
|
|
|
track->codec_priv.size = 0;
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Failed to decode codec private data\n");
|
|
|
|
} else if (offset > 0) {
|
|
|
|
track->codec_priv.data = av_malloc(track->codec_priv.size + offset);
|
|
|
|
memcpy(track->codec_priv.data,
|
|
|
|
encodings[0].compression.settings.data, offset);
|
|
|
|
memcpy(track->codec_priv.data+offset, codec_priv,
|
|
|
|
track->codec_priv.size);
|
|
|
|
track->codec_priv.size += offset;
|
|
|
|
}
|
|
|
|
if (codec_priv != track->codec_priv.data)
|
|
|
|
av_free(codec_priv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-05 11:11:04 +02:00
|
|
|
for(j=0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++){
|
2008-08-05 02:40:52 +02:00
|
|
|
if(!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
|
|
|
|
strlen(ff_mkv_codec_tags[j].str))){
|
|
|
|
codec_id= ff_mkv_codec_tags[j].id;
|
|
|
|
break;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-06-18 11:43:24 +02:00
|
|
|
st = track->stream = avformat_new_stream(s, NULL);
|
2008-08-05 02:40:52 +02:00
|
|
|
if (st == NULL)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2008-08-05 02:42:49 +02:00
|
|
|
if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC")
|
2008-08-05 02:41:31 +02:00
|
|
|
&& track->codec_priv.size >= 40
|
|
|
|
&& track->codec_priv.data != NULL) {
|
2010-03-03 22:46:43 +01:00
|
|
|
track->ms_compat = 1;
|
2011-06-14 01:58:11 +02:00
|
|
|
fourcc = AV_RL32(track->codec_priv.data + 16);
|
|
|
|
codec_id = ff_codec_get_id(ff_codec_bmp_tags, fourcc);
|
2009-08-24 15:43:33 +02:00
|
|
|
extradata_offset = 40;
|
2008-08-05 02:42:49 +02:00
|
|
|
} else if (!strcmp(track->codec_id, "A_MS/ACM")
|
2009-10-01 23:14:05 +02:00
|
|
|
&& track->codec_priv.size >= 14
|
2008-08-05 02:41:31 +02:00
|
|
|
&& track->codec_priv.data != NULL) {
|
2011-04-12 17:44:20 +02:00
|
|
|
int ret;
|
2011-02-20 11:04:13 +01:00
|
|
|
ffio_init_context(&b, track->codec_priv.data, track->codec_priv.size,
|
2011-04-15 16:42:09 +02:00
|
|
|
AVIO_FLAG_READ, NULL, NULL, NULL, NULL);
|
2011-04-12 17:44:20 +02:00
|
|
|
ret = ff_get_wav_header(&b, st->codec, track->codec_priv.size);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2009-01-18 18:13:12 +01:00
|
|
|
codec_id = st->codec->codec_id;
|
2009-10-01 23:14:05 +02:00
|
|
|
extradata_offset = FFMIN(track->codec_priv.size, 18);
|
2008-08-05 02:41:31 +02:00
|
|
|
} else if (!strcmp(track->codec_id, "V_QUICKTIME")
|
|
|
|
&& (track->codec_priv.size >= 86)
|
|
|
|
&& (track->codec_priv.data != NULL)) {
|
2011-06-14 01:58:11 +02:00
|
|
|
fourcc = AV_RL32(track->codec_priv.data);
|
2012-02-16 00:49:16 +01:00
|
|
|
codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
|
2012-08-07 22:45:46 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX-12) {
|
2012-08-05 16:25:48 +02:00
|
|
|
/* Only ALAC's magic cookie is stored in Matroska's track headers.
|
|
|
|
Create the "atom size", "tag", and "tag version" fields the
|
|
|
|
decoder expects manually. */
|
|
|
|
extradata_size = 12 + track->codec_priv.size;
|
|
|
|
extradata = av_mallocz(extradata_size);
|
|
|
|
if (extradata == NULL)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
AV_WB32(extradata, extradata_size);
|
|
|
|
memcpy(&extradata[4], "alac", 4);
|
|
|
|
AV_WB32(&extradata[8], 0);
|
|
|
|
memcpy(&extradata[12], track->codec_priv.data, track->codec_priv.size);
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
|
2008-08-20 02:49:45 +02:00
|
|
|
switch (track->audio.bitdepth) {
|
2012-08-05 11:11:04 +02:00
|
|
|
case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
|
|
|
|
case 24: codec_id = AV_CODEC_ID_PCM_S24BE; break;
|
|
|
|
case 32: codec_id = AV_CODEC_ID_PCM_S32BE; break;
|
2008-08-20 02:49:45 +02:00
|
|
|
}
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
|
2008-08-20 02:49:45 +02:00
|
|
|
switch (track->audio.bitdepth) {
|
2012-08-05 11:11:04 +02:00
|
|
|
case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
|
|
|
|
case 24: codec_id = AV_CODEC_ID_PCM_S24LE; break;
|
|
|
|
case 32: codec_id = AV_CODEC_ID_PCM_S32LE; break;
|
2008-08-20 02:49:45 +02:00
|
|
|
}
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id==AV_CODEC_ID_PCM_F32LE && track->audio.bitdepth==64) {
|
|
|
|
codec_id = AV_CODEC_ID_PCM_F64LE;
|
|
|
|
} else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
|
2008-08-05 02:40:52 +02:00
|
|
|
int profile = matroska_aac_profile(track->codec_id);
|
|
|
|
int sri = matroska_aac_sri(track->audio.samplerate);
|
2012-01-25 23:34:21 +01:00
|
|
|
extradata = av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE);
|
2008-08-05 02:40:52 +02:00
|
|
|
if (extradata == NULL)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
|
|
|
|
extradata[1] = ((sri&0x01) << 7) | (track->audio.channels<<3);
|
|
|
|
if (strstr(track->codec_id, "SBR")) {
|
|
|
|
sri = matroska_aac_sri(track->audio.out_samplerate);
|
|
|
|
extradata[2] = 0x56;
|
|
|
|
extradata[3] = 0xE5;
|
|
|
|
extradata[4] = 0x80 | (sri<<3);
|
|
|
|
extradata_size = 5;
|
2008-08-05 02:41:10 +02:00
|
|
|
} else
|
2008-08-05 02:40:52 +02:00
|
|
|
extradata_size = 2;
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_TTA) {
|
2008-08-05 02:40:52 +02:00
|
|
|
extradata_size = 30;
|
2012-01-26 17:22:34 +01:00
|
|
|
extradata = av_mallocz(extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
|
2008-08-05 02:40:52 +02:00
|
|
|
if (extradata == NULL)
|
|
|
|
return AVERROR(ENOMEM);
|
2011-02-20 11:04:13 +01:00
|
|
|
ffio_init_context(&b, extradata, extradata_size, 1,
|
2008-08-05 02:40:52 +02:00
|
|
|
NULL, NULL, NULL, NULL);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(&b, "TTA1", 4);
|
|
|
|
avio_wl16(&b, 1);
|
|
|
|
avio_wl16(&b, track->audio.channels);
|
|
|
|
avio_wl16(&b, track->audio.bitdepth);
|
|
|
|
avio_wl32(&b, track->audio.out_samplerate);
|
|
|
|
avio_wl32(&b, matroska->ctx->duration * track->audio.out_samplerate);
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_RV10 || codec_id == AV_CODEC_ID_RV20 ||
|
|
|
|
codec_id == AV_CODEC_ID_RV30 || codec_id == AV_CODEC_ID_RV40) {
|
2008-08-05 02:40:52 +02:00
|
|
|
extradata_offset = 26;
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (codec_id == AV_CODEC_ID_RA_144) {
|
2008-08-05 02:40:52 +02:00
|
|
|
track->audio.out_samplerate = 8000;
|
|
|
|
track->audio.channels = 1;
|
2012-08-07 22:45:46 +02:00
|
|
|
} else if ((codec_id == AV_CODEC_ID_RA_288 || codec_id == AV_CODEC_ID_COOK ||
|
|
|
|
codec_id == AV_CODEC_ID_ATRAC3 || codec_id == AV_CODEC_ID_SIPR)
|
2012-04-14 19:33:24 +02:00
|
|
|
&& track->codec_priv.data) {
|
2010-03-13 00:49:06 +01:00
|
|
|
int flavor;
|
2012-04-14 19:33:24 +02:00
|
|
|
|
2011-02-20 11:04:13 +01:00
|
|
|
ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size,
|
2008-08-05 02:40:52 +02:00
|
|
|
0, NULL, NULL, NULL, NULL);
|
2011-03-15 09:14:38 +01:00
|
|
|
avio_skip(&b, 22);
|
2011-02-21 16:43:01 +01:00
|
|
|
flavor = avio_rb16(&b);
|
|
|
|
track->audio.coded_framesize = avio_rb32(&b);
|
2011-03-15 09:14:38 +01:00
|
|
|
avio_skip(&b, 12);
|
2011-02-21 16:43:01 +01:00
|
|
|
track->audio.sub_packet_h = avio_rb16(&b);
|
|
|
|
track->audio.frame_size = avio_rb16(&b);
|
|
|
|
track->audio.sub_packet_size = avio_rb16(&b);
|
2008-08-05 02:40:52 +02:00
|
|
|
track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
|
2012-08-05 11:11:04 +02:00
|
|
|
if (codec_id == AV_CODEC_ID_RA_288) {
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->block_align = track->audio.coded_framesize;
|
|
|
|
track->codec_priv.size = 0;
|
|
|
|
} else {
|
2012-08-05 11:11:04 +02:00
|
|
|
if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) {
|
2010-03-13 00:49:06 +01:00
|
|
|
const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
|
|
|
|
track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
|
|
|
|
st->codec->bit_rate = sipr_bit_rate[flavor];
|
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->block_align = track->audio.sub_packet_size;
|
|
|
|
extradata_offset = 78;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
}
|
2009-08-24 15:40:30 +02:00
|
|
|
track->codec_priv.size -= extradata_offset;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2012-08-05 11:11:04 +02:00
|
|
|
if (codec_id == AV_CODEC_ID_NONE)
|
2008-08-05 02:40:52 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
2012-08-05 11:11:04 +02:00
|
|
|
"Unknown/unsupported AVCodecID %s.\n", track->codec_id);
|
2007-06-05 00:19:17 +02:00
|
|
|
|
2008-09-09 13:23:48 +02:00
|
|
|
if (track->time_scale < 0.01)
|
|
|
|
track->time_scale = 1.0;
|
2011-11-29 19:28:15 +01:00
|
|
|
avpriv_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
|
2007-06-05 00:19:17 +02:00
|
|
|
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->codec_id = codec_id;
|
|
|
|
st->start_time = 0;
|
|
|
|
if (strcmp(track->language, "und"))
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(&st->metadata, "language", track->language, 0);
|
|
|
|
av_dict_set(&st->metadata, "title", track->name, 0);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:52 +02:00
|
|
|
if (track->flag_default)
|
|
|
|
st->disposition |= AV_DISPOSITION_DEFAULT;
|
2010-07-02 18:38:44 +02:00
|
|
|
if (track->flag_forced)
|
|
|
|
st->disposition |= AV_DISPOSITION_FORCED;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2009-10-01 23:14:46 +02:00
|
|
|
if (!st->codec->extradata) {
|
2009-10-01 23:15:36 +02:00
|
|
|
if(extradata){
|
|
|
|
st->codec->extradata = extradata;
|
|
|
|
st->codec->extradata_size = extradata_size;
|
|
|
|
} else if(track->codec_priv.data && track->codec_priv.size > 0){
|
|
|
|
st->codec->extradata = av_mallocz(track->codec_priv.size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
|
|
|
if(st->codec->extradata == NULL)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
st->codec->extradata_size = track->codec_priv.size;
|
|
|
|
memcpy(st->codec->extradata,
|
|
|
|
track->codec_priv.data + extradata_offset,
|
|
|
|
track->codec_priv.size);
|
|
|
|
}
|
2009-10-01 23:14:46 +02:00
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
|
|
|
|
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
|
2011-05-24 01:09:24 +02:00
|
|
|
MatroskaTrackPlane *planes = track->operation.combine_planes.elem;
|
|
|
|
|
2010-03-31 01:30:55 +02:00
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
|
2011-06-14 01:58:11 +02:00
|
|
|
st->codec->codec_tag = fourcc;
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->width = track->video.pixel_width;
|
|
|
|
st->codec->height = track->video.pixel_height;
|
2008-08-24 01:43:20 +02:00
|
|
|
av_reduce(&st->sample_aspect_ratio.num,
|
|
|
|
&st->sample_aspect_ratio.den,
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->height * track->video.display_width,
|
|
|
|
st->codec-> width * track->video.display_height,
|
|
|
|
255);
|
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS;
|
2012-04-18 01:32:07 +02:00
|
|
|
if (track->default_duration) {
|
2012-06-26 13:10:01 +02:00
|
|
|
av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
|
2012-04-18 01:32:07 +02:00
|
|
|
1000000000, track->default_duration, 30000);
|
2012-06-26 13:10:01 +02:00
|
|
|
#if FF_API_R_FRAME_RATE
|
|
|
|
st->r_frame_rate = st->avg_frame_rate;
|
|
|
|
#endif
|
2012-04-18 01:32:07 +02:00
|
|
|
}
|
2011-05-21 17:14:14 +02:00
|
|
|
|
2011-05-24 01:09:24 +02:00
|
|
|
/* export stereo mode flag as metadata tag */
|
|
|
|
if (track->video.stereo_mode && track->video.stereo_mode < MATROSKA_VIDEO_STEREO_MODE_COUNT)
|
2011-06-13 19:02:50 +02:00
|
|
|
av_dict_set(&st->metadata, "stereo_mode", matroska_video_stereo_mode[track->video.stereo_mode], 0);
|
2011-05-24 01:09:24 +02:00
|
|
|
|
|
|
|
/* if we have virtual track, mark the real tracks */
|
|
|
|
for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
|
|
|
|
char buf[32];
|
2011-05-24 23:26:24 +02:00
|
|
|
if (planes[j].type >= MATROSKA_VIDEO_STEREO_PLANE_COUNT)
|
2011-05-24 01:09:24 +02:00
|
|
|
continue;
|
|
|
|
snprintf(buf, sizeof(buf), "%s_%d",
|
|
|
|
matroska_video_stereo_plane[planes[j].type], i);
|
|
|
|
for (k=0; k < matroska->tracks.nb_elem; k++)
|
|
|
|
if (planes[j].uid == tracks[k].uid) {
|
2011-06-13 19:02:50 +02:00
|
|
|
av_dict_set(&s->streams[k]->metadata,
|
|
|
|
"stereo_mode", buf, 0);
|
2011-05-21 17:14:14 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-08-05 02:40:52 +02:00
|
|
|
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
|
2010-03-31 01:30:55 +02:00
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
|
2008-08-05 02:40:52 +02:00
|
|
|
st->codec->sample_rate = track->audio.out_samplerate;
|
|
|
|
st->codec->channels = track->audio.channels;
|
2012-08-05 11:11:04 +02:00
|
|
|
if (st->codec->codec_id != AV_CODEC_ID_AAC)
|
2010-04-20 23:19:27 +02:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS;
|
2008-08-05 02:40:52 +02:00
|
|
|
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
|
2010-03-31 01:30:55 +02:00
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
|
2012-08-05 11:11:04 +02:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_SSA)
|
2012-04-19 20:12:24 +02:00
|
|
|
matroska->contains_ssa = 1;
|
2008-08-05 02:40:52 +02:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:40:55 +02:00
|
|
|
attachements = attachements_list->elem;
|
|
|
|
for (j=0; j<attachements_list->nb_elem; j++) {
|
|
|
|
if (!(attachements[j].filename && attachements[j].mime &&
|
|
|
|
attachements[j].bin.data && attachements[j].bin.size > 0)) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
|
|
|
|
} else {
|
2011-06-18 11:43:24 +02:00
|
|
|
AVStream *st = avformat_new_stream(s, NULL);
|
2008-08-05 02:40:55 +02:00
|
|
|
if (st == NULL)
|
|
|
|
break;
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(&st->metadata, "filename",attachements[j].filename, 0);
|
2011-09-27 10:36:53 +02:00
|
|
|
av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
|
2012-08-05 11:11:04 +02:00
|
|
|
st->codec->codec_id = AV_CODEC_ID_NONE;
|
2010-03-31 01:30:55 +02:00
|
|
|
st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
|
2012-01-26 17:22:34 +01:00
|
|
|
st->codec->extradata = av_malloc(attachements[j].bin.size + FF_INPUT_BUFFER_PADDING_SIZE);
|
2008-08-05 02:40:55 +02:00
|
|
|
if(st->codec->extradata == NULL)
|
|
|
|
break;
|
|
|
|
st->codec->extradata_size = attachements[j].bin.size;
|
|
|
|
memcpy(st->codec->extradata, attachements[j].bin.data, attachements[j].bin.size);
|
|
|
|
|
2012-08-05 11:11:04 +02:00
|
|
|
for (i=0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
|
2008-08-05 02:40:55 +02:00
|
|
|
if (!strncmp(ff_mkv_mime_tags[i].str, attachements[j].mime,
|
|
|
|
strlen(ff_mkv_mime_tags[i].str))) {
|
|
|
|
st->codec->codec_id = ff_mkv_mime_tags[i].id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-02-15 16:53:55 +01:00
|
|
|
attachements[j].stream = st;
|
2008-08-05 02:40:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
chapters = chapters_list->elem;
|
|
|
|
for (i=0; i<chapters_list->nb_elem; i++)
|
2009-01-15 01:42:57 +01:00
|
|
|
if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid
|
|
|
|
&& (max_start==0 || chapters[i].start > max_start)) {
|
2009-02-15 16:25:14 +01:00
|
|
|
chapters[i].chapter =
|
2011-10-17 08:58:50 +02:00
|
|
|
avpriv_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
|
2008-08-05 02:40:55 +02:00
|
|
|
chapters[i].start, chapters[i].end,
|
|
|
|
chapters[i].title);
|
2011-05-22 12:46:29 +02:00
|
|
|
av_dict_set(&chapters[i].chapter->metadata,
|
2010-04-25 16:27:42 +02:00
|
|
|
"title", chapters[i].title, 0);
|
2009-01-15 01:42:57 +01:00
|
|
|
max_start = chapters[i].start;
|
|
|
|
}
|
2008-08-05 02:40:55 +02:00
|
|
|
|
2011-09-22 16:51:00 +02:00
|
|
|
matroska_add_index_entries(matroska);
|
|
|
|
|
2009-02-15 16:53:55 +01:00
|
|
|
matroska_convert_tags(s);
|
|
|
|
|
2008-08-05 02:40:58 +02:00
|
|
|
return 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:39 +02:00
|
|
|
/*
|
|
|
|
* Put one packet in an application-supplied AVPacket struct.
|
|
|
|
* Returns 0 on success or -1 on failure.
|
|
|
|
*/
|
|
|
|
static int matroska_deliver_packet(MatroskaDemuxContext *matroska,
|
|
|
|
AVPacket *pkt)
|
|
|
|
{
|
|
|
|
if (matroska->num_packets > 0) {
|
|
|
|
memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
|
|
|
|
av_free(matroska->packets[0]);
|
|
|
|
if (matroska->num_packets > 1) {
|
2011-07-28 14:59:54 +02:00
|
|
|
void *newpackets;
|
2008-08-05 02:42:39 +02:00
|
|
|
memmove(&matroska->packets[0], &matroska->packets[1],
|
|
|
|
(matroska->num_packets - 1) * sizeof(AVPacket *));
|
2011-07-28 14:59:54 +02:00
|
|
|
newpackets = av_realloc(matroska->packets,
|
|
|
|
(matroska->num_packets - 1) * sizeof(AVPacket *));
|
|
|
|
if (newpackets)
|
|
|
|
matroska->packets = newpackets;
|
2008-08-05 02:42:39 +02:00
|
|
|
} else {
|
|
|
|
av_freep(&matroska->packets);
|
2012-04-19 20:12:24 +02:00
|
|
|
matroska->prev_pkt = NULL;
|
2008-08-05 02:42:39 +02:00
|
|
|
}
|
|
|
|
matroska->num_packets--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free all packets in our internal queue.
|
|
|
|
*/
|
|
|
|
static void matroska_clear_queue(MatroskaDemuxContext *matroska)
|
|
|
|
{
|
|
|
|
if (matroska->packets) {
|
|
|
|
int n;
|
|
|
|
for (n = 0; n < matroska->num_packets; n++) {
|
|
|
|
av_free_packet(matroska->packets[n]);
|
|
|
|
av_free(matroska->packets[n]);
|
|
|
|
}
|
2008-08-06 02:21:10 +02:00
|
|
|
av_freep(&matroska->packets);
|
2008-08-05 02:42:39 +02:00
|
|
|
matroska->num_packets = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
|
|
|
|
int size, int64_t pos, uint64_t cluster_time,
|
2008-09-07 01:39:59 +02:00
|
|
|
uint64_t duration, int is_keyframe,
|
|
|
|
int64_t cluster_pos)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2008-09-09 13:54:35 +02:00
|
|
|
uint64_t timecode = AV_NOPTS_VALUE;
|
2008-08-05 02:40:12 +02:00
|
|
|
MatroskaTrack *track;
|
2008-09-07 01:44:29 +02:00
|
|
|
int res = 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
AVStream *st;
|
|
|
|
AVPacket *pkt;
|
|
|
|
int16_t block_time;
|
|
|
|
uint32_t *lace_size = NULL;
|
|
|
|
int n, flags, laces = 0;
|
|
|
|
uint64_t num;
|
|
|
|
|
2008-08-05 02:42:52 +02:00
|
|
|
if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
|
2007-06-05 00:10:54 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
|
2012-04-30 02:39:31 +02:00
|
|
|
return n;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
data += n;
|
|
|
|
size -= n;
|
|
|
|
|
|
|
|
track = matroska_find_track_by_num(matroska, num);
|
2011-10-30 01:17:51 +02:00
|
|
|
if (!track || !track->stream) {
|
2007-06-05 00:10:54 +02:00
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
2008-08-05 02:40:12 +02:00
|
|
|
"Invalid stream %"PRIu64" or size %u\n", num, size);
|
2012-02-13 23:06:19 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2011-10-30 01:17:51 +02:00
|
|
|
} else if (size <= 3)
|
|
|
|
return 0;
|
2008-08-05 02:40:12 +02:00
|
|
|
st = track->stream;
|
2008-08-05 02:41:10 +02:00
|
|
|
if (st->discard >= AVDISCARD_ALL)
|
2007-06-05 00:10:54 +02:00
|
|
|
return res;
|
2012-04-24 00:19:55 +02:00
|
|
|
av_assert1(duration != AV_NOPTS_VALUE);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2007-06-23 14:32:19 +02:00
|
|
|
block_time = AV_RB16(data);
|
2007-06-05 00:10:54 +02:00
|
|
|
data += 2;
|
2007-06-23 14:49:36 +02:00
|
|
|
flags = *data++;
|
|
|
|
size -= 3;
|
2007-06-05 00:10:54 +02:00
|
|
|
if (is_keyframe == -1)
|
2010-03-31 14:29:58 +02:00
|
|
|
is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-09-09 13:54:35 +02:00
|
|
|
if (cluster_time != (uint64_t)-1
|
|
|
|
&& (block_time >= 0 || cluster_time >= -block_time)) {
|
|
|
|
timecode = cluster_time + block_time;
|
2008-09-09 14:07:10 +02:00
|
|
|
if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE
|
|
|
|
&& timecode < track->end_timecode)
|
|
|
|
is_keyframe = 0; /* overlapping subtitles are not key frame */
|
2008-09-12 02:06:06 +02:00
|
|
|
if (is_keyframe)
|
2008-09-09 13:54:35 +02:00
|
|
|
av_add_index_entry(st, cluster_pos, timecode, 0,0,AVINDEX_KEYFRAME);
|
|
|
|
}
|
|
|
|
|
2008-09-09 14:10:25 +02:00
|
|
|
if (matroska->skip_to_keyframe && track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
|
2012-04-14 00:17:30 +02:00
|
|
|
if (timecode < matroska->skip_to_timecode)
|
2007-06-05 00:10:54 +02:00
|
|
|
return res;
|
2012-04-14 00:17:30 +02:00
|
|
|
if (!st->skip_to_keyframe) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
|
|
|
|
matroska->skip_to_keyframe = 0;
|
|
|
|
}
|
|
|
|
if (is_keyframe)
|
|
|
|
matroska->skip_to_keyframe = 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
switch ((flags & 0x06) >> 1) {
|
|
|
|
case 0x0: /* no lacing */
|
|
|
|
laces = 1;
|
|
|
|
lace_size = av_mallocz(sizeof(int));
|
|
|
|
lace_size[0] = size;
|
|
|
|
break;
|
|
|
|
|
2008-08-05 10:28:57 +02:00
|
|
|
case 0x1: /* Xiph lacing */
|
2007-06-05 00:10:54 +02:00
|
|
|
case 0x2: /* fixed-size lacing */
|
|
|
|
case 0x3: /* EBML lacing */
|
2012-06-15 01:27:56 +02:00
|
|
|
av_assert0(size>0); // size <=3 is checked before size-=3 above
|
2007-06-05 00:10:54 +02:00
|
|
|
laces = (*data) + 1;
|
|
|
|
data += 1;
|
|
|
|
size -= 1;
|
|
|
|
lace_size = av_mallocz(laces * sizeof(int));
|
|
|
|
|
|
|
|
switch ((flags & 0x06) >> 1) {
|
2008-08-05 10:28:57 +02:00
|
|
|
case 0x1: /* Xiph lacing */ {
|
2007-06-05 00:10:54 +02:00
|
|
|
uint8_t temp;
|
|
|
|
uint32_t total = 0;
|
|
|
|
for (n = 0; res == 0 && n < laces - 1; n++) {
|
|
|
|
while (1) {
|
|
|
|
if (size == 0) {
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
temp = *data;
|
|
|
|
lace_size[n] += temp;
|
|
|
|
data += 1;
|
|
|
|
size -= 1;
|
|
|
|
if (temp != 0xff)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
total += lace_size[n];
|
|
|
|
}
|
|
|
|
lace_size[n] = size - total;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 0x2: /* fixed-size lacing */
|
|
|
|
for (n = 0; n < laces; n++)
|
|
|
|
lace_size[n] = size / laces;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x3: /* EBML lacing */ {
|
|
|
|
uint32_t total;
|
2008-08-05 02:42:52 +02:00
|
|
|
n = matroska_ebmlnum_uint(matroska, data, size, &num);
|
2007-06-05 00:10:54 +02:00
|
|
|
if (n < 0) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
|
|
|
"EBML block data error\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
data += n;
|
|
|
|
size -= n;
|
|
|
|
total = lace_size[0] = num;
|
|
|
|
for (n = 1; res == 0 && n < laces - 1; n++) {
|
|
|
|
int64_t snum;
|
|
|
|
int r;
|
2008-08-05 02:42:52 +02:00
|
|
|
r = matroska_ebmlnum_sint(matroska, data, size, &snum);
|
2007-06-05 00:10:54 +02:00
|
|
|
if (r < 0) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_INFO,
|
|
|
|
"EBML block data error\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
data += r;
|
|
|
|
size -= r;
|
|
|
|
lace_size[n] = lace_size[n - 1] + snum;
|
|
|
|
total += lace_size[n];
|
|
|
|
}
|
2011-10-15 00:03:55 +02:00
|
|
|
lace_size[laces - 1] = size - total;
|
2007-06-05 00:10:54 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res == 0) {
|
2012-08-08 17:53:41 +02:00
|
|
|
if (!duration)
|
|
|
|
duration = track->default_duration * laces / matroska->time_scale;
|
|
|
|
|
|
|
|
if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
|
|
|
|
track->end_timecode = FFMAX(track->end_timecode, timecode+duration);
|
|
|
|
|
2007-06-05 00:10:54 +02:00
|
|
|
for (n = 0; n < laces; n++) {
|
2012-08-08 17:53:41 +02:00
|
|
|
int64_t lace_duration = duration*(n+1) / laces - duration*n / laces;
|
|
|
|
|
2012-06-15 01:28:40 +02:00
|
|
|
if (lace_size[n] > size) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-08-05 11:11:04 +02:00
|
|
|
if ((st->codec->codec_id == AV_CODEC_ID_RA_288 ||
|
|
|
|
st->codec->codec_id == AV_CODEC_ID_COOK ||
|
|
|
|
st->codec->codec_id == AV_CODEC_ID_SIPR ||
|
|
|
|
st->codec->codec_id == AV_CODEC_ID_ATRAC3) &&
|
2010-01-11 01:31:55 +01:00
|
|
|
st->codec->block_align && track->audio.sub_packet_size) {
|
2007-10-22 00:27:24 +02:00
|
|
|
int a = st->codec->block_align;
|
2008-08-05 02:40:31 +02:00
|
|
|
int sps = track->audio.sub_packet_size;
|
|
|
|
int cfs = track->audio.coded_framesize;
|
|
|
|
int h = track->audio.sub_packet_h;
|
|
|
|
int y = track->audio.sub_packet_cnt;
|
|
|
|
int w = track->audio.frame_size;
|
2007-10-22 00:27:24 +02:00
|
|
|
int x;
|
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
if (!track->audio.pkt_cnt) {
|
2011-02-26 12:52:01 +01:00
|
|
|
if (track->audio.sub_packet_cnt == 0)
|
|
|
|
track->audio.buf_timecode = timecode;
|
2012-08-05 11:11:04 +02:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_RA_288) {
|
2012-03-02 02:01:22 +01:00
|
|
|
if (size < cfs * h / 2) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Corrupt int4 RM-style audio packet size\n");
|
2012-04-13 06:24:04 +02:00
|
|
|
res = AVERROR_INVALIDDATA;
|
|
|
|
goto end;
|
2012-03-02 02:01:22 +01:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
for (x=0; x<h/2; x++)
|
2008-08-05 02:40:31 +02:00
|
|
|
memcpy(track->audio.buf+x*2*w+y*cfs,
|
2007-10-22 00:27:24 +02:00
|
|
|
data+x*cfs, cfs);
|
2012-08-05 11:11:04 +02:00
|
|
|
} else if (st->codec->codec_id == AV_CODEC_ID_SIPR) {
|
2012-03-02 02:01:22 +01:00
|
|
|
if (size < w) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Corrupt sipr RM-style audio packet size\n");
|
2012-04-13 06:24:04 +02:00
|
|
|
res = AVERROR_INVALIDDATA;
|
|
|
|
goto end;
|
2012-03-02 02:01:22 +01:00
|
|
|
}
|
2010-03-13 00:49:06 +01:00
|
|
|
memcpy(track->audio.buf + y*w, data, w);
|
2012-03-02 02:01:22 +01:00
|
|
|
} else {
|
|
|
|
if (size < sps * w / sps) {
|
|
|
|
av_log(matroska->ctx, AV_LOG_ERROR,
|
|
|
|
"Corrupt generic RM-style audio packet size\n");
|
2012-04-13 06:24:04 +02:00
|
|
|
res = AVERROR_INVALIDDATA;
|
|
|
|
goto end;
|
2012-03-02 02:01:22 +01:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
for (x=0; x<w/sps; x++)
|
2008-08-05 02:40:31 +02:00
|
|
|
memcpy(track->audio.buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);
|
2012-03-02 02:01:22 +01:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
if (++track->audio.sub_packet_cnt >= h) {
|
2012-08-05 11:11:04 +02:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_SIPR)
|
2010-03-13 00:49:06 +01:00
|
|
|
ff_rm_reorder_sipr_data(track->audio.buf, h, w);
|
2008-08-05 02:40:31 +02:00
|
|
|
track->audio.sub_packet_cnt = 0;
|
|
|
|
track->audio.pkt_cnt = h*w / a;
|
2007-07-11 15:37:07 +02:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
}
|
2008-08-05 02:40:31 +02:00
|
|
|
while (track->audio.pkt_cnt) {
|
2007-06-05 00:21:29 +02:00
|
|
|
pkt = av_mallocz(sizeof(AVPacket));
|
2007-10-22 00:27:24 +02:00
|
|
|
av_new_packet(pkt, a);
|
2008-08-05 02:40:31 +02:00
|
|
|
memcpy(pkt->data, track->audio.buf
|
|
|
|
+ a * (h*w / a - track->audio.pkt_cnt--), a);
|
2011-02-26 12:52:01 +01:00
|
|
|
pkt->pts = track->audio.buf_timecode;
|
|
|
|
track->audio.buf_timecode = AV_NOPTS_VALUE;
|
2007-06-05 00:21:29 +02:00
|
|
|
pkt->pos = pos;
|
2008-08-05 02:40:06 +02:00
|
|
|
pkt->stream_index = st->index;
|
2008-08-06 02:17:47 +02:00
|
|
|
dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
|
2007-06-05 00:19:17 +02:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
} else {
|
2008-08-05 02:40:31 +02:00
|
|
|
MatroskaTrackEncoding *encodings = track->encodings.elem;
|
2012-06-15 00:22:25 +02:00
|
|
|
int offset = 0;
|
|
|
|
uint32_t pkt_size = lace_size[n];
|
2008-05-09 03:53:59 +02:00
|
|
|
uint8_t *pkt_data = data;
|
2007-10-22 00:27:24 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
if (encodings && encodings->scope & 1) {
|
2008-08-05 02:41:22 +02:00
|
|
|
offset = matroska_decode_buffer(&pkt_data,&pkt_size, track);
|
2008-06-22 17:49:44 +02:00
|
|
|
if (offset < 0)
|
|
|
|
continue;
|
2012-06-15 01:35:52 +02:00
|
|
|
av_assert0(offset + pkt_size >= pkt_size);
|
2008-05-08 23:47:31 +02:00
|
|
|
}
|
|
|
|
|
2007-10-22 00:27:24 +02:00
|
|
|
pkt = av_mallocz(sizeof(AVPacket));
|
|
|
|
/* XXX: prevent data copy... */
|
2008-05-09 03:53:59 +02:00
|
|
|
if (av_new_packet(pkt, pkt_size+offset) < 0) {
|
2008-06-03 01:27:14 +02:00
|
|
|
av_free(pkt);
|
2007-10-22 00:27:24 +02:00
|
|
|
res = AVERROR(ENOMEM);
|
|
|
|
break;
|
|
|
|
}
|
2008-05-08 23:47:31 +02:00
|
|
|
if (offset)
|
2008-08-05 02:40:31 +02:00
|
|
|
memcpy (pkt->data, encodings->compression.settings.data, offset);
|
2008-05-09 03:53:59 +02:00
|
|
|
memcpy (pkt->data+offset, pkt_data, pkt_size);
|
2007-10-22 00:27:24 +02:00
|
|
|
|
2008-06-22 17:46:36 +02:00
|
|
|
if (pkt_data != data)
|
|
|
|
av_free(pkt_data);
|
|
|
|
|
2007-10-22 00:27:24 +02:00
|
|
|
if (n == 0)
|
|
|
|
pkt->flags = is_keyframe;
|
2008-08-05 02:40:06 +02:00
|
|
|
pkt->stream_index = st->index;
|
2007-10-22 00:27:24 +02:00
|
|
|
|
2010-03-03 22:46:43 +01:00
|
|
|
if (track->ms_compat)
|
|
|
|
pkt->dts = timecode;
|
|
|
|
else
|
2010-03-03 22:49:24 +01:00
|
|
|
pkt->pts = timecode;
|
2007-10-22 00:27:24 +02:00
|
|
|
pkt->pos = pos;
|
matroskadec, matroskadec, srtenc: Read/Write duration for subtitles.
After much discussion and back-and-forth, we reached the conclusion
that matroska uses convergence_duration for subtitle duration because
a 32bit value isn't large enough to store the duration if sub-micro-second
timebases are used. Matroska may not be the only one that supports these
timebases, but it's certainly the only one that ffmpeg attempts to support
in this way.
The long term solution that we seemed to reach was that if we encounter
a matroska file with a sub-micro-second timebase, we should internally
scale it up to at least micro-second, and then duration can be used
normally. This suggests that on the encode side, we should not allow
generation of files with sub-micro-second timebases, but that's a separate
issue.
That being a non-trivial change, and the subtitle interoperability breakage
being very real, I'm re-submitting this small change for consideration.
In this diff, we make sure that duration is populated by the matroska
demuxer, and that convergence_duration is respected in matroskaenc and
srtenc, but that duration is used otherwise. This ends up being a strict
improvement - pipelines that use convergence duration are unchanged, and
ones that are currently broken due to the duration mismatch will start
working - except for the ones with the extreme timebases, but those were
already broken.
Signed-off-by: Philip Langdale <philipl@overt.org>
2012-05-23 06:50:02 +02:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_SUBRIP) {
|
|
|
|
/*
|
|
|
|
* For backward compatibility.
|
|
|
|
* Historically, we have put subtitle duration
|
|
|
|
* in convergence_duration, on the off chance
|
|
|
|
* that the time_scale is less than 1us, which
|
|
|
|
* could result in a 32bit overflow on the
|
|
|
|
* normal duration field.
|
|
|
|
*/
|
2012-08-08 17:53:41 +02:00
|
|
|
pkt->convergence_duration = lace_duration;
|
matroskadec, matroskadec, srtenc: Read/Write duration for subtitles.
After much discussion and back-and-forth, we reached the conclusion
that matroska uses convergence_duration for subtitle duration because
a 32bit value isn't large enough to store the duration if sub-micro-second
timebases are used. Matroska may not be the only one that supports these
timebases, but it's certainly the only one that ffmpeg attempts to support
in this way.
The long term solution that we seemed to reach was that if we encounter
a matroska file with a sub-micro-second timebase, we should internally
scale it up to at least micro-second, and then duration can be used
normally. This suggests that on the encode side, we should not allow
generation of files with sub-micro-second timebases, but that's a separate
issue.
That being a non-trivial change, and the subtitle interoperability breakage
being very real, I'm re-submitting this small change for consideration.
In this diff, we make sure that duration is populated by the matroska
demuxer, and that convergence_duration is respected in matroskaenc and
srtenc, but that duration is used otherwise. This ends up being a strict
improvement - pipelines that use convergence duration are unchanged, and
ones that are currently broken due to the duration mismatch will start
working - except for the ones with the extreme timebases, but those were
already broken.
Signed-off-by: Philip Langdale <philipl@overt.org>
2012-05-23 06:50:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE ||
|
|
|
|
lace_duration <= INT_MAX) {
|
|
|
|
/*
|
|
|
|
* For non subtitle tracks, just store the duration
|
|
|
|
* as normal.
|
|
|
|
*
|
|
|
|
* If it's a subtitle track and duration value does
|
|
|
|
* not overflow a uint32, then also store it normally.
|
|
|
|
*/
|
2012-08-08 17:53:41 +02:00
|
|
|
pkt->duration = lace_duration;
|
matroskadec, matroskadec, srtenc: Read/Write duration for subtitles.
After much discussion and back-and-forth, we reached the conclusion
that matroska uses convergence_duration for subtitle duration because
a 32bit value isn't large enough to store the duration if sub-micro-second
timebases are used. Matroska may not be the only one that supports these
timebases, but it's certainly the only one that ffmpeg attempts to support
in this way.
The long term solution that we seemed to reach was that if we encounter
a matroska file with a sub-micro-second timebase, we should internally
scale it up to at least micro-second, and then duration can be used
normally. This suggests that on the encode side, we should not allow
generation of files with sub-micro-second timebases, but that's a separate
issue.
That being a non-trivial change, and the subtitle interoperability breakage
being very real, I'm re-submitting this small change for consideration.
In this diff, we make sure that duration is populated by the matroska
demuxer, and that convergence_duration is respected in matroskaenc and
srtenc, but that duration is used otherwise. This ends up being a strict
improvement - pipelines that use convergence duration are unchanged, and
ones that are currently broken due to the duration mismatch will start
working - except for the ones with the extreme timebases, but those were
already broken.
Signed-off-by: Philip Langdale <philipl@overt.org>
2012-05-23 06:50:02 +02:00
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
|
2012-08-05 11:11:04 +02:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_SSA)
|
2012-08-08 17:53:41 +02:00
|
|
|
matroska_fix_ass_packet(matroska, pkt, lace_duration);
|
2008-09-05 01:26:12 +02:00
|
|
|
|
2008-09-29 01:06:25 +02:00
|
|
|
if (matroska->prev_pkt &&
|
2008-10-02 23:14:56 +02:00
|
|
|
timecode != AV_NOPTS_VALUE &&
|
2008-09-29 01:06:25 +02:00
|
|
|
matroska->prev_pkt->pts == timecode &&
|
2010-07-02 18:41:38 +02:00
|
|
|
matroska->prev_pkt->stream_index == st->index &&
|
2012-08-05 11:11:04 +02:00
|
|
|
st->codec->codec_id == AV_CODEC_ID_SSA)
|
2008-09-29 01:06:25 +02:00
|
|
|
matroska_merge_packets(matroska->prev_pkt, pkt);
|
|
|
|
else {
|
2008-10-02 23:15:48 +02:00
|
|
|
dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
|
2008-09-29 01:06:25 +02:00
|
|
|
matroska->prev_pkt = pkt;
|
|
|
|
}
|
2007-10-22 00:27:24 +02:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2007-10-22 00:27:24 +02:00
|
|
|
if (timecode != AV_NOPTS_VALUE)
|
2012-08-08 17:53:41 +02:00
|
|
|
timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
|
2007-06-05 00:10:54 +02:00
|
|
|
data += lace_size[n];
|
2010-03-07 03:26:30 +01:00
|
|
|
size -= lace_size[n];
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-13 06:24:04 +02:00
|
|
|
end:
|
2007-06-05 00:10:54 +02:00
|
|
|
av_free(lace_size);
|
2008-09-07 01:44:29 +02:00
|
|
|
return res;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2012-04-19 20:12:24 +02:00
|
|
|
static int matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska)
|
|
|
|
{
|
|
|
|
EbmlList *blocks_list;
|
|
|
|
MatroskaBlock *blocks;
|
|
|
|
int i, res;
|
|
|
|
res = ebml_parse(matroska,
|
|
|
|
matroska_cluster_incremental_parsing,
|
|
|
|
&matroska->current_cluster);
|
|
|
|
if (res == 1) {
|
|
|
|
/* New Cluster */
|
|
|
|
if (matroska->current_cluster_pos)
|
|
|
|
ebml_level_end(matroska);
|
|
|
|
ebml_free(matroska_cluster, &matroska->current_cluster);
|
|
|
|
memset(&matroska->current_cluster, 0, sizeof(MatroskaCluster));
|
|
|
|
matroska->current_cluster_num_blocks = 0;
|
|
|
|
matroska->current_cluster_pos = avio_tell(matroska->ctx->pb);
|
|
|
|
matroska->prev_pkt = NULL;
|
|
|
|
/* sizeof the ID which was already read */
|
|
|
|
if (matroska->current_id)
|
|
|
|
matroska->current_cluster_pos -= 4;
|
|
|
|
res = ebml_parse(matroska,
|
|
|
|
matroska_clusters_incremental,
|
|
|
|
&matroska->current_cluster);
|
|
|
|
/* Try parsing the block again. */
|
|
|
|
if (res == 1)
|
|
|
|
res = ebml_parse(matroska,
|
|
|
|
matroska_cluster_incremental_parsing,
|
|
|
|
&matroska->current_cluster);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!res &&
|
|
|
|
matroska->current_cluster_num_blocks <
|
|
|
|
matroska->current_cluster.blocks.nb_elem) {
|
|
|
|
blocks_list = &matroska->current_cluster.blocks;
|
|
|
|
blocks = blocks_list->elem;
|
|
|
|
|
|
|
|
matroska->current_cluster_num_blocks = blocks_list->nb_elem;
|
|
|
|
i = blocks_list->nb_elem - 1;
|
|
|
|
if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
|
|
|
|
int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
|
|
|
|
if (!blocks[i].non_simple)
|
2012-04-24 00:19:55 +02:00
|
|
|
blocks[i].duration = 0;
|
2012-04-19 20:12:24 +02:00
|
|
|
res = matroska_parse_block(matroska,
|
|
|
|
blocks[i].bin.data, blocks[i].bin.size,
|
|
|
|
blocks[i].bin.pos,
|
|
|
|
matroska->current_cluster.timecode,
|
|
|
|
blocks[i].duration, is_keyframe,
|
|
|
|
matroska->current_cluster_pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res < 0) matroska->done = 1;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
2008-08-05 02:41:05 +02:00
|
|
|
MatroskaCluster cluster = { 0 };
|
|
|
|
EbmlList *blocks_list;
|
|
|
|
MatroskaBlock *blocks;
|
2008-09-07 01:39:59 +02:00
|
|
|
int i, res;
|
2012-04-19 20:12:24 +02:00
|
|
|
int64_t pos;
|
|
|
|
if (!matroska->contains_ssa)
|
|
|
|
return matroska_parse_cluster_incremental(matroska);
|
|
|
|
pos = avio_tell(matroska->ctx->pb);
|
2008-09-29 01:06:25 +02:00
|
|
|
matroska->prev_pkt = NULL;
|
2010-06-11 18:36:51 +02:00
|
|
|
if (matroska->current_id)
|
2008-08-25 02:09:08 +02:00
|
|
|
pos -= 4; /* sizeof the ID which was already read */
|
2010-06-11 18:45:38 +02:00
|
|
|
res = ebml_parse(matroska, matroska_clusters, &cluster);
|
2008-08-05 02:41:05 +02:00
|
|
|
blocks_list = &cluster.blocks;
|
|
|
|
blocks = blocks_list->elem;
|
2011-07-06 19:57:11 +02:00
|
|
|
for (i=0; i<blocks_list->nb_elem; i++)
|
2010-05-26 00:55:12 +02:00
|
|
|
if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
|
2009-08-10 20:06:14 +02:00
|
|
|
int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
|
2008-08-05 02:41:05 +02:00
|
|
|
res=matroska_parse_block(matroska,
|
|
|
|
blocks[i].bin.data, blocks[i].bin.size,
|
|
|
|
blocks[i].bin.pos, cluster.timecode,
|
2009-08-10 20:06:14 +02:00
|
|
|
blocks[i].duration, is_keyframe,
|
2008-09-07 01:39:59 +02:00
|
|
|
pos);
|
2009-08-10 20:06:14 +02:00
|
|
|
}
|
2008-08-05 02:41:05 +02:00
|
|
|
ebml_free(matroska_cluster, &cluster);
|
2007-06-05 00:10:54 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
MatroskaDemuxContext *matroska = s->priv_data;
|
|
|
|
|
2011-07-06 19:57:11 +02:00
|
|
|
while (matroska_deliver_packet(matroska, pkt)) {
|
2012-02-13 23:06:19 +01:00
|
|
|
int64_t pos = avio_tell(matroska->ctx->pb);
|
2007-06-05 00:10:54 +02:00
|
|
|
if (matroska->done)
|
2009-02-19 22:01:45 +01:00
|
|
|
return AVERROR_EOF;
|
2012-02-13 23:06:19 +01:00
|
|
|
if (matroska_parse_cluster(matroska) < 0)
|
|
|
|
matroska_resync(matroska, pos);
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2011-07-06 19:57:11 +02:00
|
|
|
return 0;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_read_seek(AVFormatContext *s, int stream_index,
|
|
|
|
int64_t timestamp, int flags)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
MatroskaDemuxContext *matroska = s->priv_data;
|
2008-09-09 14:10:25 +02:00
|
|
|
MatroskaTrack *tracks = matroska->tracks.elem;
|
2007-06-05 00:10:54 +02:00
|
|
|
AVStream *st = s->streams[stream_index];
|
2008-09-09 14:10:25 +02:00
|
|
|
int i, index, index_sub, index_min;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2011-07-09 07:48:43 +02:00
|
|
|
/* Parse the CUES now since we need the index data to seek. */
|
2012-02-12 14:09:03 +01:00
|
|
|
if (matroska->cues_parsing_deferred > 0) {
|
2011-07-09 07:48:43 +02:00
|
|
|
matroska->cues_parsing_deferred = 0;
|
2012-02-12 14:09:03 +01:00
|
|
|
matroska_parse_cues(matroska);
|
2011-07-09 07:48:43 +02:00
|
|
|
}
|
|
|
|
|
2008-09-12 02:06:06 +02:00
|
|
|
if (!st->nb_index_entries)
|
2012-02-12 14:09:03 +01:00
|
|
|
goto err;
|
2008-09-12 02:06:06 +02:00
|
|
|
timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
|
2008-08-25 01:57:29 +02:00
|
|
|
|
2008-08-27 21:57:42 +02:00
|
|
|
if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(s->pb, st->index_entries[st->nb_index_entries-1].pos, SEEK_SET);
|
2011-07-01 17:57:42 +02:00
|
|
|
matroska->current_id = 0;
|
2008-08-27 21:58:55 +02:00
|
|
|
while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
|
2012-04-23 18:15:31 +02:00
|
|
|
matroska->prev_pkt = NULL;
|
2008-08-27 21:58:55 +02:00
|
|
|
matroska_clear_queue(matroska);
|
|
|
|
if (matroska_parse_cluster(matroska) < 0)
|
|
|
|
break;
|
|
|
|
}
|
2008-08-27 21:57:42 +02:00
|
|
|
}
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2007-12-29 19:35:38 +01:00
|
|
|
matroska_clear_queue(matroska);
|
2012-02-12 14:09:03 +01:00
|
|
|
if (index < 0 || (matroska->cues_parsing_deferred < 0 && index == st->nb_index_entries - 1))
|
|
|
|
goto err;
|
2007-12-29 19:35:38 +01:00
|
|
|
|
2008-09-09 14:10:25 +02:00
|
|
|
index_min = index;
|
|
|
|
for (i=0; i < matroska->tracks.nb_elem; i++) {
|
2011-02-26 12:52:01 +01:00
|
|
|
tracks[i].audio.pkt_cnt = 0;
|
|
|
|
tracks[i].audio.sub_packet_cnt = 0;
|
|
|
|
tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
|
2008-09-09 14:10:25 +02:00
|
|
|
tracks[i].end_timecode = 0;
|
|
|
|
if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE
|
|
|
|
&& !tracks[i].stream->discard != AVDISCARD_ALL) {
|
|
|
|
index_sub = av_index_search_timestamp(tracks[i].stream, st->index_entries[index].timestamp, AVSEEK_FLAG_BACKWARD);
|
|
|
|
if (index_sub >= 0
|
|
|
|
&& st->index_entries[index_sub].pos < st->index_entries[index_min].pos
|
|
|
|
&& st->index_entries[index].timestamp - st->index_entries[index_sub].timestamp < 30000000000/matroska->time_scale)
|
|
|
|
index_min = index_sub;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
|
2011-07-01 17:57:42 +02:00
|
|
|
matroska->current_id = 0;
|
2012-04-14 00:17:30 +02:00
|
|
|
st->skip_to_keyframe =
|
2007-06-05 00:10:54 +02:00
|
|
|
matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
|
2008-09-09 14:01:51 +02:00
|
|
|
matroska->skip_to_timecode = st->index_entries[index].timestamp;
|
2008-08-25 02:17:31 +02:00
|
|
|
matroska->done = 0;
|
2012-02-12 14:07:04 +01:00
|
|
|
matroska->num_levels = 0;
|
2011-10-16 15:03:30 +02:00
|
|
|
ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
|
2007-06-05 00:10:54 +02:00
|
|
|
return 0;
|
2012-02-12 14:09:03 +01:00
|
|
|
err:
|
|
|
|
// slightly hackish but allows proper fallback to
|
|
|
|
// the generic seeking code.
|
|
|
|
matroska_clear_queue(matroska);
|
|
|
|
matroska->current_id = 0;
|
2012-04-14 00:17:30 +02:00
|
|
|
st->skip_to_keyframe =
|
2012-02-12 14:09:03 +01:00
|
|
|
matroska->skip_to_keyframe = 0;
|
|
|
|
matroska->done = 0;
|
|
|
|
matroska->num_levels = 0;
|
|
|
|
return -1;
|
2007-06-05 00:10:54 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 02:42:05 +02:00
|
|
|
static int matroska_read_close(AVFormatContext *s)
|
2007-06-05 00:10:54 +02:00
|
|
|
{
|
|
|
|
MatroskaDemuxContext *matroska = s->priv_data;
|
2008-08-05 02:40:31 +02:00
|
|
|
MatroskaTrack *tracks = matroska->tracks.elem;
|
2008-08-05 02:41:13 +02:00
|
|
|
int n;
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2007-12-29 19:32:47 +01:00
|
|
|
matroska_clear_queue(matroska);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
2008-08-05 02:40:31 +02:00
|
|
|
for (n=0; n < matroska->tracks.nb_elem; n++)
|
|
|
|
if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
|
|
|
|
av_free(tracks[n].audio.buf);
|
2012-04-19 20:12:24 +02:00
|
|
|
ebml_free(matroska_cluster, &matroska->current_cluster);
|
2008-08-05 02:40:58 +02:00
|
|
|
ebml_free(matroska_segment, matroska);
|
2007-06-05 00:10:54 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-25 23:03:28 +01:00
|
|
|
AVInputFormat ff_matroska_demuxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "matroska,webm",
|
2012-07-24 23:51:41 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Matroska / WebM"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.priv_data_size = sizeof(MatroskaDemuxContext),
|
|
|
|
.read_probe = matroska_probe,
|
|
|
|
.read_header = matroska_read_header,
|
|
|
|
.read_packet = matroska_read_packet,
|
|
|
|
.read_close = matroska_read_close,
|
|
|
|
.read_seek = matroska_read_seek,
|
2007-06-05 00:10:54 +02:00
|
|
|
};
|