示例#1
0
        public TgaFile(Stream aStream)
        {
            ByteArray lByteArray = new ByteArrayLittle(aStream);

            header = new TgaHeader(lByteArray);
            data   = new TgaData(lByteArray, header);
        }
示例#2
0
        public VorbisPacket(ByteArray aByteArray, VorbisHeader aVorbisHeader, Byte[] aFirstSegmentArray)
        {
            oggPageHeader = new OggPageHeader(aByteArray);

            sizeSegmentList    = oggPageHeader.GetSegmentSizeList();
            vorbisSegmentArray = new VorbisSegment[sizeSegmentList.Count];

            for (int i = 0; i < sizeSegmentList.Count; i++)
            {
                Byte[] lPacket    = aByteArray.ReadBytes(sizeSegmentList[i]);
                Byte[] lPacketAll = new Byte[sizeSegmentList[i] + aFirstSegmentArray.Length];

                for (int j = 0; j < aFirstSegmentArray.Length; j++)
                {
                    lPacketAll[j] = aFirstSegmentArray[j];
                }

                for (int j = 0; j < sizeSegmentList[i]; j++)
                {
                    lPacketAll[aFirstSegmentArray.Length + j] = lPacket[j];
                }

                MemoryStream    lMemoryStream = new MemoryStream(lPacketAll);
                ByteArrayLittle lByteArray    = new ByteArrayLittle(lMemoryStream);

                vorbisSegmentArray[i] = new VorbisSegment(lByteArray, aVorbisHeader);

                aFirstSegmentArray = new Byte[0];
            }

            nextSegmentArray = aByteArray.ReadBytes(oggPageHeader.GetNextSegmentSize());
        }
示例#3
0
        public XmFile(Stream aStream)
        {
            ByteArray lByteArray = new ByteArrayLittle(aStream);

            idText        = lByteArray.ReadString(17);
            moduleName    = lByteArray.ReadString(20);
            _1A           = lByteArray.ReadByte();
            trackerName   = lByteArray.ReadString(20);
            versionNumber = lByteArray.ReadUInt16();

            headerSize          = lByteArray.ReadUInt32();
            songLength          = lByteArray.ReadUInt16();
            restartPosition     = lByteArray.ReadUInt16();
            numberOfChannels    = lByteArray.ReadUInt16();
            numberOfPatterns    = lByteArray.ReadUInt16();
            numberOfInstruments = lByteArray.ReadUInt16();
            flags             = lByteArray.ReadUInt16();
            defaultTempo      = lByteArray.ReadUInt16();
            defaultBpm        = lByteArray.ReadUInt16();
            patternOrderTable = lByteArray.ReadBytes(256);

            patternChunkArray    = new PatternChunk[numberOfPatterns];
            instrumentChunkArray = new InstrumentChunk[numberOfInstruments];

            for (int i = 0; i < numberOfPatterns; i++)
            {
                patternChunkArray[i] = new PatternChunk(lByteArray);
            }

            for (int i = 0; i < numberOfInstruments; i++)
            {
                instrumentChunkArray[i] = new InstrumentChunk(lByteArray);
            }
        }
示例#4
0
        public BmpFile(Stream aStream)
        {
            ByteArray lByteArray = new ByteArrayLittle(aStream);

            bmpHeader = new BmpHeader(lByteArray);
            bmpData   = new BmpData(lByteArray, bmpHeader);
        }
