/* DISCLAIMER:

 * This code sample is governed by the Microsoft Permissive License as defined at 

http://www.microsoft.com/resources/sharedsource/licensingbasics/permissivelicense.mspx.

 * (c) 2007 Microsoft Corporation.  All rights reserved.

*/

using System;
using Microsoft.SpeechServer.Common.Wave;
using System.IO;
using System.Data.SqlClient;

namespace ConsoleApplication1
{
    class Program
    {
        private const int RIFF_CHUNKS_BYTE_SIZE = 46;
        
        static void Main(string[] args)
        {
            if (args != null && args.Length < 3)
            {
                Console.WriteLine("Three parameters are required: <database name> <'reco' | 'prompt'> <audio stream database ID>");
                return;
            }

            String dbName = args[0];
            
            String audioType = args[1];
            if (audioType != "reco" && audioType != "prompt")
            {
                Console.WriteLine(String.Format("I don't know audio type: {0}", audioType));
                return;
            }
            
            int id;
            if (!int.TryParse(args[2], out id))
            {
                Console.WriteLine("Could not parse audio stream ID");
                return;
            }



            string filePath = audioType + "_" + id + ".wav";
            
            WavGenerator wavGenerator = new WavGenerator();


            byte[] formatArray;
            byte[] audioArray;
            // Get raw audio from database
            GetDBAudioReco(dbName, audioType, id, out formatArray, out audioArray);

            
            byte[] normalizedAudioData = null;
            bool bArrayHasRiffHeader = false;
            wavGenerator.GetNormalizedAudioReco(id, 
                                                audioArray, 
                                                formatArray, 
                                                out normalizedAudioData, 
                                                out bArrayHasRiffHeader);

            if (bArrayHasRiffHeader)
            {
                // Don't include RIFF chunks
                wavGenerator.WriteArrayToFile(normalizedAudioData, 
                                              RIFF_CHUNKS_BYTE_SIZE, 
                                              normalizedAudioData.Length - RIFF_CHUNKS_BYTE_SIZE, 
                                              filePath);
            }
            else
            {
                wavGenerator.WriteArrayToFile(normalizedAudioData, 
                                              0, 
                                              normalizedAudioData.Length, 
                                              filePath);
            }

            Console.WriteLine("Created File: " + filePath);
        }

