← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavformat/mpegts.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/mpegts.c
25
25
#include "libavutil/intreadwrite.h"
26
26
#include "libavutil/log.h"
27
27
#include "libavutil/dict.h"
 
28
#include "libavutil/mathematics.h"
28
29
#include "libavutil/opt.h"
29
30
#include "libavcodec/bytestream.h"
 
31
#include "libavcodec/get_bits.h"
30
32
#include "avformat.h"
31
33
#include "mpegts.h"
32
34
#include "internal.h"
41
43
 
42
44
#define MAX_PES_PAYLOAD 200*1024
43
45
 
 
46
#define MAX_MP4_DESCR_COUNT 16
 
47
 
44
48
enum MpegTSFilterType {
45
49
    MPEGTS_PES,
46
50
    MPEGTS_SECTION,
71
75
 
72
76
struct MpegTSFilter {
73
77
    int pid;
 
78
    int es_id;
74
79
    int last_cc; /* last cc code (-1 if first packet) */
75
80
    enum MpegTSFilterType type;
76
81
    union {
125
130
};
126
131
 
127
132
static const AVOption options[] = {
128
 
    {"compute_pcr", "Compute exact PCR for each transport stream packet.", offsetof(MpegTSContext, mpeg2ts_compute_pcr), FF_OPT_TYPE_INT,
 
133
    {"compute_pcr", "Compute exact PCR for each transport stream packet.", offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,
129
134
     {.dbl = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
130
135
    { NULL },
131
136
};
163
168
    enum MpegTSState state;
164
169
    /* used to get the format */
165
170
    int data_index;
 
171
    int flags; /**< copied to the AVPacket flags */
166
172
    int total_size;
167
173
    int pes_header_size;
168
174
    int extended_stream_id;
170
176
    int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
171
177
    uint8_t header[MAX_PES_HEADER_SIZE];
172
178
    uint8_t *buffer;
 
179
    SLConfigDescr sl;
173
180
} PESContext;
174
181
 
175
182
extern AVInputFormat ff_mpegts_demuxer;
221
228
}
222
229
 
223
230
/**
224
 
 * \brief discard_pid() decides if the pid is to be discarded according
 
231
 * @brief discard_pid() decides if the pid is to be discarded according
225
232
 *                      to caller's programs selection
226
 
 * \param ts    : - TS context
227
 
 * \param pid   : - pid
228
 
 * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
 
233
 * @param ts    : - TS context
 
234
 * @param pid   : - pid
 
235
 * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
229
236
 *         0 otherwise
230
237
 */
231
238
static int discard_pid(MpegTSContext *ts, unsigned int pid)
313
320
    ts->pids[pid] = filter;
314
321
    filter->type = MPEGTS_SECTION;
315
322
    filter->pid = pid;
 
323
    filter->es_id = -1;
316
324
    filter->last_cc = -1;
317
325
    sec = &filter->u.section_filter;
318
326
    sec->section_cb = section_cb;
341
349
    ts->pids[pid] = filter;
342
350
    filter->type = MPEGTS_PES;
343
351
    filter->pid = pid;
 
352
    filter->es_id = -1;
344
353
    filter->last_cc = -1;
345
354
    pes = &filter->u.pes_filter;
346
355
    pes->pes_cb = pes_cb;
359
368
        PESContext *pes = filter->u.pes_filter.opaque;
360
369
        av_freep(&pes->buffer);
361
370
        /* referenced private data will be freed later in
362
 
         * av_close_input_stream */
 
371
         * avformat_close_input */
363
372
        if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
364
373
            av_freep(&filter->u.pes_filter.opaque);
365
374
        }
447
456
    return c;
448
457
}
449
458
 
450
 
/* read and allocate a DVB string preceeded by its length */
 
459
/* read and allocate a DVB string preceded by its length */
451
460
static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
452
461
{
453
462
    int len;
568
577
static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
569
578
                                  uint32_t stream_type, uint32_t prog_reg_desc)
570
579
{
571
 
    av_set_pts_info(st, 33, 1, 90000);
 
580
    avpriv_set_pts_info(st, 33, 1, 90000);
572
581
    st->priv_data = pes;
573
582
    st->codec->codec_type = AVMEDIA_TYPE_DATA;
574
583
    st->codec->codec_id   = CODEC_ID_NONE;
596
605
                return AVERROR(ENOMEM);
597
606
            memcpy(sub_pes, pes, sizeof(*sub_pes));
598
607
 
599
 
            sub_st = av_new_stream(pes->stream, pes->pid);
 
608
            sub_st = avformat_new_stream(pes->stream, NULL);
600
609
            if (!sub_st) {
601
610
                av_free(sub_pes);
602
611
                return AVERROR(ENOMEM);
603
612
            }
604
613
 
605
 
            av_set_pts_info(sub_st, 33, 1, 90000);
 
614
            sub_st->id = pes->pid;
 
615
            avpriv_set_pts_info(sub_st, 33, 1, 90000);
606
616
            sub_st->priv_data = sub_pes;
607
617
            sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
608
618
            sub_st->codec->codec_id   = CODEC_ID_AC3;
623
633
    pkt->destruct = av_destruct_packet;
624
634
    pkt->data = pes->buffer;
625
635
    pkt->size = pes->data_index;
 
636
 
 
637
    if(pes->total_size != MAX_PES_PAYLOAD &&
 
638
       pes->pes_header_size + pes->data_index != pes->total_size + PES_START_SIZE) {
 
639
        av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
 
640
        pes->flags |= AV_PKT_FLAG_CORRUPT;
 
641
    }
626
642
    memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
627
643
 
628
644
    // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
634
650
    pkt->dts = pes->dts;
635
651
    /* store position of first TS packet of this PES packet */
636
652
    pkt->pos = pes->ts_packet_pos;
 
653
    pkt->flags = pes->flags;
637
654
 
638
655
    /* reset pts values */
639
656
    pes->pts = AV_NOPTS_VALUE;
640
657
    pes->dts = AV_NOPTS_VALUE;
641
658
    pes->buffer = NULL;
642
659
    pes->data_index = 0;
 
660
    pes->flags = 0;
 
661
}
 
662
 
 
663
static uint64_t get_bits64(GetBitContext *gb, int bits)
 
664
{
 
665
    uint64_t ret = 0;
 
666
    while (bits > 17) {
 
667
        ret <<= 17;
 
668
        ret |= get_bits(gb, 17);
 
669
        bits -= 17;
 
670
    }
 
671
    ret <<= bits;
 
672
    ret |= get_bits(gb, bits);
 
673
    return ret;
 
674
}
 
675
 
 
676
static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
 
677
{
 
678
    GetBitContext gb;
 
679
    int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
 
680
    int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
 
681
    int dts_flag = -1, cts_flag = -1;
 
682
    int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
 
683
    init_get_bits(&gb, buf, buf_size*8);
 
684
 
 
685
    if (sl->use_au_start)
 
686
        au_start_flag = get_bits1(&gb);
 
687
    if (sl->use_au_end)
 
688
        au_end_flag = get_bits1(&gb);
 
689
    if (!sl->use_au_start && !sl->use_au_end)
 
690
        au_start_flag = au_end_flag = 1;
 
691
    if (sl->ocr_len > 0)
 
692
        ocr_flag = get_bits1(&gb);
 
693
    if (sl->use_idle)
 
694
        idle_flag = get_bits1(&gb);
 
695
    if (sl->use_padding)
 
696
        padding_flag = get_bits1(&gb);
 
697
    if (padding_flag)
 
698
        padding_bits = get_bits(&gb, 3);
 
699
 
 
700
    if (!idle_flag && (!padding_flag || padding_bits != 0)) {
 
701
        if (sl->packet_seq_num_len)
 
702
            skip_bits_long(&gb, sl->packet_seq_num_len);
 
703
        if (sl->degr_prior_len)
 
704
            if (get_bits1(&gb))
 
705
                skip_bits(&gb, sl->degr_prior_len);
 
706
        if (ocr_flag)
 
707
            skip_bits_long(&gb, sl->ocr_len);
 
708
        if (au_start_flag) {
 
709
            if (sl->use_rand_acc_pt)
 
710
                get_bits1(&gb);
 
711
            if (sl->au_seq_num_len > 0)
 
712
                skip_bits_long(&gb, sl->au_seq_num_len);
 
713
            if (sl->use_timestamps) {
 
714
                dts_flag = get_bits1(&gb);
 
715
                cts_flag = get_bits1(&gb);
 
716
            }
 
717
        }
 
718
        if (sl->inst_bitrate_len)
 
719
            inst_bitrate_flag = get_bits1(&gb);
 
720
        if (dts_flag == 1)
 
721
            dts = get_bits64(&gb, sl->timestamp_len);
 
722
        if (cts_flag == 1)
 
723
            cts = get_bits64(&gb, sl->timestamp_len);
 
724
        if (sl->au_len > 0)
 
725
            skip_bits_long(&gb, sl->au_len);
 
726
        if (inst_bitrate_flag)
 
727
            skip_bits_long(&gb, sl->inst_bitrate_len);
 
728
    }
 
729
 
 
730
    if (dts != AV_NOPTS_VALUE)
 
731
        pes->dts = dts;
 
732
    if (cts != AV_NOPTS_VALUE)
 
733
        pes->pts = cts;
 
734
 
 
735
    if (sl->timestamp_len && sl->timestamp_res)
 
736
        avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);
 
737
 
 
738
    return (get_bits_count(&gb) + 7) >> 3;
643
739
}
644
740
 
