git.sesse.net Git - ffmpeg/blob - libavformat/oggdec.c

   1 /*
   2  * Ogg bitstream support
   3  * Luca Barbato <lu_zero@gentoo.org>
   4  * Based on tcvp implementation
   5  */
   6
   7 /*
   8     Copyright (C) 2005  Michael Ahlberg, Måns Rullgård
   9
  10     Permission is hereby granted, free of charge, to any person
  11     obtaining a copy of this software and associated documentation
  12     files (the "Software"), to deal in the Software without
  13     restriction, including without limitation the rights to use, copy,
  14     modify, merge, publish, distribute, sublicense, and/or sell copies
  15     of the Software, and to permit persons to whom the Software is
  16     furnished to do so, subject to the following conditions:
  17
  18     The above copyright notice and this permission notice shall be
  19     included in all copies or substantial portions of the Software.
  20
  21     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  25     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  26     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  27     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  28     DEALINGS IN THE SOFTWARE.
  29  */
  30
  31 #include <stdio.h>
  32 #include "libavutil/avassert.h"
  33 #include "libavutil/intreadwrite.h"
  34 #include "oggdec.h"
  35 #include "avformat.h"
  36 #include "internal.h"
  37 #include "vorbiscomment.h"
  38
  39 #define MAX_PAGE_SIZE 65307
  40 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
  41
  42 static const struct ogg_codec * const ogg_codecs[] = {
  43     &ff_skeleton_codec,
  44     &ff_dirac_codec,
  45     &ff_speex_codec,
  46     &ff_vorbis_codec,
  47     &ff_theora_codec,
  48     &ff_flac_codec,
  49     &ff_celt_codec,
  50     &ff_opus_codec,
  51     &ff_vp8_codec,
  52     &ff_old_dirac_codec,
  53     &ff_old_flac_codec,
  54     &ff_ogm_video_codec,
  55     &ff_ogm_audio_codec,
  56     &ff_ogm_text_codec,
  57     &ff_ogm_old_codec,
  58     NULL
  59 };
  60
  61 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts);
  62 static int ogg_new_stream(AVFormatContext *s, uint32_t serial);
  63
  64 //FIXME We could avoid some structure duplication
  65 static int ogg_save(AVFormatContext *s)
  66 {
  67     struct ogg *ogg = s->priv_data;
  68     struct ogg_state *ost =
  69         av_malloc(sizeof(*ost) + (ogg->nstreams - 1) * sizeof(*ogg->streams));
  70     int i;
  71
  72     if (!ost)
  73         return AVERROR(ENOMEM);
  74
  75     ost->pos      = avio_tell(s->pb);
  76     ost->curidx   = ogg->curidx;
  77     ost->next     = ogg->state;
  78     ost->nstreams = ogg->nstreams;
  79     memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
  80
  81     for (i = 0; i < ogg->nstreams; i++) {
  82         struct ogg_stream *os = ogg->streams + i;
  83         os->buf = av_mallocz(os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
  84         memcpy(os->buf, ost->streams[i].buf, os->bufpos);
  85         os->new_metadata      = NULL;
  86         os->new_metadata_size = 0;
  87     }
  88
  89     ogg->state = ost;
  90
  91     return 0;
  92 }
  93
  94 static int ogg_restore(AVFormatContext *s, int discard)
  95 {
  96     struct ogg *ogg = s->priv_data;
  97     AVIOContext *bc = s->pb;
  98     struct ogg_state *ost = ogg->state;
  99     int i, err;
 100
 101     if (!ost)
 102         return 0;
 103
 104     ogg->state = ost->next;
 105
 106     if (!discard) {
 107
 108         for (i = 0; i < ogg->nstreams; i++)
 109             av_freep(&ogg->streams[i].buf);
 110
 111         avio_seek(bc, ost->pos, SEEK_SET);
 112         ogg->page_pos = -1;
 113         ogg->curidx   = ost->curidx;
 114         ogg->nstreams = ost->nstreams;
 115         if ((err = av_reallocp_array(&ogg->streams, ogg->nstreams,
 116                                      sizeof(*ogg->streams))) < 0) {
 117             ogg->nstreams = 0;
 118             return err;
 119         } else
 120             memcpy(ogg->streams, ost->streams,
 121                    ost->nstreams * sizeof(*ogg->streams));
 122     }
 123
 124     av_free(ost);
 125
 126     return 0;
 127 }
 128
 129 static int ogg_reset(AVFormatContext *s)
 130 {
 131     struct ogg *ogg = s->priv_data;
 132     int i;
 133     int64_t start_pos = avio_tell(s->pb);
 134
 135     for (i = 0; i < ogg->nstreams; i++) {
 136         struct ogg_stream *os = ogg->streams + i;
 137         os->bufpos     = 0;
 138         os->pstart     = 0;
 139         os->psize      = 0;
 140         os->granule    = -1;
 141         os->lastpts    = AV_NOPTS_VALUE;
 142         os->lastdts    = AV_NOPTS_VALUE;
 143         os->sync_pos   = -1;
 144         os->page_pos   = 0;
 145         os->nsegs      = 0;
 146         os->segp       = 0;
 147         os->incomplete = 0;
 148         os->got_data = 0;
 149         if (start_pos <= s->internal->data_offset) {
 150             os->lastpts = 0;
 151         }
 152         os->end_trimming = 0;
 153         av_freep(&os->new_metadata);
 154         os->new_metadata_size = 0;
 155     }
 156
 157     ogg->page_pos = -1;
 158     ogg->curidx = -1;
 159
 160     return 0;
 161 }
 162
 163 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
 164 {
 165     int i;
 166
 167     for (i = 0; ogg_codecs[i]; i++)
 168         if (size >= ogg_codecs[i]->magicsize &&
 169             !memcmp(buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
 170             return ogg_codecs[i];
 171
 172     return NULL;
 173 }
 174
 175 /**
 176  * Replace the current stream with a new one. This is a typical webradio
 177  * situation where a new audio stream spawn (identified with a new serial) and
 178  * must replace the previous one (track switch).
 179  */
 180 static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, int nsegs)
 181 {
 182     struct ogg *ogg = s->priv_data;
 183     struct ogg_stream *os;
 184     const struct ogg_codec *codec;
 185     int i = 0;
 186
 187     if (s->pb->seekable) {
 188         uint8_t magic[8];
 189         int64_t pos = avio_tell(s->pb);
 190         avio_skip(s->pb, nsegs);
 191         avio_read(s->pb, magic, sizeof(magic));
 192         avio_seek(s->pb, pos, SEEK_SET);
 193         codec = ogg_find_codec(magic, sizeof(magic));
 194         if (!codec) {
 195             av_log(s, AV_LOG_ERROR, "Cannot identify new stream\n");
 196             return AVERROR_INVALIDDATA;
 197         }
 198         for (i = 0; i < ogg->nstreams; i++) {
 199             if (ogg->streams[i].codec == codec)
 200                 break;
 201         }
 202         if (i >= ogg->nstreams)
 203             return ogg_new_stream(s, serial);
 204     } else if (ogg->nstreams != 1) {
 205         avpriv_report_missing_feature(s, "Changing stream parameters in multistream ogg");
 206         return AVERROR_PATCHWELCOME;
 207     }
 208
 209     os = &ogg->streams[i];
 210
 211     os->serial  = serial;
 212     return i;
 213
 214 #if 0
 215     buf     = os->buf;
 216     bufsize = os->bufsize;
 217     codec   = os->codec;
 218
 219     if (!ogg->state || ogg->state->streams[i].private != os->private)
 220         av_freep(&ogg->streams[i].private);
 221
 222     /* Set Ogg stream settings similar to what is done in ogg_new_stream(). We
 223      * also re-use the ogg_stream allocated buffer */
 224     memset(os, 0, sizeof(*os));
 225     os->serial  = serial;
 226     os->bufsize = bufsize;
 227     os->buf     = buf;
 228     os->header  = -1;
 229     os->codec   = codec;
 230
 231     return i;
 232 #endif
 233 }
 234
 235 static int ogg_new_stream(AVFormatContext *s, uint32_t serial)
 236 {
 237     struct ogg *ogg = s->priv_data;
 238     int idx         = ogg->nstreams;
 239     AVStream *st;
 240     struct ogg_stream *os;
 241     size_t size;
 242
 243     if (ogg->state) {
 244         av_log(s, AV_LOG_ERROR, "New streams are not supposed to be added "
 245                "in between Ogg context save/restore operations.\n");
 246         return AVERROR_BUG;
 247     }
 248
 249     /* Allocate and init a new Ogg Stream */
 250     if (av_size_mult(ogg->nstreams + 1, sizeof(*ogg->streams), &size) < 0 ||
 251         !(os = av_realloc(ogg->streams, size)))
 252         return AVERROR(ENOMEM);
 253     ogg->streams = os;
 254     os           = ogg->streams + idx;
 255     memset(os, 0, sizeof(*os));
 256     os->serial        = serial;
 257     os->bufsize       = DECODER_BUFFER_SIZE;
 258     os->buf           = av_malloc(os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
 259     os->header        = -1;
 260     os->start_granule = OGG_NOGRANULE_VALUE;
 261     if (!os->buf)
 262         return AVERROR(ENOMEM);
 263
 264     /* Create the associated AVStream */
 265     st = avformat_new_stream(s, NULL);
 266     if (!st) {
 267         av_freep(&os->buf);
 268         return AVERROR(ENOMEM);
 269     }
 270     st->id = idx;
 271     avpriv_set_pts_info(st, 64, 1, 1000000);
 272
 273     ogg->nstreams++;
 274     return idx;
 275 }
 276
 277 static int ogg_new_buf(struct ogg *ogg, int idx)
 278 {
 279     struct ogg_stream *os = ogg->streams + idx;
 280     uint8_t *nb = av_malloc(os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
 281     int size = os->bufpos - os->pstart;
 282
 283     if (!nb)
 284         return AVERROR(ENOMEM);
 285
 286     if (os->buf) {
 287         memcpy(nb, os->buf + os->pstart, size);
 288         av_free(os->buf);
 289     }
 290
 291     os->buf    = nb;
 292     os->bufpos = size;
 293     os->pstart = 0;
 294
 295     return 0;
 296 }
 297
 298 static int data_packets_seen(const struct ogg *ogg)
 299 {
 300     int i;
 301
 302     for (i = 0; i < ogg->nstreams; i++)
 303         if (ogg->streams[i].got_data)
 304             return 1;
 305     return 0;
 306 }
 307
 308 static int ogg_read_page(AVFormatContext *s, int *sid)
 309 {
 310     AVIOContext *bc = s->pb;
 311     struct ogg *ogg = s->priv_data;
 312     struct ogg_stream *os;
 313     int ret, i = 0;
 314     int flags, nsegs;
 315     uint64_t gp;
 316     uint32_t serial;
 317     int size, idx;
 318     uint8_t sync[4];
 319     int sp = 0;
 320
 321     ret = avio_read(bc, sync, 4);
 322     if (ret < 4)
 323         return ret < 0 ? ret : AVERROR_EOF;
 324
 325     do {
 326         int c;
 327
 328         if (sync[sp & 3] == 'O' &&
 329             sync[(sp + 1) & 3] == 'g' &&
 330             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
 331             break;
 332
 333         if(!i && bc->seekable && ogg->page_pos > 0) {
 334             memset(sync, 0, 4);
 335             avio_seek(bc, ogg->page_pos+4, SEEK_SET);
 336             ogg->page_pos = -1;
 337         }
 338
 339         c = avio_r8(bc);
 340
 341         if (avio_feof(bc))
 342             return AVERROR_EOF;
 343
 344         sync[sp++ & 3] = c;
 345     } while (i++ < MAX_PAGE_SIZE);
 346
 347     if (i >= MAX_PAGE_SIZE) {
 348         av_log(s, AV_LOG_INFO, "cannot find sync word\n");
 349         return AVERROR_INVALIDDATA;
 350     }
 351
 352     if (avio_r8(bc) != 0) {      /* version */
 353         av_log (s, AV_LOG_ERROR, "ogg page, unsupported version\n");
 354         return AVERROR_INVALIDDATA;
 355     }
 356
 357     flags  = avio_r8(bc);
 358     gp     = avio_rl64(bc);
 359     serial = avio_rl32(bc);
 360     avio_skip(bc, 8); /* seq, crc */
 361     nsegs  = avio_r8(bc);
 362
 363     idx = ogg_find_stream(ogg, serial);
 364     if (idx < 0) {
 365         if (data_packets_seen(ogg))
 366             idx = ogg_replace_stream(s, serial, nsegs);
 367         else
 368             idx = ogg_new_stream(s, serial);
 369
 370         if (idx < 0) {
 371             av_log(s, AV_LOG_ERROR, "failed to create or replace stream\n");
 372             return idx;
 373         }
 374     }
 375
 376     os = ogg->streams + idx;
 377     ogg->page_pos =
 378     os->page_pos = avio_tell(bc) - 27;
 379
 380     if (os->psize > 0) {
 381         ret = ogg_new_buf(ogg, idx);
 382         if (ret < 0)
 383             return ret;
 384     }
 385
 386     ret = avio_read(bc, os->segments, nsegs);
 387     if (ret < nsegs)
 388         return ret < 0 ? ret : AVERROR_EOF;
 389
 390     os->nsegs = nsegs;
 391     os->segp  = 0;
 392
 393     size = 0;
 394     for (i = 0; i < nsegs; i++)
 395         size += os->segments[i];
 396
 397     if (!(flags & OGG_FLAG_BOS))
 398         os->got_data = 1;
 399
 400     if (flags & OGG_FLAG_CONT || os->incomplete) {
 401         if (!os->psize) {
 402             // If this is the very first segment we started
 403             // playback in the middle of a continuation packet.
 404             // Discard it since we missed the start of it.
 405             while (os->segp < os->nsegs) {
 406                 int seg = os->segments[os->segp++];
 407                 os->pstart += seg;
 408                 if (seg < 255)
 409                     break;
 410             }
 411             os->sync_pos = os->page_pos;
 412         }
 413     } else {
 414         os->psize    = 0;
 415         os->sync_pos = os->page_pos;
 416     }
 417
 418     if (os->bufsize - os->bufpos < size) {
 419         uint8_t *nb = av_malloc((os->bufsize *= 2) + FF_INPUT_BUFFER_PADDING_SIZE);
 420         if (!nb)
 421             return AVERROR(ENOMEM);
 422         memcpy(nb, os->buf, os->bufpos);
 423         av_free(os->buf);
 424         os->buf = nb;
 425     }
 426
 427     ret = avio_read(bc, os->buf + os->bufpos, size);
 428     if (ret < size)
 429         return ret < 0 ? ret : AVERROR_EOF;
 430
 431     os->bufpos += size;
 432     os->granule = gp;
 433     os->flags   = flags;
 434
 435     memset(os->buf + os->bufpos, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 436     if (sid)
 437         *sid = idx;
 438
 439     return 0;
 440 }
 441
 442 /**
 443  * @brief find the next Ogg packet
 444  * @param *sid is set to the stream for the packet or -1 if there is
 445  *             no matching stream, in that case assume all other return
 446  *             values to be uninitialized.
 447  * @return negative value on error or EOF.
 448  */
 449 static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize,
 450                       int64_t *fpos)
 451 {
 452     struct ogg *ogg = s->priv_data;
 453     int idx, i, ret;
 454     struct ogg_stream *os;
 455     int complete = 0;
 456     int segp     = 0, psize = 0;
 457
 458     av_log(s, AV_LOG_TRACE, "ogg_packet: curidx=%i\n", ogg->curidx);
 459     if (sid)
 460         *sid = -1;
 461
 462     do {
 463         idx = ogg->curidx;
 464
 465         while (idx < 0) {
 466             ret = ogg_read_page(s, &idx);
 467             if (ret < 0)
 468                 return ret;
 469         }
 470
 471         os = ogg->streams + idx;
 472
 473         av_log(s, AV_LOG_TRACE, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
 474                 idx, os->pstart, os->psize, os->segp, os->nsegs);
 475
 476         if (!os->codec) {
 477             if (os->header < 0) {
 478                 os->codec = ogg_find_codec(os->buf, os->bufpos);
 479                 if (!os->codec) {
 480                     av_log(s, AV_LOG_WARNING, "Codec not found\n");
 481                     os->header = 0;
 482                     return 0;
 483                 }
 484             } else {
 485                 return 0;
 486             }
 487         }
 488
 489         segp  = os->segp;
 490         psize = os->psize;
 491
 492         while (os->segp < os->nsegs) {
 493             int ss = os->segments[os->segp++];
 494             os->psize += ss;
 495             if (ss < 255) {
 496                 complete = 1;
 497                 break;
 498             }
 499         }
 500
 501         if (!complete && os->segp == os->nsegs) {
 502             ogg->curidx    = -1;
 503             // Do not set incomplete for empty packets.
 504             // Together with the code in ogg_read_page
 505             // that discards all continuation of empty packets
 506             // we would get an infinite loop.
 507             os->incomplete = !!os->psize;
 508         }
 509     } while (!complete);
 510
 511
 512     if (os->granule == -1)
 513         av_log(s, AV_LOG_WARNING,
 514                "Page at %"PRId64" is missing granule\n",
 515                os->page_pos);
 516
 517     ogg->curidx    = idx;
 518     os->incomplete = 0;
 519
 520     if (os->header) {
 521         os->header = os->codec->header(s, idx);
 522         if (!os->header) {
 523             os->segp  = segp;
 524             os->psize = psize;
 525
 526             // We have reached the first non-header packet in this stream.
 527             // Unfortunately more header packets may still follow for others,
 528             // but if we continue with header parsing we may lose data packets.
 529             ogg->headers = 1;
 530
 531             // Update the header state for all streams and
 532             // compute the data_offset.
 533             if (!s->internal->data_offset)
 534                 s->internal->data_offset = os->sync_pos;
 535
 536             for (i = 0; i < ogg->nstreams; i++) {
 537                 struct ogg_stream *cur_os = ogg->streams + i;
 538
 539                 // if we have a partial non-header packet, its start is
 540                 // obviously at or after the data start
 541                 if (cur_os->incomplete)
 542                     s->internal->data_offset = FFMIN(s->internal->data_offset, cur_os->sync_pos);
 543             }
 544         } else {
 545             os->nb_header++;
 546             os->pstart += os->psize;
 547             os->psize   = 0;
 548         }
 549     } else {
 550         os->pflags    = 0;
 551         os->pduration = 0;
 552         if (os->codec && os->codec->packet)
 553             os->codec->packet(s, idx);
 554         if (sid)
 555             *sid = idx;
 556         if (dstart)
 557             *dstart = os->pstart;
 558         if (dsize)
 559             *dsize = os->psize;
 560         if (fpos)
 561             *fpos = os->sync_pos;
 562         os->pstart  += os->psize;
 563         os->psize    = 0;
 564         if(os->pstart == os->bufpos)
 565             os->bufpos = os->pstart = 0;
 566         os->sync_pos = os->page_pos;
 567     }
 568
 569     // determine whether there are more complete packets in this page
 570     // if not, the page's granule will apply to this packet
 571     os->page_end = 1;
 572     for (i = os->segp; i < os->nsegs; i++)
 573         if (os->segments[i] < 255) {
 574             os->page_end = 0;
 575             break;
 576         }
 577
 578     if (os->segp == os->nsegs)
 579         ogg->curidx = -1;
 580
 581     return 0;
 582 }
 583
 584 static int ogg_get_length(AVFormatContext *s)
 585 {
 586     struct ogg *ogg = s->priv_data;
 587     int i, ret;
 588     int64_t size, end;
 589     int streams_left=0;
 590
 591     if (!s->pb->seekable)
 592         return 0;
 593
 594 // already set
 595     if (s->duration != AV_NOPTS_VALUE)
 596         return 0;
 597
 598     size = avio_size(s->pb);
 599     if (size < 0)
 600         return 0;
 601     end = size > MAX_PAGE_SIZE ? size - MAX_PAGE_SIZE : 0;
 602
 603     ret = ogg_save(s);
 604     if (ret < 0)
 605         return ret;
 606     avio_seek(s->pb, end, SEEK_SET);
 607     ogg->page_pos = -1;
 608
 609     while (!ogg_read_page(s, &i)) {
 610         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
 611             ogg->streams[i].codec) {
 612             s->streams[i]->duration =
 613                 ogg_gptopts(s, i, ogg->streams[i].granule, NULL);
 614             if (s->streams[i]->start_time != AV_NOPTS_VALUE) {
 615                 s->streams[i]->duration -= s->streams[i]->start_time;
 616                 streams_left-= (ogg->streams[i].got_start==-1);
 617                 ogg->streams[i].got_start= 1;
 618             } else if(!ogg->streams[i].got_start) {
 619                 ogg->streams[i].got_start= -1;
 620                 streams_left++;
 621             }
 622         }
 623     }
 624
 625     ogg_restore(s, 0);
 626
 627     ret = ogg_save(s);
 628     if (ret < 0)
 629         return ret;
 630
 631     avio_seek (s->pb, s->internal->data_offset, SEEK_SET);
 632     ogg_reset(s);
 633     while (streams_left > 0 && !ogg_packet(s, &i, NULL, NULL, NULL)) {
 634         int64_t pts;
 635         if (i < 0) continue;
 636         pts = ogg_calc_pts(s, i, NULL);
 637         if (pts != AV_NOPTS_VALUE && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
 638             s->streams[i]->duration -= pts;
 639             ogg->streams[i].got_start= 1;
 640             streams_left--;
 641         }else if(s->streams[i]->start_time != AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
 642             ogg->streams[i].got_start= 1;
 643             streams_left--;
 644         }
 645     }
 646     ogg_restore (s, 0);
 647
 648     return 0;
 649 }
 650
 651 static int ogg_read_close(AVFormatContext *s)
 652 {
 653     struct ogg *ogg = s->priv_data;
 654     int i;
 655
 656     for (i = 0; i < ogg->nstreams; i++) {
 657         av_freep(&ogg->streams[i].buf);
 658         if (ogg->streams[i].codec &&
 659             ogg->streams[i].codec->cleanup) {
 660             ogg->streams[i].codec->cleanup(s, i);
 661         }
 662         av_freep(&ogg->streams[i].private);
 663         av_freep(&ogg->streams[i].new_metadata);
 664     }
 665
 666     ogg->nstreams = 0;
 667
 668     av_freep(&ogg->streams);
 669     return 0;
 670 }
 671
 672 static int ogg_read_header(AVFormatContext *s)
 673 {
 674     struct ogg *ogg = s->priv_data;
 675     int ret, i;
 676
 677     ogg->curidx = -1;
 678
 679     //linear headers seek from start
 680     do {
 681         ret = ogg_packet(s, NULL, NULL, NULL, NULL);
 682         if (ret < 0) {
 683             ogg_read_close(s);
 684             return ret;
 685         }
 686     } while (!ogg->headers);
 687     av_log(s, AV_LOG_TRACE, "found headers\n");
 688
 689     for (i = 0; i < ogg->nstreams; i++) {
 690         struct ogg_stream *os = ogg->streams + i;
 691
 692         if (ogg->streams[i].header < 0) {
 693             av_log(s, AV_LOG_ERROR, "Header parsing failed for stream %d\n", i);
 694             ogg->streams[i].codec = NULL;
 695         } else if (os->codec && os->nb_header < os->codec->nb_header) {
 696             av_log(s, AV_LOG_WARNING,
 697                    "Headers mismatch for stream %d: "
 698                    "expected %d received %d.\n",
 699                    i, os->codec->nb_header, os->nb_header);
 700             if (s->error_recognition & AV_EF_EXPLODE)
 701                 return AVERROR_INVALIDDATA;
 702         }
 703         if (os->start_granule != OGG_NOGRANULE_VALUE)
 704             os->lastpts = s->streams[i]->start_time =
 705                 ogg_gptopts(s, i, os->start_granule, NULL);
 706     }
 707
 708     //linear granulepos seek from end
 709     ret = ogg_get_length(s);
 710     if (ret < 0) {
 711         ogg_read_close(s);
 712         return ret;
 713     }
 714
 715     return 0;
 716 }
 717
 718 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
 719 {
 720     struct ogg *ogg       = s->priv_data;
 721     struct ogg_stream *os = ogg->streams + idx;
 722     int64_t pts           = AV_NOPTS_VALUE;
 723
 724     if (dts)
 725         *dts = AV_NOPTS_VALUE;
 726
 727     if (os->lastpts != AV_NOPTS_VALUE) {
 728         pts         = os->lastpts;
 729         os->lastpts = AV_NOPTS_VALUE;
 730     }
 731     if (os->lastdts != AV_NOPTS_VALUE) {
 732         if (dts)
 733             *dts = os->lastdts;
 734         os->lastdts = AV_NOPTS_VALUE;
 735     }
 736     if (os->page_end) {
 737         if (os->granule != -1LL) {
 738             if (os->codec && os->codec->granule_is_start)
 739                 pts = ogg_gptopts(s, idx, os->granule, dts);
 740             else
 741                 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
 742             os->granule = -1LL;
 743         }
 744     }
 745     return pts;
 746 }
 747
 748 static void ogg_validate_keyframe(AVFormatContext *s, int idx, int pstart, int psize)
 749 {
 750     struct ogg *ogg = s->priv_data;
 751     struct ogg_stream *os = ogg->streams + idx;
 752     int invalid = 0;
 753     if (psize) {
 754         switch (s->streams[idx]->codec->codec_id) {
 755         case AV_CODEC_ID_THEORA:
 756             invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 0x40);
 757         break;
 758         case AV_CODEC_ID_VP8:
 759             invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 1);
 760         }
 761         if (invalid) {
 762             os->pflags ^= AV_PKT_FLAG_KEY;
 763             av_log(s, AV_LOG_WARNING, "Broken file, %skeyframe not correctly marked.\n",
 764                    (os->pflags & AV_PKT_FLAG_KEY) ? "" : "non-");
 765         }
 766     }
 767 }
 768
 769 static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
 770 {
 771     struct ogg *ogg;
 772     struct ogg_stream *os;
 773     int idx, ret;
 774     int pstart, psize;
 775     int64_t fpos, pts, dts;
 776
 777     if (s->io_repositioned) {
 778         ogg_reset(s);
 779         s->io_repositioned = 0;
 780     }
 781
 782     //Get an ogg packet
 783 retry:
 784     do {
 785         ret = ogg_packet(s, &idx, &pstart, &psize, &fpos);
 786         if (ret < 0)
 787             return ret;
 788     } while (idx < 0 || !s->streams[idx]);
 789
 790     ogg = s->priv_data;
 791     os  = ogg->streams + idx;
 792
 793     // pflags might not be set until after this
 794     pts = ogg_calc_pts(s, idx, &dts);
 795     ogg_validate_keyframe(s, idx, pstart, psize);
 796
 797     if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
 798         goto retry;
 799     os->keyframe_seek = 0;
 800
 801     //Alloc a pkt
 802     ret = av_new_packet(pkt, psize);
 803     if (ret < 0)
 804         return ret;
 805     pkt->stream_index = idx;
 806     memcpy(pkt->data, os->buf + pstart, psize);
 807
 808     pkt->pts      = pts;
 809     pkt->dts      = dts;
 810     pkt->flags    = os->pflags;
 811     pkt->duration = os->pduration;
 812     pkt->pos      = fpos;
 813
 814     if (os->end_trimming) {
 815         uint8_t *side_data = av_packet_new_side_data(pkt,
 816                                                      AV_PKT_DATA_SKIP_SAMPLES,
 817                                                      10);
 818         if(!side_data)
 819             goto fail;
 820         AV_WL32(side_data + 4, os->end_trimming);
 821         os->end_trimming = 0;
 822     }
 823
 824     if (os->new_metadata) {
 825         uint8_t *side_data = av_packet_new_side_data(pkt,
 826                                                      AV_PKT_DATA_METADATA_UPDATE,
 827                                                      os->new_metadata_size);
 828         if(!side_data)
 829             goto fail;
 830
 831         memcpy(side_data, os->new_metadata, os->new_metadata_size);
 832         av_freep(&os->new_metadata);
 833         os->new_metadata_size = 0;
 834     }
 835
 836     return psize;
 837 fail:
 838     av_free_packet(pkt);
 839     return AVERROR(ENOMEM);
 840 }
 841
 842 static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index,
 843                                   int64_t *pos_arg, int64_t pos_limit)
 844 {
 845     struct ogg *ogg = s->priv_data;
 846     AVIOContext *bc = s->pb;
 847     int64_t pts     = AV_NOPTS_VALUE;
 848     int64_t keypos  = -1;
 849     int i;
 850     int pstart, psize;
 851     avio_seek(bc, *pos_arg, SEEK_SET);
 852     ogg_reset(s);
 853
 854     while (   avio_tell(bc) <= pos_limit
 855            && !ogg_packet(s, &i, &pstart, &psize, pos_arg)) {
 856         if (i == stream_index) {
 857             struct ogg_stream *os = ogg->streams + stream_index;
 858             // Do not trust the last timestamps of a ogm video
 859             if (    (os->flags & OGG_FLAG_EOS)
 860                 && !(os->flags & OGG_FLAG_BOS)
 861                 && os->codec == &ff_ogm_video_codec)
 862                 continue;
 863             pts = ogg_calc_pts(s, i, NULL);
 864             ogg_validate_keyframe(s, i, pstart, psize);
 865             if (os->pflags & AV_PKT_FLAG_KEY) {
 866                 keypos = *pos_arg;
 867             } else if (os->keyframe_seek) {
 868                 // if we had a previous keyframe but no pts for it,
 869                 // return that keyframe with this pts value.
 870                 if (keypos >= 0)
 871                     *pos_arg = keypos;
 872                 else
 873                     pts = AV_NOPTS_VALUE;
 874             }
 875         }
 876         if (pts != AV_NOPTS_VALUE)
 877             break;
 878     }
 879     ogg_reset(s);
 880     return pts;
 881 }
 882
 883 static int ogg_read_seek(AVFormatContext *s, int stream_index,
 884                          int64_t timestamp, int flags)
 885 {
 886     struct ogg *ogg       = s->priv_data;
 887     struct ogg_stream *os = ogg->streams + stream_index;
 888     int ret;
 889
 890     av_assert0(stream_index < ogg->nstreams);
 891     // Ensure everything is reset even when seeking via
 892     // the generated index.
 893     ogg_reset(s);
 894
 895     // Try seeking to a keyframe first. If this fails (very possible),
 896     // av_seek_frame will fall back to ignoring keyframes
 897     if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO
 898         && !(flags & AVSEEK_FLAG_ANY))
 899         os->keyframe_seek = 1;
 900
 901     ret = ff_seek_frame_binary(s, stream_index, timestamp, flags);
 902     os  = ogg->streams + stream_index;
 903     if (ret < 0)
 904         os->keyframe_seek = 0;
 905     return ret;
 906 }
 907
 908 static int ogg_probe(AVProbeData *p)
 909 {
 910     if (!memcmp("OggS", p->buf, 5) && p->buf[5] <= 0x7)
 911         return AVPROBE_SCORE_MAX;
 912     return 0;
 913 }
 914
 915 AVInputFormat ff_ogg_demuxer = {
 916     .name           = "ogg",
 917     .long_name      = NULL_IF_CONFIG_SMALL("Ogg"),
 918     .priv_data_size = sizeof(struct ogg),
 919     .read_probe     = ogg_probe,
 920     .read_header    = ogg_read_header,
 921     .read_packet    = ogg_read_packet,
 922     .read_close     = ogg_read_close,
 923     .read_seek      = ogg_read_seek,
 924     .read_timestamp = ogg_read_timestamp,
 925     .extensions     = "ogg",
 926     .flags          = AVFMT_GENERIC_INDEX | AVFMT_TS_DISCONT | AVFMT_NOBINSEARCH,
 927 };