        private static void GetDBAudioReco(string dbName,
                                           String audioType,
                                           long requestId,
                                           out byte[] formatArray,
                                           out byte[] audioArray)
        {
            string connectionString = "Initial Catalog=" + dbName + ";Data Source=localhost;Integrated Security=SSPI;";

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                String dataString = "SELECT [Data] FROM {0} WHERE {1} = " + requestId;
                String formatString = "SELECT [AudioFormat] FROM {0} WHERE {1} = " + requestId;
                String fromData;
                String fromFormat;
                String where;
                if (audioType == "prompt")
                {
                    fromData = "[dbo].[PromptAudioData]";
                    fromFormat = "[dbo].[PromptAudio]";
                    where = "[PromptRequestId]";
                }
                else
                {
                    fromData = "[dbo].[EngineRecoAudioData]";
                    fromFormat = "[dbo].[EngineRecoAudio]";
                    where = "[SpeechRequestId]";
                }

                String dataSqlCmd = String.Format(dataString, fromData, where);
                String formatSqlCmd = String.Format(formatString, fromFormat, where);

                using (SqlCommand sqlCmd = new SqlCommand())
                {
                    sqlCmd.Connection = connection;

                    // Retrieve Audio Data
                    sqlCmd.CommandText = dataSqlCmd;
                    audioArray = sqlCmd.ExecuteScalar() as byte[];

                    // Retrieve Audio Format
                    sqlCmd.CommandText = formatSqlCmd;
                    formatArray = sqlCmd.ExecuteScalar() as byte[];
                }
            }
        }


    }

    public class WavGenerator
    {
        public void WriteArrayToFile(byte[] audioArray, int startOffset, int cBytesToWrite, string fileName)
        {
			using ( FileStream fileStream = new FileStream( fileName, FileMode.Create, FileAccess.ReadWrite ) )
			{
                WaveWriter waveWriter = null;
				WaveFormat newFormat;

				newFormat = new WaveFormat(WaveFormatTags.WaveFormatPcm);
				waveWriter = new WaveWriter(fileStream, newFormat, true, new MemoryStream(0x400));
				waveWriter.Write(audioArray, startOffset, cBytesToWrite);
				waveWriter.Close();
			}
        }


        public void GetNormalizedAudioReco(long requestId,
                                           byte[] audioData,
                                           byte[] formatArray,
                                           out byte[] audioArray,
                                           out bool bArrayHasRiffHeader)
        {
            // 2 - Convert to 16-bit 8 kHz PCM
            WaveFormat waveFormat;
            byte[] newAudioArray = null;

            waveFormat = new WaveFormat(formatArray);
            if (waveFormat.FormatTag == WaveFormatTags.WaveFormatPcm)
            {
                // Data is already correct format, no conversion is required
                audioArray = audioData;
                bArrayHasRiffHeader = false;
            }
            else if (waveFormat.FormatTag == WaveFormatTags.WaveFormatPcmWithMetadata)
            {
                // Strip out the reco engine meta-data
                ConvertAudioToPCM(waveFormat, audioData, out newAudioArray);
                audioArray = newAudioArray;
                bArrayHasRiffHeader = true;
            }
            else if (waveFormat.FormatTag == WaveFormatTags.WaveFormatMuLaw)
            {
                // Decompress uLaw to PCM
                ConvertULawToPCM(audioData, out newAudioArray);
                audioArray = newAudioArray;
                bArrayHasRiffHeader = false;
            }
            else
            {
                audioArray = null;
                bArrayHasRiffHeader = false;
                // Handle this Error
            }
        }

        private void ConvertAudioToPCM(WaveFormat waveFormat, byte[] src, out byte[] dest)
        {
            MemoryStream audioStream;
            WaveWriter waveObj;

            // Convert audio to stream
            waveObj = new WaveWriter(new MemoryStream(0x0400),
                                                waveFormat,
                                                true,
                                                new MemoryStream(0x400));
            {
                waveObj.Write(src, 0, src.Length);
                audioStream = (MemoryStream)(waveObj.BaseStream);
                waveObj.Flush();
                dest = audioStream.ToArray();
            }
        }

        private void ConvertULawToPCM(byte[] srcData, out byte[] destData)
        {
            byte[] newData = null;

            if ((srcData == null) || (srcData.Length == 0))
            {
                // Handle Error
            }
            else
            {
                newData = new byte[srcData.Length * 2];
                for (int i = 0, j = 0; i < srcData.Length; i++, j += 2)
                {
                    int sample;

                    // Lookup PCM sample 
                    sample = ULawToPCM[srcData[i]];

                    // Save out as bytes
                    //
                    // Slow way to do this. Should use unsafe pointers or
                    // at least convert lookup table to bytes
                    newData[j] = (byte)(sample & 0xFF);
                    newData[j + 1] = (byte)((sample >> 8) & 0xFF);
                }
            }

            // Return result array to caller
            destData = newData;
        }

        static readonly private int[] ULawToPCM = new int[256]
        {
            -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
            -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
            -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
            -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
            -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
            -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
            -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
            -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
            -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
            -1372, -1308, -1244, -1180, -1116, -1052,  -988,  -924,
            -876,  -844,  -812,  -780,  -748,  -716,  -684,  -652,
            -620,  -588,  -556,  -524,  -492,  -460,  -428,  -396,
            -372,  -356,  -340,  -324,  -308,  -292,  -276,  -260,
            -244,  -228,  -212,  -196,  -180,  -164,  -148,  -132,
            -120,  -112,  -104,   -96,   -88,   -80,   -72,   -64,
            -56,   -48,   -40,   -32,   -24,   -16,    -8,     0,
            32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
            23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
            15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
            11900, 11388, 10876, 10364,  9852,  9340,  8828,  8316,
            7932,  7676,  7420,  7164,  6908,  6652,  6396,  6140,
            5884,  5628,  5372,  5116,  4860,  4604,  4348,  4092,
            3900,  3772,  3644,  3516,  3388,  3260,  3132,  3004,
            2876,  2748,  2620,  2492,  2364,  2236,  2108,  1980,
            1884,  1820,  1756,  1692,  1628,  1564,  1500,  1436,
            1372,  1308,  1244,  1180,  1116,  1052,   988,   924,
            876,   844,   812,   780,   748,   716,   684,   652,
            620,   588,   556,   524,   492,   460,   428,   396,
            372,   356,   340,   324,   308,   292,   276,   260,
            244,   228,   212,   196,   180,   164,   148,   132,
            120,   112,   104,    96,    88,    80,    72,    64,
            56,    48,    40,    32,    24,    16,     8,     0
        };

    }
}