645
741
/* return non zero if a packet could be constructed */
690
786
 
691
787
                    /* stream not present in PMT */
692
788
                    if (!pes->st) {
693
 
                        pes->st = av_new_stream(ts->stream, pes->pid);
 
789
                        pes->st = avformat_new_stream(ts->stream, NULL);
694
790
                        if (!pes->st)
695
791
                            return AVERROR(ENOMEM);
 
792
                        pes->st->id = pes->pid;
696
793
                        mpegts_set_stream_info(pes->st, pes, 0, 0);
697
794
                    }
698
795
 
792
889
                /* we got the full header. We parse it and get the payload */
793
890
                pes->state = MPEGTS_PAYLOAD;
794
891
                pes->data_index = 0;
 
892
                if (pes->stream_type == 0x12) {
 
893
                    int sl_header_bytes = read_sl_header(pes, &pes->sl, p, buf_size);
 
894
                    pes->pes_header_size += sl_header_bytes;
 
895
                    p += sl_header_bytes;
 
896
                    buf_size -= sl_header_bytes;
 
897
                }
795
898
            }
796
899
            break;
797
900
        case MPEGTS_PAYLOAD:
816
919
             * decreases demuxer delay for infrequent packets like subtitles from
817
920
             * a couple of seconds to milliseconds for properly muxed files.
