← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavformat/matroskadec.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavformat/matroskadec.c
22
22
/**
23
23
 * @file
24
24
 * Matroska file demuxer
25
 
 * by Ronald Bultje <rbultje@ronald.bitfreak.net>
26
 
 * with a little help from Moritz Bunkus <moritz@bunkus.org>
27
 
 * totally reworked by Aurelien Jacobs <aurel@gnuage.org>
28
 
 * Specs available on the Matroska project page: http://www.matroska.org/.
 
25
 * @author Ronald Bultje <rbultje@ronald.bitfreak.net>
 
26
 * @author with a little help from Moritz Bunkus <moritz@bunkus.org>
 
27
 * @author totally reworked by Aurelien Jacobs <aurel@gnuage.org>
 
28
 * @see specs available on the Matroska project page: http://www.matroska.org/
29
29
 */
30
30
 
31
31
#include <stdio.h>
38
38
#include "rm.h"
39
39
#include "matroska.h"
40
40
#include "libavcodec/mpeg4audio.h"
41
 
#include "libavutil/intfloat_readwrite.h"
 
41
#include "libavutil/intfloat.h"
42
42
#include "libavutil/intreadwrite.h"
43
43
#include "libavutil/avstring.h"
44
44
#include "libavutil/lzo.h"
244
244
    /* What to skip before effectively reading a packet. */
245
245
    int skip_to_keyframe;
246
246
    uint64_t skip_to_timecode;
 
247
 
 
248
    /* File has a CUES element, but we defer parsing until it is needed. */
 
249
    int cues_parsing_deferred;
247
250
} MatroskaDemuxContext;
248
251
 
249
252
typedef struct {
621
624
    if (size == 0) {
622
625
        *num = 0;
623
626
    } else if (size == 4) {
624
 
        *num= av_int2flt(avio_rb32(pb));
625
 
    } else if(size==8){
626
 
        *num= av_int2dbl(avio_rb64(pb));
 
627
        *num = av_int2float(avio_rb32(pb));
 
628
    } else if (size == 8){
 
629
        *num = av_int2double(avio_rb64(pb));
627
630
    } else
628
631
        return AVERROR_INVALIDDATA;
629
632
 
798
801
    uint32_t id = syntax->id;
799
802
    uint64_t length;
800
803
    int res;
 
804
    void *newelem;
801
805
 
802
806
    data = (char *)data + syntax->data_offset;
803
807
    if (syntax->list_elem_size) {
804
808
        EbmlList *list = data;
805
 
        list->elem = av_realloc(list->elem, (list->nb_elem+1)*syntax->list_elem_size);
 
809
        newelem = av_realloc(list->elem, (list->nb_elem+1)*syntax->list_elem_size);
 
810
        if (!newelem)
 
811
            return AVERROR(ENOMEM);
 
812
        list->elem = newelem;
806
813
        data = (char*)list->elem + list->nb_elem*syntax->list_elem_size;
807
814
        memset(data, 0, syntax->list_elem_size);
808
815
        list->nb_elem++;
900
907
     * Not fully fool-proof, but good enough. */
901
908
    for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
902
909
        int probelen = strlen(matroska_doctypes[i]);
 
910
        if (total < probelen)
 
911
            continue;
903
912
        for (n = 4+size; n <= 4+size+total-probelen; n++)
904
913
            if (!memcmp(p->buf+n, matroska_doctypes[i], probelen))
905
914
                return AVPROBE_SCORE_MAX;
930
939
    uint8_t* data = *buf;
931
940
    int isize = *buf_size;
932
941
    uint8_t* pkt_data = NULL;
 
942
    uint8_t* newpktdata;
933
943
    int pkt_size = isize;
934
944
    int result = 0;
935
945
    int olen;
959
969
        zstream.avail_in = isize;
960
970
        do {
961
971
            pkt_size *= 3;
962
 
            pkt_data = av_realloc(pkt_data, pkt_size);
 
972
            newpktdata = av_realloc(pkt_data, pkt_size);
 
973
            if (!newpktdata) {
 
974
                inflateEnd(&zstream);
 
975
                goto failed;
 
976
            }
 
977
            pkt_data = newpktdata;
963
978
            zstream.avail_out = pkt_size - zstream.total_out;
964
979
            zstream.next_out = pkt_data + zstream.total_out;
965
980
            result = inflate(&zstream, Z_NO_FLUSH);
980
995
        bzstream.avail_in = isize;
981
996
        do {
982
997
            pkt_size *= 3;
983
 
            pkt_data = av_realloc(pkt_data, pkt_size);
 
998
            newpktdata = av_realloc(pkt_data, pkt_size);
 
999
            if (!newpktdata) {
 
1000
                BZ2_bzDecompressEnd(&bzstream);
 
1001
                goto failed;
 
1002
            }
 
1003
            pkt_data = newpktdata;
984
1004
            bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
985
1005
            bzstream.next_out = pkt_data + bzstream.total_out_lo32;
986
1006
            result = BZ2_bzDecompress(&bzstream);
1035
1055
    }
1036
1056
}
1037
1057
 
1038
 
static void matroska_merge_packets(AVPacket *out, AVPacket *in)
 
1058
static int matroska_merge_packets(AVPacket *out, AVPacket *in)
1039
1059
{
1040
 
    out->data = av_realloc(out->data, out->size+in->size);
 
1060
    void *newdata = av_realloc(out->data, out->size+in->size);
 
1061
    if (!newdata)
 
1062
        return AVERROR(ENOMEM);
 
1063
    out->data = newdata;
1041
1064
    memcpy(out->data+out->size, in->data, in->size);
1042
1065
    out->size += in->size;
1043
1066
    av_destruct_packet(in);
1044
1067
    av_free(in);
 
1068
    return 0;
1045
1069
}
1046
1070
 
1047
1071
static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
1110
1134
    }
1111
1135
}
1112
1136
 
