* 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 16 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 "vorbis/codec.h"
+#include "vorbis/vorbisfile.h"
+
#include "os.h"
-#include "codec.h"
-#include "vorbisfile.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);
}
/* 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;
/* extract the initial header from the first page and verify that the
Ogg bitstream is in fact Vorbis data */
- vorbis_info_clear(vi);
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;
}
goto bail_header;
}
}
- ogg_stream_clear(&vf->os);
return 0;
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=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(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...? */
- memset(&initial,0,sizeof(vorbis_info));
- 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,dataoffset);
+ _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;
}
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);
- ogg_stream_reset(&vf->os,ogg_page_pageno(&og));
- 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);
}
if(i>=vf->links)return(-1);
if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
if(i<0){
- int64_t bits;
+ int64_t bits=0;
int i;
for(i=0;i<vf->links;i++)
bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
}
}
- 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);
- }
+ }
}
}
projects / platform / upstream / libvorbis.git / blobdiff