libavformat/ogg2.c

   1 /*
   2  * Ogg bitstream support
   3  * Luca Barbato <lu_zero@gentoo.org>
   4  * Based on tcvp implementation
   5  *
   6  */
   7
   8 /**
   9     Copyright (C) 2005  Michael Ahlberg, Måns Rullgård
  10
  11     Permission is hereby granted, free of charge, to any person
  12     obtaining a copy of this software and associated documentation
  13     files (the "Software"), to deal in the Software without
  14     restriction, including without limitation the rights to use, copy,
  15     modify, merge, publish, distribute, sublicense, and/or sell copies
  16     of the Software, and to permit persons to whom the Software is
  17     furnished to do so, subject to the following conditions:
  18
  19     The above copyright notice and this permission notice shall be
  20     included in all copies or substantial portions of the Software.
  21
  22     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  26     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  27     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  28     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  29     DEALINGS IN THE SOFTWARE.
  30 **/
  31
  32
  33 #include <stdio.h>
  34 #include "ogg2.h"
  35 #include "avformat.h"
  36
  37 #define MAX_PAGE_SIZE 65307
  38 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
  39
  40 static ogg_codec_t *ogg_codecs[] = {
  41     &vorbis_codec,
  42     &theora_codec,
  43     &flac_codec,
  44     &ogm_video_codec,
  45     &ogm_audio_codec,
  46     &ogm_old_codec,
  47     NULL
  48 };
  49
  50 #if 0                           // CONFIG_MUXERS
  51 static int
  52 ogg_write_header (AVFormatContext * avfcontext)
  53 {
  54 }
  55
  56 static int
  57 ogg_write_packet (AVFormatContext * avfcontext, AVPacket * pkt)
  58 {
  59 }
  60
  61
  62 static int
  63 ogg_write_trailer (AVFormatContext * avfcontext)
  64 {
  65 }
  66
  67
  68 AVOutputFormat ogg_muxer = {
  69     "ogg",
  70     "Ogg Vorbis",
  71     "audio/x-vorbis",
  72     "ogg",
  73     sizeof (OggContext),
  74     CODEC_ID_VORBIS,
  75     0,
  76     ogg_write_header,
  77     ogg_write_packet,
  78     ogg_write_trailer,
  79 };
  80 #endif //CONFIG_MUXERS
  81
  82 //FIXME We could avoid some structure duplication
  83 static int
  84 ogg_save (AVFormatContext * s)
  85 {
  86     ogg_t *ogg = s->priv_data;
  87     ogg_state_t *ost =
  88         av_malloc(sizeof (*ost) + (ogg->nstreams-1) * sizeof (*ogg->streams));
  89     int i;
  90     ost->pos = url_ftell (&s->pb);;
  91     ost->curidx = ogg->curidx;
  92     ost->next = ogg->state;
  93     ost->nstreams = ogg->nstreams;
  94     memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
  95
  96     for (i = 0; i < ogg->nstreams; i++){
  97         ogg_stream_t *os = ogg->streams + i;
  98         os->buf = av_malloc (os->bufsize);
  99         memset (os->buf, 0, os->bufsize);
 100         memcpy (os->buf, ost->streams[i].buf, os->bufpos);
 101     }
 102
 103     ogg->state = ost;
 104
 105     return 0;
 106 }
 107
 108 static int
 109 ogg_restore (AVFormatContext * s, int discard)
 110 {
 111     ogg_t *ogg = s->priv_data;
 112     ByteIOContext *bc = &s->pb;
 113     ogg_state_t *ost = ogg->state;
 114     int i;
 115
 116     if (!ost)
 117         return 0;
 118
 119     ogg->state = ost->next;
 120
 121     if (!discard){
 122         for (i = 0; i < ogg->nstreams; i++)
 123             av_free (ogg->streams[i].buf);
 124
 125         url_fseek (bc, ost->pos, SEEK_SET);
 126         ogg->curidx = ost->curidx;
 127         ogg->nstreams = ost->nstreams;
 128         memcpy(ogg->streams, ost->streams,
 129                ost->nstreams * sizeof(*ogg->streams));
 130     }
 131
 132     av_free (ost);
 133
 134     return 0;
 135 }
 136
 137 static int
 138 ogg_reset (ogg_t * ogg)
 139 {
 140     int i;
 141
 142     for (i = 0; i < ogg->nstreams; i++){
 143         ogg_stream_t *os = ogg->streams + i;
 144         os->bufpos = 0;
 145         os->pstart = 0;
 146         os->psize = 0;
 147         os->granule = -1;
 148         os->lastgp = -1;
 149         os->nsegs = 0;
 150         os->segp = 0;
 151     }
 152
 153     ogg->curidx = -1;
 154
 155     return 0;
 156 }
 157
 158 static ogg_codec_t *
 159 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 static int
 172 ogg_find_stream (ogg_t * ogg, int serial)
 173 {
 174     int i;
 175
 176     for (i = 0; i < ogg->nstreams; i++)
 177         if (ogg->streams[i].serial == serial)
 178             return i;
 179
 180     return -1;
 181 }
 182
 183 static int
 184 ogg_new_stream (AVFormatContext * s, uint32_t serial)
 185 {
 186
 187     ogg_t *ogg = s->priv_data;
 188     int idx = ogg->nstreams++;
 189     AVStream *st;
 190     ogg_stream_t *os;
 191
 192     ogg->streams = av_realloc (ogg->streams,
 193                                ogg->nstreams * sizeof (*ogg->streams));
 194     memset (ogg->streams + idx, 0, sizeof (*ogg->streams));
 195     os = ogg->streams + idx;
 196     os->serial = serial;
 197     os->bufsize = DECODER_BUFFER_SIZE;
 198     os->buf = av_malloc(os->bufsize);
 199     os->header = -1;
 200
 201     st = av_new_stream (s, idx);
 202     if (!st)
 203         return AVERROR_NOMEM;
 204
 205     av_set_pts_info(st, 64, 1, 1000000);
 206
 207     return idx;
 208 }
 209
 210 static int
 211 ogg_new_buf(ogg_t *ogg, int idx)
 212 {
 213     ogg_stream_t *os = ogg->streams + idx;
 214     uint8_t *nb = av_malloc(os->bufsize);
 215     int size = os->bufpos - os->pstart;
 216     if(os->buf){
 217         memcpy(nb, os->buf + os->pstart, size);
 218         av_free(os->buf);
 219     }
 220     os->buf = nb;
 221     os->bufpos = size;
 222     os->pstart = 0;
 223
 224     return 0;
 225 }
 226
 227 static int
 228 ogg_read_page (AVFormatContext * s, int *str)
 229 {
 230     ByteIOContext *bc = &s->pb;
 231     ogg_t *ogg = s->priv_data;
 232     ogg_stream_t *os;
 233     int i = 0;
 234     int flags, nsegs;
 235     uint64_t gp;
 236     uint32_t serial;
 237     uint32_t seq;
 238     uint32_t crc;
 239     int size, idx;
 240     uint8_t sync[4];
 241     int sp = 0;
 242
 243     if (get_buffer (bc, sync, 4) < 4)
 244         return -1;
 245
 246     do{
 247         int c;
 248
 249         if (sync[sp & 3] == 'O' &&
 250             sync[(sp + 1) & 3] == 'g' &&
 251             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
 252             break;
 253
 254         c = url_fgetc (bc);
 255         if (c < 0)
 256             return -1;
 257         sync[sp++ & 3] = c;
 258     }while (i++ < MAX_PAGE_SIZE);
 259
 260     if (i >= MAX_PAGE_SIZE){
 261         av_log (s, AV_LOG_INFO, "ogg, can't find sync word\n");
 262         return -1;
 263     }
 264
 265     if (url_fgetc (bc) != 0)      /* version */
 266         return -1;
 267
 268     flags = url_fgetc (bc);
 269     gp = get_le64 (bc);
 270     serial = get_le32 (bc);
 271     seq = get_le32 (bc);
 272     crc = get_le32 (bc);
 273     nsegs = url_fgetc (bc);
 274
 275     idx = ogg_find_stream (ogg, serial);
 276     if (idx < 0){
 277         idx = ogg_new_stream (s, serial);
 278         if (idx < 0)
 279             return -1;
 280     }
 281
 282     os = ogg->streams + idx;
 283
 284     if(os->psize > 0)
 285         ogg_new_buf(ogg, idx);
 286
 287     if (get_buffer (bc, os->segments, nsegs) < nsegs)
 288         return -1;
 289
 290     os->nsegs = nsegs;
 291     os->segp = 0;
 292
 293     size = 0;
 294     for (i = 0; i < nsegs; i++)
 295         size += os->segments[i];
 296
 297     if (flags & OGG_FLAG_CONT){
 298         if (!os->psize){
 299             while (os->segp < os->nsegs){
 300                 int seg = os->segments[os->segp++];
 301                 os->pstart += seg;
 302                 if (seg < 255)
 303                   break;
 304             }
 305         }
 306     }else{
 307       os->psize = 0;
 308     }
 309
 310     if (os->bufsize - os->bufpos < size){
 311         uint8_t *nb = av_malloc (os->bufsize *= 2);
 312         memcpy (nb, os->buf, os->bufpos);
 313         av_free (os->buf);
 314         os->buf = nb;
 315     }
 316
 317     if (get_buffer (bc, os->buf + os->bufpos, size) < size)
 318         return -1;
 319
 320     os->lastgp = os->granule;
 321     os->bufpos += size;
 322     os->granule = gp;
 323     os->flags = flags;
 324
 325     if (str)
 326         *str = idx;
 327
 328     return 0;
 329 }
 330
 331 static int
 332 ogg_packet (AVFormatContext * s, int *str, int *dstart, int *dsize)
 333 {
 334     ogg_t *ogg = s->priv_data;
 335     int idx;
 336     ogg_stream_t *os;
 337     int complete = 0;
 338     int segp = 0, psize = 0;
 339
 340 #if 0
 341     av_log (s, AV_LOG_DEBUG, "ogg_packet: curidx=%i\n", ogg->curidx);
 342 #endif
 343
 344     do{
 345         idx = ogg->curidx;
 346
 347         while (idx < 0){
 348             if (ogg_read_page (s, &idx) < 0)
 349                 return -1;
 350         }
 351
 352         os = ogg->streams + idx;
 353
 354 #if 0
 355         av_log (s, AV_LOG_DEBUG,
 356                 "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
 357                 idx, os->pstart, os->psize, os->segp, os->nsegs);
 358 #endif
 359
 360         if (!os->codec){
 361             if (os->header < 0){
 362                 os->codec = ogg_find_codec (os->buf, os->bufpos);
 363                 if (!os->codec){
 364                     os->header = 0;
 365                     return 0;
 366                 }
 367             }else{
 368                 return 0;
 369             }
 370         }
 371
 372         segp = os->segp;
 373         psize = os->psize;
 374
 375         while (os->segp < os->nsegs){
 376             int ss = os->segments[os->segp++];
 377             os->psize += ss;
 378             if (ss < 255){
 379                 complete = 1;
 380                 break;
 381             }
 382         }
 383
 384         if (!complete && os->segp == os->nsegs){
 385             ogg->curidx = -1;
 386         }
 387     }while (!complete);
 388
 389 #if 0
 390     av_log (s, AV_LOG_DEBUG,
 391             "ogg_packet: idx %i, frame size %i, start %i\n",
 392             idx, os->psize, os->pstart);
 393 #endif
 394
 395     ogg->curidx = idx;
 396
 397     if (os->header < 0){
 398         int hdr = os->codec->header (s, idx);
 399         if (!hdr){
 400           os->header = os->seq;
 401           os->segp = segp;
 402           os->psize = psize;
 403           ogg->headers = 1;
 404         }else{
 405           os->pstart += os->psize;
 406           os->psize = 0;
 407         }
 408     }
 409
 410     if (os->header > -1 && os->seq > os->header){
 411         if (os->codec && os->codec->packet)
 412             os->codec->packet (s, idx);
 413         if (str)
 414             *str = idx;
 415         if (dstart)
 416             *dstart = os->pstart;
 417         if (dsize)
 418             *dsize = os->psize;
 419         os->pstart += os->psize;
 420         os->psize = 0;
 421     }
 422
 423     os->seq++;
 424     if (os->segp == os->nsegs)
 425         ogg->curidx = -1;
 426
 427     return 0;
 428 }
 429
 430 static int
 431 ogg_get_headers (AVFormatContext * s)
 432 {
 433     ogg_t *ogg = s->priv_data;
 434
 435     do{
 436         if (ogg_packet (s, NULL, NULL, NULL) < 0)
 437             return -1;
 438     }while (!ogg->headers);
 439
 440 #if 0
 441     av_log (s, AV_LOG_DEBUG, "found headers\n");
 442 #endif
 443
 444     return 0;
 445 }
 446
 447 static uint64_t
 448 ogg_gptopts (AVFormatContext * s, int i, uint64_t gp)
 449 {
 450     ogg_t *ogg = s->priv_data;
 451     ogg_stream_t *os = ogg->streams + i;
 452     uint64_t pts = AV_NOPTS_VALUE;
 453
 454     if(os->codec->gptopts){
 455         pts = os->codec->gptopts(s, i, gp);
 456     } else {
 457         pts = gp;
 458     }
 459
 460     return pts;
 461 }
 462
 463
 464 static int
 465 ogg_get_length (AVFormatContext * s)
 466 {
 467     ogg_t *ogg = s->priv_data;
 468     int idx = -1, i;
 469     offset_t size, end;
 470
 471     if(s->pb.is_streamed)
 472         return 0;
 473
 474 // already set
 475     if (s->duration != AV_NOPTS_VALUE)
 476         return 0;
 477
 478     size = url_fsize(&s->pb);
 479     if(size < 0)
 480         return 0;
 481     end = size > MAX_PAGE_SIZE? size - MAX_PAGE_SIZE: size;
 482
 483     ogg_save (s);
 484     url_fseek (&s->pb, end, SEEK_SET);
 485
 486     while (!ogg_read_page (s, &i)){
 487         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
 488             ogg->streams[i].codec)
 489             idx = i;
 490     }
 491
 492     if (idx != -1){
 493         s->streams[idx]->duration =
 494             ogg_gptopts (s, idx, ogg->streams[idx].granule);
 495     }
 496
 497     ogg->size = size;
 498     ogg_restore (s, 0);
 499     ogg_save (s);
 500     while (!ogg_read_page (s, &i)) {
 501         if (i == idx && ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0)
 502             break;
 503     }
 504     if (i == idx) {
 505         s->streams[idx]->start_time = ogg_gptopts (s, idx, ogg->streams[idx].granule);
 506         s->streams[idx]->duration -= s->streams[idx]->start_time;
 507     }
 508     ogg_restore (s, 0);
 509
 510     return 0;
 511 }
 512
 513
 514 static int
 515 ogg_read_header (AVFormatContext * s, AVFormatParameters * ap)
 516 {
 517     ogg_t *ogg = s->priv_data;
 518     ogg->curidx = -1;
 519     //linear headers seek from start
 520     if (ogg_get_headers (s) < 0){
 521       return -1;
 522     }
 523
 524     //linear granulepos seek from end
 525     ogg_get_length (s);
 526
 527     //fill the extradata in the per codec callbacks
 528     return 0;
 529 }
 530
 531
 532 static int
 533 ogg_read_packet (AVFormatContext * s, AVPacket * pkt)
 534 {
 535     ogg_t *ogg;
 536     ogg_stream_t *os;
 537     int idx = -1;
 538     int pstart, psize;
 539
 540     //Get an ogg packet
 541     do{
 542         if (ogg_packet (s, &idx, &pstart, &psize) < 0)
 543             return AVERROR_IO;
 544     }while (idx < 0 || !s->streams[idx]);
 545
 546     ogg = s->priv_data;
 547     os = ogg->streams + idx;
 548
 549     //Alloc a pkt
 550     if (av_new_packet (pkt, psize) < 0)
 551         return AVERROR_IO;
 552     pkt->stream_index = idx;
 553     memcpy (pkt->data, os->buf + pstart, psize);
 554     if (os->lastgp != -1LL){
 555         pkt->pts = ogg_gptopts (s, idx, os->lastgp);
 556         os->lastgp = -1;
 557     }
 558
 559     return psize;
 560 }
 561
 562
 563 static int
 564 ogg_read_close (AVFormatContext * s)
 565 {
 566     ogg_t *ogg = s->priv_data;
 567     int i;
 568
 569     for (i = 0; i < ogg->nstreams; i++){
 570         av_free (ogg->streams[i].buf);
 571         av_free (ogg->streams[i].private);
 572     }
 573     av_free (ogg->streams);
 574     return 0;
 575 }
 576
 577
 578 static int
 579 ogg_read_seek (AVFormatContext * s, int stream_index, int64_t target_ts,
 580                int flags)
 581 {
 582     AVStream *st = s->streams[stream_index];
 583     ogg_t *ogg = s->priv_data;
 584     ByteIOContext *bc = &s->pb;
 585     uint64_t min = 0, max = ogg->size;
 586     uint64_t tmin = st->start_time, tmax = st->start_time + st->duration;
 587     int64_t pts = AV_NOPTS_VALUE;
 588
 589     ogg_save (s);
 590
 591     if ((uint64_t)target_ts < tmin || target_ts < 0)
 592         target_ts = tmin;
 593     while (min <= max && tmin < tmax){
 594         uint64_t p = min + (max - min) * (target_ts - tmin) / (tmax - tmin);
 595         int i = -1;
 596
 597         url_fseek (bc, p, SEEK_SET);
 598
 599         while (!ogg_read_page (s, &i)){
 600             if (i == stream_index && ogg->streams[i].granule != 0 &&
 601                 ogg->streams[i].granule != -1)
 602                 break;
 603         }
 604
 605         if (i == -1)
 606             break;
 607
 608         pts = ogg_gptopts (s, i, ogg->streams[i].granule);
 609         p = url_ftell (bc);
 610
 611         if (FFABS (pts - target_ts) * st->time_base.num < st->time_base.den)
 612             break;
 613
 614         if (pts > target_ts){
 615             if (max == p && tmax == pts) {
 616                 // probably our tmin is wrong, causing us to always end up too late in the file
 617                 tmin = (target_ts + tmin + 1) / 2;
 618                 if (tmin == target_ts) {
 619                     url_fseek(bc, min, SEEK_SET);
 620                     break;
 621                 }
 622             }
 623             max = p;
 624             tmax = pts;
 625         }else{
 626             if (min == p && tmin == pts) {
 627                 // probably our tmax is wrong, causing us to always end up too early in the file
 628                 tmax = (target_ts + tmax) / 2;
 629                 if (tmax == target_ts) {
 630                     url_fseek(bc, max, SEEK_SET);
 631                     break;
 632                 }
 633             }
 634             min = p;
 635             tmin = pts;
 636         }
 637     }
 638
 639     if (FFABS (pts - target_ts) * st->time_base.num < st->time_base.den){
 640         ogg_restore (s, 1);
 641         ogg_reset (ogg);
 642     }else{
 643         ogg_restore (s, 0);
 644         pts = AV_NOPTS_VALUE;
 645     }
 646
 647     av_update_cur_dts(s, st, pts);
 648     return 0;
 649
 650 #if 0
 651     //later...
 652     int64_t pos;
 653     if (av_seek_frame_binary (s, stream_index, target_ts, flags) < 0)
 654         return -1;
 655     pos = url_ftell (&s->pb);
 656     ogg_read_timestamp (s, stream_index, &pos, pos - 1);
 657 #endif
 658
 659 }
 660
 661 #if 0
 662 static int64_t
 663 ogg_read_timestamp (AVFormatContext * s, int stream_index, int64_t * pos_arg,
 664                     int64_t pos_limit)
 665 {
 666     ogg_t *ogg = s->priv_data;
 667     ByteIOContext *bc = &s->pb;
 668     int64_t pos, pts;
 669
 670     if (*pos_arg < 0)
 671         return AV_NOPTS_VALUE;
 672
 673     pos = *pos_arg;
 674 }
 675 #endif
 676
 677 static int ogg_probe(AVProbeData *p)
 678 {
 679     if (p->buf_size < 6)
 680         return 0;
 681     if (p->buf[0] == 'O' && p->buf[1] == 'g' &&
 682         p->buf[2] == 'g' && p->buf[3] == 'S' &&
 683         p->buf[4] == 0x0 && p->buf[5] <= 0x7 )
 684         return AVPROBE_SCORE_MAX;
 685     else
 686         return 0;
 687 }
 688
 689 AVInputFormat ogg_demuxer = {
 690     "ogg",
 691     "Ogg",
 692     sizeof (ogg_t),
 693     ogg_probe,
 694     ogg_read_header,
 695     ogg_read_packet,
 696     ogg_read_close,
 697     ogg_read_seek,
 698 // ogg_read_timestamp,
 699     .extensions = "ogg",
 700 };