1113
 
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
 
1137
static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int idx)
1114
1138
{
1115
1139
    EbmlList *seekhead_list = &matroska->seekhead;
1116
1140
    MatroskaSeekhead *seekhead = seekhead_list->elem;
1118
1142
    int64_t before_pos = avio_tell(matroska->ctx->pb);
1119
1143
    uint32_t saved_id = matroska->current_id;
1120
1144
    MatroskaLevel level;
1121
 
    int i;
1122
 
 
1123
 
    // we should not do any seeking in the streaming case
1124
 
    if (!matroska->ctx->pb->seekable ||
1125
 
        (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
1126
 
        return;
1127
 
 
1128
 
    for (i=0; i<seekhead_list->nb_elem; i++) {
1129
 
        int64_t offset = seekhead[i].pos + matroska->segment_start;
1130
 
 
1131
 
        if (seekhead[i].pos <= before_pos
1132
 
            || seekhead[i].id == MATROSKA_ID_SEEKHEAD
1133
 
            || seekhead[i].id == MATROSKA_ID_CLUSTER)
1134
 
            continue;
1135
 
 
1136
 
        /* seek */
1137
 
        if (avio_seek(matroska->ctx->pb, offset, SEEK_SET) != offset)
1138
 
            continue;
1139
 
 
 
1145
    int64_t offset;
 
1146
    int ret = 0;
 
1147
 
 
1148
    if (idx >= seekhead_list->nb_elem
 
1149
            || seekhead[idx].id == MATROSKA_ID_SEEKHEAD
 
1150
            || seekhead[idx].id == MATROSKA_ID_CLUSTER)
 
1151
        return 0;
 
1152
 
 
1153
    /* seek */
 
1154
    offset = seekhead[idx].pos + matroska->segment_start;
 
1155
    if (avio_seek(matroska->ctx->pb, offset, SEEK_SET) == offset) {
1140
1156
        /* We don't want to lose our seekhead level, so we add
1141
1157
         * a dummy. This is a crude hack. */
1142
1158
        if (matroska->num_levels == EBML_MAX_DEPTH) {
1143
1159
            av_log(matroska->ctx, AV_LOG_INFO,
1144
1160
                   "Max EBML element depth (%d) reached, "
1145
1161
                   "cannot parse further.\n", EBML_MAX_DEPTH);
1146
 
            break;
1147
 
        }
1148
 
 
1149
 
        level.start = 0;
1150
 
        level.length = (uint64_t)-1;
1151
 
        matroska->levels[matroska->num_levels] = level;
1152
 
        matroska->num_levels++;
1153
 
        matroska->current_id = 0;
1154
 
 
1155
 
        ebml_parse(matroska, matroska_segment, matroska);
1156
 
 
1157
 
        /* remove dummy level */
1158
 
        while (matroska->num_levels) {
1159
 
            uint64_t length = matroska->levels[--matroska->num_levels].length;
1160
 
            if (length == (uint64_t)-1)
1161
 
                break;
 
1162
            ret = AVERROR_INVALIDDATA;
 
1163
        } else {
 
1164
            level.start = 0;
 
1165
            level.length = (uint64_t)-1;
 
1166
            matroska->levels[matroska->num_levels] = level;
 
1167
            matroska->num_levels++;
 
1168
            matroska->current_id = 0;
 
1169
 
 
1170
            ret = ebml_parse(matroska, matroska_segment, matroska);
 
1171
 
 
1172
            /* remove dummy level */
 
1173
            while (matroska->num_levels) {
 
1174
                uint64_t length = matroska->levels[--matroska->num_levels].length;
 
1175
                if (length == (uint64_t)-1)
 
1176
                    break;
 
1177
            }
1162
1178
        }
1163
1179
    }
1164
 
 
1165
1180
    /* seek back */
1166
1181
    avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
1167
1182
    matroska->level_up = level_up;
1168
1183
    matroska->current_id = saved_id;
 
1184
 
 
1185
    return ret;
 
1186
}
 
1187
 
 
1188
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
 
1189
{
 
1190
    EbmlList *seekhead_list = &matroska->seekhead;
 
1191
    int64_t before_pos = avio_tell(matroska->ctx->pb);
 
1192
    int i;
 
1193
 
 
1194
    // we should not do any seeking in the streaming case
 
1195
    if (!matroska->ctx->pb->seekable ||
 
1196
        (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
 
1197
        return;
 
1198
 
 
1199
    for (i = 0; i < seekhead_list->nb_elem; i++) {
 
1200
        MatroskaSeekhead *seekhead = seekhead_list->elem;
 
1201
        if (seekhead[i].pos <= before_pos)
 
1202
            continue;
 
1203
 
 
1204
        // defer cues parsing until we actually need cue data.
 
1205
        if (seekhead[i].id == MATROSKA_ID_CUES) {
 
1206
            matroska->cues_parsing_deferred = 1;
 
1207
            continue;
 
1208
        }
 
1209
 
 
1210
        if (matroska_parse_seekhead_entry(matroska, i) < 0)
 
1211
            break;
 
1212
    }
 
1213
}
 
1214
 
 
1215
static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
 
1216
    EbmlList *seekhead_list = &matroska->seekhead;
 
1217
    MatroskaSeekhead *seekhead = seekhead_list->elem;
 
1218
    EbmlList *index_list;
 
1219
    MatroskaIndex *index;
 
1220
    int index_scale = 1;
 
1221
    int i, j;
 
1222
 
 
1223
    for (i = 0; i < seekhead_list->nb_elem; i++)
 
1224
        if (seekhead[i].id == MATROSKA_ID_CUES)
 
1225
            break;
 
1226
    assert(i <= seekhead_list->nb_elem);
 
1227
 
 
1228
    matroska_parse_seekhead_entry(matroska, i);
 
1229
 
 
1230
    index_list = &matroska->index;
 
1231
    index = index_list->elem;
 
1232
    if (index_list->nb_elem
 
1233
        && index[0].time > 1E14/matroska->time_scale) {
 
1234
        av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
 
1235
        index_scale = matroska->time_scale;
 
1236
    }
 
1237
    for (i = 0; i < index_list->nb_elem; i++) {
 
1238
        EbmlList *pos_list = &index[i].pos;
 
1239
        MatroskaIndexPos *pos = pos_list->elem;
 
1240
        for (j = 0; j < pos_list->nb_elem; j++) {
 
1241
            MatroskaTrack *track = matroska_find_track_by_num(matroska, pos[j].track);
 
1242
            if (track && track->stream)
 
1243
                av_add_index_entry(track->stream,
 
1244
                                   pos[j].pos + matroska->segment_start,
 
1245
                                   index[i].time/index_scale, 0, 0,
 
1246
                                   AVINDEX_KEYFRAME);
 
1247
        }
 
1248
    }
1169
1249
}
1170
1250
 
1171
1251
static int matroska_aac_profile(char *codec_id)
1183
1263
{
1184
1264
    int sri;
1185
1265
 
1186
 
    for (sri=0; sri<FF_ARRAY_ELEMS(ff_mpeg4audio_sample_rates); sri++)
1187
 
        if (ff_mpeg4audio_sample_rates[sri] == samplerate)
 
1266
    for (sri=0; sri<FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
 
1267
        if (avpriv_mpeg4audio_sample_rates[sri] == samplerate)
1188
1268
            break;
1189
1269
    return sri;
1190
1270
}
1197
1277
    EbmlList *chapters_list = &matroska->chapters;
1198
1278
    MatroskaChapter *chapters;
1199
1279
    MatroskaTrack *tracks;
1200
 
    EbmlList *index_list;
1201
 
    MatroskaIndex *index;
1202
 
    int index_scale = 1;
1203
1280
    uint64_t max_start = 0;
1204
1281
    Ebml ebml = { 0 };
1205
1282
    AVStream *st;
1274
1351
        }
1275
1352
        if (encodings_list->nb_elem > 1) {
1276
1353
            av_log(matroska->ctx, AV_LOG_ERROR,
1277
 
                   "Multiple combined encodings no supported");
 
1354
                   "Multiple combined encodings not supported");
1278
1355
        } else if (encodings_list->nb_elem == 1) {
1279
1356
            if (encodings[0].type ||
1280
1357
                (encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
1319
1396
            }
1320
1397
        }
1321
1398
 
1322
 
        st = track->stream = av_new_stream(s, 0);
 
1399
        st = track->stream = avformat_new_stream(s, NULL);
1323
1400
        if (st == NULL)
1324
1401
            return AVERROR(ENOMEM);
1325
1402
 
1429
1506
 
1430
1507
        if (track->time_scale < 0.01)
1431
1508
            track->time_scale = 1.0;
1432
 
        av_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
 
1509
        avpriv_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
1433
1510
 
1434
1511
        st->codec->codec_id = codec_id;
1435
1512
        st->start_time = 0;
1442
1519
        if (track->flag_forced)
1443
1520
            st->disposition |= AV_DISPOSITION_FORCED;
1444
1521
 
1445
 
        if (track->default_duration)
1446
 
            av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
1447
 
                      track->default_duration, 1000000000, 30000);
1448
 
 
1449
1522
        if (!st->codec->extradata) {
1450
1523
            if(extradata){
1451
1524
                st->codec->extradata = extradata;
1493
1566
              attachements[j].bin.data && attachements[j].bin.size > 0)) {
1494
1567
            av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
1495
1568
        } else {
1496
 
            AVStream *st = av_new_stream(s, 0);
 
1569
            AVStream *st = avformat_new_stream(s, NULL);
1497
1570
            if (st == NULL)
1498
1571
                break;
1499
1572
            av_dict_set(&st->metadata, "filename",attachements[j].filename, 0);
 
1573
            av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
1500
1574
            st->codec->codec_id = CODEC_ID_NONE;
1501
1575
            st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
1502
1576
            st->codec->extradata  = av_malloc(attachements[j].bin.size);
1521
1595
        if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid
1522
1596
            && (max_start==0 || chapters[i].start > max_start)) {
1523
1597
            chapters[i].chapter =
1524
 
            ff_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
 
1598
            avpriv_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
1525
1599
                           chapters[i].start, chapters[i].end,
1526
1600
                           chapters[i].title);
1527
1601
            av_dict_set(&chapters[i].chapter->metadata,
1529
1603
            max_start = chapters[i].start;
1530
1604
        }
1531
1605
 
1532
 
    index_list = &matroska->index;
1533
 
    index = index_list->elem;
1534
 
    if (index_list->nb_elem
1535
 
        && index[0].time > 100000000000000/matroska->time_scale) {
1536
 
        av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
1537
 
        index_scale = matroska->time_scale;
1538
 
    }
1539
 
    for (i=0; i<index_list->nb_elem; i++) {
1540
 
        EbmlList *pos_list = &index[i].pos;
1541
 
        MatroskaIndexPos *pos = pos_list->elem;
1542
 
        for (j=0; j<pos_list->nb_elem; j++) {
1543
 
            MatroskaTrack *track = matroska_find_track_by_num(matroska,
1544
 
                                                              pos[j].track);
1545
 
            if (track && track->stream)
1546
 
                av_add_index_entry(track->stream,
1547
 
                                   pos[j].pos + matroska->segment_start,
1548
 
                                   index[i].time/index_scale, 0, 0,
1549
 
                                   AVINDEX_KEYFRAME);
1550
 
        }
1551
 
    }
1552
 
 
1553
1606
    matroska_convert_tags(s);
1554
1607
 
1555
1608
    return 0;
1566
1619
        memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
1567
1620
        av_free(matroska->packets[0]);
1568
1621
        if (matroska->num_packets > 1) {
 
1622
            void *newpackets;
1569
1623
            memmove(&matroska->packets[0], &matroska->packets[1],
1570
1624
                    (matroska->num_packets - 1) * sizeof(AVPacket *));
1571
 
            matroska->packets =
1572
 
                av_realloc(matroska->packets, (matroska->num_packets - 1) *
1573
 
                           sizeof(AVPacket *));
 
1625
            newpackets = av_realloc(matroska->packets,
 
1626
                            (matroska->num_packets - 1) * sizeof(AVPacket *));
 
1627
            if (newpackets)
 
1628
                matroska->packets = newpackets;
1574
1629
        } else {
1575
1630
            av_freep(&matroska->packets);
1576
1631
        }
1620
1675
    size -= n;
1621
1676
 
1622
1677
    track = matroska_find_track_by_num(matroska, num);
1623
 
    if (size <= 3 || !track || !track->stream) {
 
1678
    if (!track || !track->stream) {
1624
1679
        av_log(matroska->ctx, AV_LOG_INFO,
1625
1680
               "Invalid stream %"PRIu64" or size %u\n", num, size);
1626
 
        return res;
1627
 
    }
 
1681
        return AVERROR_INVALIDDATA;
 
1682
    } else if (size <= 3)
 
1683
        return 0;
1628
1684
    st = track->stream;
1629
1685
    if (st->discard >= AVDISCARD_ALL)
1630
1686
        return res;
1724
1780
                        lace_size[n] = lace_size[n - 1] + snum;
1725
1781
                        total += lace_size[n];
1726
1782
                    }
1727
 
                    lace_size[n] = size - total;
 
1783
                    lace_size[laces - 1] = size - total;
1728
1784
                    break;
1729
1785
                }
1730
1786
            }