818
921
             * total_size is the number of bytes following pes_packet_length
819
 
             * in the pes header, i.e. not counting the first 6 bytes */
 
922
             * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
820
923
            if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&
821
 
                pes->pes_header_size + pes->data_index == pes->total_size + 6) {
 
924
                pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {
822
925
                ts->stop_parse = 1;
823
926
                new_pes_packet(pes, ts->pkt);
824
927
            }
856
959
    return pes;
857
960
}
858
961
 
 
962
#define MAX_LEVEL 4
 
963
typedef struct {
 
964
    AVFormatContext *s;
 
965
    AVIOContext pb;
 
966
    Mp4Descr *descr;
 
967
    Mp4Descr *active_descr;
 
968
    int descr_count;
 
969
    int max_descr_count;
 
970
    int level;
 
971
} MP4DescrParseContext;
 
972
 
 
973
static int init_MP4DescrParseContext(
 
974
    MP4DescrParseContext *d, AVFormatContext *s, const uint8_t *buf,
 
975
    unsigned size, Mp4Descr *descr, int max_descr_count)
 
976
{
 
977
    int ret;
 
978
    if (size > (1<<30))
 
979
        return AVERROR_INVALIDDATA;
 
980
 
 
981
    if ((ret = ffio_init_context(&d->pb, (unsigned char*)buf, size, 0,
 
982
                          NULL, NULL, NULL, NULL)) < 0)
 
983
        return ret;
 
984
 
 
985
    d->s = s;
 
986
    d->level = 0;
 
987
    d->descr_count = 0;
 
988
    d->descr = descr;
 
989
    d->active_descr = NULL;
 
990
    d->max_descr_count = max_descr_count;
 
991
 
 
992
    return 0;
 
993
}
 
994
 
 
995
static void update_offsets(AVIOContext *pb, int64_t *off, int *len) {
 
996
    int64_t new_off = avio_tell(pb);
 
997
    (*len) -= new_off - *off;
 
998
    *off = new_off;
 
999
}
 
1000
 
 
1001
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
 
1002
                           int target_tag);
 
1003
 
 
1004
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
 
1005
{
 
1006
    while (len > 0) {
 
1007
        if (parse_mp4_descr(d, off, len, 0) < 0)
 
1008
            return -1;
 
1009
        update_offsets(&d->pb, &off, &len);
 
1010
    }
 
1011
    return 0;
 
1012
}
 
1013
 
 
1014
static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
 
1015
{
 
1016
    avio_rb16(&d->pb); // ID
 
1017
    avio_r8(&d->pb);
 
1018
    avio_r8(&d->pb);
 
1019
    avio_r8(&d->pb);
 
1020
    avio_r8(&d->pb);
 
1021
    avio_r8(&d->pb);
 
1022
    update_offsets(&d->pb, &off, &len);
 
1023
    return parse_mp4_descr_arr(d, off, len);
 
1024
}
 
1025
 
 
1026
static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
 
1027
{
 
1028
    int id_flags;
 
1029
    if (len < 2)
 
1030
        return 0;
 
1031
    id_flags = avio_rb16(&d->pb);
 
1032
    if (!(id_flags & 0x0020)) { //URL_Flag
 
1033
        update_offsets(&d->pb, &off, &len);
 
1034
        return parse_mp4_descr_arr(d, off, len); //ES_Descriptor[]
 
1035
    } else {
 
1036
        return 0;
 
1037
    }
 
1038
}
 
1039
 
 
1040
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
 
1041
{
 
1042
    int es_id = 0;
 
1043
    if (d->descr_count >= d->max_descr_count)
 
1044
        return -1;
 
1045
    ff_mp4_parse_es_descr(&d->pb, &es_id);
 
1046
    d->active_descr = d->descr + (d->descr_count++);
 
1047
 
 
1048
    d->active_descr->es_id = es_id;
 
1049
    update_offsets(&d->pb, &off, &len);
 
1050
    parse_mp4_descr(d, off, len, MP4DecConfigDescrTag);
 
1051
    update_offsets(&d->pb, &off, &len);
 
1052
    if (len > 0)
 
1053
        parse_mp4_descr(d, off, len, MP4SLDescrTag);
 
1054
    d->active_descr = NULL;
 
1055
    return 0;
 
1056
}
 
1057
 
 
1058
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
 
1059
{
 
1060
    Mp4Descr *descr = d->active_descr;
 
1061
    if (!descr)
 
1062
        return -1;
 
1063
    d->active_descr->dec_config_descr = av_malloc(len);
 
1064
    if (!descr->dec_config_descr)
 
1065
        return AVERROR(ENOMEM);
 
1066
    descr->dec_config_descr_len = len;
 
1067
    avio_read(&d->pb, descr->dec_config_descr, len);
 
1068
    return 0;
 
1069
}
 
1070
 
 
1071
static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
 
