HOTSPOT PUBLIC SW32 vorbis_encode( const char *filename, void *data, W32 size, W32 in_channels, W32 in_samplesize,
W32 rate, W32 quality, W32 max_bitrate, W32 min_bitrate )
{
FILE *fp;
ogg_stream_state os;
ogg_page og;
ogg_packet op;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info vi;
ogg_packet header_main;
ogg_packet header_comments;
ogg_packet header_codebooks;
SW32 result;
W32 serialno = 0;
vorbis_comment comments;
SW32 ret = 0;
SW32 eos;
W32 samplesdone = 0;
W32 packetsdone = 0;
W32 bytes_written = 0;
fp = fopen( filename, "wb" );
if( fp == NULL )
{
return 0;
}
memset( &comments, 0, sizeof( comments ) );
channels = in_channels;
samplesize = in_samplesize;
ptrCurrent = (PW8)data;
ptrEnd = (PW8)data + size;
vorbis_info_init( &vi );
if( vorbis_encode_setup_vbr( &vi, channels, rate, quality ) )
{
fprintf( stderr, "Mode initialisation failed: invalid parameters for quality\n" );
vorbis_info_clear( &vi );
// Añadido como consejo de cppcheck.
fclose(fp);
return 1;
}
/* do we have optional hard quality restrictions? */
if( max_bitrate > 0 || min_bitrate > 0 )
{
struct ovectl_ratemanage_arg ai;
vorbis_encode_ctl( &vi, OV_ECTL_RATEMANAGE_GET, &ai );
ai.bitrate_hard_min = min_bitrate;
ai.bitrate_hard_max = max_bitrate;
ai.management_active = 1;
vorbis_encode_ctl( &vi, OV_ECTL_RATEMANAGE_SET, &ai );
}
/* Turn off management entirely (if it was turned on). */
vorbis_encode_ctl( &vi, OV_ECTL_RATEMANAGE_SET, NULL );
vorbis_encode_setup_init( &vi );
vorbis_analysis_init( &vd, &vi );
vorbis_block_init( &vd, &vb );
ogg_stream_init( &os, serialno );
/* Now, build the three header packets and send through to the stream
output stage (but defer actual file output until the main encode loop) */
/* Build the packets */
ret = vorbis_analysis_headerout( &vd, &comments,
&header_main, &header_comments, &header_codebooks );
/* And stream them out */
ogg_stream_packetin( &os, &header_main );
ogg_stream_packetin( &os, &header_comments );
ogg_stream_packetin( &os, &header_codebooks );
while( (result = ogg_stream_flush( &os, &og )) )
{
ret = fwrite( og.header, 1, og.header_len, fp );
ret += fwrite( og.body, 1, og.body_len, fp );
if(ret != og.header_len + og.body_len)
{
fprintf( stderr, "[vorbis_encode]: Failed writing header to output stream\n") ;
ret = 1;
goto cleanup; /* Bail and try to clean up stuff */
}
}
eos = 0;
/* Main encode loop - continue until end of file */
while( ! eos )
{
float **buffer = vorbis_analysis_buffer( &vd, READSIZE );
SW32 samples_read = read_samples( buffer, READSIZE );
if( samples_read == 0 )
{
/* Tell the library that we wrote 0 bytes - signalling the end */
vorbis_analysis_wrote( &vd, 0 );
}
else
{
samplesdone += samples_read;
/* Call progress update every 40 pages */
if( packetsdone >= 40 )
{
packetsdone = 0;
// progress bar here
}
/* Tell the library how many samples (per channel) we wrote
into the supplied buffer */
vorbis_analysis_wrote( &vd, samples_read );
}
/* While we can get enough data from the library to analyse, one
block at a time... */
while( vorbis_analysis_blockout( &vd, &vb ) == 1 )
{
/* Do the main analysis, creating a packet */
vorbis_analysis( &vb, NULL );
vorbis_bitrate_addblock( &vb );
while( vorbis_bitrate_flushpacket( &vd, &op ) )
{
/* Add packet to bitstream */
ogg_stream_packetin( &os, &op );
packetsdone++;
/* If we've gone over a page boundary, we can do actual output,
so do so (for however many pages are available) */
while( ! eos )
{
SW32 result = ogg_stream_pageout( &os, &og );
if( ! result )
{
break;
}
ret = fwrite( og.header, 1, og.header_len, fp );
ret += fwrite( og.body, 1, og.body_len, fp );
if(ret != og.header_len + og.body_len)
{
fprintf( stderr, "[vorbis_encode]: Failed writing data to output stream\n" );
ret = 1;
goto cleanup; /* Bail */
}
else
{
bytes_written += ret;
}
if( ogg_page_eos( &og ) )
{
eos = 1;
}
}
}
}
}
cleanup:
fclose( fp );
ogg_stream_clear( &os );
vorbis_block_clear( &vb );
vorbis_dsp_clear( &vd );
vorbis_info_clear( &vi );
return 0;
}
int oe_encode ( oe_enc_opt* opt )
{
ogg_stream_state os;
ogg_page og;
ogg_packet op;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info vi;
long samplesdone = 0;
int eos;
long bytes_written = 0;
long packetsdone = 0;
int ret = 0;
vorbis_info_init ( &vi );
if ( opt->quality >= 0.0f )
{
if ( vorbis_encode_init_vbr ( &vi, opt->channels, opt->rate, opt->quality ) )
{
vorbis_info_clear ( &vi );
return 1;
}
}
else
{
if ( vorbis_encode_init (
&vi,
opt->channels,
opt->rate,
opt->max_bitrate > 0 ? opt->max_bitrate * 1000 : -1,
opt->bitrate * 1000,
opt->min_bitrate > 0 ? opt->min_bitrate * 1000 : -1
) )
{
vorbis_info_clear ( &vi );
return 1;
}
}
vorbis_analysis_init ( &vd, &vi );
vorbis_block_init ( &vd, &vb );
ogg_stream_init ( &os, opt->serialno );
ogg_packet header_main;
ogg_packet header_comments;
ogg_packet header_codebooks;
int result;
vorbis_analysis_headerout ( &vd,opt->comments, &header_main, &header_comments, &header_codebooks );
ogg_stream_packetin ( &os, &header_main );
ogg_stream_packetin ( &os, &header_comments );
ogg_stream_packetin ( &os, &header_codebooks );
while ( ( result = ogg_stream_flush ( &os, &og ) ) )
{
if ( !result )
break;
ret = oe_write_page ( &og, opt->out );
if ( ret != og.header_len + og.body_len )
{
ret = 1;
goto cleanup;
}
else
bytes_written += ret;
}
eos = 0;
while ( !eos )
{
float** buffer = vorbis_analysis_buffer ( &vd, READSIZE );
long samples_read = opt->read_samples ( opt->readdata, buffer, READSIZE );
if ( samples_read == 0 )
vorbis_analysis_wrote ( &vd, 0 );
else
{
samplesdone += samples_read;
vorbis_analysis_wrote ( &vd, samples_read );
}
while ( vorbis_analysis_blockout ( &vd, &vb ) == 1 )
{
vorbis_analysis ( &vb, NULL );
vorbis_bitrate_addblock ( &vb );
while ( vorbis_bitrate_flushpacket ( &vd, &op ) )
{
ogg_stream_packetin ( &os,&op );
packetsdone++;
while ( !eos )
{
int result = ogg_stream_pageout ( &os, &og );
if ( !result )
break;
ret = oe_write_page ( &og, opt->out );
if ( ret != og.header_len + og.body_len )
{
ret = 1;
goto cleanup;
}
else
bytes_written += ret;
if ( ogg_page_eos ( &og ) )
eos = 1;
}
}
}
}
ret = 0;
cleanup:
ogg_stream_clear ( &os );
vorbis_block_clear ( &vb );
vorbis_dsp_clear ( &vd );
vorbis_info_clear ( &vi );
return ret;
}
int main(){
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream
settings */
vorbis_comment vc; /* struct that stores all the user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
int eos=0;
int i, founddata;
#if defined(macintosh) && defined(__MWERKS__)
int argc = 0;
char **argv = NULL;
argc = ccommand(&argv); /* get a "command line" from the Mac user */
/* this also lets the user set stdin and stdout */
#endif
/* we cheat on the WAV header; we just bypass 44 bytes and never
verify that it matches 16bit/stereo/44.1kHz. This is just an
example, after all. */
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
#endif
/* we cheat on the WAV header; we just bypass the header and never
verify that it matches 16bit/stereo/44.1kHz. This is just an
example, after all. */
readbuffer[0] = '\0';
for (i=0, founddata=0; i<30 && ! feof(stdin) && ! ferror(stdin); i++)
{
fread(readbuffer,1,2,stdin);
if ( ! strncmp(readbuffer, "da", 2) )
{
founddata = 1;
fread(readbuffer,1,6,stdin);
break;
}
}
/********** Encode setup ************/
/* choose an encoding mode */
/* (quality mode .4: 44kHz stereo coupled, roughly 128kbps VBR) */
vorbis_info_init(&vi);
vorbis_encode_init_vbr(&vi,2,44100,.1); // max compression
/* add a comment */
vorbis_comment_init(&vc);
vorbis_comment_add_tag(&vc,"ENCODER","encoder_example.c");
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
/* set up our packet->stream encoder */
/* pick a random serial number; that way we can more likely build
chained streams just by concatenation */
srand(time(NULL));
ogg_stream_init(&os,rand());
/* Vorbis streams begin with three headers; the initial header (with
most of the codec setup parameters) which is mandated by the Ogg
bitstream spec. The second header holds any comment fields. The
third header holds the bitstream codebook. We merely need to
make the headers, then pass them to libvorbis one at a time;
libvorbis handles the additional Ogg bitstream constraints */
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
ogg_stream_packetin(&os,&header); /* automatically placed in its own
page */
ogg_stream_packetin(&os,&header_comm);
ogg_stream_packetin(&os,&header_code);
/* We don't have to write out here, but doing so makes streaming
* much easier, so we do, flushing ALL pages. This ensures the actual
* audio data will start on a new page
*/
while(!eos){
int result=ogg_stream_flush(&os,&og);
if(result==0)break;
fwrite(og.header,1,og.header_len,stdout);
fwrite(og.body,1,og.body_len,stdout);
}
}
while(!eos){
long i;
long bytes=fread(readbuffer,1,READ*4,stdin); /* stereo hardwired here */
if(bytes==0){
/* end of file. this can be done implicitly in the mainline,
but it's easier to see here in non-clever fashion.
Tell the library we're at end of stream so that it can handle
the last frame and mark end of stream in the output properly */
vorbis_analysis_wrote(&vd,0);
}else{
/* data to encode */
/* expose the buffer to submit data */
float **buffer=vorbis_analysis_buffer(&vd,READ);
/* uninterleave samples */
for(i=0;i<bytes/4;i++){
buffer[0][i]=((readbuffer[i*4+1]<<8)|
(0x00ff&(int)readbuffer[i*4]))/32768.f;
buffer[1][i]=((readbuffer[i*4+3]<<8)|
(0x00ff&(int)readbuffer[i*4+2]))/32768.f;
}
/* tell the library how much we actually submitted */
vorbis_analysis_wrote(&vd,i);
}
/* vorbis does some data preanalysis, then divvies up blocks for
more involved (potentially parallel) processing. Get a single
block for encoding now */
while(vorbis_analysis_blockout(&vd,&vb)==1){
/* analysis, assume we want to use bitrate management */
vorbis_analysis(&vb,NULL);
vorbis_bitrate_addblock(&vb);
while(vorbis_bitrate_flushpacket(&vd,&op)){
/* weld the packet into the bitstream */
ogg_stream_packetin(&os,&op);
/* write out pages (if any) */
while(!eos){
int result=ogg_stream_pageout(&os,&og);
if(result==0)break;
fwrite(og.header,1,og.header_len,stdout);
fwrite(og.body,1,og.body_len,stdout);
/* this could be set above, but for illustrative purposes, I do
it here (to show that vorbis does know where the stream ends) */
if(ogg_page_eos(&og))eos=1;
}
}
}
}
/* clean up and exit. vorbis_info_clear() must be called last */
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
fprintf(stderr,"Done.\n");
return(0);
}
static int
ogg_read_header (SF_PRIVATE *psf, int log_data)
{
OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
char *buffer ;
int bytes ;
int i, nn ;
odata->eos = 0 ;
/* Weird stuff happens if these aren't called. */
ogg_stream_reset (&odata->os) ;
ogg_sync_reset (&odata->oy) ;
/*
** Grab some data at the head of the stream. We want the first page
** (which is guaranteed to be small and only contain the Vorbis
** stream initial header) We need the first page to get the stream
** serialno.
*/
/* Expose the buffer */
buffer = ogg_sync_buffer (&odata->oy, 4096L) ;
/* Grab the part of the header that has already been read. */
memcpy (buffer, psf->header, psf->headindex) ;
bytes = psf->headindex ;
/* Submit a 4k block to libvorbis' Ogg layer */
bytes += psf_fread (buffer + psf->headindex, 1, 4096 - psf->headindex, psf) ;
ogg_sync_wrote (&odata->oy, bytes) ;
/* Get the first page. */
if ((nn = ogg_sync_pageout (&odata->oy, &odata->og)) != 1)
{
/* Have we simply run out of data? If so, we're done. */
if (bytes < 4096)
return 0 ;
/* Error case. Must not be Vorbis data */
psf_log_printf (psf, "Input does not appear to be an Ogg bitstream.\n") ;
return SFE_MALFORMED_FILE ;
} ;
/*
** Get the serial number and set up the rest of decode.
** Serialno first ; use it to set up a logical stream.
*/
ogg_stream_clear (&odata->os) ;
ogg_stream_init (&odata->os, ogg_page_serialno (&odata->og)) ;
/*
** This function (ogg_read_header) gets called multiple times, so the OGG
** and vorbis structs have to be cleared every time we pass through to
** prevent memory leaks.
*/
vorbis_block_clear (&vdata->vb) ;
vorbis_dsp_clear (&vdata->vd) ;
vorbis_comment_clear (&vdata->vc) ;
vorbis_info_clear (&vdata->vi) ;
/*
** Extract the initial header from the first page and verify that the
** Ogg bitstream is in fact Vorbis data.
**
** I handle the initial header first instead of just having the code
** read all three Vorbis headers at once because reading the initial
** header is an easy way to identify a Vorbis bitstream and it's
** useful to see that functionality seperated out.
*/
vorbis_info_init (&vdata->vi) ;
vorbis_comment_init (&vdata->vc) ;
if (ogg_stream_pagein (&odata->os, &odata->og) < 0)
{ /* Error ; stream version mismatch perhaps. */
psf_log_printf (psf, "Error reading first page of Ogg bitstream data\n") ;
return SFE_MALFORMED_FILE ;
} ;
if (ogg_stream_packetout (&odata->os, &odata->op) != 1)
{ /* No page? must not be vorbis. */
psf_log_printf (psf, "Error reading initial header packet.\n") ;
return SFE_MALFORMED_FILE ;
} ;
if (vorbis_synthesis_headerin (&vdata->vi, &vdata->vc, &odata->op) < 0)
{ /* Error case ; not a vorbis header. */
psf_log_printf (psf, "This Ogg bitstream does not contain Vorbis audio data.\n") ;
return SFE_MALFORMED_FILE ;
} ;
/*
** Common Ogg metadata fields?
** TITLE, VERSION, ALBUM, TRACKNUMBER, ARTIST, PERFORMER, COPYRIGHT, LICENSE,
** ORGANIZATION, DESCRIPTION, GENRE, DATE, LOCATION, CONTACT, ISRC,
*/
if (log_data)
{ int k ;
for (k = 0 ; k < ARRAY_LEN (vorbis_metatypes) ; k++)
{ char *dd ;
dd = vorbis_comment_query (&vdata->vc, vorbis_metatypes [k].name, 0) ;
if (dd == NULL)
continue ;
psf_store_string (psf, vorbis_metatypes [k].id, dd) ;
} ;
} ;
/*
** At this point, we're sure we're Vorbis. We've set up the logical (Ogg)
** bitstream decoder. Get the comment and codebook headers and set up the
** Vorbis decoder.
**
** The next two packets in order are the comment and codebook headers.
** They're likely large and may span multiple pages. Thus we reead
** and submit data until we get our two pacakets, watching that no
** pages are missing. If a page is missing, error out ; losing a
** header page is the only place where missing data is fatal.
*/
i = 0 ; /* Count of number of packets read */
while (i < 2)
{ int result = ogg_sync_pageout (&odata->oy, &odata->og) ;
if (result == 0)
{ /* Need more data */
buffer = ogg_sync_buffer (&odata->oy, 4096) ;
bytes = psf_fread (buffer, 1, 4096, psf) ;
if (bytes == 0)
{ psf_log_printf (psf, "End of file before finding all Vorbis headers!\n") ;
return SFE_MALFORMED_FILE ;
} ;
nn = ogg_sync_wrote (&odata->oy, bytes) ;
}
else if (result == 1)
{ /*
** Don't complain about missing or corrupt data yet. We'll
** catch it at the packet output phase.
**
** We can ignore any errors here as they'll also become apparent
** at packetout.
*/
nn = ogg_stream_pagein (&odata->os, &odata->og) ;
while (i < 2)
{ result = ogg_stream_packetout (&odata->os, &odata->op) ;
if (result == 0)
break ;
if (result < 0)
{ /* Uh oh ; data at some point was corrupted or missing!
** We can't tolerate that in a header. Die. */
psf_log_printf (psf, "Corrupt secondary header. Exiting.\n") ;
return SFE_MALFORMED_FILE ;
} ;
vorbis_synthesis_headerin (&vdata->vi, &vdata->vc, &odata->op) ;
i++ ;
} ;
} ;
} ;
if (log_data)
{ int printed_metadata_msg = 0 ;
int k ;
psf_log_printf (psf, "\nBitstream is %d channel, %D Hz\n", vdata->vi.channels, vdata->vi.rate) ;
psf_log_printf (psf, "Encoded by: %s\n", vdata->vc.vendor) ;
/* Throw the comments plus a few lines about the bitstream we're decoding. */
for (k = 0 ; k < ARRAY_LEN (vorbis_metatypes) ; k++)
{ char *dd ;
dd = vorbis_comment_query (&vdata->vc, vorbis_metatypes [k].name, 0) ;
if (dd == NULL)
continue ;
if (printed_metadata_msg == 0)
{ psf_log_printf (psf, "Metadata :\n") ;
printed_metadata_msg = 1 ;
} ;
psf_store_string (psf, vorbis_metatypes [k].id, dd) ;
psf_log_printf (psf, " %-10s : %s\n", vorbis_metatypes [k].name, dd) ;
} ;
psf_log_printf (psf, "End\n") ;
} ;
psf->sf.samplerate = vdata->vi.rate ;
psf->sf.channels = vdata->vi.channels ;
psf->sf.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS ;
/* OK, got and parsed all three headers. Initialize the Vorbis
** packet->PCM decoder.
** Central decode state. */
vorbis_synthesis_init (&vdata->vd, &vdata->vi) ;
/* Local state for most of the decode so multiple block decodes can
** proceed in parallel. We could init multiple vorbis_block structures
** for vd here. */
vorbis_block_init (&vdata->vd, &vdata->vb) ;
vdata->loc = 0 ;
return 0 ;
} /* ogg_read_header */
int main(int argc,char *argv[]){
int i,j;
ogg_packet op;
FILE *infile = stdin;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
#endif
/* open the input file if any */
if(argc==2){
infile=fopen(argv[1],"rb");
if(infile==NULL){
fprintf(stderr,"Unable to open '%s' for playback.\n", argv[1]);
exit(1);
}
}
if(argc>2){
usage();
exit(1);
}
/* start up Ogg stream synchronization layer */
ogg_sync_init(&oy);
/* init supporting Vorbis structures needed in header parsing */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
/* init supporting Theora structures needed in header parsing */
theora_comment_init(&tc);
theora_info_init(&ti);
/* Ogg file open; parse the headers */
/* Only interested in Vorbis/Theora streams */
while(!stateflag){
int ret=buffer_data(infile,&oy);
if(ret==0)break;
while(ogg_sync_pageout(&oy,&og)>0){
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&og)){
/* don't leak the page; get it into the appropriate stream */
queue_page(&og);
stateflag=1;
break;
}
ogg_stream_init(&test,ogg_page_serialno(&og));
ogg_stream_pagein(&test,&og);
ogg_stream_packetout(&test,&op);
/* identify the codec: try theora */
if(!theora_p && theora_decode_header(&ti,&tc,&op)>=0){
/* it is theora */
memcpy(&to,&test,sizeof(test));
theora_p=1;
}else if(!vorbis_p && vorbis_synthesis_headerin(&vi,&vc,&op)>=0){
/* it is vorbis */
memcpy(&vo,&test,sizeof(test));
vorbis_p=1;
}else{
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
/* we're expecting more header packets. */
while((theora_p && theora_p<3) || (vorbis_p && vorbis_p<3)){
int ret;
/* look for further theora headers */
while(theora_p && (theora_p<3) && (ret=ogg_stream_packetout(&to,&op))){
if(ret<0){
fprintf(stderr,"Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
if(theora_decode_header(&ti,&tc,&op)){
printf("Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
theora_p++;
if(theora_p==3)break;
}
/* look for more vorbis header packets */
while(vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op))){
if(ret<0){
fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)){
fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
vorbis_p++;
if(vorbis_p==3)break;
}
/* The header pages/packets will arrive before anything else we
care about, or the stream is not obeying spec */
if(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og); /* demux into the appropriate stream */
}else{
int ret=buffer_data(infile,&oy); /* someone needs more data */
if(ret==0){
fprintf(stderr,"End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if(theora_p){
theora_decode_init(&td,&ti);
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n",
(unsigned int)to.serialno,ti.width,ti.height,
(double)ti.fps_numerator/ti.fps_denominator);
if(ti.width!=ti.frame_width || ti.height!=ti.frame_height)
printf(" Frame content is %dx%d with offset (%d,%d).\n",
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
report_colorspace(&ti);
dump_comments(&tc);
}else{
/* tear down the partial theora setup */
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
if(vorbis_p){
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
fprintf(stderr,"Ogg logical stream %x is Vorbis %d channel %d Hz audio.\n",
(unsigned int)vo.serialno,vi.channels,(int)vi.rate);
}else{
/* tear down the partial vorbis setup */
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
/* open audio */
if(vorbis_p)open_audio();
/* open video */
if(theora_p)open_video();
/* install signal handler as SDL clobbered the default */
signal (SIGINT, sigint_handler);
/* on to the main decode loop. We assume in this example that audio
and video start roughly together, and don't begin playback until
we have a start frame for both. This is not necessarily a valid
assumption in Ogg A/V streams! It will always be true of the
example_encoder (and most streams) though. */
stateflag=0; /* playback has not begun */
while(!got_sigint){
/* we want a video and audio frame ready to go at all times. If
we have to buffer incoming, buffer the compressed data (ie, let
ogg do the buffering) */
while(vorbis_p && !audiobuf_ready){
int ret;
float **pcm;
/* if there's pending, decoded audio, grab it */
if((ret=vorbis_synthesis_pcmout(&vd,&pcm))>0){
int count=audiobuf_fill/2;
int maxsamples=(audiofd_fragsize-audiobuf_fill)/2/vi.channels;
for(i=0;i<ret && i<maxsamples;i++)
for(j=0;j<vi.channels;j++){
int val=rint(pcm[j][i]*32767.f);
if(val>32767)val=32767;
if(val<-32768)val=-32768;
audiobuf[count++]=val;
}
vorbis_synthesis_read(&vd,i);
audiobuf_fill+=i*vi.channels*2;
if(audiobuf_fill==audiofd_fragsize)audiobuf_ready=1;
if(vd.granulepos>=0)
audiobuf_granulepos=vd.granulepos-ret+i;
else
audiobuf_granulepos+=i;
}else{
/* no pending audio; is there a pending packet to decode? */
if(ogg_stream_packetout(&vo,&op)>0){
if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
vorbis_synthesis_blockin(&vd,&vb);
}else /* we need more data; break out to suck in another page */
break;
}
}
while(theora_p && !videobuf_ready){
/* theora is one in, one out... */
if(ogg_stream_packetout(&to,&op)>0){
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
/* is it already too old to be useful? This is only actually
useful cosmetically after a SIGSTOP. Note that we have to
decode the frame even if we don't show it (for now) due to
keyframing. Soon enough libtheora will be able to deal
with non-keyframe seeks. */
if(videobuf_time>=get_time())
videobuf_ready=1;
}else
break;
}
if(!videobuf_ready && !audiobuf_ready && feof(infile))break;
if(!videobuf_ready || !audiobuf_ready){
/* no data yet for somebody. Grab another page */
int bytes=buffer_data(infile,&oy);
while(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
}
/* If playback has begun, top audio buffer off immediately. */
if(stateflag) audio_write_nonblocking();
/* are we at or past time for this video frame? */
if(stateflag && videobuf_ready && videobuf_time<=get_time()){
video_write();
videobuf_ready=0;
}
if(stateflag &&
(audiobuf_ready || !vorbis_p) &&
(videobuf_ready || !theora_p) &&
!got_sigint){
/* we have an audio frame ready (which means the audio buffer is
full), it's not time to play video, so wait until one of the
audio buffer is ready or it's near time to play video */
/* set up select wait on the audiobuffer and a timeout for video */
struct timeval timeout;
fd_set writefs;
fd_set empty;
int n=0;
FD_ZERO(&writefs);
FD_ZERO(&empty);
if(audiofd>=0){
FD_SET(audiofd,&writefs);
n=audiofd+1;
}
if(theora_p){
long milliseconds=(videobuf_time-get_time())*1000-5;
if(milliseconds>500)milliseconds=500;
if(milliseconds>0){
timeout.tv_sec=milliseconds/1000;
timeout.tv_usec=(milliseconds%1000)*1000;
n=select(n,&empty,&writefs,&empty,&timeout);
if(n)audio_calibrate_timer(0);
}
}else{
select(n,&empty,&writefs,&empty,NULL);
}
}
/* if our buffers either don't exist or are ready to go,
we can begin playback */
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready))stateflag=1;
/* same if we've run out of input */
if(feof(infile))stateflag=1;
}
/* tear it all down */
audio_close();
SDL_Quit();
if(vorbis_p){
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if(theora_p){
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
if(infile && infile!=stdin)fclose(infile);
fprintf(stderr,
"\r "
"\nDone.\n");
return(0);
}
TheoraDecoder::VorbisAudioTrack::~VorbisAudioTrack() {
vorbis_dsp_clear(&_vorbisDSP);
vorbis_block_clear(&_vorbisBlock);
delete _audStream;
free(_audioBuffer);
}
/*
return: audio wants more packets
*/
static qboolean OGV_LoadAudio(cinematic_t *cin)
{
qboolean anyDataTransferred = qtrue;
float **pcm;
int frames, frameNeeded;
int i, j;
short *ptr;
ogg_packet op;
vorbis_block vb;
memset(&op, 0, sizeof(op));
memset(&vb, 0, sizeof(vb));
vorbis_block_init(&g_ogm->vd, &vb);
while (anyDataTransferred && g_ogm->currentTime + MAX_AUDIO_PRELOAD > (int)(g_ogm->vd.granulepos * 1000 / g_ogm->vi.rate))
{
anyDataTransferred = qfalse;
if ((frames = vorbis_synthesis_pcmout(&g_ogm->vd, &pcm)) > 0)
{
// vorbis -> raw
ptr = (short *)g_ogm->audioBuffer;
frameNeeded = (SIZEOF_RAWBUFF) / (OGG_SAMPLEWIDTH * g_ogm->vi.channels);
if (frames < frameNeeded)
{
frameNeeded = frames;
}
for (i = 0; i < frameNeeded; i++)
{
for (j = 0; j < g_ogm->vi.channels; j++)
{
*(ptr++) = (short)((pcm[j][i] >= -1.0f && pcm[j][i] <= 1.0f) ? pcm[j][i] * 32767.f : 32767 * ((pcm[j][i] > 0.0f) - (pcm[j][i] < 0.0f)));
}
}
// tell libvorbis how many samples we actually consumed (we ate them all!)
vorbis_synthesis_read(&g_ogm->vd, frameNeeded);
if (!(cin->flags & CIN_silent))
{
S_RawSamples(0, frameNeeded, g_ogm->vi.rate, OGG_SAMPLEWIDTH, g_ogm->vi.channels, g_ogm->audioBuffer, 1.0f, 1.0f);
}
anyDataTransferred = qtrue;
}
if (!anyDataTransferred)
{
// op -> vorbis
if (ogg_stream_packetout(&g_ogm->os_audio, &op))
{
if (vorbis_synthesis(&vb, &op) == 0)
{
vorbis_synthesis_blockin(&g_ogm->vd, &vb);
}
anyDataTransferred = qtrue;
}
}
}
vorbis_block_clear(&vb);
return (qboolean)(g_ogm->currentTime + MIN_AUDIO_PRELOAD > (int)(g_ogm->vd.granulepos * 1000 / g_ogm->vi.rate));
}
int main(){
ogg_sync_state oy; /* sync and verify incoming physical bitstream */
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream
settings */
vorbis_comment vc; /* struct that stores all the bitstream user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
char *buffer;
int bytes;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
#endif
#if defined(macintosh) && defined(__MWERKS__)
{
int argc;
char **argv;
argc=ccommand(&argv); /* get a "command line" from the Mac user */
/* this also lets the user set stdin and stdout */
}
#endif
/********** Decode setup ************/
ogg_sync_init(&oy); /* Now we can read pages */
while(1){ /* we repeat if the bitstream is chained */
int eos=0;
int i;
/* grab some data at the head of the stream. We want the first page
(which is guaranteed to be small and only contain the Vorbis
stream initial header) We need the first page to get the stream
serialno. */
/* submit a 4k block to libvorbis' Ogg layer */
buffer=ogg_sync_buffer(&oy,4096);
bytes=fread(buffer,1,4096,stdin);
ogg_sync_wrote(&oy,bytes);
/* Get the first page. */
if(ogg_sync_pageout(&oy,&og)!=1){
/* have we simply run out of data? If so, we're done. */
if(bytes<4096)break;
/* error case. Must not be Vorbis data */
fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n");
exit(1);
}
/* Get the serial number and set up the rest of decode. */
/* serialno first; use it to set up a logical stream */
ogg_stream_init(&os,ogg_page_serialno(&og));
/* extract the initial header from the first page and verify that the
Ogg bitstream is in fact Vorbis data */
/* I handle the initial header first instead of just having the code
read all three Vorbis headers at once because reading the initial
header is an easy way to identify a Vorbis bitstream and it's
useful to see that functionality seperated out. */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
if(ogg_stream_pagein(&os,&og)<0){
/* error; stream version mismatch perhaps */
fprintf(stderr,"Error reading first page of Ogg bitstream data.\n");
exit(1);
}
if(ogg_stream_packetout(&os,&op)!=1){
/* no page? must not be vorbis */
fprintf(stderr,"Error reading initial header packet.\n");
exit(1);
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)<0){
/* error case; not a vorbis header */
fprintf(stderr,"This Ogg bitstream does not contain Vorbis "
"audio data.\n");
exit(1);
}
/* At this point, we're sure we're Vorbis. We've set up the logical
(Ogg) bitstream decoder. Get the comment and codebook headers and
set up the Vorbis decoder */
/* The next two packets in order are the comment and codebook headers.
They're likely large and may span multiple pages. Thus we read
and submit data until we get our two packets, watching that no
pages are missing. If a page is missing, error out; losing a
header page is the only place where missing data is fatal. */
i=0;
while(i<2){
while(i<2){
int result=ogg_sync_pageout(&oy,&og);
if(result==0)break; /* Need more data */
/* Don't complain about missing or corrupt data yet. We'll
catch it at the packet output phase */
if(result==1){
ogg_stream_pagein(&os,&og); /* we can ignore any errors here
as they'll also become apparent
at packetout */
while(i<2){
result=ogg_stream_packetout(&os,&op);
if(result==0)break;
if(result<0){
/* Uh oh; data at some point was corrupted or missing!
We can't tolerate that in a header. Die. */
fprintf(stderr,"Corrupt secondary header. Exiting.\n");
exit(1);
}
result=vorbis_synthesis_headerin(&vi,&vc,&op);
if(result<0){
fprintf(stderr,"Corrupt secondary header. Exiting.\n");
exit(1);
}
i++;
}
}
}
/* no harm in not checking before adding more */
buffer=ogg_sync_buffer(&oy,4096);
bytes=fread(buffer,1,4096,stdin);
if(bytes==0 && i<2){
fprintf(stderr,"End of file before finding all Vorbis headers!\n");
exit(1);
}
ogg_sync_wrote(&oy,bytes);
}
/* Throw the comments plus a few lines about the bitstream we're
decoding */
{
char **ptr=vc.user_comments;
while(*ptr){
fprintf(stderr,"%s\n",*ptr);
++ptr;
}
fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi.channels,vi.rate);
fprintf(stderr,"Encoded by: %s\n\n",vc.vendor);
}
convsize=4096/vi.channels;
/* OK, got and parsed all three headers. Initialize the Vorbis
packet->PCM decoder. */
if(vorbis_synthesis_init(&vd,&vi)==0){ /* central decode state */
vorbis_block_init(&vd,&vb); /* local state for most of the decode
so multiple block decodes can
proceed in parallel. We could init
multiple vorbis_block structures
for vd here */
/* The rest is just a straight decode loop until end of stream */
while(!eos){
while(!eos){
int result=ogg_sync_pageout(&oy,&og);
if(result==0)break; /* need more data */
if(result<0){ /* missing or corrupt data at this page position */
fprintf(stderr,"Corrupt or missing data in bitstream; "
"continuing...\n");
}else{
ogg_stream_pagein(&os,&og); /* can safely ignore errors at
this point */
while(1){
result=ogg_stream_packetout(&os,&op);
if(result==0)break; /* need more data */
if(result<0){ /* missing or corrupt data at this page position */
/* no reason to complain; already complained above */
}else{
/* we have a packet. Decode it */
float **pcm;
int samples;
if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
vorbis_synthesis_blockin(&vd,&vb);
/*
**pcm is a multichannel float vector. In stereo, for
example, pcm[0] is left, and pcm[1] is right. samples is
the size of each channel. Convert the float values
(-1.<=range<=1.) to whatever PCM format and write it out */
while((samples=vorbis_synthesis_pcmout(&vd,&pcm))>0){
int j;
int clipflag=0;
int bout=(samples<convsize?samples:convsize);
/* convert floats to 16 bit signed ints (host order) and
interleave */
for(i=0;i<vi.channels;i++){
ogg_int16_t *ptr=convbuffer+i;
float *mono=pcm[i];
for(j=0;j<bout;j++){
#if 1
int val=floor(mono[j]*32767.f+.5f);
#else /* optional dither */
int val=mono[j]*32767.f+drand48()-0.5f;
#endif
/* might as well guard against clipping */
if(val>32767){
val=32767;
clipflag=1;
}
if(val<-32768){
val=-32768;
clipflag=1;
}
*ptr=val;
ptr+=vi.channels;
}
}
if(clipflag)
fprintf(stderr,"Clipping in frame %ld\n",(long)(vd.sequence));
fwrite(convbuffer,2*vi.channels,bout,stdout);
vorbis_synthesis_read(&vd,bout); /* tell libvorbis how
many samples we
actually consumed */
}
}
}
if(ogg_page_eos(&og))eos=1;
}
}
if(!eos){
buffer=ogg_sync_buffer(&oy,4096);
bytes=fread(buffer,1,4096,stdin);
ogg_sync_wrote(&oy,bytes);
if(bytes==0)eos=1;
}
}
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
}else{
fprintf(stderr,"Error: Corrupt header during playback initialization.\n");
}
/* clean up this logical bitstream; before exit we see if we're
followed by another [chained] */
ogg_stream_clear(&os);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi); /* must be called last */
}
/* OK, clean up the framer */
ogg_sync_clear(&oy);
fprintf(stderr,"Done.\n");
return(0);
}
bool ExportOGG(AudacityProject *project,
bool stereo, wxString fName,
bool selectionOnly, double t0, double t1)
{
double rate = project->GetRate();
wxWindow *parent = project;
TrackList *tracks = project->GetTracks();
double quality = (gPrefs->Read("/FileFormats/OggExportQuality", 50)/(float)100.0);
wxLogNull logNo; // temporarily disable wxWindows error messages
bool cancelling = false;
int eos = 0;
wxFFile outFile(fName, "wb");
if(!outFile.IsOpened()) {
wxMessageBox(_("Unable to open target file for writing"));
return false;
}
// All the Ogg and Vorbis encoding data
ogg_stream_state stream;
ogg_page page;
ogg_packet packet;
vorbis_info info;
vorbis_comment comment;
vorbis_dsp_state dsp;
vorbis_block block;
// Encoding setup
vorbis_info_init(&info);
vorbis_encode_init_vbr(&info, stereo ? 2 : 1, int(rate + 0.5), quality);
vorbis_comment_init(&comment);
// If we wanted to add comments, we would do it here
// Set up analysis state and auxiliary encoding storage
vorbis_analysis_init(&dsp, &info);
vorbis_block_init(&dsp, &block);
// Set up packet->stream encoder. According to encoder example,
// a random serial number makes it more likely that you can make
// chained streams with concatenation.
srand(time(NULL));
ogg_stream_init(&stream, rand());
// First we need to write the required headers:
// 1. The Ogg bitstream header, which contains codec setup params
// 2. The Vorbis comment header
// 3. The bitstream codebook.
//
// After we create those our responsibility is complete, libvorbis will
// take care of any other ogg bistream constraints (again, according
// to the example encoder source)
ogg_packet bitstream_header;
ogg_packet comment_header;
ogg_packet codebook_header;
vorbis_analysis_headerout(&dsp, &comment, &bitstream_header, &comment_header,
&codebook_header);
// Place these headers into the stream
ogg_stream_packetin(&stream, &bitstream_header);
ogg_stream_packetin(&stream, &comment_header);
ogg_stream_packetin(&stream, &codebook_header);
// Flushing these headers now guarentees that audio data will
// start on a new page, which apparently makes streaming easier
while(ogg_stream_flush(&stream, &page))
{
outFile.Write(page.header, page.header_len);
outFile.Write(page.body, page.body_len);
}
wxProgressDialog *progress = NULL;
wxYield();
wxStartTimer();
int numWaveTracks;
WaveTrack **waveTracks;
tracks->GetWaveTracks(selectionOnly, &numWaveTracks, &waveTracks);
Mixer *mixer = new Mixer(numWaveTracks, waveTracks,
tracks->GetTimeTrack(),
t0, t1,
stereo? 2: 1, SAMPLES_PER_RUN, false,
rate, floatSample);
while(!cancelling && !eos) {
float **vorbis_buffer = vorbis_analysis_buffer(&dsp, SAMPLES_PER_RUN);
sampleCount samplesThisRun = mixer->Process(SAMPLES_PER_RUN);
if (samplesThisRun == 0) {
// Tell the library that we wrote 0 bytes - signalling the end.
vorbis_analysis_wrote(&dsp, 0);
}
else {
float *left = (float *)mixer->GetBuffer(0);
memcpy(vorbis_buffer[0], left, sizeof(float)*SAMPLES_PER_RUN);
if(stereo) {
float *right = (float *)mixer->GetBuffer(1);
memcpy(vorbis_buffer[1], right, sizeof(float)*SAMPLES_PER_RUN);
}
// tell the encoder how many samples we have
vorbis_analysis_wrote(&dsp, samplesThisRun);
}
// I don't understand what this call does, so here is the comment
// from the example, verbatim:
//
// vorbis does some data preanalysis, then divvies up blocks
// for more involved (potentially parallel) processing. Get
// a single block for encoding now
while(vorbis_analysis_blockout(&dsp, &block) == 1) {
// analysis, assume we want to use bitrate management
vorbis_analysis(&block, NULL);
vorbis_bitrate_addblock(&block);
while(vorbis_bitrate_flushpacket(&dsp, &packet)) {
// add the packet to the bitstream
ogg_stream_packetin(&stream, &packet);
// From vorbis-tools-1.0/oggenc/encode.c:
// If we've gone over a page boundary, we can do actual output,
// so do so (for however many pages are available).
while (!eos) {
int result = ogg_stream_pageout(&stream, &page);
if (!result)
break;
outFile.Write(page.header, page.header_len);
outFile.Write(page.body, page.body_len);
if (ogg_page_eos(&page))
eos = 1;
}
}
}
if(progress) {
int progressvalue = int (1000 * ((mixer->MixGetCurrentTime()-t0) /
(t1-t0)));
cancelling = !progress->Update(progressvalue);
}
else if(wxGetElapsedTime(false) > 500) {
wxString message = selectionOnly ?
_("Exporting the selected audio as Ogg Vorbis") :
_("Exporting the entire project as Ogg Vorbis");
progress = new wxProgressDialog(
_("Export"),
message,
1000,
parent,
wxPD_CAN_ABORT | wxPD_REMAINING_TIME | wxPD_AUTO_HIDE);
}
}
delete mixer;
ogg_stream_clear(&stream);
vorbis_block_clear(&block);
vorbis_dsp_clear(&dsp);
vorbis_info_clear(&info);
outFile.Close();
if(progress)
delete progress;
return true;
}
int OggEncode( wsul nSize, wsfb *bData, wsul nCh, int nBit, wsf_file *wOut, wsul nFreq )
{
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream
settings */
vorbis_comment vc; /* struct that stores all the user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
wsul nRLen;
int eos=0,ret;
nRLen = READ;
if (nCh == 1)
nRLen /= 2;
if (nBit)
nRLen /= 2;
if (nFreq < 22050)
nFreq = 44100;
if (nFreq > 44800)
nFreq = 44100;
wsf_file *wIn;
wIn = wsfopenmem(bData,nSize);
/********** Encode setup ************/
vorbis_info_init(&vi);
/* choose an encoding mode. A few possibilities commented out, one
actually used: */
/*********************************************************************
Encoding using a VBR quality mode. The usable range is -.1
(lowest quality, smallest file) to 1. (highest quality, largest file).
Example quality mode .4: 44kHz stereo coupled, roughly 128kbps VBR
ret = vorbis_encode_init_vbr(&vi,2,44100,.4);
---------------------------------------------------------------------
Encoding using an average bitrate mode (ABR).
example: 44kHz stereo coupled, average 128kbps VBR
ret = vorbis_encode_init(&vi,2,44100,-1,128000,-1);
---------------------------------------------------------------------
Encode using a qulity mode, but select that quality mode by asking for
an approximate bitrate. This is not ABR, it is true VBR, but selected
using the bitrate interface, and then turning bitrate management off:
ret = ( vorbis_encode_setup_managed(&vi,2,44100,-1,128000,-1) ||
vorbis_encode_ctl(&vi,OV_ECTL_RATEMANAGE_AVG,NULL) ||
vorbis_encode_setup_init(&vi));
*********************************************************************/
if (nFreq == 0)
ret = vorbis_encode_init(&vi,2,44100,-1,g_nRate*1000,-1);
else {
ret = vorbis_encode_init(&vi,2,nFreq,-1,g_nRate*1000,-1);
if (ret) {
vorbis_info_clear(&vi);
vorbis_info_init(&vi);
ret = vorbis_encode_init(&vi,2,44100,-1,g_nRate*1000,-1);
}
}
/* do not continue if setup failed; this can happen if we ask for a
mode that libVorbis does not support (eg, too low a bitrate, etc,
will return 'OV_EIMPL') */
if (ret)printf("Errorly, improper bitrate?\n\n");
if(ret)return 1;
/* add a comment */
vorbis_comment_init(&vc);
vorbis_comment_add_tag(&vc,"ENCODER","WSF Encoder");
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
/* set up our packet->stream encoder */
/* pick a random serial number; that way we can more likely build
chained streams just by concatenation */
srand(time(NULL));
ogg_stream_init(&os,rand());
/* Vorbis streams begin with three headers; the initial header (with
most of the codec setup parameters) which is mandated by the Ogg
bitstream spec. The second header holds any comment fields. The
third header holds the bitstream codebook. We merely need to
make the headers, then pass them to libvorbis one at a time;
libvorbis handles the additional Ogg bitstream constraints */
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
ogg_stream_packetin(&os,&header); /* automatically placed in its own
page */
ogg_stream_packetin(&os,&header_comm);
ogg_stream_packetin(&os,&header_code);
/* This ensures the actual
* audio data will start on a new page, as per spec
*/
while(!eos) {
int result=ogg_stream_flush(&os,&og);
if(result==0)break;
wsfwrite(og.header,og.header_len,wOut);
wsfwrite(og.body,og.body_len,wOut);
}
}
while(!eos) {
int i;
int bytes=wsfread(readbuffer,nRLen*4,wIn); /* stereo hardwired here */
if(bytes==0) {
/* end of file. this can be done implicitly in the mainline,
but it's easier to see here in non-clever fashion.
Tell the library we're at end of stream so that it can handle
the last frame and mark end of stream in the output properly */
vorbis_analysis_wrote(&vd,0);
} else {
/* data to encode */
/* expose the buffer to submit data */
float **buffer=vorbis_analysis_buffer(&vd,nRLen);
/* uninterleave samples */
if (nBit == 16)
{
for(i=0; i<bytes/4; i++) {
buffer[0][i]=((readbuffer[i*4+1]<<8)|
(0x00ff&(int)readbuffer[i*4]))/32768.f;
if (buffer[1])
buffer[1][i]=((readbuffer[i*4+3]<<8)|
(0x00ff&(int)readbuffer[i*4+2]))/32768.f;
}
}
else
{
for(i=0; i<bytes/2; i++) {
buffer[0][i]=((readbuffer[i*2+1]<<8)|
(0x00ff&(int)readbuffer[i*2]))/32768.f;
if (buffer[1])
buffer[1][i]=((readbuffer[i*2+3]<<8)|
(0x00ff&(int)readbuffer[i*2+2]))/32768.f;
}
}
/* tell the library how much we actually submitted */
vorbis_analysis_wrote(&vd,i);
}
/* vorbis does some data preanalysis, then divvies up blocks for
more involved (potentially parallel) processing. Get a single
block for encoding now */
while(vorbis_analysis_blockout(&vd,&vb)==1) {
/* analysis, assume we want to use bitrate management */
vorbis_analysis(&vb,NULL);
vorbis_bitrate_addblock(&vb);
while(vorbis_bitrate_flushpacket(&vd,&op)) {
/* weld the packet into the bitstream */
ogg_stream_packetin(&os,&op);
/* write out pages (if any) */
while(!eos) {
int result=ogg_stream_pageout(&os,&og);
if(result==0)break;
wsfwrite(og.header,og.header_len,wOut);
wsfwrite(og.body,og.body_len,wOut);
/* this could be set above, but for illustrative purposes, I do
it here (to show that vorbis does know where the stream ends) */
if(ogg_page_eos(&og))eos=1;
}
}
}
}
/* clean up and exit. vorbis_info_clear() must be called last */
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
wsfclose(wIn);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
return(0);
}
static int icecast_internal_connect(t_channel *c, t_channel_outputstream *os,
t_icecast *icecast,
char *error, int errsize)
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
(void)c;
(void)os;
if (icecast->connected)
return MSERV_SUCCESS;
if (shout_open(icecast->shout) != SHOUTERR_SUCCESS) {
snprintf(error, errsize, "icecast: failed opening connection: %s",
shout_get_error(icecast->shout));
goto failed;
}
mserv_log("Successfully connected to Icecast server '%s:%d'"
" for mount '%s'",
shout_get_host(icecast->shout), shout_get_port(icecast->shout),
shout_get_mount(icecast->shout));
icecast->connected = 1;
vorbis_info_init(&icecast->vi);
if (vorbis_encode_init(&icecast->vi, os->channels,
os->samplerate, -1,
icecast->bitrate, -1) != 0) {
snprintf(error, errsize, "icecast: failed to initialise vorbis engine");
goto failed;
}
vorbis_comment_init(&icecast->vc);
vorbis_comment_add_tag(&icecast->vc, "ENCODER", "mserv " VERSION);
vorbis_analysis_init(&icecast->vd, &icecast->vi);
vorbis_block_init(&icecast->vd, &icecast->vb);
ogg_stream_init(&icecast->os, rand());
vorbis_analysis_headerout(&icecast->vd, &icecast->vc,
&header, &header_comm, &header_code);
ogg_stream_packetin(&icecast->os, &header);
ogg_stream_packetin(&icecast->os, &header_comm);
ogg_stream_packetin(&icecast->os, &header_code);
for (;;) {
if (ogg_stream_flush(&icecast->os, &icecast->og) == 0)
break;
if (shout_send(icecast->shout, icecast->og.header,
icecast->og.header_len) != SHOUTERR_SUCCESS ||
shout_send(icecast->shout, icecast->og.body,
icecast->og.body_len) != SHOUTERR_SUCCESS) {
snprintf(error, errsize, "icecast: failed to send starter to "
"shout: %s", shout_get_error(icecast->shout));
vorbis_block_clear(&icecast->vb);
vorbis_dsp_clear(&icecast->vd);
vorbis_info_clear(&icecast->vi);
goto failed;
}
}
return MSERV_SUCCESS;
failed:
if (icecast->connected)
shout_close(icecast->shout);
icecast->connected = 0;
return MSERV_FAILURE;
}
int OggDecode( wsul nSize, wsfb *bData, int nBit, wsf_file *wOut ) {
ogg_sync_state oy; /* sync and verify incoming physical bitstream */
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream
settings */
vorbis_comment vc; /* struct that stores all the bitstream user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
char *buffer;
int bytes;
wsf_file *wIn;
wIn = wsfopenmem(bData,nSize);
/********** Decode setup ************/
ogg_sync_init(&oy); /* Now we can read pages */
while(1) { /* we repeat if the bitstream is chained */
int eos=0;
int i;
/* grab some data at the head of the stream. We want the first page
(which is guaranteed to be small and only contain the Vorbis
stream initial header) We need the first page to get the stream
serialno. */
/* submit a 4k block to libvorbis' Ogg layer */
buffer=ogg_sync_buffer(&oy,4096);
bytes=wsfread(buffer,4096,wIn);
ogg_sync_wrote(&oy,bytes);
/* Get the first page. */
if(ogg_sync_pageout(&oy,&og)!=1) {
/* have we simply run out of data? If so, we're done. */
if(bytes<4096)break;
/* error case. Must not be Vorbis data */
return 1;
}
/* Get the serial number and set up the rest of decode. */
/* serialno first; use it to set up a logical stream */
ogg_stream_init(&os,ogg_page_serialno(&og));
/* extract the initial header from the first page and verify that the
Ogg bitstream is in fact Vorbis data */
/* I handle the initial header first instead of just having the code
read all three Vorbis headers at once because reading the initial
header is an easy way to identify a Vorbis bitstream and it's
useful to see that functionality seperated out. */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
if(ogg_stream_pagein(&os,&og)<0) {
/* error; stream version mismatch perhaps */
return 1;
}
if(ogg_stream_packetout(&os,&op)!=1) {
/* no page? must not be vorbis */
return 1;
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)<0) {
/* error case; not a vorbis header */
return 1;
}
/* At this point, we're sure we're Vorbis. We've set up the logical
(Ogg) bitstream decoder. Get the comment and codebook headers and
set up the Vorbis decoder */
/* The next two packets in order are the comment and codebook headers.
They're likely large and may span multiple pages. Thus we reead
and submit data until we get our two pacakets, watching that no
pages are missing. If a page is missing, error out; losing a
header page is the only place where missing data is fatal. */
i=0;
while(i<2) {
while(i<2) {
int result=ogg_sync_pageout(&oy,&og);
if(result==0)break; /* Need more data */
/* Don't complain about missing or corrupt data yet. We'll
catch it at the packet output phase */
if(result==1) {
ogg_stream_pagein(&os,&og); /* we can ignore any errors here
as they'll also become apparent
at packetout */
while(i<2) {
result=ogg_stream_packetout(&os,&op);
if(result==0)break;
if(result<0) {
/* Uh oh; data at some point was corrupted or missing!
We can't tolerate that in a header. Die. */
return 1;
}
vorbis_synthesis_headerin(&vi,&vc,&op);
i++;
}
}
}
/* no harm in not checking before adding more */
buffer=ogg_sync_buffer(&oy,4096);
bytes=wsfread(buffer,4096,wIn);
if(bytes==0 && i<2) {
return 1;
}
ogg_sync_wrote(&oy,bytes);
}
/* Throw the comments plus a few lines about the bitstream we're
decoding */
{
char **ptr=vc.user_comments;
while(*ptr) {
++ptr;
}
}
convsize=4096/vi.channels;
/* OK, got and parsed all three headers. Initialize the Vorbis
packet->PCM decoder. */
vorbis_synthesis_init(&vd,&vi); /* central decode state */
vorbis_block_init(&vd,&vb); /* local state for most of the decode
so multiple block decodes can
proceed in parallel. We could init
multiple vorbis_block structures
for vd here */
/* The rest is just a straight decode loop until end of stream */
while(!eos) {
while(!eos) {
int result=ogg_sync_pageout(&oy,&og);
if(result==0)break; /* need more data */
if(result<0) { /* missing or corrupt data at this page position */
fprintf(stderr,"");
} else {
ogg_stream_pagein(&os,&og); /* can safely ignore errors at
this point */
while(1) {
result=ogg_stream_packetout(&os,&op);
if(result==0)break; /* need more data */
if(result<0) { /* missing or corrupt data at this page position */
/* no reason to complain; already complained above */
} else {
/* we have a packet. Decode it */
float **pcm;
int samples;
if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
vorbis_synthesis_blockin(&vd,&vb);
/*
**pcm is a multichannel float vector. In stereo, for
example, pcm[0] is left, and pcm[1] is right. samples is
the size of each channel. Convert the float values
(-1.<=range<=1.) to whatever PCM format and write it out */
while((samples=vorbis_synthesis_pcmout(&vd,&pcm))>0) {
int j;
int clipflag=0;
int bout=(samples<convsize?samples:convsize);
if (nBit == 16)
{
/* convert floats to 16 bit signed ints (host order) and
interleave */
for(i=0; i<vi.channels; i++) {
ogg_int16_t *ptr=convbuffer+i;
float *mono=pcm[i];
for(j=0; j<bout; j++) {
#if 1
int val=(int)(mono[j]*32767.f);
#else /* optional dither */
int val=mono[j]*32767.f+drand48()-0.5f;
#endif
/* might as well guard against clipping */
if(val>32767) {
val=32767;
clipflag=1;
}
if(val<-32768) {
val=-32768;
clipflag=1;
}
*ptr=val;
ptr+=vi.channels;
}
}
}
else
{
/* convert floats to 8 bit signed ints (host order) and
interleave */
for(i=0; i<vi.channels; i++) {
char *ptr=(char*)convbuffer+i;
float *mono=pcm[i];
for(j=0; j<bout; j++) {
int val=(int)(mono[j]*127.f);
/* might as well guard against clipping */
if(val>127) {
val=127;
clipflag=1;
}
if(val<-128) {
val=-128;
clipflag=1;
}
*ptr=val;
ptr+=vi.channels;
}
}
}
wsfwrite(convbuffer,(nBit/8)*vi.channels*bout,wOut);
vorbis_synthesis_read(&vd,bout); /* tell libvorbis how
many samples we
actually consumed */
}
}
}
if(ogg_page_eos(&og))eos=1;
}
}
if(!eos) {
buffer=ogg_sync_buffer(&oy,4096);
bytes=wsfread(buffer,4096,wIn);
ogg_sync_wrote(&oy,bytes);
if(bytes==0)eos=1;
}
}
/* clean up this logical bitstream; before exit we see if we're
followed by another [chained] */
ogg_stream_clear(&os);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi); /* must be called last */
}
/* OK, clean up the framer */
ogg_sync_clear(&oy);
wsfclose(wIn);
return(0);
}
virtual bool Cook(FName Format, const TArray<uint8>& SrcBuffer, FSoundQualityInfo& QualityInfo, TArray<uint8>& CompressedDataStore) const
{
check(Format == NAME_OGG);
#if WITH_OGGVORBIS
{
short ReadBuffer[SAMPLES_TO_READ * SAMPLE_SIZE * 2];
ogg_stream_state os; // take physical pages, weld into a logical stream of packets
ogg_page og; // one ogg bitstream page. Vorbis packets are inside
ogg_packet op; // one raw packet of data for decode
vorbis_info vi; // struct that stores all the static vorbis bitstream settings
vorbis_comment vc; // struct that stores all the user comments
vorbis_dsp_state vd; // central working state for the packet->PCM decoder
vorbis_block vb; // local working space for packet->PCM decode
uint32 i;
bool eos;
// Create a buffer to store compressed data
CompressedDataStore.Empty();
FMemoryWriter CompressedData( CompressedDataStore );
uint32 BufferOffset = 0;
float CompressionQuality = ( float )( QualityInfo.Quality + VORBIS_QUALITY_MODIFIER ) / 100.0f;
CompressionQuality = FMath::Clamp( CompressionQuality, -0.1f, 1.0f );
vorbis_info_init( &vi );
if( vorbis_encode_init_vbr( &vi, QualityInfo.NumChannels, QualityInfo.SampleRate, CompressionQuality ) )
{
return false;
}
// add a comment
vorbis_comment_init( &vc );
vorbis_comment_add_tag( &vc, "ENCODER", "UnrealEngine4" );
// set up the analysis state and auxiliary encoding storage
vorbis_analysis_init( &vd, &vi );
vorbis_block_init( &vd, &vb );
// set up our packet->stream encoder
ogg_stream_init( &os, 0 );
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout( &vd, &vc, &header, &header_comm, &header_code);
ogg_stream_packetin( &os, &header );
ogg_stream_packetin( &os, &header_comm );
ogg_stream_packetin( &os, &header_code );
// This ensures the actual audio data will start on a new page, as per spec
while( true )
{
int result = ogg_stream_flush( &os, &og );
if( result == 0 )
{
break;
}
CompressedData.Serialize( og.header, og.header_len );
CompressedData.Serialize( og.body, og.body_len );
}
eos = false;
while( !eos )
{
// Read samples
uint32 BytesToRead = FMath::Min( SAMPLES_TO_READ * QualityInfo.NumChannels * SAMPLE_SIZE, QualityInfo.SampleDataSize - BufferOffset );
FMemory::Memcpy( ReadBuffer, SrcBuffer.GetTypedData() + BufferOffset, BytesToRead );
BufferOffset += BytesToRead;
if( BytesToRead == 0)
{
// end of file
vorbis_analysis_wrote( &vd, 0 );
}
else
{
// expose the buffer to submit data
float **buffer = vorbis_analysis_buffer( &vd, SAMPLES_TO_READ );
if( QualityInfo.NumChannels == 1 )
{
for( i = 0; i < BytesToRead / SAMPLE_SIZE; i++ )
{
buffer[0][i] = ( ReadBuffer[i] ) / 32768.0f;
}
}
else
{
for( i = 0; i < BytesToRead / ( SAMPLE_SIZE * 2 ); i++ )
{
buffer[0][i] = ( ReadBuffer[i * 2] ) / 32768.0f;
buffer[1][i] = ( ReadBuffer[i * 2 + 1] ) / 32768.0f;
}
}
// tell the library how many samples we actually submitted
vorbis_analysis_wrote( &vd, i );
}
// vorbis does some data preanalysis, then divvies up blocks for more involved (potentially parallel) processing.
while( vorbis_analysis_blockout( &vd, &vb ) == 1 )
{
// analysis, assume we want to use bitrate management
vorbis_analysis( &vb, NULL );
vorbis_bitrate_addblock( &vb );
while( vorbis_bitrate_flushpacket( &vd, &op ) )
{
// weld the packet into the bitstream
ogg_stream_packetin( &os, &op );
// write out pages (if any)
while( !eos )
{
int result = ogg_stream_pageout( &os, &og );
if( result == 0 )
{
break;
}
CompressedData.Serialize( og.header, og.header_len );
CompressedData.Serialize( og.body, og.body_len );
// this could be set above, but for illustrative purposes, I do it here (to show that vorbis does know where the stream ends)
if( ogg_page_eos( &og ) )
{
eos = true;
}
}
}
}
}
// clean up and exit. vorbis_info_clear() must be called last
ogg_stream_clear( &os );
vorbis_block_clear( &vb );
vorbis_dsp_clear( &vd );
vorbis_comment_clear( &vc );
vorbis_info_clear( &vi );
// ogg_page and ogg_packet structs always point to storage in libvorbis. They're never freed or manipulated directly
}
return CompressedDataStore.Num() > 0;
#else
return false;
#endif // WITH_OGGVOBVIS
}
const char *
_edje_multisense_encode_to_ogg_vorbis(char *snd_path, double quality, SF_INFO sfinfo)
{
ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream settings */
vorbis_comment vc; /* struct that stores all the user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
int eos = 0, ret;
char *tmp;
SNDFILE *sfile;
FILE *fout;
sfile = sf_open(snd_path, SFM_READ, &sfinfo);
if (!sfile) return NULL;
if (!sf_format_check(&sfinfo))
{
sf_close(sfile);
return NULL;
}
tmp = malloc(strlen(snd_path) + 1 + 4);
if (!tmp)
{
sf_close(sfile);
return NULL;
}
strcpy(tmp, snd_path);
snd_path = tmp;
strcat(snd_path, ".ogg");
fout = fopen(snd_path, "wb");
if (!fout)
{
free(snd_path);
sf_close(sfile);
return NULL;
}
/********** Encode setup ************/
vorbis_info_init(&vi);
ret = vorbis_encode_init(&vi, sfinfo.channels, sfinfo.samplerate,
-1, (long)(quality * 1000), -1);
if (ret == OV_EFAULT) printf("OV_EFAULT\n");
if (ret == OV_EINVAL) printf("OV_EINVAL\n");
if (ret == OV_EIMPL) printf("OV_EIMPL\n");
if (ret)
{
fclose(fout);
free(snd_path);
sf_close(sfile);
return NULL;
}
/* add a comment */
vorbis_comment_init(&vc);
vorbis_comment_add_tag(&vc, "", "");
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&vd, &vi);
vorbis_block_init(&vd, &vb);
srand(time(NULL));
ogg_stream_init(&os, rand());
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd, &vc, &header, &header_comm, &header_code);
ogg_stream_packetin(&os, &header); /* automatically placed in its own page */
ogg_stream_packetin(&os, &header_comm);
ogg_stream_packetin(&os, &header_code);
while (!eos)
{
int result = ogg_stream_flush(&os, &og);
if (!result) break;
fwrite(og.header, 1, og.header_len, fout);
fwrite(og.body, 1, og.body_len, fout);
}
while (!eos)
{
int i, ch;
float readbuffer[READBUF * 2];
sf_count_t count;
count = sf_readf_float(sfile, readbuffer, READBUF);
if (!count)
vorbis_analysis_wrote(&vd, 0);
else
{
float **buffer = vorbis_analysis_buffer(&vd, count);
/* uninterleave samples */
for (i = 0; i < count; i++)
{
for (ch = 0; ch < sfinfo.channels; ch++)
buffer[ch][i]= readbuffer[(i * sfinfo.channels) + ch];
}
vorbis_analysis_wrote(&vd, i);
}
while (vorbis_analysis_blockout(&vd, &vb) == 1)
{
vorbis_analysis(&vb, NULL);
vorbis_bitrate_addblock(&vb);
while (vorbis_bitrate_flushpacket(&vd, &op))
{
ogg_stream_packetin(&os, &op);
while (!eos)
{
int result = ogg_stream_pageout(&os, &og);
if (!result) break;
fwrite(og.header, 1, og.header_len, fout);
fwrite(og.body, 1, og.body_len, fout);
if (ogg_page_eos(&og)) eos = 1;
}
}
}
}
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
sf_close(sfile);
fclose (fout);
return snd_path;
}
int ogg_encode(){
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream
settings */
vorbis_comment vc; /* struct that stores all the user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
int eos=0,ret;
int i, founddata;
/* we cheat on the WAV header; we just bypass 44 bytes and never
verify that it matches 16bit/stereo/44.1kHz. This is just an
example, after all. */
/* if we were reading/writing a file, it would also need to in
binary mode, eg, fopen("file.wav","wb"); */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
// _setmode( _fileno( stdin ), _O_BINARY );
// _setmode( _fileno( stdout ), _O_BINARY );
FILE *fin, *fout;
fin = fopen("C:\\Documents and Settings\\paak\\My Documents\\gaine.wav","rb");
fout = fopen("C:\\Documents and Settings\\paak\\My Documents\\gaine.ogg","wb");
/* we cheat on the WAV header; we just bypass the header and never
verify that it matches 16bit/stereo/44.1kHz. This is just an
example, after all. */
readbuffer[0] = '\0';
for (i=0, founddata=0; i<30 && ! feof(fin) && ! ferror(fin); i++)
{
fread(readbuffer,1,2,fin);
if ( ! strncmp((char*)readbuffer, "da", 2) )
{
founddata = 1;
fread(readbuffer,1,6,fin);
break;
}
}
/********** Encode setup ************/
vorbis_info_init(&vi);
/* choose an encoding mode. A few possibilities commented out, one
actually used: */
/*********************************************************************
Encoding using a VBR quality mode. The usable range is -.1
(lowest quality, smallest file) to 1. (highest quality, largest file).
Example quality mode .4: 44kHz stereo coupled, roughly 128kbps VBR
ret = vorbis_encode_init_vbr(&vi,2,44100,.4);
---------------------------------------------------------------------
Encoding using an average bitrate mode (ABR).
example: 44kHz stereo coupled, average 128kbps VBR
ret = vorbis_encode_init(&vi,2,44100,-1,128000,-1);
---------------------------------------------------------------------
Encode using a quality mode, but select that quality mode by asking for
an approximate bitrate. This is not ABR, it is true VBR, but selected
using the bitrate interface, and then turning bitrate management off:
ret = ( vorbis_encode_setup_managed(&vi,2,44100,-1,128000,-1) ||
vorbis_encode_ctl(&vi,OV_ECTL_RATEMANAGE2_SET,NULL) ||
vorbis_encode_setup_init(&vi));
*********************************************************************/
ret=vorbis_encode_init_vbr(&vi,1,48000,0.4);
// ret=vorbis_encode_init_vbr(&vi,2,44100,0.1);
/* do not continue if setup failed; this can happen if we ask for a
mode that libVorbis does not support (eg, too low a bitrate, etc,
will return 'OV_EIMPL') */
if(ret)exit(1);
/* add a comment */
vorbis_comment_init(&vc);
vorbis_comment_add_tag(&vc,"ENCODER","encoder_example.c");
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
/* set up our packet->stream encoder */
/* pick a random serial number; that way we can more likely build
chained streams just by concatenation */
srand(time(NULL));
ogg_stream_init(&os,rand());
/* Vorbis streams begin with three headers; the initial header (with
most of the codec setup parameters) which is mandated by the Ogg
bitstream spec. The second header holds any comment fields. The
third header holds the bitstream codebook. We merely need to
make the headers, then pass them to libvorbis one at a time;
libvorbis handles the additional Ogg bitstream constraints */
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
ogg_stream_packetin(&os,&header); /* automatically placed in its own
page */
ogg_stream_packetin(&os,&header_comm);
ogg_stream_packetin(&os,&header_code);
/* This ensures the actual
* audio data will start on a new page, as per spec
*/
while(!eos){
int result=ogg_stream_flush(&os,&og);
if(result==0)break;
fwrite(og.header,1,og.header_len,fout);
fwrite(og.body,1,og.body_len,fout);
}
}
while(!eos){
long i;
long bytes=fread(readbuffer,1,READ*2,fin); /* stereo hardwired here */
// long bytes=fread(readbuffer,1,READ*4,fin); /* stereo hardwired here */
if(bytes==0){
/* end of file. this can be done implicitly in the mainline,
but it's easier to see here in non-clever fashion.
Tell the library we're at end of stream so that it can handle
the last frame and mark end of stream in the output properly */
vorbis_analysis_wrote(&vd,0);
}else{
/* data to encode */
/* expose the buffer to submit data */
float **buffer=vorbis_analysis_buffer(&vd,READ);
/* uninterleave samples */
for(i=0;i<bytes/2;i++){
buffer[0][i]=((readbuffer[i*2+1]<<8)|
(0x00ff&(int)readbuffer[i*2]))/32768.f;
}
/*
for(i=0;i<bytes/4;i++){
buffer[0][i]=((readbuffer[i*4+1]<<8)|
(0x00ff&(int)readbuffer[i*4]))/32768.f;
buffer[1][i]=((readbuffer[i*4+3]<<8)|
(0x00ff&(int)readbuffer[i*4+2]))/32768.f;
}
*/
/* tell the library how much we actually submitted */
vorbis_analysis_wrote(&vd,i);
}
/* vorbis does some data preanalysis, then divvies up blocks for
more involved (potentially parallel) processing. Get a single
block for encoding now */
while(vorbis_analysis_blockout(&vd,&vb)==1){
/* analysis, assume we want to use bitrate management */
vorbis_analysis(&vb,NULL);
vorbis_bitrate_addblock(&vb);
while(vorbis_bitrate_flushpacket(&vd,&op)){
/* weld the packet into the bitstream */
ogg_stream_packetin(&os,&op);
/* write out pages (if any) */
while(!eos){
int result=ogg_stream_pageout(&os,&og);
if(result==0)break;
fwrite(og.header,1,og.header_len,fout);
fwrite(og.body,1,og.body_len,fout);
/* this could be set above, but for illustrative purposes, I do
it here (to show that vorbis does know where the stream ends) */
if(ogg_page_eos(&og))eos=1;
}
}
}
}
/* clean up and exit. vorbis_info_clear() must be called last */
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
fclose(fin);
fclose(fout);
fprintf(stderr,"Done.\n");
return(0);
}
/*
For lame_decode_fromfile: return code
-1 error, or eof
0 ok, but need more data before outputing any samples
n number of samples output.
*/
int lame_decode_ogg_fromfile( lame_global_flags* gfp,
FILE* fd,
short int pcm_l[],
short int pcm_r[],
mp3data_struct* mp3data )
{
lame_internal_flags *gfc = gfp->internal_flags;
int samples,result,i,j,eof=0,eos=0,bout=0;
double **pcm;
while(1){
/*
**pcm is a multichannel double vector. In stereo, for
example, pcm[0] is left, and pcm[1] is right. samples is
the size of each channel. Convert the float values
(-1.<=range<=1.) to whatever PCM format and write it out */
/* unpack the buffer, if it has at least 1024 samples */
convsize=1024;
samples=vorbis_synthesis_pcmout(&vd,&pcm);
if (samples >= convsize || eos || eof) {
/* read 1024 samples, or if eos, read what ever is in buffer */
int clipflag=0;
bout=(samples<convsize?samples:convsize);
/* convert doubles to 16 bit signed ints (host order) and
interleave */
for(i=0;i<vi.channels;i++){
double *mono=pcm[i];
for(j=0;j<bout;j++){
int val=mono[j]*32767.;
/* might as well guard against clipping */
if(val>32767){
val=32767;
clipflag=1;
}
if(val<-32768){
val=-32768;
clipflag=1;
}
if (i==0) pcm_l[j]=val;
if (i==1) pcm_r[j]=val;
}
}
/*
if(clipflag)
MSGF( gfc, "Clipping in frame %ld\n", vd.sequence );
*/
/* tell libvorbis how many samples we actually consumed */
vorbis_synthesis_read(&vd,bout);
break;
}
result=ogg_sync_pageout(&oy,&og);
if(result==0) {
/* need more data */
}else if (result==-1){ /* missing or corrupt data at this page position */
ERRORF( gfc, "Corrupt or missing data in bitstream; "
"continuing...\n");
}else{
/* decode this page */
ogg_stream_pagein(&os,&og); /* can safely ignore errors at
this point */
do {
result=ogg_stream_packetout(&os,&op);
if(result==0) {
/* need more data */
} else if(result==-1){ /* missing or corrupt data at this page position */
/* no reason to complain; already complained above */
}else{
/* we have a packet. Decode it */
vorbis_synthesis(&vb,&op);
vorbis_synthesis_blockin(&vd,&vb);
}
} while (result!=0);
}
/* is this the last page? */
if(ogg_page_eos(&og))eos=1;
if(!eos){
char *buffer;
int bytes;
buffer=ogg_sync_buffer(&oy,4096);
bytes=fread(buffer,1,4096,fd);
ogg_sync_wrote(&oy,bytes);
if(bytes==0)eof=1;
}
}
mp3data->stereo = vi.channels;
mp3data->samplerate = vi.rate;
mp3data->bitrate = 0; //ov_bitrate_instant(&vf);
/* mp3data->nsamp=MAX_U_32_NUM;*/
if (bout==0) {
/* clean up this logical bitstream; before exit we see if we're
followed by another [chained] */
ogg_stream_clear(&os);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_info_clear(&vi); /* must be called last */
/* OK, clean up the framer */
ogg_sync_clear(&oy);
return -1;
}
return bout;
}
void* vorbisEncoder(void *obj)
{
VS::setThreadName("vorbisEncoder");
VorbisEncoderData* ved = (VorbisEncoderData*)obj;
vorbis_info vi;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info_init(&vi);
vorbis_encode_init(&vi, ved->m_channels, ved->m_sample_rate, -1,
112000, -1);
vorbis_analysis_init(&vd, &vi);
vorbis_block_init(&vd, &vb);
vorbis_comment vc;
vorbis_comment_init(&vc);
vorbis_comment_add_tag(&vc, "ENCODER", "STK vorbis encoder");
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd, &vc, &header, &header_comm,
&header_code);
if (header.bytes > 255 || header_comm.bytes > 255)
{
Log::error("vorbisEncoder", "Header is too long.");
return NULL;
}
FILE* vb_data = fopen((getRecordingName() + ".audio").c_str(), "wb");
if (vb_data == NULL)
{
Log::error("vorbisEncoder", "Failed to open file for encoding"
" vorbis.");
return NULL;
}
fwrite(&ved->m_sample_rate, 1, sizeof(uint32_t), vb_data);
fwrite(&ved->m_channels, 1, sizeof(uint32_t), vb_data);
const uint32_t all = header.bytes + header_comm.bytes +
header_code.bytes + 3;
fwrite(&all, 1, sizeof(uint32_t), vb_data);
uint8_t size = 2;
fwrite(&size, 1, sizeof(uint8_t), vb_data);
size = (uint8_t)header.bytes;
fwrite(&size, 1, sizeof(uint8_t), vb_data);
size = (uint8_t)header_comm.bytes;
fwrite(&size, 1, sizeof(uint8_t), vb_data);
fwrite(header.packet, 1, header.bytes, vb_data);
fwrite(header_comm.packet, 1, header_comm.bytes, vb_data);
fwrite(header_code.packet, 1, header_code.bytes, vb_data);
Synchronised<std::list<int8_t*> >* audio_data =
(Synchronised<std::list<int8_t*> >*)ved->m_data;
pthread_cond_t* cond_request = ved->m_enc_request;
ogg_packet op;
int64_t last_timestamp = 0;
bool eos = false;
while (eos == false)
{
audio_data->lock();
bool waiting = audio_data->getData().empty();
while (waiting)
{
pthread_cond_wait(cond_request, audio_data->getMutex());
waiting = audio_data->getData().empty();
}
int8_t* audio_buf = audio_data->getData().front();
audio_data->getData().pop_front();
audio_data->unlock();
if (audio_buf == NULL)
{
vorbis_analysis_wrote(&vd, 0);
eos = true;
}
else
{
float **buffer = vorbis_analysis_buffer(&vd, 1024);
const unsigned channels = ved->m_channels;
if (ved->m_audio_type == VorbisEncoderData::AT_PCM)
{
for (unsigned j = 0; j < channels; j++)
{
for (unsigned i = 0; i < 1024; i++)
{
int8_t* each_channel =
&audio_buf[i * channels * 2 + j * 2];
buffer[j][i] = float((each_channel[1] << 8) |
(0x00ff & (int)each_channel[0])) / 32768.0f;
}
}
}
else
{
for (unsigned j = 0; j < channels; j++)
{
for (unsigned i = 0; i < 1024; i++)
{
float* fbuf = reinterpret_cast<float*>(audio_buf);
buffer[j][i] = fbuf[i * channels + j];
}
}
}
vorbis_analysis_wrote(&vd, 1024);
}
while (vorbis_analysis_blockout(&vd, &vb) == 1)
{
vorbis_analysis(&vb, NULL);
vorbis_bitrate_addblock(&vb);
while (vorbis_bitrate_flushpacket(&vd, &op))
{
if (op.granulepos > 0)
{
uint32_t frame_size = (uint32_t)op.bytes;
fwrite(&frame_size, 1, sizeof(uint32_t), vb_data);
fwrite(&last_timestamp, 1, sizeof(int64_t), vb_data);
fwrite(op.packet, 1, frame_size, vb_data);
double s = (double)op.granulepos /
(double)ved->m_sample_rate * 1000000000.;
last_timestamp = (int64_t)s;
}
}
}
delete[] audio_buf;
}
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
fclose(vb_data);
return NULL;
} // vorbisEncoder
bool CTheoraPlayer::playVideo(
//Plays specified OGG Theora file to screen surface.
//If screen == NULL, then this method will test that the file is playable
//by decoding it as fast as possible but not displaying anything.
//
//Returns: whether playback was successful
CStretchyBuffer& buffer, SDL_Surface *screen,
const int x, const int y) //[default=(0,0)]
{
//init
theora_p = vorbis_p = 0;
startticks = 0;
bool bSkippedLastFrame = false;
// start up Ogg stream synchronization layer
ogg_sync_init(&oy);
// init supporting Vorbis structures needed in header parsing
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
// init supporting Theora structures needed in header parsing
theora_comment_init(&tc);
theora_info_init(&ti);
if (!screen)
ti.quick_p = 1;
ti.quality = 63;
if (!parseHeaders(buffer))
return false;
// force audio off
vorbis_p = 0;
// initialize decoders
if (theora_p) {
theora_decode_init(&td,&ti);
#if 0
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n"
" Frame content is %dx%d with offset (%d,%d).\n",
to.serialno,ti.width,ti.height, (double)ti.fps_numerator/ti.fps_denominator,
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
//report_colorspace(&ti); //we're not using this info for anything
dump_comments(&tc);
#endif
} else {
// tear down the partial theora setup
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
if(vorbis_p) {
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
printf("Ogg logical stream %lx is Vorbis %d channel %ld Hz audio.\n",
vo.serialno,vi.channels,vi.rate);
} else {
// tear down the partial vorbis setup
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
// open audio
if (vorbis_p)
open_audio();
// open video
SDL_Overlay *yuv_overlay = NULL;
if (theora_p && screen)
yuv_overlay = open_video(screen);
// single frame video buffering
ogg_packet op;
ogg_int64_t videobuf_granulepos=-1;
double videobuf_time=0;
double last_frame_time = 0;
bool hasdatatobuffer = true;
// Main loop
bool audiobuf_ready=false;
bool videobuf_ready=false;
bool playbackdone = (yuv_overlay == NULL);
bool isPlaying = false;
bool bBreakout = false;
while (!playbackdone)
{
// break out on SDL quit event
SDL_Event event;
if (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT: playbackdone = bBreakout = true; break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
playbackdone = bBreakout = true;
break;
default: break;
}
}
while (theora_p && !videobuf_ready) {
// get one video packet...
if (ogg_stream_packetout(&to,&op)>0)
{
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
#if 0
//Without sound channels to synch to, don't need to worry about skipping frames when slow.
// update the frame counter
//++frameNum;
// check if this frame time has not passed yet.
// If the frame is late we need to decode additional
// ones and keep looping, since theora at this stage
// needs to decode all frames.
const double now=get_time();
const double delay=videobuf_time-now;
if(delay>=0.0){
/// got a good frame, not late, ready to break out
videobuf_ready=true;
} else if(now-last_frame_time>=1.0) {
// display at least one frame per second, regardless
videobuf_ready=true;
} else {
//Need to catch up -- no time to display frame.
if (bSkippedLastFrame) //only allow skipping one frame in a row
videobuf_ready = true; //show anyway
else
bSkippedLastFrame = true;
//printf("dropping frame %d (%.3fs behind)\n", frameNum, -delay);
}
#else
videobuf_ready = true; //show every frame
#endif
} else {
// need more data
break;
}
}
if (!hasdatatobuffer && !videobuf_ready && !audiobuf_ready) {
isPlaying = false;
playbackdone = true;
}
//If we're set for the next frame, sleep.
//In other words, don't show frames too rapidly.
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready))
{
const int ticks = (int)(1000*(videobuf_time-get_time()));
if(ticks>0 && screen) //don't need to sleep if only testing file
SDL_Delay(ticks);
}
if (videobuf_ready)
{
// time to write our cached frame
if (screen)
{
const bool bRes = video_write(screen, yuv_overlay, x, y);
if (!bRes) //couldn't display image
playbackdone = bBreakout = true;
}
videobuf_ready=false;
last_frame_time=get_time();
bSkippedLastFrame = false;
// if audio has not started (first frame) then start it
if ((!isPlaying)&&(vorbis_p)) {
start_audio();
isPlaying = true;
}
}
// HACK: always look for more audio data
audiobuf_ready=false;
// buffer compressed data every loop
if (hasdatatobuffer) {
hasdatatobuffer = buffer_data(&oy, buffer) > 0;
if (!hasdatatobuffer) {
//printf("Ogg buffering stopped, end of file reached.\n");
}
}
if (ogg_sync_pageout(&oy,&og)>0)
queue_page(&og);
} // playbackdone
// show number of video frames decoded
//printf("\nFrames decoded: %d\n", frameNum);
// deinit
if (vorbis_p) {
audio_close();
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if (theora_p) {
if (yuv_overlay)
SDL_FreeYUVOverlay(yuv_overlay);
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
//If broken out of testing, return false since entire file was not verified.
return !bBreakout || screen != NULL;
}
int Encode_Ogg(void *stream,void(*writefunc)(void *bytes,int count,void *stream),int freq,int channels,float *samples,int length,float compression) {
oggwriter *ogg;
int eos;
int result;
ogg=(oggwriter*)malloc(sizeof(oggwriter));
vorbis_info_init(&ogg->vi);
result=vorbis_encode_init_vbr(&ogg->vi,channels,freq,compression);
if(result) return -1; //error format not supported...
// add a comment
vorbis_comment_init(&ogg->vc);
vorbis_comment_add_tag(&ogg->vc,"ENCODER","encoder_example.c");
// set up the analysis state and auxiliary encoding storage
vorbis_analysis_init(&ogg->vd,&ogg->vi);
vorbis_block_init(&ogg->vd,&ogg->vb);
srand(time(NULL));
ogg_stream_init(&ogg->os,rand());
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&ogg->vd,&ogg->vc,&header,&header_comm,&header_code);
ogg_stream_packetin(&ogg->os,&header); //automatically placed in its own page
ogg_stream_packetin(&ogg->os,&header_comm);
ogg_stream_packetin(&ogg->os,&header_code);
//This ensures the actual audio data will start on a new page, as per spec
while(1) {
result=ogg_stream_flush(&ogg->os,&ogg->og);
if(result==0)break;
writefunc(ogg->og.header,ogg->og.header_len,stream);
writefunc(ogg->og.body,ogg->og.body_len,stream);
}
int i,c,n;
eos=0;
while(!eos) {
if (length>0) {
float **buffer=vorbis_analysis_buffer(&ogg->vd,READ);
n=length;
if (n>READ) n=READ;
//uninterleave samples
for (i=0; i<n; i++) {
for (c=0; c<channels; c++) {
buffer[c][i]=*samples++;
}
}
length=length-n;
//tell the library how much we actually submitted
vorbis_analysis_wrote(&ogg->vd,i);
} else {
vorbis_analysis_wrote(&ogg->vd,0);
}
while(vorbis_analysis_blockout(&ogg->vd,&ogg->vb)==1) {
//analysis, assume we want to use bitrate management
vorbis_analysis(&ogg->vb,NULL);
vorbis_bitrate_addblock(&ogg->vb);
while(vorbis_bitrate_flushpacket(&ogg->vd,&ogg->op)) {
//weld the packet into the bitstream
ogg_stream_packetin(&ogg->os,&ogg->op);
//write out pages (if any)
while(!eos) {
result=ogg_stream_pageout(&ogg->os,&ogg->og);
if(result==0)break;
writefunc(ogg->og.header,ogg->og.header_len,stream);
writefunc(ogg->og.body,ogg->og.body_len,stream);
if (ogg_page_eos(&ogg->og)) eos=1;
}
}
}
}
//clean up and exit. vorbis_info_clear() must be called last
ogg_stream_clear(&ogg->os);
vorbis_block_clear(&ogg->vb);
vorbis_dsp_clear(&ogg->vd);
vorbis_comment_clear(&ogg->vc);
vorbis_info_clear(&ogg->vi);
free(ogg);
return 0;
}
static int encode_ogg (cdrom_drive *drive, rip_opts_s *rip_opts,
text_tag_s *text_tag, int track,
int tracktot, char *filename, char **filenames)
{
ogg_stream_state os;
ogg_page og;
ogg_packet op;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info vi;
long samplesdone = 0;
int sector = 0, last_sector = 0;
long bytes_written = 0, packetsdone = 0;
double time_elapsed = 0.0;
int ret = 0;
time_t *timer;
double time;
int serialno = rand ();
vorbis_comment vc;
long total_samples_per_channel = 0;
int channels = 2;
int eos = 0;
long rate = 44100;
FILE *out = fopen (filename, "w+");
timer = timer_start ();
if (!rip_opts->managed && (rip_opts->min_bitrate > 0 || rip_opts->max_bitrate > 0)) {
log_msg ("Min or max bitrate requires managed", FL, FN, LN);
return -1;
}
if (rip_opts->bitrate < 0 && rip_opts->min_bitrate < 0 && rip_opts->max_bitrate < 0) {
rip_opts->quality_set = 1;
}
start_func (filename, rip_opts->bitrate, rip_opts->quality, rip_opts->quality_set,
rip_opts->managed, rip_opts->min_bitrate, rip_opts->max_bitrate);
vorbis_info_init (&vi);
if (rip_opts->quality_set > 0) {
if (vorbis_encode_setup_vbr (&vi, channels, rate, rip_opts->quality)) {
log_msg ("Couldn't initialize vorbis_info", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
/* two options here, max or min bitrate */
if (rip_opts->max_bitrate > 0 || rip_opts->min_bitrate > 0) {
struct ovectl_ratemanage_arg ai;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_GET, &ai);
ai.bitrate_hard_min = rip_opts->min_bitrate;
ai.bitrate_hard_max = rip_opts->max_bitrate;
ai.management_active = 1;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, &ai);
}
} else {
if (vorbis_encode_setup_managed (&vi, channels, rate,
rip_opts->max_bitrate > 0 ? rip_opts->max_bitrate * 1000 : -1,
rip_opts->bitrate * 1000,
rip_opts->min_bitrate > 0 ? rip_opts->min_bitrate * 1000 : -1)) {
log_msg ("Mode init failed, encode setup managed", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
}
if (rip_opts->managed && rip_opts->bitrate < 0) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_AVG, NULL);
} else if (!rip_opts->managed) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, NULL);
}
/* set advanced encoder options */
vorbis_encode_setup_init (&vi);
vorbis_analysis_init (&vd, &vi);
vorbis_block_init (&vd, &vb);
ogg_stream_init (&os, serialno);
{
ogg_packet header_main;
ogg_packet header_comments;
ogg_packet header_codebooks;
int result;
char buf[32];
vorbis_comment_init (&vc);
vorbis_comment_add_tag (&vc, "title", text_tag->songname);
vorbis_comment_add_tag (&vc, "artist", text_tag->artistname);
vorbis_comment_add_tag (&vc, "album", text_tag->albumname);
vorbis_comment_add_tag (&vc, "genre", text_tag->genre);
snprintf (buf, 32, "%d", text_tag->year);
vorbis_comment_add_tag (&vc, "date", buf);
snprintf (buf, 32, "%02d", text_tag->track);
vorbis_comment_add_tag (&vc, "tracknumber", buf);
vorbis_analysis_headerout (&vd, &vc, &header_main, &header_comments, &header_codebooks);
ogg_stream_packetin (&os, &header_main);
ogg_stream_packetin (&os, &header_comments);
ogg_stream_packetin (&os, &header_codebooks);
while ((result = ogg_stream_flush (&os, &og))) {
if (result == 0)
break;
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
}
}
sector = cdda_track_firstsector (drive, track);
last_sector = cdda_track_lastsector (drive, track);
total_samples_per_channel = (last_sector - sector) * (CD_FRAMESAMPLES / 2);
int eos = 0;
while (!eos) {
signed char *buffer = (signed char *)malloc (CD_FRAMESIZE_RAW * READ_SECTORS);
//use this variable as a s**t
long sectors_read = last_sector - sector;
if (sectors_read > READ_SECTORS)
sectors_read = READ_SECTORS;
sectors_read = cdda_read (drive, (signed char *)buffer, sector, sectors_read);
int i;
if (sectors_read == 0) {
vorbis_analysis_wrote (&vd, 0);
} else {
float **vorbbuf = vorbis_analysis_buffer (&vd, CD_FRAMESIZE_RAW * sectors_read);
for (i = 0; i < (CD_FRAMESIZE_RAW * sectors_read) / 4; i++) {
vorbbuf[0][i] = ((buffer[i * 4 + 1] << 8) | (0x00ff&(int)buffer[i * 4])) / 32768.f;
vorbbuf[1][i] = ((buffer[i * 4 + 3] << 8) | (0x00ff&(int)buffer[i * 4 + 2])) / 32768.f;
}
int samples_read = sectors_read * (CD_FRAMESAMPLES / 2);
samplesdone += samples_read;
// progress every 60 pages
if (packetsdone >= 60) {
packetsdone = 0;
time = timer_time (timer);
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
}
vorbis_analysis_wrote (&vd, i);
}
free (buffer);
sector += sectors_read;
while (vorbis_analysis_blockout (&vd, &vb) == 1) {
vorbis_analysis (&vb, &op);
vorbis_bitrate_addblock (&vb);
while (vorbis_bitrate_flushpacket (&vd, &op)) {
ogg_stream_packetin (&os, &op);
packetsdone++;
while (!eos) {
int result = ogg_stream_pageout (&os, &og);
if (result == 0) {
break;
}
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
} else
bytes_written += ret;
if (ogg_page_eos (&og)) {
eos = 1;
}
}
}
}
}
}
ret = 0;
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
ogg_stream_clear (&os);
vorbis_block_clear (&vb);
vorbis_dsp_clear (&vd);
vorbis_comment_clear (&vc);
vorbis_info_clear (&vi);
vorbis_comment_clear (&vc);
time_elapsed = timer_time (timer);
end_func (time_elapsed, rate, samplesdone, bytes_written);
timer_clear (timer);
fclose (out);
return ret;
}
int ExportOGG::Export(AudacityProject *project,
int numChannels,
const wxString &fName,
bool selectionOnly,
double t0,
double t1,
MixerSpec *mixerSpec,
const Tags *metadata,
int WXUNUSED(subformat))
{
double rate = project->GetRate();
const TrackList *tracks = project->GetTracks();
double quality = (gPrefs->Read(wxT("/FileFormats/OggExportQuality"), 50)/(float)100.0);
wxLogNull logNo; // temporarily disable wxWidgets error messages
int updateResult = eProgressSuccess;
int eos = 0;
FileIO outFile(fName, FileIO::Output);
if (!outFile.IsOpened()) {
wxMessageBox(_("Unable to open target file for writing"));
return false;
}
// All the Ogg and Vorbis encoding data
ogg_stream_state stream;
ogg_page page;
ogg_packet packet;
vorbis_info info;
vorbis_comment comment;
vorbis_dsp_state dsp;
vorbis_block block;
// Encoding setup
vorbis_info_init(&info);
vorbis_encode_init_vbr(&info, numChannels, int(rate + 0.5), quality);
// Retrieve tags
if (!FillComment(project, &comment, metadata)) {
return false;
}
// Set up analysis state and auxiliary encoding storage
vorbis_analysis_init(&dsp, &info);
vorbis_block_init(&dsp, &block);
// Set up packet->stream encoder. According to encoder example,
// a random serial number makes it more likely that you can make
// chained streams with concatenation.
srand(time(NULL));
ogg_stream_init(&stream, rand());
// First we need to write the required headers:
// 1. The Ogg bitstream header, which contains codec setup params
// 2. The Vorbis comment header
// 3. The bitstream codebook.
//
// After we create those our responsibility is complete, libvorbis will
// take care of any other ogg bistream constraints (again, according
// to the example encoder source)
ogg_packet bitstream_header;
ogg_packet comment_header;
ogg_packet codebook_header;
vorbis_analysis_headerout(&dsp, &comment, &bitstream_header, &comment_header,
&codebook_header);
// Place these headers into the stream
ogg_stream_packetin(&stream, &bitstream_header);
ogg_stream_packetin(&stream, &comment_header);
ogg_stream_packetin(&stream, &codebook_header);
// Flushing these headers now guarentees that audio data will
// start on a NEW page, which apparently makes streaming easier
while (ogg_stream_flush(&stream, &page)) {
outFile.Write(page.header, page.header_len);
outFile.Write(page.body, page.body_len);
}
const WaveTrackConstArray waveTracks =
tracks->GetWaveTrackConstArray(selectionOnly, false);
{
auto mixer = CreateMixer(waveTracks,
tracks->GetTimeTrack(),
t0, t1,
numChannels, SAMPLES_PER_RUN, false,
rate, floatSample, true, mixerSpec);
ProgressDialog progress(wxFileName(fName).GetName(),
selectionOnly ?
_("Exporting the selected audio as Ogg Vorbis") :
_("Exporting the entire project as Ogg Vorbis"));
while (updateResult == eProgressSuccess && !eos) {
float **vorbis_buffer = vorbis_analysis_buffer(&dsp, SAMPLES_PER_RUN);
sampleCount samplesThisRun = mixer->Process(SAMPLES_PER_RUN);
if (samplesThisRun == 0) {
// Tell the library that we wrote 0 bytes - signalling the end.
vorbis_analysis_wrote(&dsp, 0);
}
else {
for (int i = 0; i < numChannels; i++) {
float *temp = (float *)mixer->GetBuffer(i);
memcpy(vorbis_buffer[i], temp, sizeof(float)*SAMPLES_PER_RUN);
}
// tell the encoder how many samples we have
vorbis_analysis_wrote(&dsp, samplesThisRun);
}
// I don't understand what this call does, so here is the comment
// from the example, verbatim:
//
// vorbis does some data preanalysis, then divvies up blocks
// for more involved (potentially parallel) processing. Get
// a single block for encoding now
while (vorbis_analysis_blockout(&dsp, &block) == 1) {
// analysis, assume we want to use bitrate management
vorbis_analysis(&block, NULL);
vorbis_bitrate_addblock(&block);
while (vorbis_bitrate_flushpacket(&dsp, &packet)) {
// add the packet to the bitstream
ogg_stream_packetin(&stream, &packet);
// From vorbis-tools-1.0/oggenc/encode.c:
// If we've gone over a page boundary, we can do actual output,
// so do so (for however many pages are available).
while (!eos) {
int result = ogg_stream_pageout(&stream, &page);
if (!result) {
break;
}
outFile.Write(page.header, page.header_len);
outFile.Write(page.body, page.body_len);
if (ogg_page_eos(&page)) {
eos = 1;
}
}
}
}
updateResult = progress.Update(mixer->MixGetCurrentTime() - t0, t1 - t0);
}
}
ogg_stream_clear(&stream);
vorbis_block_clear(&block);
vorbis_dsp_clear(&dsp);
vorbis_info_clear(&info);
vorbis_comment_clear(&comment);
outFile.Close();
return updateResult;
}
void CompressionTool::encodeRaw(const char *rawData, int length, int samplerate, const char *outname, AudioFormat compmode) {
print(" - len=%ld, ch=%d, rate=%d, %dbits", length, (rawAudioType.isStereo ? 2 : 1), samplerate, rawAudioType.bitsPerSample);
#ifdef USE_VORBIS
if (compmode == AUDIO_VORBIS) {
char outputString[256] = "";
int numChannels = (rawAudioType.isStereo ? 2 : 1);
int totalSamples = length / ((rawAudioType.bitsPerSample / 8) * numChannels);
int samplesLeft = totalSamples;
int eos = 0;
int totalBytes = 0;
vorbis_info vi;
vorbis_comment vc;
vorbis_dsp_state vd;
vorbis_block vb;
ogg_stream_state os;
ogg_page og;
ogg_packet op;
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
Common::File outputOgg(outname, "wb");
vorbis_info_init(&vi);
if (oggparms.nominalBitr > 0) {
int result = 0;
/* Input is in kbps, function takes bps */
result = vorbis_encode_setup_managed(&vi, numChannels, samplerate, (oggparms.maxBitr > 0 ? 1000 * oggparms.maxBitr : -1), (1000 * oggparms.nominalBitr), (oggparms.minBitr > 0 ? 1000 * oggparms.minBitr : -1));
if (result == OV_EFAULT) {
vorbis_info_clear(&vi);
error("Error: Internal Logic Fault");
} else if ((result == OV_EINVAL) || (result == OV_EIMPL)) {
vorbis_info_clear(&vi);
error("Error: Invalid bitrate parameters");
}
if (!oggparms.silent) {
sprintf(outputString, "Encoding to\n \"%s\"\nat average bitrate %i kbps (", outname, oggparms.nominalBitr);
if (oggparms.minBitr > 0) {
sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr);
} else {
sprintf(outputString + strlen(outputString), "no min, ");
}
if (oggparms.maxBitr > 0) {
sprintf(outputString + strlen(outputString), "max %i kbps),\nusing full bitrate management engine\nSet optional hard quality restrictions\n", oggparms.maxBitr);
} else {
sprintf(outputString + strlen(outputString), "no max),\nusing full bitrate management engine\nSet optional hard quality restrictions\n");
}
}
} else {
int result = 0;
/* Quality input is -1 - 10, function takes -0.1 through 1.0 */
result = vorbis_encode_setup_vbr(&vi, numChannels, samplerate, oggparms.quality * 0.1f);
if (result == OV_EFAULT) {
vorbis_info_clear(&vi);
error("Internal Logic Fault");
} else if ((result == OV_EINVAL) || (result == OV_EIMPL)) {
vorbis_info_clear(&vi);
error("Invalid bitrate parameters");
}
if (!oggparms.silent) {
sprintf(outputString, "Encoding to\n \"%s\"\nat quality %2.2f", outname, oggparms.quality);
}
if ((oggparms.minBitr > 0) || (oggparms.maxBitr > 0)) {
struct ovectl_ratemanage_arg extraParam;
vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_GET, &extraParam);
extraParam.bitrate_hard_min = (oggparms.minBitr > 0 ? (1000 * oggparms.minBitr) : -1);
extraParam.bitrate_hard_max = (oggparms.maxBitr > 0 ? (1000 * oggparms.maxBitr) : -1);
extraParam.management_active = 1;
vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_SET, &extraParam);
if (!oggparms.silent) {
sprintf(outputString + strlen(outputString), " using constrained VBR (");
if (oggparms.minBitr != -1) {
sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr);
} else {
sprintf(outputString + strlen(outputString), "no min, ");
}
if (oggparms.maxBitr != -1) {
sprintf(outputString + strlen(outputString), "max %i kbps)\nSet optional hard quality restrictions\n", oggparms.maxBitr);
} else {
sprintf(outputString + strlen(outputString), "no max)\nSet optional hard quality restrictions\n");
}
}
} else {
sprintf(outputString + strlen(outputString), "\n");
}
}
puts(outputString);
vorbis_encode_setup_init(&vi);
vorbis_comment_init(&vc);
vorbis_analysis_init(&vd, &vi);
vorbis_block_init(&vd, &vb);
ogg_stream_init(&os, 0);
vorbis_analysis_headerout(&vd, &vc, &header, &header_comm, &header_code);
ogg_stream_packetin(&os, &header);
ogg_stream_packetin(&os, &header_comm);
ogg_stream_packetin(&os, &header_code);
while (!eos) {
int result = ogg_stream_flush(&os,&og);
if (result == 0) {
break;
}
outputOgg.write(og.header, og.header_len);
outputOgg.write(og.body, og.body_len);
}
while (!eos) {
int numSamples = ((samplesLeft < 2048) ? samplesLeft : 2048);
float **buffer = vorbis_analysis_buffer(&vd, numSamples);
/* We must tell the encoder that we have reached the end of the stream */
if (numSamples == 0) {
vorbis_analysis_wrote(&vd, 0);
} else {
/* Adapted from oggenc 1.1.1 */
if (rawAudioType.bitsPerSample == 8) {
const byte *rawDataUnsigned = (const byte *)rawData;
for (int i = 0; i < numSamples; i++) {
for (int j = 0; j < numChannels; j++) {
buffer[j][i] = ((int)(rawDataUnsigned[i * numChannels + j]) - 128) / 128.0f;
}
}
} else if (rawAudioType.bitsPerSample == 16) {
if (rawAudioType.isLittleEndian) {
for (int i = 0; i < numSamples; i++) {
for (int j = 0; j < numChannels; j++) {
buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j) + 1] << 8) | (rawData[(i * 2 * numChannels) + (2 * j)] & 0xff)) / 32768.0f;
}
}
} else {
for (int i = 0; i < numSamples; i++) {
for (int j = 0; j < numChannels; j++) {
buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j)] << 8) | (rawData[(i * 2 * numChannels) + (2 * j) + 1] & 0xff)) / 32768.0f;
}
}
}
}
vorbis_analysis_wrote(&vd, numSamples);
}
while (vorbis_analysis_blockout(&vd, &vb) == 1) {
vorbis_analysis(&vb, NULL);
vorbis_bitrate_addblock(&vb);
while (vorbis_bitrate_flushpacket(&vd, &op)) {
ogg_stream_packetin(&os, &op);
while (!eos) {
int result = ogg_stream_pageout(&os, &og);
if (result == 0) {
break;
}
totalBytes += outputOgg.write(og.header, og.header_len);
totalBytes += outputOgg.write(og.body, og.body_len);
if (ogg_page_eos(&og)) {
eos = 1;
}
}
}
}
rawData += 2048 * (rawAudioType.bitsPerSample / 8) * numChannels;
samplesLeft -= 2048;
}
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_info_clear(&vi);
if (!oggparms.silent) {
print("\nDone encoding file \"%s\"", outname);
print("\n\tFile length: %dm %ds", (int)(totalSamples / samplerate / 60), (totalSamples / samplerate % 60));
print("\tAverage bitrate: %.1f kb/s\n", (8.0 * (double)totalBytes / 1000.0) / ((double)totalSamples / (double)samplerate));
}
}
#endif
#ifdef USE_FLAC
if (compmode == AUDIO_FLAC) {
int i;
int numChannels = (rawAudioType.isStereo ? 2 : 1);
int samplesPerChannel = length / ((rawAudioType.bitsPerSample / 8) * numChannels);
FLAC__StreamEncoder *encoder;
FLAC__StreamEncoderInitStatus initStatus;
FLAC__int32 *flacData;
flacData = (FLAC__int32 *)malloc(samplesPerChannel * numChannels * sizeof(FLAC__int32));
if (rawAudioType.bitsPerSample == 8) {
for (i = 0; i < samplesPerChannel * numChannels; i++) {
FLAC__uint8 *rawDataUnsigned;
rawDataUnsigned = (FLAC__uint8 *)rawData;
flacData[i] = (FLAC__int32)rawDataUnsigned[i] - 0x80;
}
} else if (rawAudioType.bitsPerSample == 16) {
/* The rawData pointer is an 8-bit char so we must create a new pointer to access 16-bit samples */
FLAC__int16 *rawData16;
rawData16 = (FLAC__int16 *)rawData;
for (i = 0; i < samplesPerChannel * numChannels; i++) {
flacData[i] = (FLAC__int32)rawData16[i];
}
}
if (!flacparms.silent) {
print("Encoding to\n \"%s\"\nat compression level %d using blocksize %d\n", outname, flacparms.compressionLevel, flacparms.blocksize);
}
encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_bits_per_sample(encoder, rawAudioType.bitsPerSample);
FLAC__stream_encoder_set_blocksize(encoder, flacparms.blocksize);
FLAC__stream_encoder_set_channels(encoder, numChannels);
FLAC__stream_encoder_set_compression_level(encoder, flacparms.compressionLevel);
FLAC__stream_encoder_set_sample_rate(encoder, samplerate);
FLAC__stream_encoder_set_streamable_subset(encoder, false);
FLAC__stream_encoder_set_total_samples_estimate(encoder, samplesPerChannel);
FLAC__stream_encoder_set_verify(encoder, flacparms.verify);
initStatus = FLAC__stream_encoder_init_file(encoder, outname, NULL, NULL);
if (initStatus != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
char buf[2048];
sprintf(buf, "Error in FLAC encoder. (check the parameters)\nExact error was:%s", FLAC__StreamEncoderInitStatusString[initStatus]);
free(flacData);
throw ToolException(buf);
} else {
FLAC__stream_encoder_process_interleaved(encoder, flacData, samplesPerChannel);
}
FLAC__stream_encoder_finish(encoder);
FLAC__stream_encoder_delete(encoder);
free(flacData);
if (!flacparms.silent) {
print("\nDone encoding file \"%s\"", outname);
print("\n\tFile length: %dm %ds\n", (int)(samplesPerChannel / samplerate / 60), (samplesPerChannel / samplerate % 60));
}
}
#endif
}
/*!
* \brief Create a new OGG/Vorbis filestream and set it up for reading.
* \param s File that points to on disk storage of the OGG/Vorbis data.
* \return The new filestream.
*/
static int ogg_vorbis_open(struct ast_filestream *s)
{
int i;
int bytes;
int result;
char **ptr;
char *buffer;
struct vorbis_desc *tmp = (struct vorbis_desc *)s->_private;
tmp->writing = 0;
ogg_sync_init(&tmp->oy);
buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);
bytes = fread(buffer, 1, BLOCK_SIZE, s->f);
ogg_sync_wrote(&tmp->oy, bytes);
result = ogg_sync_pageout(&tmp->oy, &tmp->og);
if (result != 1) {
if(bytes < BLOCK_SIZE) {
ast_log(LOG_ERROR, "Run out of data...\n");
} else {
ast_log(LOG_ERROR, "Input does not appear to be an Ogg bitstream.\n");
}
ogg_sync_clear(&tmp->oy);
return -1;
}
ogg_stream_init(&tmp->os, ogg_page_serialno(&tmp->og));
vorbis_info_init(&tmp->vi);
vorbis_comment_init(&tmp->vc);
if (ogg_stream_pagein(&tmp->os, &tmp->og) < 0) {
ast_log(LOG_ERROR, "Error reading first page of Ogg bitstream data.\n");
error:
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
return -1;
}
if (ogg_stream_packetout(&tmp->os, &tmp->op) != 1) {
ast_log(LOG_ERROR, "Error reading initial header packet.\n");
goto error;
}
if (vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op) < 0) {
ast_log(LOG_ERROR, "This Ogg bitstream does not contain Vorbis audio data.\n");
goto error;
}
for (i = 0; i < 2 ; ) {
while (i < 2) {
result = ogg_sync_pageout(&tmp->oy, &tmp->og);
if (result == 0)
break;
if (result == 1) {
ogg_stream_pagein(&tmp->os, &tmp->og);
while(i < 2) {
result = ogg_stream_packetout(&tmp->os,&tmp->op);
if(result == 0)
break;
if(result < 0) {
ast_log(LOG_ERROR, "Corrupt secondary header. Exiting.\n");
goto error;
}
vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op);
i++;
}
}
}
buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);
bytes = fread(buffer, 1, BLOCK_SIZE, s->f);
if (bytes == 0 && i < 2) {
ast_log(LOG_ERROR, "End of file before finding all Vorbis headers!\n");
goto error;
}
ogg_sync_wrote(&tmp->oy, bytes);
}
for (ptr = tmp->vc.user_comments; *ptr; ptr++)
ast_log(LOG_DEBUG, "OGG/Vorbis comment: %s\n", *ptr);
ast_log(LOG_DEBUG, "OGG/Vorbis bitstream is %d channel, %ldHz\n", tmp->vi.channels, tmp->vi.rate);
ast_log(LOG_DEBUG, "OGG/Vorbis file encoded by: %s\n", tmp->vc.vendor);
if (tmp->vi.channels != 1) {
ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files are currently supported!\n");
goto error;
}
if (tmp->vi.rate != DEFAULT_SAMPLE_RATE) {
ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are currently supported!\n");
vorbis_block_clear(&tmp->vb);
vorbis_dsp_clear(&tmp->vd);
goto error;
}
vorbis_synthesis_init(&tmp->vd, &tmp->vi);
vorbis_block_init(&tmp->vd, &tmp->vb);
return 0;
}
/* Opens the Ogg stream, searching for and initializing Theora and Vorbis media
*/
int alogg_open(APEG_LAYER *layer)
{
ALOGG_INFO *info;
int vok = 0, aok = 0;
int flag, cs, size;
info = calloc(1, sizeof(ALOGG_INFO));
if(!info)
return APEG_ERROR;
LOCK_DATA(info, sizeof(ALOGG_INFO));
ogg_sync_init(&info->osync);
theora_comment_init(&info->tcomment);
theora_info_init(&info->tinfo);
vorbis_info_init(&info->vinfo);
vorbis_comment_init(&info->vcomment);
flag = FALSE;
while(!flag)
{
int ret = buffer_data(layer, info);
if(ret == 0)
break;
while(ogg_sync_pageout(&info->osync, &info->opage) > 0)
{
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&info->opage))
{
if(vok > 0)
ogg_stream_pagein(&info->ostream[0], &info->opage);
if(aok > 0)
ogg_stream_pagein(&info->ostream[1], &info->opage);
flag = TRUE;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&info->opage));
ogg_stream_pagein(&test, &info->opage);
ogg_stream_packetout(&test, &info->opkt);
/* identify the codec: try theora */
if(!vok && theora_decode_header(&info->tinfo, &info->tcomment,
&info->opkt) >= 0)
{
/* it is theora */
if(!_apeg_ignore_video)
{
memcpy(&info->ostream[0], &test, sizeof(test));
vok = 1;
}
else
ogg_stream_clear(&test);
}
else if(!aok && vorbis_synthesis_headerin(&info->vinfo,
&info->vcomment, &info->opkt) >= 0)
{
/* it is vorbis */
if(!_apeg_ignore_audio)
{
memcpy(&info->ostream[1], &test, sizeof(test));
aok = 1;
}
else
ogg_stream_clear(&test);
}
/* whatever it is, we don't care about it */
else
ogg_stream_clear(&test);
}
/* fall through to non-bos page parsing */
}
/* look for further theora headers */
while((vok > 0 && vok < 3) || (aok > 0 && aok < 3))
{
int ret;
// Get the last two of three Theora headers
while(vok > 0 && vok < 3 &&
(ret = ogg_stream_packetout(&info->ostream[0], &info->opkt)))
{
if(ret < 0)
goto error;
if(theora_decode_header(&info->tinfo, &info->tcomment, &info->opkt))
goto error;
++vok;
}
// Get the last two of three Vorbis headers
while(aok > 0 && aok < 3 &&
(ret = ogg_stream_packetout(&info->ostream[1], &info->opkt)))
{
if(ret < 0)
goto error;
if(vorbis_synthesis_headerin(&info->vinfo, &info->vcomment,
&info->opkt))
goto error;
++aok;
}
if(ogg_sync_pageout(&info->osync, &info->opage) <= 0)
{
/* need more data */
if(buffer_data(layer, info) == 0)
break;
}
else
{
if(vok > 0)
ogg_stream_pagein(&info->ostream[0], &info->opage);
if(aok > 0)
ogg_stream_pagein(&info->ostream[1], &info->opage);
}
}
// Neither Vorbis or Theora fully initialized. Error.
if(vok != 3 && aok != 3)
goto error;
layer->ogg_info = info;
if(aok == 3)
{
vorbis_synthesis_init(&info->vdsp, &info->vinfo);
vorbis_block_init(&info->vdsp, &info->vblock);
if(info->vinfo.channels == 1)
layer->stream.audio.down_channel = FALSE;
layer->stream.audio.channels = info->vinfo.channels;
layer->stream.audio.freq = info->vinfo.rate >>
layer->stream.audio.down_sample;
if(_apeg_audio_reset_parameters(layer) != APEG_OK)
{
vorbis_block_clear(&info->vblock);
vorbis_dsp_clear(&info->vdsp);
goto error;
}
// layer->audio.inited = TRUE;
layer->stream.flags |= APEG_VORBIS_AUDIO;
}
static void *recordingThreadFct(void *data)
{
enum {
bufInCount=1024,
bufInSize=2*bufInCount,
};
short int bufIn[bufInSize];
char *bufInBytes=(char*)bufIn;
ogg_packet op;
RecordingParams *rp=(RecordingParams*)data;
int l;
while (1) {
sb_lock(recBuffer);
if (recBuffer->usedCount>=bufInSize) {
//buffer contains enough data, let's encode it
sb_unlock(recBuffer);
sb_retrieveData(recBuffer, bufIn, bufInSize);
//convert PCM to OGG library compatible format
float **buffer = vorbis_analysis_buffer(&rp->vd, bufInCount);
if (rp->vi.channels==1) {
for(l=0; l<bufInCount; l++) {
buffer[0][l]=((bufInBytes[l*2+1]<<8)|(0x00ff&(int)bufInBytes[l*2]))/32768.f;
}
} else {
for(l=0; l<bufInCount; l++) {
buffer[0][l]=((bufInBytes[l*4+1]<<8)|(0x00ff&(int)bufInBytes[l*4]))/32768.f;
buffer[1][l]=((bufInBytes[l*4+3]<<8)|(0x00ff&(int)bufInBytes[l*4+2]))/32768.f;
}
}
//encode and write out
vorbis_analysis_wrote(&rp->vd, bufInCount);
while(vorbis_analysis_blockout(&rp->vd, &rp->vb) == 1) {
vorbis_analysis(&rp->vb, NULL);
vorbis_bitrate_addblock(&rp->vb);
while(vorbis_bitrate_flushpacket(&rp->vd, &op)) {
ogg_stream_packetin(&rp->os,&op);
ogg_flushall(rp);
}
}
} else {
//not much in the buffer, wait for a while to get new data
sb_unlock(recBuffer);
#ifndef _WIN32
usleep(100*1000);
#else
Sleep(100);
#endif
}
pthread_mutex_lock(&threadRunMutex);
if (threadRunStop) {
pthread_mutex_unlock(&threadRunMutex);
break;
}
pthread_mutex_unlock(&threadRunMutex);
}
//close encoder and output file
vorbis_analysis_wrote(&rp->vd, 0);
ogg_flushall(rp);
vorbis_block_clear(&rp->vb);
vorbis_dsp_clear(&rp->vd);
vorbis_info_clear(&rp->vi);
fclose(rp->outputFile);
//empty output buffer
pthread_spin_lock(&recBufferLock);
sb_destroyBuffer(recBuffer);
recBuffer=0;
pthread_spin_unlock(&recBufferLock);
free(rp);
pthread_exit(NULL);
return 0; // returns something
}
void IoVorbisBlock_free(IoVorbisBlock *self)
{
vorbis_block_clear(DATA(self));
free(DATA(self));
}
S32 encode_vorbis_file(const std::string& in_fname, const std::string& out_fname)
{
#define READ_BUFFER 1024
unsigned char readbuffer[READ_BUFFER*4+44]; /* out of the data segment, not the stack */ /*Flawfinder: ignore*/
ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
vorbis_info vi; /* struct that stores all the static vorbis bitstream settings */
vorbis_comment vc; /* struct that stores all the user comments */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
int eos=0;
int result;
U16 num_channels = 0;
U32 sample_rate = 0;
U32 bits_per_sample = 0;
S32 format_error = 0;
std::string error_msg;
if ((format_error = check_for_invalid_wav_formats(in_fname, error_msg)))
{
llwarns << error_msg << ": " << in_fname << llendl;
return(format_error);
}
#if 1
unsigned char wav_header[44]; /*Flawfinder: ignore*/
S32 data_left = 0;
LLAPRFile infile ;
infile.open(in_fname,LL_APR_RB);
if (!infile.getFileHandle())
{
llwarns << "Couldn't open temporary ogg file for writing: " << in_fname
<< llendl;
return(LLVORBISENC_SOURCE_OPEN_ERR);
}
LLAPRFile outfile ;
outfile.open(out_fname,LL_APR_WPB);
if (!outfile.getFileHandle())
{
llwarns << "Couldn't open upload sound file for reading: " << in_fname
<< llendl;
return(LLVORBISENC_DEST_OPEN_ERR);
}
// parse the chunks
U32 chunk_length = 0;
U32 file_pos = 12; // start at the first chunk (usually fmt but not always)
while (infile.eof() != APR_EOF)
{
infile.seek(APR_SET,file_pos);
infile.read(wav_header, 44);
chunk_length = ((U32) wav_header[7] << 24)
+ ((U32) wav_header[6] << 16)
+ ((U32) wav_header[5] << 8)
+ wav_header[4];
// llinfos << "chunk found: '" << wav_header[0] << wav_header[1] << wav_header[2] << wav_header[3] << "'" << llendl;
if (!(strncmp((char *)&(wav_header[0]),"fmt ",4)))
{
num_channels = ((U16) wav_header[11] << 8) + wav_header[10];
sample_rate = ((U32) wav_header[15] << 24)
+ ((U32) wav_header[14] << 16)
+ ((U32) wav_header[13] << 8)
+ wav_header[12];
bits_per_sample = ((U16) wav_header[23] << 8) + wav_header[22];
}
else if (!(strncmp((char *)&(wav_header[0]),"data",4)))
{
infile.seek(APR_SET,file_pos+8);
// leave the file pointer at the beginning of the data chunk data
data_left = chunk_length;
break;
}
file_pos += (chunk_length + 8);
chunk_length = 0;
}
/********** Encode setup ************/
/* choose an encoding mode */
/* (mode 0: 44kHz stereo uncoupled, roughly 128kbps VBR) */
vorbis_info_init(&vi);
// always encode to mono
// SL-52913 & SL-53779 determined this quality level to be our 'good
// enough' general-purpose quality level with a nice low bitrate.
// Equivalent to oggenc -q0.5
F32 quality = 0.05f;
// quality = (bitrate==128000 ? 0.4f : 0.1);
// if (vorbis_encode_init(&vi, /* num_channels */ 1 ,sample_rate, -1, bitrate, -1))
if (vorbis_encode_init_vbr(&vi, /* num_channels */ 1 ,sample_rate, quality))
// if (vorbis_encode_setup_managed(&vi,1,sample_rate,-1,bitrate,-1) ||
// vorbis_encode_ctl(&vi,OV_ECTL_RATEMANAGE_AVG,NULL) ||
// vorbis_encode_setup_init(&vi))
{
llwarns << "unable to initialize vorbis codec at quality " << quality << llendl;
// llwarns << "unable to initialize vorbis codec at bitrate " << bitrate << llendl;
return(LLVORBISENC_DEST_OPEN_ERR);
}
/* add a comment */
vorbis_comment_init(&vc);
// vorbis_comment_add(&vc,"Linden");
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
/* set up our packet->stream encoder */
/* pick a random serial number; that way we can more likely build
chained streams just by concatenation */
ogg_stream_init(&os, ll_rand());
/* Vorbis streams begin with three headers; the initial header (with
most of the codec setup parameters) which is mandated by the Ogg
bitstream spec. The second header holds any comment fields. The
third header holds the bitstream codebook. We merely need to
make the headers, then pass them to libvorbis one at a time;
libvorbis handles the additional Ogg bitstream constraints */
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code);
ogg_stream_packetin(&os,&header); /* automatically placed in its own
page */
ogg_stream_packetin(&os,&header_comm);
ogg_stream_packetin(&os,&header_code);
/* We don't have to write out here, but doing so makes streaming
* much easier, so we do, flushing ALL pages. This ensures the actual
* audio data will start on a new page
*/
while(!eos){
int result=ogg_stream_flush(&os,&og);
if(result==0)break;
outfile.write(og.header, og.header_len);
outfile.write(og.body, og.body_len);
}
}
while(!eos)
{
long bytes_per_sample = bits_per_sample/8;
long bytes=(long)infile.read(readbuffer,llclamp((S32)(READ_BUFFER*num_channels*bytes_per_sample),0,data_left)); /* stereo hardwired here */
if (bytes==0)
{
/* end of file. this can be done implicitly in the mainline,
but it's easier to see here in non-clever fashion.
Tell the library we're at end of stream so that it can handle
the last frame and mark end of stream in the output properly */
vorbis_analysis_wrote(&vd,0);
// eos = 1;
}
else
{
long i;
long samples;
int temp;
data_left -= bytes;
/* data to encode */
/* expose the buffer to submit data */
float **buffer=vorbis_analysis_buffer(&vd,READ_BUFFER);
i = 0;
samples = bytes / (num_channels * bytes_per_sample);
if (num_channels == 2)
{
if (bytes_per_sample == 2)
{
/* uninterleave samples */
for(i=0; i<samples ;i++)
{
temp = ((signed char *)readbuffer)[i*4+1]; /*Flawfinder: ignore*/
temp += ((signed char *)readbuffer)[i*4+3]; /*Flawfinder: ignore*/
temp <<= 8;
temp += readbuffer[i*4];
temp += readbuffer[i*4+2];
buffer[0][i] = ((float)temp) / 65536.f;
}
}
else // presume it's 1 byte per which is unsigned (F#@%ing wav "standard")
{
/* uninterleave samples */
for(i=0; i<samples ;i++)
{
temp = readbuffer[i*2+0];
temp += readbuffer[i*2+1];
temp -= 256;
buffer[0][i] = ((float)temp) / 256.f;
}
}
}
else if (num_channels == 1)
{
if (bytes_per_sample == 2)
{
for(i=0; i < samples ;i++)
{
temp = ((signed char*)readbuffer)[i*2+1];
temp <<= 8;
temp += readbuffer[i*2];
buffer[0][i] = ((float)temp) / 32768.f;
}
}
else // presume it's 1 byte per which is unsigned (F#@%ing wav "standard")
{
for(i=0; i < samples ;i++)
{
temp = readbuffer[i];
temp -= 128;
buffer[0][i] = ((float)temp) / 128.f;
}
}
}
/* tell the library how much we actually submitted */
vorbis_analysis_wrote(&vd,i);
}
/* vorbis does some data preanalysis, then divvies up blocks for
more involved (potentially parallel) processing. Get a single
block for encoding now */
while(vorbis_analysis_blockout(&vd,&vb)==1)
{
/* analysis */
/* Do the main analysis, creating a packet */
vorbis_analysis(&vb, NULL);
vorbis_bitrate_addblock(&vb);
while(vorbis_bitrate_flushpacket(&vd, &op))
{
/* weld the packet into the bitstream */
ogg_stream_packetin(&os,&op);
/* write out pages (if any) */
while(!eos)
{
result = ogg_stream_pageout(&os,&og);
if(result==0)
break;
outfile.write(og.header, og.header_len);
outfile.write(og.body, og.body_len);
/* this could be set above, but for illustrative purposes, I do
it here (to show that vorbis does know where the stream ends) */
if(ogg_page_eos(&og))
eos=1;
}
}
}
}
/* clean up and exit. vorbis_info_clear() must be called last */
ogg_stream_clear(&os);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They're never freed or manipulated directly */
// fprintf(stderr,"Vorbis encoding: Done.\n");
llinfos << "Vorbis encoding: Done." << llendl;
#endif
return(LLVORBISENC_NOERR);
}
void deinit() {
vorbis_block_clear(&block);
vorbis_dsp_clear(&dsp_state);
vorbis_comment_clear(&comment);
vorbis_info_clear(&settings);
}
void
MediaRecorder::StopRecord(void *data)
{
nsresult rv;
PRUint32 wr;
MediaRecorder *mr = static_cast<MediaRecorder*>(data);
if (mr->v_rec) {
rv = mr->vState->backend->Stop();
if (NS_FAILED(rv)) {
NS_DispatchToMainThread(new MediaCallback(
mr->observer, "error", "could not stop video recording"
));
return;
}
}
if (mr->a_rec) {
rv = mr->aState->backend->Stop();
if (NS_FAILED(rv)) {
NS_DispatchToMainThread(new MediaCallback(
mr->observer, "error", "could not stop audio recording"
));
return;
}
}
/* Wait for encoder to finish */
if (mr->v_rec) {
mr->v_stp = PR_TRUE;
mr->vState->vPipeOut->Close();
}
if (mr->a_rec) {
mr->a_stp = PR_TRUE;
mr->aState->aPipeOut->Close();
}
PR_JoinThread(mr->thread);
if (mr->v_rec) {
mr->vState->vPipeIn->Close();
th_encode_free(mr->vState->th);
/* Video trailer */
if (ogg_stream_flush(&mr->vState->os, &mr->vState->og)) {
rv = mr->WriteData(
mr->vState->og.header, mr->vState->og.header_len, &wr
);
rv = mr->WriteData(
mr->vState->og.body, mr->vState->og.body_len, &wr
);
}
ogg_stream_clear(&mr->vState->os);
mr->v_rec = PR_FALSE;
}
if (mr->a_rec) {
mr->aState->aPipeIn->Close();
/* Audio trailer */
vorbis_analysis_wrote(&mr->aState->vd, 0);
mr->WriteAudio();
vorbis_block_clear(&mr->aState->vb);
vorbis_dsp_clear(&mr->aState->vd);
vorbis_comment_clear(&mr->aState->vc);
vorbis_info_clear(&mr->aState->vi);
ogg_stream_clear(&mr->aState->os);
mr->a_rec = PR_FALSE;
}
/* GG */
mr->pipeStream->Close();
NS_DispatchToMainThread(new MediaCallback(
mr->observer, "stopped", ""
));
return;
}
static int decode(quicktime_t *file,
int16_t *output_i,
float *output_f,
long samples,
int track,
int channel)
{
int result = 0;
int bytes;
int i, j;
quicktime_audio_map_t *track_map = &(file->atracks[track]);
quicktime_trak_t *trak = track_map->track;
quicktime_vorbis_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
long current_position = track_map->current_position;
long end_position = current_position + samples;
unsigned char *buffer;
// End of data in ogg buffer
int eos = 0;
// End of file
int eof = 0;
float *pcm;
int have_chunk = 0;
if(samples > OUTPUT_ALLOCATION)
printf("vorbis.c decode: can't read more than %p samples at a time.\n", OUTPUT_ALLOCATION);
if(output_i) bzero(output_i, sizeof(int16_t) * samples);
if(output_f) bzero(output_f, sizeof(float) * samples);
// Seeked outside output buffer's range or not initialized: restart
if(current_position < codec->output_position - codec->output_size ||
current_position > codec->output_position ||
!codec->decode_initialized)
{
quicktime_chunk_of_sample(&codec->output_position,
&codec->chunk,
trak,
current_position);
// We know the first ogg packet in the chunk has a pcm_offset from the encoding.
codec->output_size = 0;
codec->output_end = 0;
codec->chunk_samples = 0;
// Initialize and load initial buffer for decoding
if(!codec->decode_initialized)
{
int init_chunk = 1;
codec->decode_initialized = 1;
codec->output = malloc(sizeof(float*) * track_map->channels);
for(i = 0; i < track_map->channels; i++)
{
codec->output[i] = malloc(sizeof(float) * OUTPUT_ALLOCATION);
}
codec->output_allocated = OUTPUT_ALLOCATION;
ogg_sync_init(&codec->dec_oy); /* Now we can read pages */
READ_CHUNK(init_chunk);
init_chunk++;
if(ogg_sync_pageout(&codec->dec_oy, &codec->dec_og)!=1)
{
fprintf(stderr, "decode: ogg_sync_pageout: Must not be Vorbis data\n");
return 1;
}
ogg_stream_init(&codec->dec_os, ogg_page_serialno(&codec->dec_og));
vorbis_info_init(&codec->dec_vi);
vorbis_comment_init(&codec->dec_vc);
if(ogg_stream_pagein(&codec->dec_os, &codec->dec_og) < 0)
{
fprintf(stderr,"decode: ogg_stream_pagein: stream version mismatch perhaps.\n");
return 1;
}
if(ogg_stream_packetout(&codec->dec_os, &codec->dec_op) != 1)
{
fprintf(stderr, "decode: ogg_stream_packetout: Must not be Vorbis data\n");
return 1;
}
if(vorbis_synthesis_headerin(&codec->dec_vi, &codec->dec_vc, &codec->dec_op) < 0)
{
fprintf(stderr, "decode: vorbis_synthesis_headerin: not a vorbis header\n");
return 1;
}
i = 0;
while(i < 2)
{
while(i < 2)
{
result = ogg_sync_pageout(&codec->dec_oy, &codec->dec_og);
if(result == 0) break;
if(result == 1)
{
ogg_stream_pagein(&codec->dec_os, &codec->dec_og);
while(i < 2)
{
result = ogg_stream_packetout(&codec->dec_os, &codec->dec_op);
if(result == 0) break;
if(result < 0)
{
fprintf(stderr, "decode: ogg_stream_packetout: corrupt secondary header\n");
return 1;
}
vorbis_synthesis_headerin(&codec->dec_vi, &codec->dec_vc, &codec->dec_op);
i++;
}
}
}
if(i < 2)
{
READ_CHUNK(init_chunk);
init_chunk++;
}
// Header should never span more than one chunk so assume it's done here
}
vorbis_synthesis_init(&codec->dec_vd, &codec->dec_vi);
vorbis_block_init(&codec->dec_vd, &codec->dec_vb);
// Also the first chunk needed in decoding so don't reread after this.
if(codec->chunk == init_chunk - 1)
{
have_chunk = 1;
codec->chunk++;
}
}
// Don't already have initial chunk from header
if(!have_chunk)
{
// Get initial chunk for decoding at new location
// From vorbisfile.c
/* clear out decoding machine state */
ogg_stream_clear(&codec->dec_os);
vorbis_dsp_clear(&codec->dec_vd);
vorbis_block_clear(&codec->dec_vb);
ogg_sync_reset(&codec->dec_oy);
ogg_stream_init(&codec->dec_os, ogg_page_serialno(&codec->dec_og));
ogg_sync_init(&codec->dec_oy);
vorbis_synthesis_init(&codec->dec_vd, &codec->dec_vi);
vorbis_block_init(&codec->dec_vd, &codec->dec_vb);
READ_CHUNK(codec->chunk);
codec->chunk++;
have_chunk = 1;
}
}
// Assume the chunk exists by now and rely on libogg to say if it's out of
// data.
have_chunk = 1;
// Read chunks until output buffer is on or after end_position
result = 0;
while(codec->output_position < end_position)
{
// Read chunk to decode if it hasn't been read yet.
if(!have_chunk)
{
codec->chunk_samples = 0;
READ_CHUNK(codec->chunk);
if(result) break;
codec->chunk++;
}
eos = 0;
while(!eos)
{
result = ogg_sync_pageout(&codec->dec_oy, &codec->dec_og);
// Need more data from chunk
if(result == 0)
{
// End of chunk
eos = 1;
}
else
// This stage checks for OggS and a checksum error.
// It doesn't tell if it's the end of a chunk. Need to manually parse OggS
// pages to figure out how big the chunk is.
if(result < 0)
{
//printf("ogg_sync_pageout=-1\n");
;
}
else
{
ogg_stream_pagein(&codec->dec_os, &codec->dec_og);
while(!eos)
{
//printf("decode 7\n");
result = ogg_stream_packetout(&codec->dec_os, &codec->dec_op);
//printf("decode 8 %d\n", result);
if(result == 0)
{
//printf("ogg_stream_packetout=0\n");
// End of page
eos = 1;
}
else
// This stage doesn't check for OggS.
if(result < 0)
{
//printf("ogg_stream_packetout=-1\n");
}
else
{
float **pcm;
if(vorbis_synthesis(&codec->dec_vb, &codec->dec_op) == 0)
{
vorbis_synthesis_blockin(&codec->dec_vd,
&codec->dec_vb);
}
while((result = vorbis_synthesis_pcmout(&codec->dec_vd, &pcm)) > 0)
{
//printf("vorbis_synthesis_pcmout=%x\n", result);
for(i = 0; i < track_map->channels; i++)
{
float *output_channel = codec->output[i];
float *input_channel = pcm[i];
int k = codec->output_end;
for(j = 0; j < result; j++)
{
output_channel[k++] = input_channel[j];
if(k >= codec->output_allocated)
k = 0;
}
if(i == track_map->channels - 1)
codec->output_end = k;
}
//printf("codec->output_end = %d\n", codec->output_end);
codec->output_position += result;
codec->output_size += result;
codec->chunk_samples += result;
if(codec->output_size > codec->output_allocated)
codec->output_size = codec->output_allocated;
vorbis_synthesis_read(&codec->dec_vd, result);
}
}
//printf("decode 11\n");
}
// Reset end of page so it isn't interpreted as an end of chunk
eos = 0;
}
}
// Next chunk
if(eos)
{
//printf("decode 12 got=%x\n", codec->chunk_samples);
have_chunk = 0;
}
}
// Fill silence
while(codec->output_position < end_position)
{
for(i = 0; i < track_map->channels; i++)
codec->output[i][codec->output_end] = 0;
codec->output_end++;
if(codec->output_end >= codec->output_allocated)
codec->output_end = 0;
codec->output_position++;
}
//printf("decode 15\n");
//printf("decode 2 codec->output_position=%lld codec->output_end=%d codec->output_size=%d\n",
// codec->output_position, codec->output_end, codec->output_size);
current_position = track_map->current_position;
i = codec->output_end - (codec->output_position - current_position);
j = 0;
while(i < 0) i += codec->output_allocated;
pcm = codec->output[channel];
if(output_i)
{
for( ; j < samples; j++)
{
int sample = pcm[i] * 32767;
CLAMP(sample, -32768, 32767);
output_i[j] = sample;
i++;
if(i >= codec->output_allocated) i = 0;
}
}
else
if(output_f)
{
for( ; j < samples; j++)
{
output_f[j] = pcm[i];
i++;
if(i >= codec->output_allocated) i = 0;
}
}
//printf("decode 16\n");
return 0;
}