示例#5
0
        public static void Execute(string aFilePathOutput, LoopInformation aLoopInformation)
        {
            RiffWaveRiff lRiffWaveRiff = ( RiffWaveRiff )PoolCollection.GetRiffWave(aFilePathOutput);

            WaveformReaderPcm waveform = new WaveformReaderPcm(lRiffWaveRiff, true);

            OverrideCuePoint(lRiffWaveRiff, ( int )aLoopInformation.start.sample, ( int )aLoopInformation.end.sample);
            OverrideSampleLoop(lRiffWaveRiff, ( int )aLoopInformation.start.sample, ( int )aLoopInformation.end.sample);

            Byte[]       lDataArrayRead = null;
            RiffWaveData dataChunk      = ( RiffWaveData )lRiffWaveRiff.GetChunk(RiffWaveData.ID);

            using (FileStream u = new FileStream(lRiffWaveRiff.name, FileMode.Open, FileAccess.Read))
            {
                AByteArray l = new ByteArrayLittle(u);

                int bytePosition = ( int )dataChunk.position;

                l.SetPosition(bytePosition);

                lDataArrayRead = l.ReadBytes(dataChunk.Size);
            }

            Byte[] lDataArrayWrite = lDataArrayRead;

            if (IsCutLast == true)
            {
                int lLength = ( int )(aLoopInformation.end.sample + 1) * waveform.format.channels * (waveform.format.sampleBits / 8);
                Logger.BreakDebug("End:" + aLoopInformation.end.sample);

                lDataArrayWrite = new Byte[lLength];

                for (int i = 0; i < lLength; i++)
                {
                    lDataArrayWrite[i] = lDataArrayRead[i];
                }
            }

            SetDataArray(lRiffWaveRiff, lDataArrayWrite);

            MemoryStream    lMemoryStreamWrite = new MemoryStream(( int )lRiffWaveRiff.Size + 8);
            ByteArrayLittle lByteArray         = new ByteArrayLittle(lMemoryStreamWrite);

            lRiffWaveRiff.WriteByteArray(lByteArray);

            Logger.BreakDebug("WriteByteArray");
            Logger.BreakDebug("Out:" + aFilePathOutput);

            try
            {
                using (FileStream u = new FileStream(aFilePathOutput, FileMode.Create, FileAccess.Write, FileShare.Read))
                {
                    u.Write(lMemoryStreamWrite.GetBuffer(), 0, ( int )lMemoryStreamWrite.Length);
                }
            }
            catch (Exception aExpection)
            {
                Logger.BreakError("Write Exception:" + aExpection);
            }
        }
示例#6
0
        public VmdFile(Stream aStream)
        {
            ByteArray lByteArray = new ByteArrayLittle(aStream);

            header      = new VmdHeader(lByteArray);
            chunkMotion = new VmdMotionChunk(lByteArray);
            //chunkSkin = new VmdSkinChunk( lByteArray );
            //chunkCamera = new VmdCameraChunk( lByteArray );
            //chunkLight = new VmdLightChunk( lByteArray );
            //vmdSelfShadowCount = new VmdSelfShadowCount( lByteArray );
        }
示例#7
0
        public void WriteByteArray(AByteArray aByteArray)
        {
            if (name != null && name != "")
            {
                using (FileStream u = new FileStream(name, FileMode.Open, FileAccess.Read))
                {
                    AByteArray lByteArray = new ByteArrayLittle(u);

                    WriteByteArray(lByteArray, aByteArray);
                }
            }
        }
 public void SetDataArray(Byte[] aSampleData)
 {
     if (dataChunk == null)
     {
         // Error.
     }
     else
     {
         MemoryStream lMemoryStream = new MemoryStream(aSampleData);
         ByteArray    lByteArray    = new ByteArrayLittle(lMemoryStream);
         lByteArray.WriteBytes(new byte[dataChunk.position]);
         OverrideChunk(new RiffChunkData(RiffChunkData.ID, ( UInt32 )aSampleData.Length, lByteArray, this));
     }
 }
示例#9
0
        public override void WriteByteArray(ByteArray aByteArrayRead, ByteArray aByteArray)
        {
            if (name != null && name != "")
            {
                using (FileStream u = new FileStream(name, FileMode.Open, FileAccess.Read))
                {
                    ByteArray lByteArray = new ByteArrayLittle(u);

                    foreach (RiffChunk lChunk in chunkList)
                    {
                        lChunk.WriteByteArray(lByteArray, aByteArray);
                    }
                }
            }
        }
示例#10
0
        public static void SetDataArray(RiffWaveRiff lRiffWaveRiff, Byte[] aSampleData)
        {
            Logger.BreakDebug("SetDataArray");

            RiffWaveData dataChunk = ( RiffWaveData )lRiffWaveRiff.GetChunk(RiffWaveData.ID);

            if (dataChunk == null)
            {
                // Error.
            }
            else
            {
                MemoryStream lMemoryStream = new MemoryStream(aSampleData);
                AByteArray   lByteArray    = new ByteArrayLittle(lMemoryStream);
                lByteArray.WriteBytes(new byte[dataChunk.position]);
                lRiffWaveRiff.OverrideChunk(new RiffWaveData(RiffWaveData.ID, ( UInt32 )aSampleData.Length, lByteArray, lRiffWaveRiff));
            }
        }