1072
{
 
1073
    Mp4Descr *descr = d->active_descr;
 
1074
    int predefined;
 
1075
    if (!descr)
 
1076
        return -1;
 
1077
 
 
1078
    predefined = avio_r8(&d->pb);
 
1079
    if (!predefined) {
 
1080
        int lengths;
 
1081
        int flags = avio_r8(&d->pb);
 
1082
        descr->sl.use_au_start       = !!(flags & 0x80);
 
1083
        descr->sl.use_au_end         = !!(flags & 0x40);
 
1084
        descr->sl.use_rand_acc_pt    = !!(flags & 0x20);
 
1085
        descr->sl.use_padding        = !!(flags & 0x08);
 
1086
        descr->sl.use_timestamps     = !!(flags & 0x04);
 
1087
        descr->sl.use_idle           = !!(flags & 0x02);
 
1088
        descr->sl.timestamp_res      = avio_rb32(&d->pb);
 
1089
                                       avio_rb32(&d->pb);
 
1090
        descr->sl.timestamp_len      = avio_r8(&d->pb);
 
1091
        descr->sl.ocr_len            = avio_r8(&d->pb);
 
1092
        descr->sl.au_len             = avio_r8(&d->pb);
 
1093
        descr->sl.inst_bitrate_len   = avio_r8(&d->pb);
 
1094
        lengths                      = avio_rb16(&d->pb);
 
1095
        descr->sl.degr_prior_len     = lengths >> 12;
 
1096
        descr->sl.au_seq_num_len     = (lengths >> 7) & 0x1f;
 
1097
        descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
 
1098
    } else {
 
1099
        av_log_missing_feature(d->s, "Predefined SLConfigDescriptor\n", 0);
 
1100
    }
 
1101
    return 0;
 
1102
}
 
1103
 
 
1104
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
 
1105
                           int target_tag) {
 
1106
    int tag;
 
1107
    int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);
 
1108
    update_offsets(&d->pb, &off, &len);
 
1109
    if (len < 0 || len1 > len || len1 <= 0) {
 
1110
        av_log(d->s, AV_LOG_ERROR, "Tag %x length violation new length %d bytes remaining %d\n", tag, len1, len);
 
1111
        return -1;
 
1112
    }
 
1113
 
 
1114
    if (d->level++ >= MAX_LEVEL) {
 
1115
        av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
 
1116
        goto done;
 
1117
    }
 
1118
 
 
1119
    if (target_tag && tag != target_tag) {
 
1120
        av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag, target_tag);
 
1121
        goto done;
 
1122
    }
 
1123
 
 
1124
    switch (tag) {
 
1125
    case MP4IODescrTag:
 
1126
        parse_MP4IODescrTag(d, off, len1);
 
1127
        break;
 
1128
    case MP4ODescrTag:
 
1129
        parse_MP4ODescrTag(d, off, len1);
 
1130
        break;
 
1131
    case MP4ESDescrTag:
 
1132
        parse_MP4ESDescrTag(d, off, len1);
 
1133
        break;
 
1134
    case MP4DecConfigDescrTag:
 
1135
        parse_MP4DecConfigDescrTag(d, off, len1);
 
1136
        break;
 
1137
    case MP4SLDescrTag:
 
1138
        parse_MP4SLDescrTag(d, off, len1);
 
1139
        break;
 
1140
    }
 
1141
 
 
1142
done:
 
1143
    d->level--;
 
1144
    avio_seek(&d->pb, off + len1, SEEK_SET);
 
1145
    return 0;
 
1146
}
 
1147
 
859
1148
static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
860
 
                         int *es_id, uint8_t **dec_config_descr,
861
 
                         int *dec_config_descr_size)
862
 
{
 
1149
                         Mp4Descr *descr, int *descr_count, int max_descr_count)
 
1150
{
 
1151
    MP4DescrParseContext d;
 
1152
    if (init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count) < 0)
 
1153
        return -1;
 
1154
 
 
1155
    parse_mp4_descr(&d, avio_tell(&d.pb), size, MP4IODescrTag);
 
1156
 
 
1157
    *descr_count = d.descr_count;
 
1158
    return 0;
 
1159
}
 
1160
 
 
1161
static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
 
1162
                       Mp4Descr *descr, int *descr_count, int max_descr_count)
 
1163
{
 
1164
    MP4DescrParseContext d;
 
1165
    if (init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count) < 0)
 
1166
        return -1;
 
1167
 
 
1168
    parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);
 
1169
 
 
1170
    *descr_count = d.descr_count;
 
1171
    return 0;
 
1172
}
 
1173
 
 
1174
static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
 
