5b67291c633bc91c515f638e14e0cffa7a910439
[ffmpeg.git] / libavformat / oggdec.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 "oggdec.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     &old_flac_codec,
45     &ogm_video_codec,
46     &ogm_audio_codec,
47     &ogm_text_codec,
48     &ogm_old_codec,
49     NULL
50 };
51
52 //FIXME We could avoid some structure duplication
53 static int
54 ogg_save (AVFormatContext * s)
55 {
56     ogg_t *ogg = s->priv_data;
57     ogg_state_t *ost =
58         av_malloc(sizeof (*ost) + (ogg->nstreams-1) * sizeof (*ogg->streams));
59     int i;
60     ost->pos = url_ftell (s->pb);
61     ost->curidx = ogg->curidx;
62     ost->next = ogg->state;
63     ost->nstreams = ogg->nstreams;
64     memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
65
66     for (i = 0; i < ogg->nstreams; i++){
67         ogg_stream_t *os = ogg->streams + i;
68         os->buf = av_malloc (os->bufsize);
69         memset (os->buf, 0, os->bufsize);
70         memcpy (os->buf, ost->streams[i].buf, os->bufpos);
71     }
72
73     ogg->state = ost;
74
75     return 0;
76 }
77
78 static int
79 ogg_restore (AVFormatContext * s, int discard)
80 {
81     ogg_t *ogg = s->priv_data;
82     ByteIOContext *bc = s->pb;
83     ogg_state_t *ost = ogg->state;
84     int i;
85
86     if (!ost)
87         return 0;
88
89     ogg->state = ost->next;
90
91     if (!discard){
92         for (i = 0; i < ogg->nstreams; i++)
93             av_free (ogg->streams[i].buf);
94
95         url_fseek (bc, ost->pos, SEEK_SET);
96         ogg->curidx = ost->curidx;
97         ogg->nstreams = ost->nstreams;
98         memcpy(ogg->streams, ost->streams,
99                ost->nstreams * sizeof(*ogg->streams));
100     }
101
102     av_free (ost);
103
104     return 0;
105 }
106
107 static int
108 ogg_reset (ogg_t * ogg)
109 {
110     int i;
111
112     for (i = 0; i < ogg->nstreams; i++){
113         ogg_stream_t *os = ogg->streams + i;
114         os->bufpos = 0;
115         os->pstart = 0;
116         os->psize = 0;
117         os->granule = -1;
118         os->lastgp = -1;
119         os->nsegs = 0;
120         os->segp = 0;
121     }
122
123     ogg->curidx = -1;
124
125     return 0;
126 }
127
128 static ogg_codec_t *
129 ogg_find_codec (uint8_t * buf, int size)
130 {
131     int i;
132
133     for (i = 0; ogg_codecs[i]; i++)
134         if (size >= ogg_codecs[i]->magicsize &&
135             !memcmp (buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
136             return ogg_codecs[i];
137
138     return NULL;
139 }
140
141 static int
142 ogg_find_stream (ogg_t * ogg, int serial)
143 {
144     int i;
145
146     for (i = 0; i < ogg->nstreams; i++)
147         if (ogg->streams[i].serial == serial)
148             return i;
149
150     return -1;
151 }
152
153 static int
154 ogg_new_stream (AVFormatContext * s, uint32_t serial)
155 {
156
157     ogg_t *ogg = s->priv_data;
158     int idx = ogg->nstreams++;
159     AVStream *st;
160     ogg_stream_t *os;
161
162     ogg->streams = av_realloc (ogg->streams,
163                                ogg->nstreams * sizeof (*ogg->streams));
164     memset (ogg->streams + idx, 0, sizeof (*ogg->streams));
165     os = ogg->streams + idx;
166     os->serial = serial;
167     os->bufsize = DECODER_BUFFER_SIZE;
168     os->buf = av_malloc(os->bufsize);
169     os->header = -1;
170
171     st = av_new_stream (s, idx);
172     if (!st)
173         return AVERROR(ENOMEM);
174
175     av_set_pts_info(st, 64, 1, 1000000);
176
177     return idx;
178 }
179
180 static int
181 ogg_new_buf(ogg_t *ogg, int idx)
182 {
183     ogg_stream_t *os = ogg->streams + idx;
184     uint8_t *nb = av_malloc(os->bufsize);
185     int size = os->bufpos - os->pstart;
186     if(os->buf){
187         memcpy(nb, os->buf + os->pstart, size);
188         av_free(os->buf);
189     }
190     os->buf = nb;
191     os->bufpos = size;
192     os->pstart = 0;
193
194     return 0;
195 }
196
197 static int
198 ogg_read_page (AVFormatContext * s, int *str)
199 {
200     ByteIOContext *bc = s->pb;
201     ogg_t *ogg = s->priv_data;
202     ogg_stream_t *os;
203     int i = 0;
204     int flags, nsegs;
205     uint64_t gp;
206     uint32_t serial;
207     uint32_t seq;
208     uint32_t crc;
209     int size, idx;
210     uint8_t sync[4];
211     int sp = 0;
212
213     if (get_buffer (bc, sync, 4) < 4)
214         return -1;
215
216     do{
217         int c;
218
219         if (sync[sp & 3] == 'O' &&
220             sync[(sp + 1) & 3] == 'g' &&
221             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
222             break;
223
224         c = url_fgetc (bc);
225         if (c < 0)
226             return -1;
227         sync[sp++ & 3] = c;
228     }while (i++ < MAX_PAGE_SIZE);
229
230     if (i >= MAX_PAGE_SIZE){
231         av_log (s, AV_LOG_INFO, "ogg, can't find sync word\n");
232         return -1;
233     }
234
235     if (url_fgetc (bc) != 0)      /* version */
236         return -1;
237
238     flags = url_fgetc (bc);
239     gp = get_le64 (bc);
240     serial = get_le32 (bc);
241     seq = get_le32 (bc);
242     crc = get_le32 (bc);
243     nsegs = url_fgetc (bc);
244
245     idx = ogg_find_stream (ogg, serial);
246     if (idx < 0){
247         idx = ogg_new_stream (s, serial);
248         if (idx < 0)
249             return -1;
250     }
251
252     os = ogg->streams + idx;
253
254     if(os->psize > 0)
255         ogg_new_buf(ogg, idx);
256
257     if (get_buffer (bc, os->segments, nsegs) < nsegs)
258         return -1;
259
260     os->nsegs = nsegs;
261     os->segp = 0;
262
263     size = 0;
264     for (i = 0; i < nsegs; i++)
265         size += os->segments[i];
266
267     if (flags & OGG_FLAG_CONT){
268         if (!os->psize){
269             while (os->segp < os->nsegs){
270                 int seg = os->segments[os->segp++];
271                 os->pstart += seg;
272                 if (seg < 255)
273                   break;
274             }
275         }
276     }else{
277       os->psize = 0;
278     }
279
280     if (os->bufsize - os->bufpos < size){
281         uint8_t *nb = av_malloc (os->bufsize *= 2);
282         memcpy (nb, os->buf, os->bufpos);
283         av_free (os->buf);
284         os->buf = nb;
285     }
286
287     if (get_buffer (bc, os->buf + os->bufpos, size) < size)
288         return -1;
289
290     os->lastgp = os->granule;
291     os->bufpos += size;
292     os->granule = gp;
293     os->flags = flags;
294
295     if (str)
296         *str = idx;
297
298     return 0;
299 }
300
301 static int
302 ogg_packet (AVFormatContext * s, int *str, int *dstart, int *dsize)
303 {
304     ogg_t *ogg = s->priv_data;
305     int idx;
306     ogg_stream_t *os;
307     int complete = 0;
308     int segp = 0, psize = 0;
309
310 #if 0
311     av_log (s, AV_LOG_DEBUG, "ogg_packet: curidx=%i\n", ogg->curidx);
312 #endif
313
314     do{
315         idx = ogg->curidx;
316
317         while (idx < 0){
318             if (ogg_read_page (s, &idx) < 0)
319                 return -1;
320         }
321
322         os = ogg->streams + idx;
323
324 #if 0
325         av_log (s, AV_LOG_DEBUG,
326                 "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
327                 idx, os->pstart, os->psize, os->segp, os->nsegs);
328 #endif
329
330         if (!os->codec){
331             if (os->header < 0){
332                 os->codec = ogg_find_codec (os->buf, os->bufpos);
333                 if (!os->codec){
334                     os->header = 0;
335                     return 0;
336                 }
337             }else{
338                 return 0;
339             }
340         }
341
342         segp = os->segp;
343         psize = os->psize;
344
345         while (os->segp < os->nsegs){
346             int ss = os->segments[os->segp++];
347             os->psize += ss;
348             if (ss < 255){
349                 complete = 1;
350                 break;
351             }
352         }
353
354         if (!complete && os->segp == os->nsegs){
355             ogg->curidx = -1;
356         }
357     }while (!complete);
358
359 #if 0
360     av_log (s, AV_LOG_DEBUG,
361             "ogg_packet: idx %i, frame size %i, start %i\n",
362             idx, os->psize, os->pstart);
363 #endif
364
365     ogg->curidx = idx;
366
367     if (os->header < 0){
368         int hdr = os->codec->header (s, idx);
369         if (!hdr){
370           os->header = os->seq;
371           os->segp = segp;
372           os->psize = psize;
373           ogg->headers = 1;
374         }else{
375           os->pstart += os->psize;
376           os->psize = 0;
377         }
378     }
379
380     if (os->header > -1 && os->seq > os->header){
381         os->pflags = 0;
382         if (os->codec && os->codec->packet)
383             os->codec->packet (s, idx);
384         if (str)
385             *str = idx;
386         if (dstart)
387             *dstart = os->pstart;
388         if (dsize)
389             *dsize = os->psize;
390         os->pstart += os->psize;
391         os->psize = 0;
392     }
393
394     os->seq++;
395     if (os->segp == os->nsegs)
396         ogg->curidx = -1;
397
398     return 0;
399 }
400
401 static int
402 ogg_get_headers (AVFormatContext * s)
403 {
404     ogg_t *ogg = s->priv_data;
405
406     do{
407         if (ogg_packet (s, NULL, NULL, NULL) < 0)
408             return -1;
409     }while (!ogg->headers);
410
411 #if 0
412     av_log (s, AV_LOG_DEBUG, "found headers\n");
413 #endif
414
415     return 0;
416 }
417
418 static uint64_t
419 ogg_gptopts (AVFormatContext * s, int i, uint64_t gp)
420 {
421     ogg_t *ogg = s->priv_data;
422     ogg_stream_t *os = ogg->streams + i;
423     uint64_t pts = AV_NOPTS_VALUE;
424
425     if(os->codec->gptopts){
426         pts = os->codec->gptopts(s, i, gp);
427     } else {
428         pts = gp;
429     }
430
431     return pts;
432 }
433
434
435 static int
436 ogg_get_length (AVFormatContext * s)
437 {
438     ogg_t *ogg = s->priv_data;
439     int idx = -1, i;
440     offset_t size, end;
441
442     if(url_is_streamed(s->pb))
443         return 0;
444
445 // already set
446     if (s->duration != AV_NOPTS_VALUE)
447         return 0;
448
449     size = url_fsize(s->pb);
450     if(size < 0)
451         return 0;
452     end = size > MAX_PAGE_SIZE? size - MAX_PAGE_SIZE: size;
453
454     ogg_save (s);
455     url_fseek (s->pb, end, SEEK_SET);
456
457     while (!ogg_read_page (s, &i)){
458         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
459             ogg->streams[i].codec)
460             idx = i;
461     }
462
463     if (idx != -1){
464         s->streams[idx]->duration =
465             ogg_gptopts (s, idx, ogg->streams[idx].granule);
466     }
467
468     ogg->size = size;
469     ogg_restore (s, 0);
470     ogg_save (s);
471     while (!ogg_read_page (s, &i)) {
472         if (i == idx && ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0)
473             break;
474     }
475     if (i == idx) {
476         s->streams[idx]->start_time = ogg_gptopts (s, idx, ogg->streams[idx].granule);
477         s->streams[idx]->duration -= s->streams[idx]->start_time;
478     }
479     ogg_restore (s, 0);
480
481     return 0;
482 }
483
484
485 static int
486 ogg_read_header (AVFormatContext * s, AVFormatParameters * ap)
487 {
488     ogg_t *ogg = s->priv_data;
489     ogg->curidx = -1;
490     //linear headers seek from start
491     if (ogg_get_headers (s) < 0){
492       return -1;
493     }
494
495     //linear granulepos seek from end
496     ogg_get_length (s);
497
498     //fill the extradata in the per codec callbacks
499     return 0;
500 }
501
502
503 static int
504 ogg_read_packet (AVFormatContext * s, AVPacket * pkt)
505 {
506     ogg_t *ogg;
507     ogg_stream_t *os;
508     int idx = -1;
509     int pstart, psize;
510
511     //Get an ogg packet
512     do{
513         if (ogg_packet (s, &idx, &pstart, &psize) < 0)
514             return AVERROR(EIO);
515     }while (idx < 0 || !s->streams[idx]);
516
517     ogg = s->priv_data;
518     os = ogg->streams + idx;
519
520     //Alloc a pkt
521     if (av_new_packet (pkt, psize) < 0)
522         return AVERROR(EIO);
523     pkt->stream_index = idx;
524     memcpy (pkt->data, os->buf + pstart, psize);
525     if (os->lastgp != -1LL){
526         pkt->pts = ogg_gptopts (s, idx, os->lastgp);
527         os->lastgp = -1;
528     }
529
530     pkt->flags = os->pflags;
531
532     return psize;
533 }
534
535
536 static int
537 ogg_read_close (AVFormatContext * s)
538 {
539     ogg_t *ogg = s->priv_data;
540     int i;
541
542     for (i = 0; i < ogg->nstreams; i++){
543         av_free (ogg->streams[i].buf);
544         av_free (ogg->streams[i].private);
545     }
546     av_free (ogg->streams);
547     return 0;
548 }
549
550
551 static int64_t
552 ogg_read_timestamp (AVFormatContext * s, int stream_index, int64_t * pos_arg,
553                     int64_t pos_limit)
554 {
555     ogg_t *ogg = s->priv_data;
556     ByteIOContext *bc = s->pb;
557     int64_t pts = AV_NOPTS_VALUE;
558     int i;
559     url_fseek(bc, *pos_arg, SEEK_SET);
560     while (url_ftell(bc) < pos_limit && !ogg_read_page (s, &i)) {
561         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
562             ogg->streams[i].codec && i == stream_index) {
563             pts = ogg_gptopts(s, i, ogg->streams[i].granule);
564             // FIXME: this is the position of the packet after the one with above
565             // pts.
566             *pos_arg = url_ftell(bc);
567             break;
568         }
569     }
570     ogg_reset(ogg);
571     return pts;
572 }
573
574 static int ogg_probe(AVProbeData *p)
575 {
576     if (p->buf[0] == 'O' && p->buf[1] == 'g' &&
577         p->buf[2] == 'g' && p->buf[3] == 'S' &&
578         p->buf[4] == 0x0 && p->buf[5] <= 0x7 )
579         return AVPROBE_SCORE_MAX;
580     else
581         return 0;
582 }
583
584 AVInputFormat ogg_demuxer = {
585     "ogg",
586     "Ogg",
587     sizeof (ogg_t),
588     ogg_probe,
589     ogg_read_header,
590     ogg_read_packet,
591     ogg_read_close,
592     NULL,
593     ogg_read_timestamp,
594     .extensions = "ogg",
595 };