Second Life viewer sources 1.13.2.12

1 files changed, 321 insertions, 0 deletions

diff --git a/linden/indra/llaudio/vorbisdecode.cpp b/linden/indra/llaudio/vorbisdecode.cpp
new file mode 100644
index 0000000..4308b71
--- /dev/null
+++ b/linden/indra/llaudio/vorbisdecode.cpp
@@ -0,0 +1,321 @@
+/** 
+ * @file vorbisdecode.cpp
+ * @brief Vorbis decoding routine routine for Indra.
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#include "linden_common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "vorbis/codec.h"
+#include "vorbis/vorbisfile.h"
+#include "llerror.h"
+#include "llmath.h"
+#include "llvfile.h"
+
+#if 0
+
+size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        if (size > 0 && file->read((U8*)ptr, size * nmemb))     /*Flawfinder: ignore*/
+        {
+                S32 read = file->getLastBytesRead();
+                return  read / size;    /*Flawfinder: ignore*/
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+int vfs_seek(void *datasource, ogg_int64_t offset, int whence)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        // vfs has 31-bit files
+        if (offset > S32_MAX)
+        {
+                return -1;
+        }
+
+        S32 origin;
+        switch (whence) {
+        case SEEK_SET:
+                origin = 0;
+                break;
+        case SEEK_END:
+                origin = file->getSize();
+                break;
+        case SEEK_CUR:
+                origin = -1;
+                break;
+        default:
+                llerrs << "Invalid whence argument to vfs_seek" << llendl;
+                return -1;
+        }
+
+        if (file->seek((S32)offset, origin))
+        {
+                return 0;
+        }
+        else
+        {
+                return -1;
+        }
+}
+
+int vfs_close (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        delete file;
+
+        return 0;
+}
+
+long vfs_tell (void *datasource)
+{
+        LLVFile *file = (LLVFile *)datasource;
+
+        return file->tell();
+}
+
+
+BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname)
+{
+        ov_callbacks vfs_callbacks;
+        vfs_callbacks.read_func = vfs_read;
+        vfs_callbacks.seek_func = vfs_seek;
+        vfs_callbacks.close_func = vfs_close;
+        vfs_callbacks.tell_func = vfs_tell;
+
+        char pcmout[4096]; /*Flawfinder: ignore*/
+
+        unsigned char temp[64]; /*Flawfinder: ignore*/
+
+        LLVFile *in_vfile;
+
+        U32 data_length = 0;
+
+        llinfos << "Vorbis decode from vfile: " << in_uuid << llendl;
+
+        in_vfile = new LLVFile(vfs, in_uuid, LLAssetType::AT_SOUND);
+        if (! in_vfile->getSize())
+        {
+                llwarning("unable to open vorbis source vfile for reading",0);
+                return(FALSE);
+        }
+        apr_file_t* outfp = ll_apr_file_open(out_fname,LL_APR_WPB);
+        if (!outfp)
+        {
+                llwarning("unable to open vorbis destination file for writing",0);
+                return(FALSE);          
+        }
+        else
+        {
+                // write the .wav format header
+                //"RIFF"
+                temp[0] = 0x52;
+                temp[1] = 0x49;
+                temp[2] = 0x46;
+                temp[3] = 0x46;
+                
+                // length = datalen + 36 (to be filled in later)
+                temp[4] = 0x00;
+                temp[5] = 0x00;
+                temp[6] = 0x00;
+                temp[7] = 0x00;
+                
+                //"WAVE"
+                temp[8] = 0x57;
+                temp[9] = 0x41;
+                temp[10] = 0x56;
+                temp[11] = 0x45;
+
+                // "fmt "
+                temp[12] = 0x66;
+                temp[13] = 0x6D;
+                temp[14] = 0x74;
+                temp[15] = 0x20;
+
+                // chunk size = 16
+                temp[16] = 0x10;
+                temp[17] = 0x00;
+                temp[18] = 0x00;
+                temp[19] = 0x00;
+
+                // format (1 = PCM)
+                temp[20] = 0x01;
+                temp[21] = 0x00;
+
+                // number of channels
+                temp[22] = 0x01;
+                temp[23] = 0x00;
+
+                // samples per second
+                temp[24] = 0x44;
+                temp[25] = 0xAC;
+                temp[26] = 0x00;
+                temp[27] = 0x00;
+
+                // average bytes per second
+                temp[28] = 0x88;
+                temp[29] = 0x58;
+                temp[30] = 0x01;
+                temp[31] = 0x00;
+
+                // bytes to output at a single time
+                temp[32] = 0x02;
+                temp[33] = 0x00;
+                 
+                // 16 bits per sample
+                temp[34] = 0x10;
+                temp[35] = 0x00;
+
+                // "data"
+                temp[36] = 0x64;
+                temp[37] = 0x61;
+                temp[38] = 0x74;
+                temp[39] = 0x61;
+
+
+                // these are the length of the data chunk, to be filled in later
+                temp[40] = 0x00;
+                temp[41] = 0x00;
+                temp[42] = 0x00;
+                temp[43] = 0x00;
+
+
+                ll_apr_file_write(outfp, temp, 44);
+        }
+
+        OggVorbis_File vf;
+        int eof=0;
+        int current_section;
+ 
+        int r = ov_open_callbacks(in_vfile, &vf, NULL, 0, vfs_callbacks);
+        if(r < 0) 
+        {
+                llwarns << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << in_uuid << llendl;
+                return(FALSE);
+        }
+
+        {
+                char **ptr=ov_comment(&vf,-1)->user_comments;
+//              vorbis_info *vi=ov_info(&vf,-1);
+                while(*ptr){
+                        fprintf(stderr,"%s\n",*ptr);
+                        ++ptr;
+                }
+//    fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate);
+//    fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1));
+//    fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor);
+        }
+  
+        while(!eof){
+                long ret=ov_read(&vf,pcmout,sizeof(pcmout),0,2,1,&current_section);
+                if (ret == 0) {
+                        /* EOF */
+                        eof=1;
+//                      llinfos << "Vorbis EOF" << llendl;
+                } else if (ret < 0) {
+                        /* error in the stream.  Not a problem, just reporting it in
+                           case we (the app) cares.  In this case, we don't. */
+                        llwarning("Error in vorbis stream",0); 
+                        break;
+
+                } else {
+//                      llinfos << "Vorbis read " << ret << "bytes" << llendl;
+                        /* we don't bother dealing with sample rate changes, etc, but.
+                           you'll have to*/
+                        data_length += ll_apr_file_write(outfp, pcmout, ret);
+                }
+        }
+
+        ov_clear(&vf);
+  
+        // write "data" chunk length
+        ll_apr_file_seek(outfp,APR_SET,40);
+        ll_apr_file_write(outfp,&data_length,4);
+ 
+        // write overall "RIFF" length
+        data_length += 36;
+        ll_apr_file_seek(outfp,APR_SET,4);
+        ll_apr_file_write(outfp,&data_length,1*4);
+
+        // FUCK!!! Vorbis encode/decode messes up loop point transitions (pop)
+        // do a cheap-and-cheesy crossfade 
+        
+
+        S16 *samplep;
+        S32 i;
+        S32 fade_length;
+
+        fade_length = llmin((S32)128,(S32)(data_length-36)/8);
+        
+        ll_apr_file_seek(outfp,APR_SET,44);
+        ll_apr_file_read(outfp, pcmout,2*fade_length);  //read first 16 samples
+
+        samplep = (S16 *)pcmout;
+
+        for (i = 0 ;i < fade_length; i++)
+        {
+                *samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));          
+        }
+        
+        ll_apr_file_seek(outfp,APR_SET,44);
+        ll_apr_file_write(outfp,pcmout,2*fade_length);  //write back xfaded first 16 samples
+
+        ll_apr_file_seek(outfp,APR_END,-fade_length*2); 
+        ll_apr_file_read(outfp, pcmout,2*fade_length);  //read last 16 samples
+
+        samplep = (S16 *)pcmout;
+
+        for (i = fade_length-1 ; i >=  0; i--)
+        {
+                *samplep++ = ((F32)*samplep * ((F32)i/(F32)fade_length));          
+        }
+        
+        ll_apr_file_seek(outfp,SEEK_END,-fade_length*2); 
+        ll_apr_file_write(outfp,pcmout,2*fade_length);  //write back xfaded last 16 samples
+
+        apr_file_close(outfp);
+
+        if ((36 == data_length) || (!(eof)))
+        {
+                llwarning("BAD Vorbis DECODE!, removing .wav!",0); 
+                LLFile::remove(out_fname);
+                return (FALSE);
+        }
+    
+//      fprintf(stderr,"Done.\n");
+
+        return(TRUE);
+}
+#endif