1860
1916
    res = ebml_parse(matroska, matroska_clusters, &cluster);
1861
1917
    blocks_list = &cluster.blocks;
1862
1918
    blocks = blocks_list->elem;
1863
 
    for (i=0; i<blocks_list->nb_elem; i++)
 
1919
    for (i=0; i<blocks_list->nb_elem && !res; i++)
1864
1920
        if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
1865
1921
            int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
1866
1922
            if (!blocks[i].non_simple)
1879
1935
static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
1880
1936
{
1881
1937
    MatroskaDemuxContext *matroska = s->priv_data;
 
1938
    int ret = 0;
1882
1939
 
1883
 
    while (matroska_deliver_packet(matroska, pkt)) {
 
1940
    while (!ret && matroska_deliver_packet(matroska, pkt)) {
1884
1941
        if (matroska->done)
1885
1942
            return AVERROR_EOF;
1886
 
        matroska_parse_cluster(matroska);
 
1943
        ret = matroska_parse_cluster(matroska);
1887
1944
    }
1888
1945
 
1889
 
    return 0;
 
1946
    return ret;
1890
1947
}
1891
1948
 
1892
1949
static int matroska_read_seek(AVFormatContext *s, int stream_index,
1897
1954
    AVStream *st = s->streams[stream_index];
1898
1955
    int i, index, index_sub, index_min;
1899
1956
 
 
1957
    /* Parse the CUES now since we need the index data to seek. */
 
1958
    if (matroska->cues_parsing_deferred) {
 
1959
        matroska_parse_cues(matroska);
 
1960
        matroska->cues_parsing_deferred = 0;
 
1961
    }
 
1962
 
1900
1963
    if (!st->nb_index_entries)
1901
1964
        return 0;
1902
1965
    timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
1903
1966
 
1904
1967
    if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
1905
1968
        avio_seek(s->pb, st->index_entries[st->nb_index_entries-1].pos, SEEK_SET);
 
1969
        matroska->current_id = 0;
1906
1970
        while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
1907
1971
            matroska_clear_queue(matroska);
1908
1972
            if (matroska_parse_cluster(matroska) < 0)
1931
1995
    }
1932
1996
 
1933
1997
    avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
 
1998
    matroska->current_id = 0;
1934
1999
    matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
1935
2000
    matroska->skip_to_timecode = st->index_entries[index].timestamp;
1936
2001
    matroska->done = 0;
1937
 
    av_update_cur_dts(s, st, st->index_entries[index].timestamp);
 
2002
    ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
1938
2003
    return 0;
1939
2004
}
1940
2005
 
1955
2020
}
1956
2021
 
1957
2022
AVInputFormat ff_matroska_demuxer = {
1958
 
    "matroska,webm",
1959
 
    NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
1960
 
    sizeof(MatroskaDemuxContext),
1961
 
    matroska_probe,
1962
 
    matroska_read_header,
1963
 
    matroska_read_packet,
1964
 
    matroska_read_close,
1965
 
    matroska_read_seek,
 
2023
    .name           = "matroska,webm",
 
2024
    .long_name      = NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
 
2025
    .priv_data_size = sizeof(MatroskaDemuxContext),
 
2026
    .read_probe     = matroska_probe,
 
2027
    .read_header    = matroska_read_header,
 
2028
    .read_packet    = matroska_read_packet,
 
2029
    .read_close     = matroska_read_close,
 
2030
    .read_seek      = matroska_read_seek,
1966
2031
};