* THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE. *
* PLEASE READ THESE TERMS DISTRIBUTING. *
* *
- * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-1999 *
- * by 1999 Monty <monty@xiph.org> and The XIPHOPHORUS Company *
+ * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-2000 *
+ * by Monty <monty@xiph.org> and The XIPHOPHORUS Company *
* http://www.xiph.org/ *
* *
********************************************************************
function: stdio-based convenience library for opening/seeking/decoding
- author: Monty <xiphmont@mit.edu>
- modifications by: Monty
- last modification date: Nov 04 1999
+ last mod: $Id: vorbisfile.c,v 1.21 2000/04/23 15:34:12 msmith Exp $
********************************************************************/
#include <stdlib.h>
#include <stdio.h>
+#include <string.h>
#include <math.h>
-#include "codec.h"
-#include "vorbisfile.h"
+#include "vorbis/codec.h"
+#include "vorbis/vorbisfile.h"
+
+#include "os.h"
+#include "misc.h"
/* A 'chained bitstream' is a Vorbis bitstream that contains more than
one logical bitstream arranged end to end (the only form of Ogg
/* read a little more data from the file/pipe into the ogg_sync framer */
#define CHUNKSIZE 4096
static long _get_data(OggVorbis_File *vf){
- char *buffer=ogg_sync_buffer(&vf->oy,4096);
- long bytes=fread(buffer,1,4096,vf->f);
+ char *buffer=ogg_sync_buffer(&vf->oy,CHUNKSIZE);
+ long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource);
ogg_sync_wrote(&vf->oy,bytes);
return(bytes);
}
/* save a tiny smidge of verbosity to make the code more readable */
static void _seek_helper(OggVorbis_File *vf,long offset){
- fseek(vf->f,offset,SEEK_SET);
+ (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET);
vf->offset=offset;
ogg_sync_reset(&vf->oy);
}
long endsearched=end;
long next=end;
ogg_page og;
+ long ret;
/* the below guards against garbage seperating the last and
first pages of two links. */
while(searched<endsearched){
long bisect;
- long ret;
if(endsearched-searched<CHUNKSIZE){
bisect=searched;
searched=ret+og.header_len+og.body_len;
}
}
- if(searched>=end){
+
+ _seek_helper(vf,next);
+ ret=_get_next_page(vf,&og,-1);
+
+ if(searched>=end || ret==-1){
vf->links=m+1;
vf->offsets=malloc((m+2)*sizeof(long));
vf->offsets[m+1]=searched;
}else{
- _bisect_forward_serialno(vf,next,next,
+ _bisect_forward_serialno(vf,next,vf->offset,
end,ogg_page_serialno(&og),m+1);
}
/* uses the local ogg_stream storage in vf; this is important for
non-streaming input sources */
-static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,long *serialno){
+static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
+ long *serialno){
ogg_page og;
ogg_packet op;
int i,ret;
Ogg bitstream is in fact Vorbis data */
vorbis_info_init(vi);
+ vorbis_comment_init(vc);
i=0;
while(i<3){
fprintf(stderr,"Corrupt header in logical bitstream.\n");
goto bail_header;
}
- if(vorbis_info_headerin(vi,&op)){
+ if(vorbis_synthesis_headerin(vi,vc,&op)){
fprintf(stderr,"Illegal header in logical bitstream.\n");
goto bail_header;
}
bail_header:
vorbis_info_clear(vi);
+ vorbis_comment_clear(vc);
ogg_stream_clear(&vf->os);
return -1;
}
vorbis_info structs and PCM positions. Only called by the seekable
initialization (local stream storage is hacked slightly; pay
attention to how that's done) */
-static void _prefetch_all_headers(OggVorbis_File *vf,vorbis_info *first){
+static void _prefetch_all_headers(OggVorbis_File *vf,vorbis_info *first_i,
+ vorbis_comment *first_c,
+ long dataoffset){
ogg_page og;
int i,ret;
- vf->vi=malloc(vf->links*sizeof(vorbis_info));
+ vf->vi=calloc(vf->links,sizeof(vorbis_info));
+ vf->vc=calloc(vf->links,sizeof(vorbis_info));
vf->dataoffsets=malloc(vf->links*sizeof(long));
- vf->pcmlengths=malloc(vf->links*sizeof(size64));
+ vf->pcmlengths=malloc(vf->links*sizeof(int64_t));
vf->serialnos=malloc(vf->links*sizeof(long));
for(i=0;i<vf->links;i++){
- if(first && i==0){
+ if(first_i && first_c && i==0){
/* we already grabbed the initial header earlier. This just
saves the waste of grabbing it again */
- memcpy(vf->vi+i,first,sizeof(vorbis_info));
- memset(first,0,sizeof(vorbis_info));
+ memcpy(vf->vi+i,first_i,sizeof(vorbis_info));
+ memcpy(vf->vc+i,first_c,sizeof(vorbis_comment));
+ vf->dataoffsets[i]=dataoffset;
}else{
/* seek to the location of the initial header */
_seek_helper(vf,vf->offsets[i]);
- if(_fetch_headers(vf,vf->vi+i,NULL)==-1){
- vorbis_info_clear(vf->vi+i);
+ if(_fetch_headers(vf,vf->vi+i,vf->vc+i,NULL)==-1){
fprintf(stderr,"Error opening logical bitstream #%d.\n\n",i+1);
-
- ogg_stream_clear(&vf->os); /* clear local storage. This is not
- done in _fetch_headers, as that may
- be called in a non-seekable stream
- (in which case, we need to preserve
- the stream local storage) */
- vf->dataoffsets[i]=-1;
- }else
+ vf->dataoffsets[i]=-1;
+ }else{
vf->dataoffsets[i]=vf->offset;
+ ogg_stream_clear(&vf->os);
+ }
}
/* get the serial number and PCM length of this link. To do this,
fprintf(stderr,"Could not find last page of logical "
"bitstream #%d\n\n",i);
vorbis_info_clear(vf->vi+i);
+ vorbis_comment_clear(vf->vc+i);
break;
}
if(ogg_page_frameno(&og)!=-1){
}
}
+static int _make_decode_ready(OggVorbis_File *vf){
+ if(vf->decode_ready)exit(1);
+ vorbis_synthesis_init(&vf->vd,vf->vi);
+ vorbis_block_init(&vf->vd,&vf->vb);
+ vf->decode_ready=1;
+ return(0);
+}
+
static int _open_seekable(OggVorbis_File *vf){
- vorbis_info initial;
+ vorbis_info initial_i;
+ vorbis_comment initial_c;
long serialno,end;
int ret;
+ long dataoffset;
ogg_page og;
/* is this even vorbis...? */
- ret=_fetch_headers(vf,&initial,&serialno);
+ ret=_fetch_headers(vf,&initial_i,&initial_c,&serialno);
+ dataoffset=vf->offset;
ogg_stream_clear(&vf->os);
if(ret==-1)return(-1);
/* we can seek, so set out learning all about this file */
vf->seekable=1;
- fseek(vf->f,0,SEEK_END);
- vf->offset=vf->end=ftell(vf->f);
+ (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
+ vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
/* We get the offset for the last page of the physical bitstream.
Most OggVorbis files will contain a single logical bitstream */
}
- _prefetch_all_headers(vf,&initial);
+ _prefetch_all_headers(vf,&initial_i,&initial_c,dataoffset);
+ ov_raw_seek(vf,0);
return(0);
}
/* we cannot seek. Set up a 'single' (current) logical bitstream entry */
vf->links=1;
vf->vi=malloc(sizeof(vorbis_info));
+ vf->vc=malloc(sizeof(vorbis_info));
/* Try to fetch the headers, maintaining all the storage */
- if(_fetch_headers(vf,vf->vi,&vf->current_serialno)==-1)return(-1);
-
+ if(_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno)==-1)return(-1);
+ _make_decode_ready(vf);
+
return 0;
}
if(vf->decode_ready){
ogg_packet op;
int result=ogg_stream_packetout(&vf->os,&op);
- size64 frameno;
+ int64_t frameno;
if(result==-1)return(-1); /* hole in the data. alert the toplevel */
if(result>0){
/* got a packet. process it */
frameno=op.frameno;
- vorbis_synthesis(&vf->vb,&op);
- vorbis_synthesis_blockin(&vf->vd,&vf->vb);
-
- /* update the pcm offset. */
- if(frameno!=-1){
- int link=(vf->seekable?vf->current_link:0);
- double **dummy;
- int i,samples;
+ if(!vorbis_synthesis(&vf->vb,&op)){ /* lazy check for lazy
+ header handling. The
+ header packets aren't
+ audio, so if/when we
+ submit them,
+ vorbis_synthesis will
+ reject them */
+ vorbis_synthesis_blockin(&vf->vd,&vf->vb);
- /* this packet has a pcm_offset on it (the last packet
- completed on a page carries the offset) After processing
- (above), we know the pcm position of the *last* sample
- ready to be returned. Find the offset of the *first* */
-
- samples=vorbis_synthesis_pcmout(&vf->vd,&dummy);
-
- frameno-=samples;
- for(i=0;i<link;i++)
- frameno+=vf->pcmlengths[i];
- vf->pcm_offset=frameno;
+ /* update the pcm offset. */
+ if(frameno!=-1){
+ int link=(vf->seekable?vf->current_link:0);
+ double **dummy;
+ int i,samples;
+
+ /* this packet has a pcm_offset on it (the last packet
+ completed on a page carries the offset) After processing
+ (above), we know the pcm position of the *last* sample
+ ready to be returned. Find the offset of the *first* */
+
+ samples=vorbis_synthesis_pcmout(&vf->vd,&dummy);
+
+ frameno-=samples;
+ for(i=0;i<link;i++)
+ frameno+=vf->pcmlengths[i];
+ vf->pcm_offset=frameno;
+ }
+ return(1);
}
- return(1);
}
}
leave machine uninitialized */
vf->current_link=link;
+
+ ogg_stream_init(&vf->os,vf->current_serialno);
+ ogg_stream_reset(&vf->os);
+
}else{
/* we're streaming */
/* fetch the three header packets, build the info struct */
- _fetch_headers(vf,vf->vi,&vf->current_serialno);
+ _fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno);
vf->current_link++;
link=0;
}
- /* reload */
- ogg_stream_init(&vf->os,vf->current_serialno);
- vorbis_synthesis_init(&vf->vd,vf->vi+link);
- vorbis_block_init(&vf->vd,&vf->vb);
- vf->decode_ready=1;
+ _make_decode_ready(vf);
}
ogg_stream_pagein(&vf->os,&og);
}
if(vf->vi && vf->links){
int i;
- for(i=0;i<vf->links;i++)
+ for(i=0;i<vf->links;i++){
vorbis_info_clear(vf->vi+i);
+ vorbis_comment_clear(vf->vc+i);
+ }
free(vf->vi);
+ free(vf->vc);
}
if(vf->dataoffsets)free(vf->dataoffsets);
if(vf->pcmlengths)free(vf->pcmlengths);
if(vf->serialnos)free(vf->serialnos);
if(vf->offsets)free(vf->offsets);
ogg_sync_clear(&vf->oy);
- if(vf->f)fclose(vf->f);
+ if(vf->datasource)(vf->callbacks.close_func)(vf->datasource);
memset(vf,0,sizeof(OggVorbis_File));
}
+#ifdef DEBUG_LEAKS
+ _VDBG_dump();
+#endif
return(0);
}
*/
int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
- long offset=fseek(f,0,SEEK_CUR);
+ ov_callbacks callbacks = {
+ (size_t (*)(void *, size_t, size_t, void *)) fread,
+ (int (*)(void *, long, int)) fseek,
+ (int (*)(void *)) fclose,
+ (long (*)(void *)) ftell
+ };
+
+ return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
+}
+
+
+int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
+ ov_callbacks callbacks)
+{
+ long offset=callbacks.seek_func(f,0,SEEK_CUR);
int ret;
memset(vf,0,sizeof(OggVorbis_File));
- vf->f=f;
+ vf->datasource=f;
+ vf->callbacks = callbacks;
/* init the framing state */
ogg_sync_init(&vf->oy);
ret=_open_nonseekable(vf);
}
if(ret){
- vf->f=NULL;
+ vf->datasource=NULL;
ov_clear(vf);
- }else{
- ogg_stream_init(&vf->os,vf->current_serialno);
- vorbis_synthesis_init(&vf->vd,vf->vi);
- vorbis_block_init(&vf->vd,&vf->vb);
- vf->decode_ready=1;
}
return(ret);
}
long ov_bitrate(OggVorbis_File *vf,int i){
if(i>=vf->links)return(-1);
- if(!vf->seekable)return(ov_bitrate(vf,0));
+ if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
if(i<0){
- size64 bits;
+ int64_t bits=0;
int i;
for(i=0;i<vf->links;i++)
- bits+=vf->offsets[i+1]-vf->dataoffsets[i];
+ bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
return(rint(bits/ov_time_total(vf,-1)));
}else{
if(vf->seekable){
/* return the actual bitrate */
- return(rint((vf->offsets[i+1]-vf->dataoffsets[i])/ov_time_total(vf,i)));
+ return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
}else{
/* return nominal if set */
if(vf->vi[i].bitrate_nominal>0){
PCM length (samples) of that logical bitstream for i==0 to n
-1 if the stream is not seekable (we can't know the length)
*/
-size64 ov_pcm_total(OggVorbis_File *vf,int i){
+int64_t ov_pcm_total(OggVorbis_File *vf,int i){
if(!vf->seekable || i>=vf->links)return(-1);
if(i<0){
- size64 acc=0;
+ int64_t acc=0;
int i;
for(i=0;i<vf->links;i++)
acc+=ov_pcm_total(vf,i);
returns zero on success, nonzero on failure */
-int ov_pcm_seek(OggVorbis_File *vf,size64 pos){
+int ov_pcm_seek(OggVorbis_File *vf,int64_t pos){
int link=-1;
- size64 total=ov_pcm_total(vf,-1);
+ int64_t total=ov_pcm_total(vf,-1);
if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
if(pos<0 || pos>total)goto seek_error;
if(pos>=total)break;
}
- /* seach within the logical bitstream for the page with the highest
+ /* search within the logical bitstream for the page with the highest
pcm_pos preceeding (or equal to) pos. There is a danger here;
missing pages or incorrect frame number information in the
bitstream could make our task impossible. Account for that (it
would be an error condition) */
{
- size64 target=pos-total;
+ int64_t target=pos-total;
long end=vf->offsets[link+1];
long begin=vf->offsets[link];
long best=begin;
ogg_page og;
while(begin<end){
long bisect;
- long ret,acc;
+ long ret;
if(end-begin<CHUNKSIZE){
bisect=begin;
}
_seek_helper(vf,bisect);
-
- acc=0;
- while(1){
- ret=_get_next_page(vf,&og,-1);
-
- if(ret==-1){
- end=bisect;
+ ret=_get_next_page(vf,&og,end-bisect);
+
+ if(ret==-1){
+ end=bisect;
+ }else{
+ int64_t frameno=ogg_page_frameno(&og);
+ if(frameno<target){
+ best=ret; /* raw offset of packet with frameno */
+ begin=vf->offset; /* raw offset of next packet */
}else{
- size64 frameno=ogg_page_frameno(&og);
- acc+=ret;
- if(frameno==-1)continue;
- if(frameno<target){
- best=bisect+acc; /* raw offset of packet with frameno */
- begin=vf->offset; /* raw offset of next packet */
- }else{
- end=bisect;
- }
+ end=bisect;
}
- break;
}
}
/* translate time to PCM position and call ov_pcm_seek */
int link=-1;
- size64 pcm_total=ov_pcm_total(vf,-1);
+ int64_t pcm_total=ov_pcm_total(vf,-1);
double time_total=ov_time_total(vf,-1);
if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
/* enough information to convert time offset to pcm offset */
{
- size64 target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
+ int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
return(ov_pcm_seek(vf,target));
}
}
/* return PCM offset (sample) of next PCM sample to be read */
-size64 ov_pcm_tell(OggVorbis_File *vf){
+int64_t ov_pcm_tell(OggVorbis_File *vf){
return(vf->pcm_offset);
}
/* translate time to PCM position and call ov_pcm_seek */
int link=-1;
- size64 pcm_total=0;
+ int64_t pcm_total=0;
double time_total=0.;
if(vf->seekable){
}
}
- return(time_total+(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
+ return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
}
/* link: -1) return the vorbis_info struct for the bitstream section
}
}
+/* grr, strong typing, grr, no templates/inheritence, grr */
+vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
+ if(vf->seekable){
+ if(link<0)
+ if(vf->decode_ready)
+ return vf->vc+vf->current_link;
+ else
+ return NULL;
+ else
+ if(link>=vf->links)
+ return NULL;
+ else
+ return vf->vc+link;
+ }else{
+ if(vf->decode_ready)
+ return vf->vc;
+ else
+ return NULL;
+ }
+}
+
/* up to this point, everything could more or less hide the multiple
logical bitstream nature of chaining from the toplevel application
if the toplevel application didn't particularly care. However, at
/* a tight loop to pack each size */
{
+ int val;
if(word==1){
int off=(sgned?0:128);
for(j=0;j<samples;j++)
for(i=0;i<channels;i++){
- int val=rint(pcm[i][j]*128.);
+ val=(int)(pcm[i][j]*128. + 0.5);
if(val>127)val=127;
- if(val<-128)val=-128;
+ else if(val<-128)val=-128;
*buffer++=val+off;
}
}else{
if(bigendianp){
for(j=0;j<samples;j++)
for(i=0;i<channels;i++){
- int val=rint(pcm[i][j]*32768.);
+ val=(int)(pcm[i][j]*32768. + 0.5);
if(val>32767)val=32767;
- if(val<-32768)val=-32768;
+ else if(val<-32768)val=-32768;
val+=off;
*buffer++=(val>>8);
*buffer++=(val&0xff);
}
}else{
+ int val;
for(j=0;j<samples;j++)
- for(i=0;i<channels;i++){
- int val=rint(pcm[i][j]*32768.);
+ for(i=0;i<channels;i++){
+ val=(int)(pcm[i][j]*32768. + 0.5);
if(val>32767)val=32767;
- if(val<-32768)val=-32768;
+ else if(val<-32768)val=-32768;
val+=off;
*buffer++=(val&0xff);
*buffer++=(val>>8);
- }
+ }
}
}
vorbis_synthesis_read(&vf->vd,samples);
vf->pcm_offset+=samples;
- *bitstream=vf->current_link;
+ if(bitstream)*bitstream=vf->current_link;
return(samples*bytespersample);
}
}
projects / platform / upstream / libvorbis.git / blobdiff