Example #1
0
 private void WriteWaveHeader(StreamMarshaler sm)
 {
     char[] array = new char[4]
     {
         'R',
         'I',
         'F',
         'F'
     };
     byte[] array2 = _audioFormat.FormatSpecificData();
     sm.WriteArray(array, array.Length);
     sm.WriteStream((uint)(_rawAudioData.Length + 38 + array2.Length));
     char[] array3 = new char[4]
     {
         'W',
         'A',
         'V',
         'E'
     };
     sm.WriteArray(array3, array3.Length);
     char[] array4 = new char[4]
     {
         'f',
         'm',
         't',
         ' '
     };
     sm.WriteArray(array4, array4.Length);
     sm.WriteStream(18 + array2.Length);
     sm.WriteStream((ushort)_audioFormat.EncodingFormat);
     sm.WriteStream((ushort)_audioFormat.ChannelCount);
     sm.WriteStream(_audioFormat.SamplesPerSecond);
     sm.WriteStream(_audioFormat.AverageBytesPerSecond);
     sm.WriteStream((ushort)_audioFormat.BlockAlign);
     sm.WriteStream((ushort)_audioFormat.BitsPerSample);
     sm.WriteStream((ushort)array2.Length);
     if (array2.Length != 0)
     {
         sm.WriteStream(array2);
     }
     char[] array5 = new char[4]
     {
         'd',
         'a',
         't',
         'a'
     };
     sm.WriteArray(array5, array5.Length);
     sm.WriteStream(_rawAudioData.Length);
 }
        private void WriteWaveHeader(StreamMarshaler sm)
        {
            char[] riff = new char[4] {
                'R', 'I', 'F', 'F'
            };
            byte[] formatSpecificData = _audioFormat.FormatSpecificData();
            sm.WriteArray <char>(riff, riff.Length);

            sm.WriteStream((uint)(_rawAudioData.Length + 38 + formatSpecificData.Length)); // Must be four bytes

            char[] wave = new char[4] {
                'W', 'A', 'V', 'E'
            };
            sm.WriteArray(wave, wave.Length);

            char[] fmt = new char[4] {
                'f', 'm', 't', ' '
            };
            sm.WriteArray(fmt, fmt.Length);

            sm.WriteStream(18 + formatSpecificData.Length);

            sm.WriteStream((ushort)_audioFormat.EncodingFormat);
            sm.WriteStream((ushort)_audioFormat.ChannelCount);
            sm.WriteStream(_audioFormat.SamplesPerSecond);
            sm.WriteStream(_audioFormat.AverageBytesPerSecond);
            sm.WriteStream((ushort)_audioFormat.BlockAlign);
            sm.WriteStream((ushort)_audioFormat.BitsPerSample);
            sm.WriteStream((ushort)formatSpecificData.Length);

            // write codec specific data
            if (formatSpecificData.Length > 0)
            {
                sm.WriteStream(formatSpecificData);
            }

            char[] data = new char[4] {
                'd', 'a', 't', 'a'
            };
            sm.WriteArray(data, data.Length);
            sm.WriteStream(_rawAudioData.Length);
        }
Example #3
0
        internal void Commit(StreamMarshaler streamBuffer)
        {
            long         position = streamBuffer.Stream.Position;
            List <State> list     = new List <State>(_states);

            _states = null;
            list.Sort();
            ValidateAndTagRules();
            CheckLeftRecursion(list);
            int num    = (_basePath != null) ? (_basePath.Length + 1) : 0;
            int idWord = 0;

            if (_globalTags.Count > 0)
            {
                StringBuilder stringBuilder = new StringBuilder();
                foreach (string globalTag in _globalTags)
                {
                    stringBuilder.Append(globalTag);
                }
                _symbols.Add(stringBuilder.ToString(), out idWord);
                idWord = _symbols.OffsetFromId(idWord);
                if (idWord > 65535)
                {
                    throw new OverflowException(SR.Get(SRID.TooManyRulesWithSemanticsGlobals));
                }
            }
            foreach (ScriptRef scriptRef in _scriptRefs)
            {
                _symbols.Add(scriptRef._sMethod, out scriptRef._idSymbol);
            }
            int cArcs;

            float[] pWeights;
            CfgGrammar.CfgSerializedHeader o = BuildHeader(list, num, (ushort)idWord, out cArcs, out pWeights);
            streamBuffer.WriteStream(o);
            streamBuffer.WriteArrayChar(_words.SerializeData(), _words.SerializeSize());
            streamBuffer.WriteArrayChar(_symbols.SerializeData(), _symbols.SerializeSize());
            foreach (Rule rule in _rules)
            {
                rule.Serialize(streamBuffer);
            }
            if (num > 0)
            {
                streamBuffer.WriteArrayChar(_basePath.ToCharArray(), _basePath.Length);
                streamBuffer.WriteArrayChar(_achZero, 1);
                streamBuffer.WriteArray(_abZero3, (num * 2) & 3);
            }
            streamBuffer.WriteStream(default(CfgArc));
            int  iOffset    = 1;
            uint iArcOffset = 1u;
            bool flag       = (GrammarOptions & GrammarOptions.MssV1) == GrammarOptions.MssV1;

            foreach (State item in list)
            {
                item.SerializeStateEntries(streamBuffer, flag, pWeights, ref iArcOffset, ref iOffset);
            }
            if (_fNeedWeightTable)
            {
                streamBuffer.WriteArray(pWeights, cArcs);
            }
            if (!flag)
            {
                foreach (State item2 in list)
                {
                    item2.SetEndArcIndexForTags();
                }
            }
            for (int num2 = _tags.Count - 1; num2 >= 0; num2--)
            {
                if (_tags[num2]._cfgTag.ArcIndex == 0)
                {
                    _tags.RemoveAt(num2);
                }
            }
            _tags.Sort();
            foreach (Tag tag in _tags)
            {
                tag.Serialize(streamBuffer);
            }
            foreach (ScriptRef scriptRef2 in _scriptRefs)
            {
                scriptRef2.Serialize(_symbols, streamBuffer);
            }
            if (_il != null && _il.Length != 0)
            {
                streamBuffer.Stream.Write(_il, 0, _il.Length);
            }
            if (_pdb != null && _pdb.Length != 0)
            {
                streamBuffer.Stream.Write(_pdb, 0, _pdb.Length);
            }
        }