示例#11
0
        public WaveformPcm(RiffWaveRiff aRiffFile)
        {
            RiffWaveData lRiffWaveData = ( RiffWaveData )aRiffFile.GetChunk(RiffWaveData.ID);
            int          lPosition     = ( int )lRiffWaveData.position;
            int          lLength       = ( int )lRiffWaveData.Size;

            RiffWaveFmt_ lRiffWaveFmt_ = ( RiffWaveFmt_ )aRiffFile.GetChunk(RiffWaveFmt_.ID);
            int          lChannels     = lRiffWaveFmt_.channels;
            int          lSampleRate   = ( int )lRiffWaveFmt_.samplesPerSec;
            int          lSampleBits   = lRiffWaveFmt_.bitsPerSample;
            int          lSamples      = lLength / (lSampleBits / 8) / lChannels;

            format = new WaweformFormat(lChannels, lSamples, lSampleRate, lSampleBits);

            using (FileStream u = new FileStream(aRiffFile.name, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                AByteArray lByteArray = new ByteArrayLittle(u);
                data = new WaveformData(format, lByteArray, lPosition);
            }
        }
示例#12
0
        public WaveformPcm(FormAiffForm aFormFile)
        {
            FormAiffSsnd lSsndChunk = ( FormAiffSsnd )aFormFile.GetChunk(FormAiffSsnd.ID);
            int          lPosition  = ( int )(lSsndChunk.position + lSsndChunk.offset + 8);
            int          lLength    = lSsndChunk.dataSize;

            FormAiffComm lChunkComm  = ( FormAiffComm )aFormFile.GetChunk(FormAiffComm.ID);
            int          lChannels   = lChunkComm.numberOfChannels;
            int          lSampleRate = ( int )lChunkComm.sampleRate;
            int          lSampleBits = lChunkComm.bitsPerSamples;
            int          lSamples    = lLength / (lSampleBits / 8) / lChannels;

            format = new WaweformFormat(lChannels, lSamples, lSampleRate, lSampleBits);

            using (FileStream u = new FileStream(aFormFile.name, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                AByteArray lByteArray = new ByteArrayLittle(u);
                data = new WaveformData(format, lByteArray, lPosition);
            }
        }
示例#13
0
        private void ReadSampleArray(int aPointSample)
        {
            if (nameFile != null)
            {
                using (FileStream u = new FileStream(nameFile, FileMode.Open, FileAccess.Read))
                {
                    ByteArray lByteArray = new ByteArrayLittle(u);

                    switch (sampleBits)
                    {
                    case 16:
                        ReadSampleArray16(lByteArray, aPointSample);
                        break;

                    case 24:
                        ReadSampleArray24(lByteArray, aPointSample);
                        break;

                    default:
                        break;
                    }
                }
            }
        }
示例#14
0
        public static void Execute(FileInfo aFileInput, string aFilePathOutput, List <double> aProgressList, int aIndex)
        {
            RiffFile          lRiffFile          = ( RiffFile )PoolCollection.poolWav.Get(aFileInput.FullName);
            RiffChunkListWave lRiffChunkListWave = ( RiffChunkListWave )lRiffFile.riffChunkList;

            WaveformBase waveform = LoaderWaveform.Load(aFileInput.FullName);

            SByte[] lSampleArray = new SByte[waveform.format.samples];

            for (int i = 0; i < waveform.format.samples; i++)
            {
                lSampleArray[i] = ( SByte )(waveform.data.GetSampleData(0, i) >> 8);
            }

            List <LoopInformation> lLoopList = null;

            try
            {
                lLoopList = LoopSearchTool.Execute(lSampleArray, aProgressList, aIndex);
            }
            catch (Exception aExpection)
            {
                UnityEngine.Debug.Log(aExpection.ToString() + ":LoopTool Exception");
            }

            //for( int i = 0; i < lLoopList.Count; i++ )
            if (lLoopList.Count >= 1)
            {
                //lRiffChunkListWave.AddCuePoint( ( int )lLoopList[i].start.sample, ( int )lLoopList[i].end.sample );
                //lRiffChunkListWave.AddSampleLoop( ( int )lLoopList[i].start.sample, ( int )lLoopList[i].end.sample );
                lRiffChunkListWave.AddCuePoint(( int )lLoopList[0].start.sample, ( int )lLoopList[0].end.sample);
                lRiffChunkListWave.AddSampleLoop(( int )lLoopList[0].start.sample, ( int )lLoopList[0].end.sample);
            }

            Byte[] lDataArrayRead = null;

            using (FileStream u = new FileStream(lRiffFile.name, FileMode.Open, FileAccess.Read))
            {
                ByteArray l = new ByteArrayLittle(u);

                int bytePosition = ( int )lRiffChunkListWave.dataChunk.position;

                l.SetPosition(bytePosition);

                lDataArrayRead = l.ReadBytes(lRiffChunkListWave.dataChunk.size);
            }

            Byte[] lDataArrayWrite = lDataArrayRead;

            if (IsCutLast == true)
            {
                lDataArrayWrite = new Byte[(( int )lLoopList[0].end.sample + 1) * 4];

                for (int i = 0; i < (lLoopList[0].end.sample + 1) * 4; i++)
                {
                    lDataArrayWrite[i] = lDataArrayRead[i];
                }
            }

            for (int i = 0; i < 64; i++)
            {
                Logger.LogDebug(i.ToString() + ":" + lDataArrayWrite[i]);
            }

            lRiffChunkListWave.SetDataArray(lDataArrayWrite);

            MemoryStream    lMemoryStreamWrite = new MemoryStream(( int )lRiffChunkListWave.size + 8);
            ByteArrayLittle lByteArray         = new ByteArrayLittle(lMemoryStreamWrite);

            //lByteArrayRead.Open();
            lRiffFile.WriteByteArray(null, lByteArray);
            //lByteArrayRead.Close();

            using (FileStream u = new FileStream(aFilePathOutput, FileMode.Create, FileAccess.Write))
            {
                u.Write(lMemoryStreamWrite.GetBuffer(), 0, ( int )lMemoryStreamWrite.Length);
            }
        }
示例#15
0
		public static void Execute( string aFilePathInput, string aFilePathOutput, InputMusicInformation aData )
		{
			RiffWaveRiff lRiffWaveRiff = ( RiffWaveRiff )PoolCollection.GetRiffWave( aFilePathInput );

			WaveformPcm lWaveform = new WaveformPcm( lRiffWaveRiff );

			SByte[] lSampleArray = new SByte[lWaveform.format.samples];
			
			lSampleArray = lWaveform.data.sampleByteArray[0];

			List<LoopInformation> lLoopList = null;

			try
			{
				if( lWaveform.format.samples > 44100 * 16 )
				{
					lLoopList = LoopSearchTool.Execute( lSampleArray, aData, aFilePathInput );
				}
				else
				{
					lLoopList = LoopSearchToolSoundfont.Execute( lSampleArray, aData, aFilePathInput );
				}
			}
			catch( Exception aExpection )
			{
				Logger.BreakError( aExpection.ToString() + ":LoopTool Exception" );
			}

			for( int i = 0; i < lLoopList.Count; i++ )
			{
				AddCuePoint( lRiffWaveRiff, ( int )lLoopList[i].start.sample, ( int )lLoopList[i].end.sample );
				AddSampleLoop( lRiffWaveRiff, ( int )lLoopList[i].start.sample, ( int )lLoopList[i].end.sample );
			}

			Byte[] lDataArrayRead = null;
			RiffWaveData dataChunk = ( RiffWaveData )lRiffWaveRiff.GetChunk( RiffWaveData.ID );
			
			using ( FileStream u = new FileStream( lRiffWaveRiff.name, FileMode.Open, FileAccess.Read ) )
			{
				AByteArray l = new ByteArrayLittle( u );
				
				int bytePosition = ( int )dataChunk.position;

				l.SetPosition( bytePosition );
				
				lDataArrayRead = l.ReadBytes( dataChunk.Size );
			}

			SetDataArray( lRiffWaveRiff, lDataArrayRead );
			
			Logger.BreakDebug( "lMemoryStreamWrite" );

			MemoryStream lMemoryStreamWrite = new MemoryStream( ( int )lRiffWaveRiff.Size + 8 );
			ByteArrayLittle lByteArray = new ByteArrayLittle( lMemoryStreamWrite );

			lRiffWaveRiff.WriteByteArray( lByteArray );
			
			Logger.BreakDebug( "WriteByteArray" );
			Logger.BreakDebug( "Out:" + aFilePathOutput );
			
			try
			{
				using( FileStream u = new FileStream( aFilePathOutput, FileMode.Create, FileAccess.Write, FileShare.Read ) )
				{
					u.Write( lMemoryStreamWrite.GetBuffer(), 0, ( int )lMemoryStreamWrite.Length );
				}
			}
			catch( Exception aExpection )
			{
				Logger.BreakError( "Write Exception:" + aExpection );
			}
		}