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