1175
{
 
1176
    MpegTSContext *ts = filter->u.section_filter.opaque;
 
1177
    SectionHeader h;
 
1178
    const uint8_t *p, *p_end;
863
1179
    AVIOContext pb;
864
 
    int tag;
865
 
    unsigned len;
866
 
 
867
 
    ffio_init_context(&pb, buf, size, 0, NULL, NULL, NULL, NULL);
868
 
 
869
 
    len = ff_mp4_read_descr(s, &pb, &tag);
870
 
    if (tag == MP4IODescrTag) {
871
 
        avio_rb16(&pb); // ID
872
 
        avio_r8(&pb);
873
 
        avio_r8(&pb);
874
 
        avio_r8(&pb);
875
 
        avio_r8(&pb);
876
 
        avio_r8(&pb);
877
 
        len = ff_mp4_read_descr(s, &pb, &tag);
878
 
        if (tag == MP4ESDescrTag) {
879
 
            *es_id = avio_rb16(&pb); /* ES_ID */
880
 
            av_dlog(s, "ES_ID %#x\n", *es_id);
881
 
            avio_r8(&pb); /* priority */
882
 
            len = ff_mp4_read_descr(s, &pb, &tag);
883
 
            if (tag == MP4DecConfigDescrTag) {
884
 
                *dec_config_descr = av_malloc(len);
885
 
                if (!*dec_config_descr)
886
 
                    return AVERROR(ENOMEM);
887
 
                *dec_config_descr_size = len;
888
 
                avio_read(&pb, *dec_config_descr, len);
 
1180
    Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = {{ 0 }};
 
1181
    int mp4_descr_count = 0;
 
1182
    int i, pid;
 
1183
    AVFormatContext *s = ts->stream;
 
1184
 
 
1185
    p_end = section + section_len - 4;
 
1186
    p = section;
 
1187
    if (parse_section_header(&h, &p, p_end) < 0)
 
1188
        return;
 
1189
    if (h.tid != M4OD_TID)
 
1190
        return;
 
1191
 
 
1192
    mp4_read_od(s, p, (unsigned)(p_end - p), mp4_descr, &mp4_descr_count, MAX_MP4_DESCR_COUNT);
 
1193
 
 
1194
    for (pid = 0; pid < NB_PID_MAX; pid++) {
 
1195
        if (!ts->pids[pid])
 
1196
             continue;
 
1197
        for (i = 0; i < mp4_descr_count; i++) {
 
1198
            PESContext *pes;
 
1199
            AVStream *st;
 
1200
            if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
 
1201
                continue;
 
1202
            if (!(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES)) {
 
1203
                av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
 
1204
                continue;
 
1205
            }
 
1206
            pes = ts->pids[pid]->u.pes_filter.opaque;
 
1207
            st = pes->st;
 
1208
            if (!st) {
 
1209
                continue;
 
1210
            }
 
1211
 
 
1212
            pes->sl = mp4_descr[i].sl;
 
1213
 
 
1214
            ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
 
1215
                              mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
 
1216
            ff_mp4_read_dec_config_descr(s, st, &pb);
 
1217
            if (st->codec->codec_id == CODEC_ID_AAC &&
 
1218
                st->codec->extradata_size > 0)
 
1219
                st->need_parsing = 0;
 
1220
            if (st->codec->codec_id == CODEC_ID_H264 &&
 
1221
                st->codec->extradata_size > 0)
 
1222
                st->need_parsing = 0;
 
1223
 
 
1224
            if (st->codec->codec_id <= CODEC_ID_NONE) {
 
1225
            } else if (st->codec->codec_id < CODEC_ID_FIRST_AUDIO) {
 
1226
                st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
 
1227
            } else if (st->codec->codec_id < CODEC_ID_FIRST_SUBTITLE) {
 
1228
                st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 
1229
            } else if (st->codec->codec_id < CODEC_ID_FIRST_UNKNOWN) {
 
1230
                st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
889
1231
            }
890
1232
        }
891
1233
    }
892
 
    return 0;
 
1234
    for (i = 0; i < mp4_descr_count; i++)
 
1235
        av_free(mp4_descr[i].dec_config_descr);
893
1236
}
894
1237
 
895
1238
int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type,
896
1239
                              const uint8_t **pp, const uint8_t *desc_list_end,
897
 
                              int mp4_dec_config_descr_len, int mp4_es_id, int pid,
898
 
                              uint8_t *mp4_dec_config_descr)
 
1240
                              Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
 
1241
                              MpegTSContext *ts)
899
1242
{
900
1243
    const uint8_t *desc_end;
901
 
    int desc_len, desc_tag;
 
1244
    int desc_len, desc_tag, desc_es_id;
902
1245
    char language[252];
903
1246
    int i;
904
1247
 
919
1262
        mpegts_find_stream_type(st, desc_tag, DESC_types);
920
1263
 
921
1264
    switch(desc_tag) {
 
1265
    case 0x1E: /* SL descriptor */
 
1266
        desc_es_id = get16(pp, desc_end);
 
1267
        if (ts && ts->pids[pid])
 
1268
            ts->pids[pid]->es_id = desc_es_id;
 
1269
        for (i = 0; i < mp4_descr_count; i++)
 
1270
        if (mp4_descr[i].dec_config_descr_len &&
 
1271
            mp4_descr[i].es_id == desc_es_id) {
 
1272
            AVIOContext pb;
 
1273
            ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
 
1274
                          mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
 
1275
            ff_mp4_read_dec_config_descr(fc, st, &pb);
 
1276
            if (st->codec->codec_id == CODEC_ID_AAC &&
 
1277
                st->codec->extradata_size > 0)
 
1278
                st->need_parsing = 0;
 
1279
            if (st->codec->codec_id == CODEC_ID_MPEG4SYSTEMS)
 
1280
                mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
 
1281
        }
 
1282
        break;
922
1283
    case 0x1F: /* FMC descriptor */
923
1284
        get16(pp, desc_end);
924
 
        if (st->codec->codec_id == CODEC_ID_AAC_LATM &&
925
 
            mp4_dec_config_descr_len && mp4_es_id == pid) {
 
1285
        if (mp4_descr_count > 0 && st->codec->codec_id == CODEC_ID_AAC_LATM &&
 
1286
            mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
926
1287
            AVIOContext pb;
927
 
            ffio_init_context(&pb, mp4_dec_config_descr,
928
 
                          mp4_dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
 
1288
            ffio_init_context(&pb, mp4_descr->dec_config_descr,
 
1289
                          mp4_descr->dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
929
1290
            ff_mp4_read_dec_config_descr(fc, st, &pb);
930
1291
            if (st->codec->codec_id == CODEC_ID_AAC &&
931
1292
                st->codec->extradata_size > 0)
1009
1370
    int program_info_length, pcr_pid, pid, stream_type;
1010
1371
    int desc_list_len;
1011
1372
    uint32_t prog_reg_desc = 0; /* registration descriptor */
1012
 
    uint8_t *mp4_dec_config_descr = NULL;
1013
 
    int mp4_dec_config_descr_len = 0;
1014
 
    int mp4_es_id = 0;
 
1373
 
 
1374
    Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = {{ 0 }};
 
1375
    int mp4_descr_count = 0;
 
1376
    int i;
1015
1377
 
1016
1378
    av_dlog(ts->stream, "PMT: len %i\n", section_len);
1017
1379
    hex_dump_debug(ts->stream, (uint8_t *)section, section_len);
1053
1415
            get8(&p, p_end); // scope
1054
1416
            get8(&p, p_end); // label
1055
1417
            len -= 2;
1056
 
            mp4_read_iods(ts->stream, p, len, &mp4_es_id,
1057
 
                          &mp4_dec_config_descr, &mp4_dec_config_descr_len);
 
1418
            mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
 
1419
                          &mp4_descr_count, MAX_MP4_DESCR_COUNT);
1058
1420
        } else if (tag == 0x05 && len >= 4) { // registration descriptor
1059
1421
            prog_reg_desc = bytestream_get_le32(&p);
1060
1422
            len -= 4;
1071
1433
 
1072
1434
    for(;;) {
1073
1435
        st = 0;
 
1436
        pes = NULL;
1074
1437
        stream_type = get8(&p, p_end);
1075
1438
        if (stream_type < 0)
1076
1439
            break;
1078
1441
        if (pid < 0)
1079
1442
            break;
1080
1443
 
1081
 
        /* now create ffmpeg stream */
 
1444
        /* now create stream */
1082
1445
        if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
1083
1446
            pes = ts->pids[pid]->u.pes_filter.opaque;
1084
 
            if (!pes->st)
1085
 
                pes->st = av_new_stream(pes->stream, pes->pid);
 
1447
            if (!pes->st) {
 
1448
                pes->st = avformat_new_stream(pes->stream, NULL);
 
1449
                pes->st->id = pes->pid;
 
1450
            }
1086
1451
            st = pes->st;
1087
 
        } else {
 
1452
        } else if (stream_type != 0x13) {
1088
1453
            if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
1089
1454
            pes = add_pes_stream(ts, pid, pcr_pid);
1090
 
            if (pes)
1091
 
                st = av_new_stream(pes->stream, pes->pid);
 
1455
            if (pes) {
 
1456
                st = avformat_new_stream(pes->stream, NULL);
 
1457
                st->id = pes->pid;
 
1458
            }
 
1459
        } else {
 
1460
            int idx = ff_find_stream_index(ts->stream, pid);
 
1461
            if (idx >= 0) {
 
1462
                st = ts->stream->streams[idx];
 
1463
            } else {
 
1464
                st = avformat_new_stream(ts->stream, NULL);
 
1465
                st->id = pid;
 
1466
                st->codec->codec_type = AVMEDIA_TYPE_DATA;
 
1467
            }
1092
1468
        }
1093
1469
 
1094
1470
        if (!st)
1095
1471
            goto out;
1096
1472
 
1097
 
        if (!pes->stream_type)
 
1473
        if (pes && !pes->stream_type)
1098
1474
            mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
1099
1475
 
1100
1476
        add_pid_to_pmt(ts, h->id, pid);
1109
1485
            break;
1110
1486
        for(;;) {
1111
1487
            if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p, desc_list_end,
1112
 
                mp4_dec_config_descr_len, mp4_es_id, pid, mp4_dec_config_descr) < 0)
 
1488
                mp4_descr, mp4_descr_count, pid, ts) < 0)
1113
1489
                break;
1114
1490
 
1115
 
            if (prog_reg_desc == AV_RL32("HDMV") && stream_type == 0x83 && pes->sub_st) {
 
1491
            if (pes && prog_reg_desc == AV_RL32("HDMV") && stream_type == 0x83 && pes->sub_st) {
1116
1492
                ff_program_add_stream_index(ts->stream, h->id, pes->sub_st->index);
1117
1493
                pes->sub_st->codec->codec_tag = st->codec->codec_tag;
1118
1494
            }
1121
1497
    }
1122
1498
 
1123
1499
 out:
1124
 
    av_free(mp4_dec_config_descr);
 
1500
    for (i = 0; i < mp4_descr_count; i++)
 
1501
        av_free(mp4_descr[i].dec_config_descr);
1125
1502
}
1126
1503
 
1127
1504
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1247
1624
{
1248
1625
    AVFormatContext *s = ts->stream;
1249
1626
    MpegTSFilter *tss;
1250
 
    int len, pid, cc, cc_ok, afc, is_start;
 
1627
    int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
 
1628
        has_adaptation, has_payload;
1251
1629
    const uint8_t *p, *p_end;
1252
1630
    int64_t pos;
1253
1631
 
1263
1641
    if (!tss)
1264
1642
        return 0;
1265
1643
 
 
1644
    afc = (packet[3] >> 4) & 3;
 
1645
    if (afc == 0) /* reserved value */
 
1646
        return 0;
 
1647
    has_adaptation = afc & 2;
 
1648
    has_payload = afc & 1;
 
1649
    is_discontinuity = has_adaptation
 
1650
                && packet[4] != 0 /* with length > 0 */
 
1651
                && (packet[5] & 0x80); /* and discontinuity indicated */
 
1652
 
1266
1653
    /* continuity check (currently not used) */
1267
1654
    cc = (packet[3] & 0xf);
1268
 
    cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
 
1655
    expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
 
1656
    cc_ok = pid == 0x1FFF // null packet PID
 
1657
            || is_discontinuity
 
1658
            || tss->last_cc < 0
 
1659
            || expected_cc == cc;
 
1660
 
1269
1661
    tss->last_cc = cc;
 
1662
    if (!cc_ok) {
 
1663
        av_log(ts->stream, AV_LOG_WARNING,
 
1664
               "Continuity check failed for pid %d expected %d got %d\n",
 
1665
               pid, expected_cc, cc);
 
1666
        if(tss->type == MPEGTS_PES) {
 
1667
            PESContext *pc = tss->u.pes_filter.opaque;
 
1668
            pc->flags |= AV_PKT_FLAG_CORRUPT;
 
1669
        }
 
1670
    }
1270
1671
 
1271
 
    /* skip adaptation field */
1272
 
    afc = (packet[3] >> 4) & 3;
 
1672
    if (!has_payload)
 
1673
        return 0;
1273
1674
    p = packet + 4;
1274
 
    if (afc == 0) /* reserved value */
1275
 
        return 0;
1276
 
    if (afc == 2) /* adaptation field only */
1277
 
        return 0;
1278
 
    if (afc == 3) {
1279
 
        /* skip adapation field */
 
1675
    if (has_adaptation) {
 
1676
        /* skip adaptation field */
1280
1677
        p += p[0] + 1;
1281
1678
    }
1282
1679
    /* if past the end of packet, ignore */
1354
1751
        len = avio_read(pb, buf, TS_PACKET_SIZE);
1355
1752
        if (len != TS_PACKET_SIZE)
1356
1753
            return len < 0 ? len : AVERROR_EOF;
1357
 
        /* check paquet sync byte */
 
1754
        /* check packet sync byte */
1358
1755
        if (buf[0] != 0x47) {
1359
1756
            /* find a new packet start */
1360
1757
            avio_seek(pb, -TS_PACKET_SIZE, SEEK_CUR);
1376
1773
{
1377
1774
    AVFormatContext *s = ts->stream;
1378
1775
    uint8_t packet[TS_PACKET_SIZE];
1379
 
    int packet_num, ret;
 
1776
    int packet_num, ret = 0;
 
1777
 
 
1778
    if (avio_tell(s->pb) != ts->last_pos) {
 
1779
        int i;
 
1780
        av_dlog(ts->stream, "Skipping after seek\n");
 
1781
        /* seek detected, flush pes buffer */
 
1782
        for (i = 0; i < NB_PID_MAX; i++) {
 
1783
            if (ts->pids[i]) {
 
1784
                if (ts->pids[i]->type == MPEGTS_PES) {
 
1785
                   PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
 
1786
                   av_freep(&pes->buffer);
 
1787
                   pes->data_index = 0;
 
1788
                   pes->state = MPEGTS_SKIP; /* skip until pes header */
 
1789
                }
 
1790
                ts->pids[i]->last_cc = -1;
 
1791
            }
 
1792
        }
 
1793
    }
1380
1794
 
1381
1795
    ts->stop_parse = 0;
1382
1796
    packet_num = 0;
1388
1802
            break;
1389
1803
        ret = read_packet(s, packet, ts->raw_packet_size);
1390
1804
        if (ret != 0)
1391
 
            return ret;
 
1805
            break;
1392
1806
        ret = handle_packet(ts, packet);
1393
1807
        if (ret != 0)
1394
 
            return ret;
 
1808
            break;
1395
1809
    }
1396
 
    return 0;
 
1810
    ts->last_pos = avio_tell(s->pb);
 
1811
    return ret;
1397
1812
}
1398
1813
 
1399
1814
static int mpegts_probe(AVProbeData *p)
1464
1879
    int len;
1465
1880
    int64_t pos;
1466
1881
 
1467
 
#if FF_API_FORMAT_PARAMETERS
1468
 
    if (ap) {
1469
 
        if (ap->mpeg2ts_compute_pcr)
1470
 
            ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr;
1471
 
        if(ap->mpeg2ts_raw){
1472
 
            av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");
1473
 
            return -1;
1474
 
        }
1475
 
    }
1476
 
#endif
1477
 
 
1478
1882
    /* read the first 1024 bytes to get packet size */
1479
1883
    pos = avio_tell(pb);
1480
1884
    len = avio_read(pb, buf, sizeof(buf));
1489
1893
    if (s->iformat == &ff_mpegts_demuxer) {
1490
1894
        /* normal demux */
1491
1895
 
1492
 
        /* first do a scaning to get all the services */
1493
 
        if (avio_seek(pb, pos, SEEK_SET) < 0)
 
1896
        /* first do a scan to get all the services */
 
1897
        if (pb->seekable && avio_seek(pb, pos, SEEK_SET) < 0)
1494
1898
            av_log(s, AV_LOG_ERROR, "Unable to seek back to the start\n");
1495
1899
 
1496
1900
        mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
1514
1918
 
1515
1919
        /* only read packets */
1516
1920
 
1517
 
        st = av_new_stream(s, 0);
 
1921
        st = avformat_new_stream(s, NULL);
1518
1922
        if (!st)
1519
1923
            goto fail;
1520
 
        av_set_pts_info(st, 60, 1, 27000000);
 
1924
        avpriv_set_pts_info(st, 60, 1, 27000000);
1521
1925
        st->codec->codec_type = AVMEDIA_TYPE_DATA;
1522
1926
        st->codec->codec_id = CODEC_ID_MPEG2TS;
1523
1927
 
1611
2015
    MpegTSContext *ts = s->priv_data;
1612
2016
    int ret, i;
1613
2017
 
1614
 
    if (avio_tell(s->pb) != ts->last_pos) {
1615
 
        /* seek detected, flush pes buffer */
1616
 
        for (i = 0; i < NB_PID_MAX; i++) {
1617
 
            if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
1618
 
                PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1619
 
                av_freep(&pes->buffer);
1620
 
                pes->data_index = 0;
1621
 
                pes->state = MPEGTS_SKIP; /* skip until pes header */
1622
 
            }
1623
 
        }
1624
 
    }
1625
 
 
1626
2018
    ts->pkt = pkt;
1627
2019
    ret = handle_packets(ts, 0);
1628
2020
    if (ret < 0) {
1640
2032
        }
1641
2033
    }
1642
2034
 
1643
 
    ts->last_pos = avio_tell(s->pb);
1644
 
 
1645
2035
    return ret;
1646
2036
}
1647
2037
 
1740
2130
            ts_adj = target_ts;
1741
2131
            stream_index_gen_search = stream_index;
1742
2132
        }
1743
 
        pos = av_gen_search(s, stream_index_gen_search, ts_adj,
 
2133
        pos = ff_gen_search(s, stream_index_gen_search, ts_adj,
1744
2134
                            0, INT64_MAX, -1,
1745
2135
                            AV_NOPTS_VALUE,
1746
2136
                            AV_NOPTS_VALUE,
1788
2178
    uint8_t buf[TS_PACKET_SIZE];
1789
2179
    int64_t pos;
1790
2180
 
1791
 
    if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
 
2181
    if (ff_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
1792
2182
        return -1;
1793
2183
 
1794
2184
    pos= avio_tell(s->pb);
1862
2252
}
1863
2253
 
1864
2254
AVInputFormat ff_mpegts_demuxer = {
1865
 
    "mpegts",
1866
 
    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1867
 
    sizeof(MpegTSContext),
1868
 
    mpegts_probe,
1869
 
    mpegts_read_header,
1870
 
    mpegts_read_packet,
1871
 
    mpegts_read_close,
1872
 
    read_seek,
1873
 
    mpegts_get_pcr,
 
2255
    .name           = "mpegts",
 
2256
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
 
2257
    .priv_data_size = sizeof(MpegTSContext),
 
2258
    .read_probe     = mpegts_probe,
 
2259
    .read_header    = mpegts_read_header,
 
2260
    .read_packet    = mpegts_read_packet,
 
2261
    .read_close     = mpegts_read_close,
 
2262
    .read_seek      = read_seek,
 
2263
    .read_timestamp = mpegts_get_pcr,
1874
2264
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1875
2265
#ifdef USE_SYNCPOINT_SEARCH
1876
2266
    .read_seek2 = read_seek2,
1878
2268
};
1879
2269
 
1880
2270
AVInputFormat ff_mpegtsraw_demuxer = {
1881
 
    "mpegtsraw",
1882
 
    NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1883
 
    sizeof(MpegTSContext),
1884
 
    NULL,
1885
 
    mpegts_read_header,
1886
 
    mpegts_raw_read_packet,
1887
 
    mpegts_read_close,
1888
 
    read_seek,
1889
 
    mpegts_get_pcr,
 
2271
    .name           = "mpegtsraw",
 
2272
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
 
2273
    .priv_data_size = sizeof(MpegTSContext),
 
2274
    .read_header    = mpegts_read_header,
 
2275
    .read_packet    = mpegts_raw_read_packet,
 
2276
    .read_close     = mpegts_read_close,
 
2277
    .read_seek      = read_seek,
 
2278
    .read_timestamp = mpegts_get_pcr,
1890
2279
    .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
1891
2280
#ifdef USE_SYNCPOINT_SEARCH
1892
2281
    .read_seek2 = read_seek2,