1 files changed, 505 insertions, 0 deletions

diff --git a/linden/indra/llaudio/llvorbisencode.cpp b/linden/indra/llaudio/llvorbisencode.cpp
new file mode 100644
index 0000000..a24394d
--- /dev/null
+++ b/linden/indra/llaudio/llvorbisencode.cpp
@@ -0,0 +1,505 @@
+/** 
+ * @file vorbisencode.cpp
+ * @brief Vorbis encoding routine routine for Indra.
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "vorbis/vorbisenc.h"
+
+#include "llvorbisencode.h"
+#include "llerror.h"
+#include "llrand.h"
+#include "llmath.h"
+#include "llapr.h"
+
+//#if LL_DARWIN
+// MBW -- XXX -- Getting rid of SecondLifeVorbis for now -- no fmod means no name collisions.
+#if 0
+#include "VorbisFramework.h"
+
+#define vorbis_analysis                         mac_vorbis_analysis
+#define vorbis_analysis_headerout       mac_vorbis_analysis_headerout
+#define vorbis_analysis_init            mac_vorbis_analysis_init
+#define vorbis_encode_ctl                       mac_vorbis_encode_ctl
+#define vorbis_encode_setup_init        mac_vorbis_encode_setup_init
+#define vorbis_encode_setup_managed     mac_vorbis_encode_setup_managed
+
+#define vorbis_info_init                        mac_vorbis_info_init
+#define vorbis_info_clear                       mac_vorbis_info_clear
+#define vorbis_comment_init                     mac_vorbis_comment_init
+#define vorbis_comment_clear            mac_vorbis_comment_clear
+#define vorbis_block_init                       mac_vorbis_block_init
+#define vorbis_block_clear                      mac_vorbis_block_clear
+#define vorbis_dsp_clear                        mac_vorbis_dsp_clear
+#define vorbis_analysis_buffer          mac_vorbis_analysis_buffer
+#define vorbis_analysis_wrote           mac_vorbis_analysis_wrote
+#define vorbis_analysis_blockout        mac_vorbis_analysis_blockout
+
+#define ogg_stream_packetin                     mac_ogg_stream_packetin
+#define ogg_stream_init                         mac_ogg_stream_init
+#define ogg_stream_flush                        mac_ogg_stream_flush
+#define ogg_stream_pageout                      mac_ogg_stream_pageout
+#define ogg_page_eos                            mac_ogg_page_eos
+#define ogg_stream_clear                        mac_ogg_stream_clear
+
+#endif
+
+S32 check_for_invalid_wav_formats(const std::string& in_fname, std::string& error_msg)
+{
+        U16 num_channels = 0;
+        U32 sample_rate = 0;
+        U32 bits_per_sample = 0;
+        U32 physical_file_size = 0;
+        U32 chunk_length = 0;
+        U32 raw_data_length = 0;
+        U32 bytes_per_sec = 0;
+        BOOL uncompressed_pcm = FALSE;
+
+        unsigned char wav_header[44];           /*Flawfinder: ignore*/
+
+        error_msg.clear();
+
+        //********************************
+        LLAPRFile infile ;
+    infile.open(in_fname,LL_APR_RB, LLAPRFile::global);
+        //********************************
+        if (!infile.getFileHandle())
+        {
+                error_msg = "CannotUploadSoundFile";
+                return(LLVORBISENC_SOURCE_OPEN_ERR);
+        }
+
+        infile.read(wav_header, 44);
+        physical_file_size = infile.seek(APR_END,0);
+
+        if (strncmp((char *)&(wav_header[0]),"RIFF",4))
+        {
+                error_msg = "SoundFileNotRIFF";
+                return(LLVORBISENC_WAV_FORMAT_ERR);
+        }
+
+        if (strncmp((char *)&(wav_header[8]),"WAVE",4))
+        {
+                error_msg = "SoundFileNotRIFF";
+                return(LLVORBISENC_WAV_FORMAT_ERR);
+        }
+        
+        // parse the chunks
+        
+        U32 file_pos = 12;  // start at the first chunk (usually fmt but not always)
+        
+        while ((file_pos + 8)< physical_file_size)
+        {
+                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)))
+                {
+                        if ((wav_header[8] == 0x01) && (wav_header[9] == 0x00))
+                        {
+                                uncompressed_pcm = TRUE;
+                        }
+                        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];
+                        bytes_per_sec = ((U32) wav_header[19] << 24) 
+                                + ((U32) wav_header[18] << 16) 
+                                + ((U32) wav_header[17] << 8) 
+                                + wav_header[16];
+                }
+                else if (!(strncmp((char *)&(wav_header[0]),"data",4)))
+                {
+                        raw_data_length = chunk_length;                 
+                }
+                file_pos += (chunk_length + 8);
+                chunk_length = 0;
+        } 
+        //****************
+        infile.close();
+        //****************
+
+        if (!uncompressed_pcm)
+        {       
+                 error_msg = "SoundFileNotPCM";
+                  return(LLVORBISENC_PCM_FORMAT_ERR);
+        }
+        
+        if ((num_channels < 1) || (num_channels > LLVORBIS_CLIP_MAX_CHANNELS))
+        {       
+                error_msg = "SoundFileInvalidChannelCount";
+                return(LLVORBISENC_MULTICHANNEL_ERR);
+        }
+
+        if (sample_rate != LLVORBIS_CLIP_SAMPLE_RATE)
+        {       
+                error_msg = "SoundFileInvalidSampleRate";
+                return(LLVORBISENC_UNSUPPORTED_SAMPLE_RATE);
+        }
+        
+        if ((bits_per_sample != 16) && (bits_per_sample != 8))
+        {                
+                error_msg = "SoundFileInvalidWordSize";
+                return(LLVORBISENC_UNSUPPORTED_WORD_SIZE);
+        }
+
+        if (!raw_data_length)
+        {
+                error_msg = "SoundFileInvalidHeader";
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+        F32 clip_length = (F32)raw_data_length/(F32)bytes_per_sec;
+                
+        if (clip_length > LLVORBIS_CLIP_MAX_TIME)
+        {
+                error_msg = "SoundFileInvalidTooLong";
+                return(LLVORBISENC_CLIP_TOO_LONG);               
+        }
+
+    return(LLVORBISENC_NOERR);
+}
+
+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, LLAPRFile::global);
+        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, LLAPRFile::global);
+        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);
+         
+}