示例#1
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            UInt64 start_offset;
            UInt64 i;

            int thpVersion = fileReader.Read_8Bits(offset + 0x06);

            /* fill in the vital statistics */
            start_offset = fileReader.Read_32bitsBE(offset + 0x28);

            // Get info from the first block
            UInt64 componentTypeOffset = offset + fileReader.Read_32bitsBE(offset + 0x20);
            uint   numComponents       = fileReader.Read_32bitsBE(componentTypeOffset);
            UInt64 componentDataOffset = componentTypeOffset + 0x14;

            componentTypeOffset += 4;

            for (i = 0; i < numComponents; i++)
            {
                if (fileReader.Read_8Bits(componentTypeOffset + i) == 1) // audio block
                {
                    uint channel_count = fileReader.Read_32bitsBE(componentDataOffset);

                    /* build the VGMSTREAM */
                    VGM_Utils.allocate_vgmStream(ref vgmStream, (int)channel_count, false);

                    vgmStream.vgmChannelCount = (int)channel_count;
                    vgmStream.vgmSampleRate   = (int)fileReader.Read_32bitsBE(componentDataOffset + 4);
                    vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(componentDataOffset + 8);
                    break;
                }
                else
                {
                    if (thpVersion == 0x10)
                    {
                        componentDataOffset += 0x0c;
                    }
                    else
                    {
                        componentDataOffset += 0x08;
                    }
                }
            }

            vgmStream.vgmTHPNextFrameSize = fileReader.Read_32bitsBE(offset + 0x18);
            vgmStream.vgmDecoder          = new DSP_Decoder();
            vgmStream.vgmLayout           = new Blocked();
            vgmStream.vgmLayoutType       = VGM_Layout_Type.THP_Blocked;

            if (InitReader)
            {
                for (i = 0; i < 2; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());
                }
                BlockedFnts.THP_Block_Update(offset + start_offset, ref vgmStream);
            }
        }
示例#2
0
        public static void THP_Block_Update(UInt64 NextBlockOffset, ref VGM_Stream vgmStream)
        {
            int    i, j;
            UInt64 start_offset;
            uint   nextFrameSize;

            vgmStream.vgmCurrentBlockOffset = NextBlockOffset;
            nextFrameSize = vgmStream.vgmChannel[0].fReader.Read_32bitsBE(vgmStream.vgmCurrentBlockOffset);

            vgmStream.vgmNextBlockOffset  = vgmStream.vgmCurrentBlockOffset + (UInt64)vgmStream.vgmTHPNextFrameSize;
            vgmStream.vgmTHPNextFrameSize = nextFrameSize;

            start_offset = vgmStream.vgmCurrentBlockOffset
                           + vgmStream.vgmChannel[0].fReader.Read_32bitsBE(vgmStream.vgmCurrentBlockOffset + 0x08) + 0x10;
            vgmStream.vgmCurrentBlockSize = (int)vgmStream.vgmChannel[0].fReader.Read_32bitsBE(start_offset);

            start_offset += 8;

            for (i = 0; i < vgmStream.vgmChannelCount; i++)
            {
                // get coeff
                for (j = 0; j < 16; j++)
                {
                    vgmStream.vgmChannel[i].adpcm_coef[j] = (Int16)vgmStream.vgmChannel[0].fReader.Read_16bitsBE(start_offset + (UInt64)((i * 0x20) + (j * 2)));
                }
                // and sample history ...
                vgmStream.vgmChannel[i].adpcm_history_16bits_1 = (short)vgmStream.vgmChannel[0].fReader.Read_16bitsBE(start_offset + (UInt64)((0x20 * vgmStream.vgmChannelCount) + (i * 4)));
                vgmStream.vgmChannel[i].adpcm_history_16bits_2 = (short)vgmStream.vgmChannel[0].fReader.Read_16bitsBE(start_offset + (UInt64)((0x20 * vgmStream.vgmChannelCount) + (i * 4) + 2));
                vgmStream.vgmChannel[i].currentOffset          = start_offset + (UInt64)(0x24 * vgmStream.vgmChannelCount) + (UInt64)(i * vgmStream.vgmCurrentBlockSize);
            }
        }
示例#3
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            bool loop_flag     = (fileReader.Read_32bits(offset + 0x1C) != 0xFFFFFFFF);
            int  channel_count = (int)fileReader.Read_32bits(offset + 0x10);
            int  sample_rate   = (int)fileReader.Read_32bits(offset + 0x0c);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            vgmStream.vgmLoopFlag            = loop_flag;
            vgmStream.vgmChannelCount        = channel_count;
            vgmStream.vgmSampleRate          = sample_rate;
            vgmStream.vgmTotalSamples        = (int)fileReader.Read_32bits(offset + 0x24) / 16 * 28 / channel_count;
            vgmStream.vgmLayout              = new Interleave();
            vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x14);
            vgmStream.vgmDecoder             = new PSX_Decoder();

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = ((int)fileReader.Read_32bits(offset + 0x18) * 0x10) / 16 * 28 / vgmStream.vgmChannelCount;
                vgmStream.vgmLoopEndSample   = ((int)fileReader.Read_32bits(offset + 0x1C) * 0x10) / 16 * 28 / vgmStream.vgmChannelCount;

                if (vgmStream.vgmLoopEndSample > vgmStream.vgmTotalSamples)
                {
                    vgmStream.vgmLoopStartSample = ((int)fileReader.Read_32bits(offset + 0x18)) / 16 * 28 / vgmStream.vgmChannelCount;
                    vgmStream.vgmLoopEndSample   = ((int)fileReader.Read_32bits(offset + 0x1C)) / 16 * 28 / vgmStream.vgmChannelCount;
                }
            }

            UInt64 start_offset = offset + 0x28;

            if (!VGM_Utils.IsPS2ADPCM(fileReader, start_offset, start_offset + 0x8000))
            {
                start_offset = offset + 0x800;
                if (!VGM_Utils.IsPS2ADPCM(fileReader, start_offset, start_offset + 0x8000))
                {
                    start_offset              = offset + 0x28;
                    vgmStream.vgmDecoder      = new PCM16_Decoder();
                    vgmStream.vgmDecoderType  = VGM_Decoder_Type.PCM16BITS;
                    vgmStream.vgmTotalSamples = (int)fileReader.Read_32bits(offset + 0x24) / 2 / channel_count;

                    if (loop_flag)
                    {
                        vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bits(offset + 0x18);
                        vgmStream.vgmLoopEndSample   = (int)fileReader.Read_32bits(offset + 0x1C);
                    }
                }
            }

            if (InitReader)
            {
                for (int i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());
                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
        public void Decode(VGM_Stream vgmStream, VGM_Channel vgmChannel, ref short[] vgmOutput, int vgmChannelSpacing,
                           int vgmFirstSample, int vgmSamplesToDo, int vgmChannelNumber)
        {
            int vgmSampleCount, i;

            int framesin = vgmFirstSample / 32;

            int scale             = vgmChannel.fReader.Read_16bitsBE((vgmChannel.currentOffset + (UInt64)(framesin * 18))) + 1;
            int vgmSampleHistory1 = vgmChannel.adpcm_history_32bits_1;
            int vgmSampleHistory2 = vgmChannel.adpcm_history_32bits_2;
            int coef1             = vgmChannel.adpcm_coef[0];
            int coef2             = vgmChannel.adpcm_coef[1];
            int vgmSample;

            vgmFirstSample = vgmFirstSample % 32;

            for (i = vgmFirstSample, vgmSampleCount = 0; i < vgmFirstSample + vgmSamplesToDo; i++, vgmSampleCount += vgmChannelSpacing)
            {
                int sample_byte = vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)((framesin * 18) + 2 + i / 2));

                sample_byte = (((i & 1) == 1) ? VGM_Utils.LOWNIBBLE_SIGNED(sample_byte) : VGM_Utils.HINIBBLE_SIGNED(sample_byte));
                vgmSample   = (sample_byte * scale);
                vgmSample  += (((coef1 * vgmSampleHistory1) + (coef2 * vgmSampleHistory2)) >> 12);
                vgmOutput[vgmStream.vgmSamplesBlockOffset + vgmSampleCount + vgmChannelNumber] = VGM_Utils.clamp16(vgmSample);

                vgmSampleHistory2 = vgmSampleHistory1;
                vgmSampleHistory1 = vgmSample;
            }

            vgmChannel.adpcm_history_32bits_1 = vgmSampleHistory1;
            vgmChannel.adpcm_history_32bits_2 = vgmSampleHistory2;
        }
示例#5
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            bool loop_flag     = (fileReader.Read_32bits(offset + 0x14) == 1);
            int  channel_count = (int)fileReader.Read_32bits(offset + 0x0C);

            if (fileReader.Read_32bits(offset + 0x30) == 0x45434B2E)
            {
                m_Description = "Konami SVAG (KCE-Tokyo)";
            }
            else
            {
                m_Description = "Konami SVAG (KONAMITYO)";
            }


            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            /* fill in the vital statistics */
            UInt64 start_offset = offset + 0x800;

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmSampleRate   = (int)fileReader.Read_32bits(offset + 0x08);
            vgmStream.vgmDecoder      = new PSX_Decoder();

            if (vgmStream.vgmChannelCount == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout = new Interleave();
            }

            vgmStream.vgmLoopFlag = loop_flag;

            vgmStream.vgmTotalSamples = (int)((fileReader.Read_32bits(offset + 0x04) * 28 / 16) / channel_count);

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)(fileReader.Read_32bits(offset + 0x18) / 16 * 28);
                vgmStream.vgmLoopEndSample   = (int)(fileReader.Read_32bits(offset + 0x04) / 16 * 28 / vgmStream.vgmChannelCount);
            }

            vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x10);

            if (InitReader)
            {
                for (int i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
        public void Decode(VGM_Stream vgmStream, VGM_Channel vgmChannel, ref short[] vgmOutput, int vgmChannelSpacing,
                           int vgmFirstSample, int vgmSamplesToDo, int vgmChannelNumber)
        {
            for (int i = vgmFirstSample, vgmSampleCount = 0; i < vgmFirstSample + vgmSamplesToDo; i++, vgmSampleCount += vgmChannelSpacing)
            {
                int offset = vgmStream.vgmSamplesBlockOffset + vgmSampleCount + vgmChannelNumber;

                vgmOutput[offset] = (short)(vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)(i * 2)) * 0x100);
            }
        }
示例#7
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            int vgmNumSamples = 0;
            int loop_start    = -1;

            UInt64 NextBlock;
            UInt64 currBlock = offset;
            int    i;

            // Calculate sample length ...
            uint blockCount = fileReader.Read_32bitsBE(offset + 0x24);

            for (i = 0; i < blockCount; i++)
            {
                NextBlock      = fileReader.Read_32bitsBE(currBlock + 0x04);
                vgmNumSamples += (int)(fileReader.Read_32bitsBE(currBlock + 0x14) / 8 * 14);

                if (fileReader.Read_32bitsBE(currBlock + 0x20) == fileReader.Read_32bitsBE(currBlock + 0x08))
                {
                    loop_start = (int)(vgmNumSamples - fileReader.Read_32bitsBE(currBlock + 0x14) / 8 * 14);
                }
                currBlock += NextBlock;
            }

            bool loop_flag = (loop_start != -1);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, 2, loop_flag);

            vgmStream.vgmLoopFlag     = loop_flag;
            vgmStream.vgmChannelCount = 2;
            vgmStream.vgmSampleRate   = 32000;
            vgmStream.vgmTotalSamples = vgmNumSamples;

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = loop_start;
                vgmStream.vgmLoopEndSample   = vgmNumSamples;
            }

            vgmStream.vgmDecoder    = new DSP_Decoder();
            vgmStream.vgmLayout     = new Blocked();
            vgmStream.vgmLayoutType = VGM_Layout_Type.CAF_Blocked;

            if (InitReader)
            {
                for (i = 0; i < 2; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());
                }
                BlockedFnts.CAF_Block_Update(offset + 0, ref vgmStream);
            }
        }
示例#8
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            Int16[] coef = new Int16[16] {
                0x04ab, -0x0313, 0x0789, -0x0121, 0x09a2, -0x051b, 0x0c90, -0x053f, 0x084d, -0x055c, 0x0982, -0x0209, 0x0af6, -0x0506, 0x0be6, -0x040b
            };
            int channel_count = fileReader.Read_8Bits(offset + 0x16);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, false);

            vgmStream.vgmDecoder = new DSP_Decoder();
            vgmStream.vgmLayout  = new Interleave();

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmLoopFlag     = false;
            vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x42) / 8 * 14) / channel_count;
            vgmStream.vgmSampleRate   = fileReader.Read_16bits(offset + 0x18);

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout     = new Interleave();
                vgmStream.vgmLayoutType = VGM_Layout_Type.Interleave_With_Shortblock;
            }

            vgmStream.vgmInterleaveBlockSize = 0x08;

            int i, j;

            for (j = 0; j < vgmStream.vgmChannelCount; j++)
            {
                for (i = 0; i < 16; i++)
                {
                    vgmStream.vgmChannel[j].adpcm_coef[i] = coef[i];
                }
            }

            UInt64 start_offset = offset + 0x46;

            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());

                    vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(i * vgmStream.vgmInterleaveBlockSize);
                }
            }
        }
示例#9
0
        public int update(ref short[] vgmBuffer, int vgmSampleCount, VGM_Stream vgmStream)
        {
            int i;
            int samples_written = 0;

            int samples_this_block = vgmStream.vgmTotalSamples;
            int samples_per_frame  = vgmStream.vgmDecoder.SamplesPerFrame();

            vgmStream.vgmSamplesBlockOffset = 0;

            if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
            {
                return(0);
            }

            while (samples_written < vgmSampleCount)
            {
                int samples_to_do;

                if (vgmStream.vgmLoopFlag && VGM_Utils.vgmstream_do_loop(vgmStream))
                {
                    continue;
                }

                samples_to_do = VGM_Utils.vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmStream);

                if (samples_written + samples_to_do > vgmSampleCount)
                {
                    samples_to_do = vgmSampleCount - samples_written;
                }

                for (i = 0; i < vgmStream.vgmChannelCount; i++)
                {
                    vgmStream.vgmDecoder.Decode(vgmStream, vgmStream.vgmChannel[i], ref vgmBuffer, vgmStream.vgmChannelCount, vgmStream.vgmSamplesIntoBlock, samples_to_do, i);
                }
                vgmStream.vgmSamplesBlockOffset += samples_to_do * vgmStream.vgmChannelCount;
                samples_written             += samples_to_do;
                vgmStream.vgmSamplePlayed   += samples_to_do;
                vgmStream.vgmDecodedSamples += samples_to_do;

                if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
                {
                    return(samples_written);
                }

                vgmStream.vgmSamplesIntoBlock += samples_to_do;
            }

            return(samples_written);
        }
示例#10
0
        public void Decode(VGM_Stream vgmStream, VGM_Channel vgmChannel, ref short[] vgmOutput, int vgmChannelSpacing,
                           int vgmFirstSample, int vgmSamplesToDo, int vgmChannelNumber)
        {
            int i;

            double vgmSample;
            int    vgmSampleCount;

            double vgmSampleHistory1 = vgmChannel.adpcm_history_dbl_1;
            double vgmSampleHistory2 = vgmChannel.adpcm_history_dbl_2;

            Int16 vgmScale;

            // Get the offset of the correct frame
            Int32 vgmFrameNum = vgmFirstSample / 28;

            Int16 vgmPredictor   = (Int16)(vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)(vgmFrameNum * 16)) >> 4);
            Int16 vgmShiftFactor = (Int16)(vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)(vgmFrameNum * 16)) & 0x0F);
            byte  vgmFlag        = vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)((vgmFrameNum * 16) + 1));

            vgmFirstSample = vgmFirstSample % 28;

            for (i = vgmFirstSample, vgmSampleCount = 0; i < vgmFirstSample + vgmSamplesToDo; i++, vgmSampleCount += vgmChannelSpacing)
            {
                vgmSample = 0;

                if (vgmFlag < 0x07)
                {
                    Int16 sample_byte = vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)((vgmFrameNum * 16) + 2 + i / 2));

                    vgmScale = (Int16)(((((i & 1) == 1) ? sample_byte >> 4 : (sample_byte & 0x0f)) << 12));

                    if (vgmPredictor < 5)
                    {
                        vgmSample = (((vgmScale >> vgmShiftFactor) + vgmSampleHistory1 * VAG_f[vgmPredictor, 0] + vgmSampleHistory2 * VAG_f[vgmPredictor, 1]));
                    }
                    else
                    {
                        vgmSample = 0;
                    }
                }
                vgmOutput[vgmStream.vgmSamplesBlockOffset + vgmSampleCount + vgmChannelNumber] = VGM_Utils.clamp16(vgmSample);
                vgmSampleHistory2 = vgmSampleHistory1;
                vgmSampleHistory1 = vgmSample;
            }

            vgmChannel.adpcm_history_dbl_1 = vgmSampleHistory1;
            vgmChannel.adpcm_history_dbl_2 = vgmSampleHistory2;
        }
示例#11
0
        public VGM_Decoding(VGM_Stream vgmStream, StreamReader.IReader fileReader)
        {
            m_vgmStream  = vgmStream;
            m_fileReader = fileReader;

            if (m_WavFormat != null)
            {
                m_WavFormat = null;
            }

            m_WavFormat   = new NAudio.Wave.WaveFormat(vgmStream.vgmSampleRate, vgmStream.vgmChannelCount);
            m_FadeSamples = (int)(m_FadeSeconds * vgmStream.vgmSampleRate);
            m_vgmStream.vgmDecodedSamples       = 0;
            m_vgmStream.vgmTotalSamplesWithLoop = VGM_Utils.get_vgmstream_play_samples(2, m_FadeSeconds, 0, vgmStream);
        }
示例#12
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            int i;

            bool loop_flag     = (fileReader.Read_32bits(offset + 0x14) != 0);
            int  channel_count = (int)fileReader.Read_32bits(offset + 0x1C);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            /* fill in the vital statistics */
            UInt64 start_offset = offset + fileReader.Read_32bits(offset + 0x08);

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmSampleRate   = (int)fileReader.Read_32bits(offset + 0x18);
            vgmStream.vgmDecoder      = new PSX_Decoder();

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout = new Interleave();
            }

            vgmStream.vgmLoopFlag = loop_flag;

            vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x0C) * 28 / 16 / channel_count);

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)((fileReader.Read_32bits(offset + 0x0C) - fileReader.Read_32bits(offset + 0x14)) * 28 / 16 / channel_count);
                vgmStream.vgmLoopEndSample   = (int)(fileReader.Read_32bits(offset + 0x0C) * 28 / 16 / channel_count);
            }

            vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x24);

            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
示例#13
0
        public void Decode(VGM_Stream vgmStream, VGM_Channel vgmChannel, ref short[] vgmOutput, int vgmChannelSpacing,
                           int vgmFirstSample, int vgmSamplesToDo, int vgmChannelNumber)
        {
            int framesin = vgmFirstSample / 14;

            vgmFirstSample = vgmFirstSample % 14;

            byte header     = vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)(framesin * 8));
            int  scale      = 1 << (header & 0xf);
            int  coef_index = (header >> 4) & 0xf;

            int vgmSampleHistory1 = vgmChannel.adpcm_history_32bits_1;
            int vgmSampleHistory2 = vgmChannel.adpcm_history_32bits_2;

            try
            {
                int coef1 = vgmChannel.adpcm_coef[coef_index * 2];
                int coef2 = vgmChannel.adpcm_coef[coef_index * 2 + 1];

                int vgmSampleCount, i;
                int vgmSample;

                for (i = vgmFirstSample, vgmSampleCount = 0; i < vgmFirstSample + vgmSamplesToDo; i++, vgmSampleCount += vgmChannelSpacing)
                {
                    int sample_byte = vgmChannel.fReader.Read_8Bits(vgmChannel.currentOffset + (UInt64)(framesin * 8 + 1 + i / 2));

                    vgmSample = (((i & 1) == 1) ? VGM_Utils.LOWNIBBLE_SIGNED(sample_byte)
                                                : VGM_Utils.HINIBBLE_SIGNED(sample_byte));

                    vgmSample = ((vgmSample * scale) << 11) + 1024;
                    vgmSample = vgmSample + (coef1 * vgmSampleHistory1 + coef2 * vgmSampleHistory2);
                    vgmSample = vgmSample >> 11;

                    vgmOutput[vgmStream.vgmSamplesBlockOffset + vgmSampleCount + vgmChannelNumber] = VGM_Utils.clamp16(vgmSample);

                    vgmSampleHistory2 = vgmSampleHistory1;
                    vgmSampleHistory1 = vgmSample;
                }

                vgmChannel.adpcm_history_32bits_1 = vgmSampleHistory1;
                vgmChannel.adpcm_history_32bits_2 = vgmSampleHistory2;
            }
            catch (Exception e)
            {
                Console.Write(e.Message + " in DSP_Decoder");
            }
        }
示例#14
0
        public void Decode(VGM_Stream vgmStream, VGM_Channel vgmChannel, ref short[] vgmOutput, int vgmChannelSpacing,
                           int vgmFirstSample, int vgmSamplesToDo, int vgmChannelNumber)
        {
            for (int i = vgmFirstSample, vgmSampleCount = 0; i < vgmFirstSample + vgmSamplesToDo; i++, vgmSampleCount += vgmChannelSpacing)
            {
                int offset = vgmStream.vgmSamplesBlockOffset + vgmSampleCount + vgmChannelNumber;

                if (vgmStream.vgmDecoderType == VGM_Decoder_Type.PCM16BITS)
                {
                    vgmOutput[offset] = (short)vgmChannel.fReader.Read_16bits(vgmChannel.currentOffset + (UInt64)(i * 2));
                }
                else
                {
                    vgmOutput[offset] = (short)vgmChannel.fReader.Read_16bitsBE(vgmChannel.currentOffset + (UInt64)(i * 2));
                }
            }
        }
示例#15
0
        public static void CAF_Block_Update(UInt64 NextBlockOffset, ref VGM_Stream vgmStream)
        {
            int i;

            vgmStream.vgmCurrentBlockOffset = NextBlockOffset;
            vgmStream.vgmCurrentBlockSize   = (int)vgmStream.vgmChannel[0].fReader.Read_32bitsBE(vgmStream.vgmCurrentBlockOffset + 0x14);
            vgmStream.vgmNextBlockOffset    = vgmStream.vgmCurrentBlockOffset + (UInt64)vgmStream.vgmChannel[0].fReader.Read_32bitsBE(vgmStream.vgmCurrentBlockOffset + 0x04);

            for (i = 0; i < vgmStream.vgmChannelCount; i++)
            {
                vgmStream.vgmChannel[i].currentOffset = vgmStream.vgmCurrentBlockOffset + vgmStream.vgmChannel[0].fReader.Read_32bitsBE(NextBlockOffset + (UInt64)(0x10 + (8 * i)));
            }

            /* coeffs */
            for (i = 0; i < 16; i++)
            {
                vgmStream.vgmChannel[0].adpcm_coef[i] = (Int16)vgmStream.vgmChannel[0].fReader.Read_16bitsBE(NextBlockOffset + (UInt64)(0x34 + (2 * i)));
                vgmStream.vgmChannel[1].adpcm_coef[i] = (Int16)vgmStream.vgmChannel[0].fReader.Read_16bitsBE(NextBlockOffset + (UInt64)(0x60 + (2 * i)));
            }
        }
示例#16
0
        /// <summary>
        /// Allocate each structures used by VGM Stream
        /// </summary>
        /// <param name="vgmStream">VGM Stream Class previously instantied</param>
        /// <param name="channels">Channel count of the current stream</param>
        /// <param name="loop_flag">Does this loop ?</param>
        public static void allocate_vgmStream(ref VGM_Stream vgmStream, int channels, bool loop_flag)
        {
            int i;

            vgmStream                   = new VGM_Stream();
            vgmStream.vgmChannel        = new VGM_Channel[channels];
            vgmStream.vgmChannelAtStart = new VGM_Channel[channels];

            for (i = 0; i < channels; i++)
            {
                vgmStream.vgmChannel[i]        = new VGM_Channel();
                vgmStream.vgmChannelAtStart[i] = new VGM_Channel();
            }

            if (loop_flag)
            {
                vgmStream.vgmChannelAtLoop = new VGM_Channel[channels];
                for (i = 0; i < channels; i++)
                {
                    vgmStream.vgmChannelAtLoop[i] = new VGM_Channel();
                }
            }
        }
示例#17
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            bool loop_flag     = (fileReader.Read_32bits(offset + 0x7FC) != 0);
            int  channel_count = (int)fileReader.Read_32bits(offset + 0x14);
            int  sample_rate   = (int)fileReader.Read_32bits(offset + 0x10);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            vgmStream.vgmLoopFlag            = loop_flag;
            vgmStream.vgmChannelCount        = channel_count;
            vgmStream.vgmSampleRate          = sample_rate;
            vgmStream.vgmTotalSamples        = (int)(fileReader.Read_32bits(offset + 0x04) * 28 / 16);
            vgmStream.vgmLayout              = new Interleave();
            vgmStream.vgmInterleaveBlockSize = (int)(fileReader.Read_32bits(offset + 0x0C) / 2);
            vgmStream.vgmDecoder             = new PSX_Decoder();

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bits(offset + 0x7FC) * 28 / 16;
                vgmStream.vgmLoopEndSample   = vgmStream.vgmTotalSamples;
            }

            UInt64 start_offset = offset + fileReader.Read_32bits(offset + 08);

            if (InitReader)
            {
                for (int i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());
                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
示例#18
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            int i;

            char vagID         = (char)fileReader.Read_8Bits(offset + 0x03);
            uint fileVagLength = fileReader.Read_32bitsBE(offset + 0x0c);

            int  channel_count = 1;
            uint interleave    = 0;

            UInt64 loopStart = 0;
            UInt64 loopEnd   = 0;

            bool loop_flag = false;

            switch (vagID)
            {
            case 'i':
                channel_count = 2;
                break;

            case 'V':
                if (fileReader.Read_32bitsBE(offset + 0x20) == 0x53746572)     // vag Stereo
                {
                    channel_count = 2;
                }
                break;

            case 'p':
                if (fileReader.Read_32bitsBE(offset + 0x24) == 0x56414778)
                {
                    loop_flag     = false;
                    channel_count = 2;
                }
                else
                {
                    if (fileReader.Read_32bitsBE(offset + 0x04) <= 0x00000004)
                    {
                        loop_flag     = (fileReader.Read_32bitsBE(offset + 0x14) != 0);
                        channel_count = 1;
                    }
                    else
                    {
                        /* Search for loop in VAG */
                        uint   vagfileLength = fileReader.Read_32bitsBE(offset + 0x0c);
                        UInt64 readOffset    = offset + 0x20;

                        do
                        {
                            readOffset += 0x10;

                            // Loop Start ...
                            if (fileReader.Read_8Bits(readOffset + 0x01) == 0x06)
                            {
                                if (loopStart == 0)
                                {
                                    loopStart = readOffset;
                                }
                            }

                            // Loop End ...
                            if (fileReader.Read_8Bits(readOffset + 0x01) == 0x03)
                            {
                                if (loopEnd == 0)
                                {
                                    loopEnd = readOffset;
                                }
                            }

                            // Loop from end to beginning ...
                            if ((fileReader.Read_8Bits(readOffset + 0x01) == 0x01))
                            {
                                // Check if we have the eof tag after the loop point ...
                                // if so we don't loop, if not present, we loop from end to start ...
                                byte[] vagBuffer = fileReader.Read(readOffset + 0x10, 0x10);
                                if ((vagBuffer[0] != 0) && (vagBuffer[0] != 0x0c))
                                {
                                    if ((vagBuffer[0] == 0x00) && (vagBuffer[0] == 0x07))
                                    {
                                        loopStart = 0x40;
                                        loopEnd   = readOffset;
                                    }
                                }
                            }
                        } while (readOffset < offset + 0x20 + vagfileLength);
                        loop_flag = (loopEnd != 0);
                    }
                }
                break;

            default:
                break;
            }

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            /* fill in the vital statistics */
            UInt64 start_offset = offset + 0x30;

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmSampleRate   = (int)fileReader.Read_32bitsBE(offset + 0x10);
            vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x04) * 28 / 16);

            vgmStream.vgmLayout = new NoLayout();

            switch (vagID)
            {
            case 'i':     // VAGi
                vgmStream.vgmLayout       = new Interleave();
                vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(0x0C) / 16 * 28;
                interleave   = fileReader.Read_32bitsBE(offset + 0x08);
                start_offset = offset + 0x800;
                break;

            case 'p':              // VAGp
                interleave = 0x10; // used for loop calc

                if (fileReader.Read_32bitsBE(offset + 0x04) == 0x00000004)
                {
                    vgmStream.vgmChannelCount = 2;
                    vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C);

                    if (loop_flag)
                    {
                        vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bitsBE(offset + 0x14);
                        vgmStream.vgmLoopEndSample   = (int)fileReader.Read_32bitsBE(offset + 0x18);
                    }

                    start_offset = offset + 0x80;

                    vgmStream.vgmLayout = new Interleave();

                    // Double VAG Header @ 0x0000 & 0x1000
                    if (fileReader.Read_32bitsBE(offset + 0) == fileReader.Read_32bitsBE(offset + 0x1000))
                    {
                        vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C) / 16 * 28;
                        interleave   = 0x1000;
                        start_offset = offset + 0;
                    }
                }
                else
                {
                    if (fileReader.Read_32bitsBE(offset + 0x24) == 0x56414778)
                    {
                        if (fileReader.Read_16bitsBE(offset + fileReader.Read_32bitsBE(offset + 0x0C) + 0x10) != 0x0007)
                        {
                            interleave = 0x8000;
                        }

                        vgmStream.vgmLayout       = new Interleave();
                        vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C) / 16 * 14;
                    }
                    else
                    {
                        vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C) / 16 * 28;
                        start_offset = offset + 0x30;
                    }
                }
                break;

            case 'V':     // pGAV
                vgmStream.vgmLayout = new Interleave();
                interleave          = 0x2000;

                // Jak X hack ...
                if (fileReader.Read_32bitsBE(offset + 0x1000) == 0x56414770)
                {
                    interleave = 0x1000;
                }

                vgmStream.vgmSampleRate   = (int)fileReader.Read_32bits(offset + 0x10);
                vgmStream.vgmTotalSamples = (int)fileReader.Read_32bits(offset + 0x0C) / 16 * 14;
                start_offset = offset + 0;
                break;
            }

            vgmStream.vgmDecoder  = new PSX_Decoder();
            vgmStream.vgmLoopFlag = loop_flag;

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)(fileReader.Read_32bits(offset + 0x08) * 28 / 16 / vgmStream.vgmChannelCount);
                vgmStream.vgmLoopEndSample   = (int)(fileReader.Read_32bits(offset + 0x04) * 28 / 16);
            }

            vgmStream.vgmInterleaveBlockSize = (int)interleave;

            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
示例#19
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            UInt64 startOffset = 0;

            UInt64[] start_offset = new UInt64[2] {
                0x140, 0x148
            };

            if (fileReader.Read_32bitsBE(offset + 0x44) == 0x6461744C) // datL
            {
                startOffset     = 0x5e;
                start_offset[0] = fileReader.Read_32bitsBE(offset + 0x48);
                start_offset[1] = fileReader.Read_32bitsBE(offset + 0x54);
            }
            else
            {
                startOffset = 0x52;
            }

            int channel_count = fileReader.Read_16bitsBE(offset + startOffset);

            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, false);

            vgmStream.vgmDecoder      = new DSP_Decoder();
            vgmStream.vgmLayout       = new Interleave();
            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmLoopFlag     = false;
            vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bitsBE(offset + startOffset + 0x14) / 8 * 14) / channel_count;

            vgmStream.vgmSampleRate = fileReader.Read_16bitsBE(offset + startOffset + 0x4);

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout     = new Interleave();
                vgmStream.vgmLayoutType = VGM_Layout_Type.Interleave_With_Shortblock;
            }

            vgmStream.vgmInterleaveBlockSize = 0x08;

            int i, j;

            for (j = 0; j < vgmStream.vgmChannelCount; j++)
            {
                for (i = 0; i < 16; i++)
                {
                    vgmStream.vgmChannel[j].adpcm_coef[i] = (Int16)fileReader.Read_16bitsBE(offset + startOffset + (UInt64)(0x2C + (i * 2) + (j * 0x60)));
                }
            }

            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());

                    vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = offset + start_offset[i];
                }
            }
        }
示例#20
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            byte[] mibBuffer   = new byte[0x10];
            byte[] testBuffer  = new byte[0x10];
            byte[] testBuffer2 = new byte[0x10];
            byte[] testBuffer3 = new byte[0x10];

            //bool doChannelUpdate=true;
            //bool bDoUpdateInterleave=true;

            UInt64 loopStart  = 0;
            UInt64 loopEnd    = 0;
            UInt64 interleave = 0;
            UInt64 readOffset = offset;

            UInt64[] loopStartPoints      = new UInt64[0x10];
            int      loopStartPointsCount = 0;

            UInt64[] loopEndPoints      = new UInt64[0x10];
            int      loopEndPointsCount = 0;

            byte[] emptyLine        = new byte[0x10];
            bool   loopToEnd        = false;
            bool   forceNoLoop      = false;
            bool   bolSaveEmptyLine = true;

            int    i, channel_count = 0;
            bool   interleave_found = false;
            UInt64 tstCount         = 0;

            UInt64[] emptyLineOffset      = new UInt64[100];
            uint     emptyLineCount       = 0;
            uint     max_interleave       = 0;
            uint     max_interleave_index = 0;

            // Initialize loop point to 0
            for (i = 0; i < 0x10; i++)
            {
                loopStartPoints[i] = 0;
                loopEndPoints[i]   = 0;
                testBuffer[i]      = 0;
                emptyLine[i]       = 0;
            }

            //if (this.Filename.ToUpper().Contains(".MIB"))

            /* Search for interleave value & loop points */
            /* Get the first 16 values */
            mibBuffer = fileReader.Read(offset, 0x10);
            if (MemoryReader.memcmp(mibBuffer, emptyLine, 0x10, 0))
            {
                tstCount = 0x10;
                //readOffset += 0x10;
            }
            else
            {
                tstCount = 0x0e;
            }

            do
            {
                testBuffer = fileReader.Read(readOffset, 0x10);

                // be sure to point to an interleave value
                if (!interleave_found)
                {
                    if (MemoryReader.memcmp(testBuffer, emptyLine, tstCount, 0x10 - tstCount))
                    {
                        // don't need to stock all empty lines :P
                        if (emptyLineCount >= 100)
                        {
                            emptyLineCount = 0;
                        }

                        if (emptyLineCount >= 1)
                        {
                            if ((readOffset - offset) > 0x60000)
                            {
                                bolSaveEmptyLine = false;
                            }
                        }

                        if (bolSaveEmptyLine)
                        {
                            emptyLineOffset[emptyLineCount] = readOffset;
                            emptyLineCount++;
                        }
                    }
                }

                // Loop Start ...
                if (testBuffer[0x01] == 0x06)
                {
                    if (loopStartPointsCount < 0x10)
                    {
                        loopStartPoints[loopStartPointsCount] = readOffset - offset - 0x10;
                        loopStartPointsCount++;
                    }
                }

                // Loop End ...
                if (((testBuffer[0x01] == 0x03) && (testBuffer[0x03] != 0x77)) ||
                    (testBuffer[0x01] == 0x01))
                {
                    if (loopEndPointsCount < 0x10)
                    {
                        loopEndPoints[loopEndPointsCount] = readOffset - offset;                 //-0x10;
                        loopEndPointsCount++;
                    }

                    if (testBuffer[0x01] == 0x01)
                    {
                        forceNoLoop = true;
                    }
                }

                if (testBuffer[0x01] == 0x04)
                {
                    // 0x04 loop points flag can't be with a 0x03 loop points flag
                    if (loopStartPointsCount < 0x10)
                    {
                        if ((readOffset - offset) == 0)
                        {
                            loopStartPoints[loopStartPointsCount] = 0;
                        }
                        else
                        {
                            loopStartPoints[loopStartPointsCount] = readOffset - offset;
                        }

                        loopStartPointsCount++;

                        // Loop end value is not set by flags ...
                        // go until end of file
                        loopToEnd = true;
                    }
                }
                readOffset += 0x10;
            } while (readOffset < (offset + fileLength));

            // Try to find biggest interleave value
            if (emptyLineCount > 1)
            {
                for (uint count = 1; count < emptyLineCount; count++)
                {
                    if (((uint)(emptyLineOffset[count] - emptyLineOffset[count - 1])) > max_interleave)
                    {
                        max_interleave       = (uint)(emptyLineOffset[count] - emptyLineOffset[count - 1]);
                        max_interleave_index = count;
                    }
                }
                if (max_interleave_index != 0)
                {
                    interleave = (uint)(emptyLineOffset[max_interleave_index] - emptyLineOffset[0]);
                }
            }

            if ((testBuffer[0] == 0x0c) && (testBuffer[1] == 0))
            {
                forceNoLoop = true;
            }

            if (channel_count == 0)
            {
                channel_count = 1;
            }

            // Calc Loop Points & Interleave ...
            if (loopStartPointsCount >= channel_count)
            {
                // can't get more then 0x10 loop point !
                // and need at least 2 loop points
                if ((loopStartPointsCount <= 0x0F) && (loopStartPointsCount >= 2))
                {
                    // Always took the first 2 loop points
                    interleave = loopStartPoints[loopStartPointsCount - 1] - loopStartPoints[loopStartPointsCount - 2];
                    loopStart  = loopStartPoints[1];

                    // Can't be one channel .mib with interleave values
                    if ((interleave > 0) && (channel_count == 1))
                    {
                        channel_count = 2;
                    }
                }
                else
                {
                    loopStart = 0;
                }
            }

            if (loopEndPointsCount >= channel_count)
            {
                // can't get more then 0x10 loop point !
                // and need at least 2 loop points
                if ((loopEndPointsCount <= 0x0F) && (loopEndPointsCount >= 2))
                {
                    if (loopEndPointsCount == 4)
                    {
                        if (interleave == 0)
                        {
                            interleave = loopEndPoints[3] - loopEndPoints[1];
                        }
                        else
                        {
                            interleave = loopEndPoints[loopEndPointsCount - 1] - loopEndPoints[loopEndPointsCount - 2];
                        }
                    }
                    loopEnd = loopEndPoints[loopEndPointsCount - 1];

                    if (interleave >= 0x10)
                    {
                        if (channel_count == 1)
                        {
                            channel_count = 2;
                        }
                    }
                }
                else
                {
                    loopToEnd = false;
                    loopEnd   = 0;
                }
            }

            if (loopToEnd)
            {
                loopEnd = fileLength;
            }

            // force no loop
            if (forceNoLoop)
            {
                loopEnd = 0;
            }

            if ((interleave > 0x10) && (channel_count == 1))
            {
                channel_count = 2;
            }

            if (interleave <= 0)
            {
                interleave = 0x10;
            }

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, (loopEnd != 0));

            /* fill in the vital statistics */
            vgmStream.vgmDecoder = new PSX_Decoder();

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout = new Interleave();
            }

            vgmStream.vgmChannelCount        = channel_count;
            vgmStream.vgmInterleaveBlockSize = (int)interleave;
            vgmStream.vgmLoopFlag            = (loopEnd != 0);

            if (m_Description == null)
            {
                vgmStream.vgmSampleRate = 44100;
            }
            else
            {
                if (System.IO.Path.GetExtension(m_Description).ToUpper() == ".MIB")
                {
                    vgmStream.vgmSampleRate = 44100;
                }
            }

            vgmStream.vgmTotalSamples = (int)(fileLength / (UInt64)16 / (UInt64)(channel_count * 28));

            if (loopEnd != 0)
            {
                if (vgmStream.vgmChannelCount == 1)
                {
                    vgmStream.vgmLoopStartSample = (int)loopStart / 16 * 18;
                    vgmStream.vgmLoopEndSample   = (int)loopEnd / 16 * 28;
                }
                else
                {
                    if (loopStart == 0)
                    {
                        vgmStream.vgmLoopStartSample = 0;
                    }
                    else
                    {
                        vgmStream.vgmLoopStartSample = (int)(((UInt64)(((loopStart / interleave) - 1) * interleave)) / (UInt64)((16 * 14 * channel_count) / channel_count));

                        if (loopStart % interleave != 0)
                        {
                            vgmStream.vgmLoopStartSample += (int)(((UInt64)((loopStart % interleave) - 1) / (UInt64)(16 * 14 * channel_count)));
                        }
                    }

                    if (loopEnd == fileLength)
                    {
                        vgmStream.vgmLoopEndSample = (int)((UInt64)loopEnd / (UInt64)((16 * 28) / channel_count));
                    }
                    else
                    {
                        vgmStream.vgmLoopEndSample = (int)((UInt64)(((loopEnd / interleave) - 1) * interleave) / (UInt64)((16 * 14 * channel_count) / channel_count));

                        if (loopEnd % interleave != 0)
                        {
                            vgmStream.vgmLoopEndSample += (int)((UInt64)((loopEnd % interleave) - 1) / (UInt64)(16 * 14 * channel_count));
                        }
                    }
                }
            }
            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].currentOffset = offset + (interleave * (UInt64)i);
                    vgmStream.vgmChannel[i].fReader       = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());
                }
            }
        }
示例#21
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            bool   loop_flag         = false;
            UInt32 loop_start_sample = 0;
            UInt32 loop_start_offset;
            UInt32 loop_end_sample = 0;
            UInt32 loop_end_offset;

            Int16 coef1 = 0;
            Int16 coef2 = 0;

            int i;

            int channel_count = fileReader.Read_8Bits(offset + 0x07);

            /* check version signature, read loop info */
            UInt16 version_signature = fileReader.Read_16bitsBE(offset + 0x12);
            UInt64 criOffset         = (UInt64)fileReader.Read_16bitsBE(offset + 2) + 4;

            /* encryption */
            if (version_signature == 0x0408)
            {
                //if (find_key(streamFile, &xor_start, &xor_mult, &xor_add))
                //{
                //    coding_type = coding_CRI_ADX_enc;
                //    version_signature = 0x0400;
                //}
            }
            if (version_signature == 0x0300)
            {      /* type 03 */
                if (criOffset - 6 >= 0x2c)
                {  /* enough space for loop info? */
                    loop_flag         = (fileReader.Read_32bitsBE(offset + 0x18) != 0);
                    loop_start_sample = (fileReader.Read_32bitsBE(offset + 0x1c));
                    loop_start_offset = fileReader.Read_32bitsBE(offset + 0x20);
                    loop_end_sample   = fileReader.Read_32bitsBE(offset + 0x24);
                    loop_end_offset   = fileReader.Read_32bitsBE(offset + 0x28);
                }
            }
            else if (version_signature == 0x0400)
            {
                UInt32 ainf_info_length = 0;

                if (fileReader.Read_32bitsBE(offset + 0x24) == 0x41494E46) /* AINF Header */
                {
                    ainf_info_length = fileReader.Read_32bitsBE(offset + 0x28);
                }

                if (criOffset - ainf_info_length - 6 >= 0x38)
                {   /* enough space for loop info? */
                    loop_flag         = (fileReader.Read_32bitsBE(offset + 0x24) != 0);
                    loop_start_sample = (fileReader.Read_32bitsBE(offset + 0x28));
                    loop_start_offset = fileReader.Read_32bitsBE(offset + 0x2C);
                    loop_end_sample   = fileReader.Read_32bitsBE(offset + 0x30);
                    loop_end_offset   = fileReader.Read_32bitsBE(offset + 0x34);
                }
            }
            else if (version_signature == 0x0500)
            {   /* found in some SFD : Buggy Heat, appears to have no loop */
            }

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmSampleRate   = (int)fileReader.Read_32bitsBE(offset + 0x08);
            vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C);

            vgmStream.vgmDecoder = new ADX_Decoder();

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout = new Interleave();
            }

            vgmStream.vgmLoopFlag = loop_flag;

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)loop_start_sample;
                vgmStream.vgmLoopEndSample   = (int)loop_end_sample;
            }

            /* high-pass cutoff frequency, always 500 that I've seen */
            UInt16 cutoff = fileReader.Read_16bitsBE(offset + 0x10);

            /* calculate filter coefficients */
            {
                double x, y, z, a, b, c;

                x = cutoff;
                y = vgmStream.vgmSampleRate;
                z = Math.Cos(2.0 * Math.PI * x / y);

                a = Math.Sqrt(2) - z;
                b = Math.Sqrt(2) - 1.0;
                c = (a - Math.Sqrt((a + b) * (a - b))) / b;

                coef1 = (Int16)Math.Floor(c * 8192);
                coef2 = (Int16)Math.Floor(c * c * -4096);
            }

            vgmStream.vgmInterleaveBlockSize = 18;

            if (InitReader)
            {
                for (i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());

                    vgmStream.vgmChannel[i].adpcm_coef[0] = coef1;
                    vgmStream.vgmChannel[i].adpcm_coef[1] = coef2;
                    vgmStream.vgmChannel[i].startOffset   = vgmStream.vgmChannel[i].currentOffset = offset + criOffset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
                }
            }
        }
示例#22
0
 public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
 {
 }
示例#23
0
        public int update(ref short[] vgmBuffer, int vgmSampleCount, VGM_Stream vgmStream)
        {
            int samples_written = 0;
            int i;

            int frame_size        = vgmStream.vgmDecoder.FrameSize();
            int samples_per_frame = vgmStream.vgmDecoder.SamplesPerFrame();
            int samples_this_block;

            vgmStream.vgmSamplesBlockOffset = 0;

            if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
            {
                return(0);
            }

            samples_this_block = vgmStream.vgmInterleaveBlockSize / frame_size * samples_per_frame;

            if ((vgmStream.vgmLayoutType == VGM_Layout_Type.Interleave_With_Shortblock) &&
                (vgmStream.vgmSamplePlayed - vgmStream.vgmSamplesIntoBlock + samples_this_block > vgmStream.vgmTotalSamples))
            {
                frame_size        = vgmStream.vgmDecoder.ShortFrameSize();
                samples_per_frame = vgmStream.vgmDecoder.SamplesPerShortFrame();

                samples_this_block = vgmStream.vgmInterleaveShortBlockSize / frame_size * samples_per_frame;
            }

            while (samples_written < vgmSampleCount)
            {
                int samples_to_do;

                if (vgmStream.vgmLoopFlag && VGM_Utils.vgmstream_do_loop(vgmStream))
                {
                    /* we assume that the loop is not back into a short block */
                    if (vgmStream.vgmLayoutType == VGM_Layout_Type.Interleave_With_Shortblock)
                    {
                        frame_size         = vgmStream.vgmDecoder.FrameSize();
                        samples_per_frame  = vgmStream.vgmDecoder.SamplesPerFrame();
                        samples_this_block = vgmStream.vgmInterleaveBlockSize / frame_size * samples_per_frame;
                    }
                    continue;
                }

                samples_to_do = VGM_Utils.vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmStream);

                if (samples_written + samples_to_do > vgmSampleCount)
                {
                    samples_to_do = vgmSampleCount - samples_written;
                }

                for (i = 0; i < vgmStream.vgmChannelCount; i++)
                {
                    vgmStream.vgmDecoder.Decode(vgmStream, vgmStream.vgmChannel[i], ref vgmBuffer, vgmStream.vgmChannelCount, vgmStream.vgmSamplesIntoBlock, samples_to_do, i);
                }

                samples_written += samples_to_do;

                vgmStream.vgmSamplesBlockOffset += samples_to_do * vgmStream.vgmChannelCount;
                vgmStream.vgmSamplePlayed       += samples_to_do;
                vgmStream.vgmDecodedSamples     += samples_to_do;
                vgmStream.vgmSamplesIntoBlock   += samples_to_do;

                if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
                {
                    return(samples_written);
                }

                if (vgmStream.vgmSamplesIntoBlock == samples_this_block)
                {
                    if ((vgmStream.vgmLayoutType == VGM_Layout_Type.Interleave_With_Shortblock) &&
                        (vgmStream.vgmSamplePlayed + samples_this_block > vgmStream.vgmTotalSamples))
                    {
                        frame_size        = vgmStream.vgmDecoder.ShortFrameSize();
                        samples_per_frame = vgmStream.vgmDecoder.SamplesPerShortFrame();

                        samples_this_block = vgmStream.vgmInterleaveShortBlockSize / frame_size * samples_per_frame;
                        for (i = 0; i < vgmStream.vgmChannelCount; i++)
                        {
                            vgmStream.vgmChannel[i].currentOffset += (UInt64)((vgmStream.vgmInterleaveBlockSize * (vgmStream.vgmChannelCount - i)) + (vgmStream.vgmInterleaveShortBlockSize * i));
                        }
                    }
                    else
                    {
                        for (i = 0; i < vgmStream.vgmChannelCount; i++)
                        {
                            vgmStream.vgmChannel[i].currentOffset += (UInt64)(vgmStream.vgmInterleaveBlockSize * vgmStream.vgmChannelCount);
                        }
                    }
                    vgmStream.vgmSamplesIntoBlock = 0;
                }
            }

            return(samples_written);
        }
示例#24
0
        public int update(ref short[] vgmBuffer, int vgmSampleCount, VGM_Stream vgmStream)
        {
            int i;
            int samples_written   = 0;
            int frame_size        = vgmStream.vgmDecoder.FrameSize();
            int samples_per_frame = vgmStream.vgmDecoder.SamplesPerFrame();
            int samples_this_block;

            if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
            {
                return(0);
            }

            vgmStream.vgmSamplesBlockOffset = 0;

            if (frame_size == 0)
            {
                samples_this_block = vgmStream.vgmCurrentBlockSize * 2 * samples_per_frame;
            }
            else
            {
                samples_this_block = vgmStream.vgmCurrentBlockSize / frame_size * samples_per_frame;
            }


            while (samples_written < vgmSampleCount)
            {
                int samples_to_do;

                if (vgmStream.vgmLoopFlag && VGM_Utils.vgmstream_do_loop(vgmStream))
                {
                    if (frame_size == 0)
                    {
                        samples_this_block = vgmStream.vgmCurrentBlockSize * 2 * samples_per_frame;
                    }
                    else
                    {
                        samples_this_block = vgmStream.vgmCurrentBlockSize / frame_size * samples_per_frame;
                    }

                    continue;
                }

                samples_to_do = VGM_Utils.vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmStream);

                if (samples_written + samples_to_do > vgmSampleCount)
                {
                    samples_to_do = vgmSampleCount - samples_written;
                }

                if (vgmStream.vgmCurrentBlockOffset >= 0)
                {
                    for (i = 0; i < vgmStream.vgmChannelCount; i++)
                    {
                        vgmStream.vgmDecoder.Decode(vgmStream, vgmStream.vgmChannel[i], ref vgmBuffer, vgmStream.vgmChannelCount, vgmStream.vgmSamplesIntoBlock, samples_to_do, i);
                    }
                }

                samples_written += samples_to_do;

                vgmStream.vgmSamplesBlockOffset += samples_to_do * vgmStream.vgmChannelCount;
                vgmStream.vgmSamplePlayed       += samples_to_do;
                vgmStream.vgmDecodedSamples     += samples_to_do;
                vgmStream.vgmSamplesIntoBlock   += samples_to_do;

                if (vgmStream.vgmDecodedSamples >= vgmStream.vgmTotalSamplesWithLoop)
                {
                    return(samples_written);
                }

                if (vgmStream.vgmSamplesIntoBlock == samples_this_block)
                {
                    switch (vgmStream.vgmLayoutType)
                    {
                    case VGM_Layout_Type.CAF_Blocked:
                        BlockedFnts.CAF_Block_Update(vgmStream.vgmNextBlockOffset, ref vgmStream);
                        break;

                    case VGM_Layout_Type.THP_Blocked:
                        BlockedFnts.THP_Block_Update(vgmStream.vgmNextBlockOffset, ref vgmStream);
                        break;

                    default:
                        break;
                    }

                    if (frame_size == 0)
                    {
                        samples_this_block = vgmStream.vgmCurrentBlockSize * 2 * samples_per_frame;
                    }
                    else
                    {
                        samples_this_block = vgmStream.vgmCurrentBlockSize / frame_size * samples_per_frame;
                    }

                    vgmStream.vgmSamplesIntoBlock = 0;
                }
            }
            return(samples_written);
        }
示例#25
0
 public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
 {
     m_Filename = System.IO.Path.GetFileNameWithoutExtension(fileReader.Read_String(offset + 0x32, 0x1e));
 }
示例#26
0
        /// <summary>
        /// Calculate the number of samples which need to be done
        /// </summary>
        /// <param name="samples_this_block"></param>
        /// <param name="samples_per_frame"></param>
        /// <param name="vgmstream"></param>
        /// <returns></returns>
        public static int vgmstream_samples_to_do(int samples_this_block, int samples_per_frame, VGM_Stream vgmstream)
        {
            int samples_to_do;
            int samples_left_this_block;

            samples_left_this_block = samples_this_block - vgmstream.vgmSamplesIntoBlock;
            samples_to_do           = samples_left_this_block;

            /* fun loopy crap */
            /* Why did I think this would be any simpler? */
            if (vgmstream.vgmLoopFlag)
            {
                /* are we going to hit the loop end during this block? */
                if (vgmstream.vgmSamplePlayed + samples_left_this_block > vgmstream.vgmLoopEndSample)
                {
                    /* only do to just before it */
                    samples_to_do = vgmstream.vgmLoopEndSample - vgmstream.vgmSamplePlayed;
                }

                /* are we going to hit the loop start during this block? */
                if (!vgmstream.vgmHitLoop && vgmstream.vgmSamplePlayed + samples_left_this_block > vgmstream.vgmLoopStartSample)
                {
                    /* only do to just before it */
                    samples_to_do = vgmstream.vgmLoopStartSample - vgmstream.vgmSamplePlayed;
                }
            }

            /* if it's a framed encoding don't do more than one frame */
            if ((samples_per_frame > 1) && ((vgmstream.vgmSamplesIntoBlock % samples_per_frame) + samples_to_do > samples_per_frame))
            {
                samples_to_do = samples_per_frame - (vgmstream.vgmSamplesIntoBlock % samples_per_frame);
            }

            return(samples_to_do);
        }
示例#27
0
        public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
        {
            UInt64 head_offset = fileReader.Read_16bitsBE(offset + 0x0C);

            if (head_offset == 0x10)
            {
                m_Description = "Nintendo RSTM Header v1";
            }
            else
            {
                m_Description = "Nintendo RSTM Header v2";
            }

            UInt64 rl_head_offset = head_offset + offset;

            bool loop_flag = (fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x19 : rl_head_offset + 0x21) != 0);
            bool isDSP     = false;

            int codec_number  = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x8 : rl_head_offset + 0x20);
            int channel_count = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0xa : rl_head_offset + 0x22);

            /* build the VGMSTREAM */
            VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);

            switch (codec_number)
            {
            case 0:
                vgmStream.vgmDecoder = new PCM8_Decoder();
                break;

            case 1:
                vgmStream.vgmDecoder     = new PCM16_Decoder();
                vgmStream.vgmDecoderType = VGM_Decoder_Type.PCM16BITSBE;
                break;

            case 2:
                isDSP = true;
                vgmStream.vgmDecoder = new DSP_Decoder();
                break;
            }

            vgmStream.vgmChannelCount = channel_count;
            vgmStream.vgmLoopFlag     = loop_flag;
            vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x14 : rl_head_offset + 0x2c);
            vgmStream.vgmSampleRate   = fileReader.Read_16bitsBE((head_offset == 0x10) ? rl_head_offset + 0xC : rl_head_offset + 0x24);

            if (loop_flag)
            {
                vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x10 : rl_head_offset + 0x28);
                vgmStream.vgmLoopEndSample   = vgmStream.vgmTotalSamples;
            }

            if (channel_count == 1)
            {
                vgmStream.vgmLayout = new NoLayout();
            }
            else
            {
                vgmStream.vgmLayout     = new Interleave();
                vgmStream.vgmLayoutType = VGM_Layout_Type.Interleave_With_Shortblock;
            }

            vgmStream.vgmInterleaveBlockSize      = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x20 : rl_head_offset + 0x38);
            vgmStream.vgmInterleaveShortBlockSize = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x30 : rl_head_offset + 0x48);

            if (isDSP)
            {
                int i, j;
                int coef_spacing = ((head_offset == 0x10) ? 0x30 : 0x38);

                UInt64 coef_offset1 = fileReader.Read_32bitsBE(rl_head_offset + 0x1C);
                UInt64 coef_offset2 = fileReader.Read_32bitsBE(rl_head_offset + 0x10 + coef_offset1);
                UInt64 coef_offset  = ((head_offset == 0x10) ? 0x38 : coef_offset2 + 0x10);

                for (j = 0; j < vgmStream.vgmChannelCount; j++)
                {
                    for (i = 0; i < 16; i++)
                    {
                        vgmStream.vgmChannel[j].adpcm_coef[i] = (Int16)fileReader.Read_16bitsBE(rl_head_offset + coef_offset + (UInt64)(j * coef_spacing + i * 2));
                    }
                }
            }

            UInt64 start_offset = offset + fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x18 : rl_head_offset + 0x30);

            if (InitReader)
            {
                for (int i = 0; i < channel_count; i++)
                {
                    vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());;
                    vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename());
                    vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID());

                    vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(i * vgmStream.vgmInterleaveBlockSize);
                }
            }
        }
示例#28
0
        /// <summary>
        /// Test if we enter a loop point
        /// </summary>
        /// <param name="vgmstream">VGM_Stream Class previously instantied</param>
        /// <returns>True if we reach a loop point (start or end)</returns>
        public static bool vgmstream_do_loop(VGM_Stream vgmstream)
        {
            int i;
            int j;

            // Loop End ?
            if (vgmstream.vgmSamplePlayed == vgmstream.vgmLoopEndSample)
            {
                for (i = 0; i < vgmstream.vgmChannelCount; i++)
                {
                    // Restore the state of each channel when loop was reached ...
                    vgmstream.vgmChannel[i].adpcm_history_16bits_1 = vgmstream.vgmChannelAtLoop[i].adpcm_history_16bits_1;
                    vgmstream.vgmChannel[i].adpcm_history_16bits_2 = vgmstream.vgmChannelAtLoop[i].adpcm_history_16bits_2;
                    vgmstream.vgmChannel[i].adpcm_history_32bits_1 = vgmstream.vgmChannelAtLoop[i].adpcm_history_32bits_1;
                    vgmstream.vgmChannel[i].adpcm_history_32bits_2 = vgmstream.vgmChannelAtLoop[i].adpcm_history_32bits_2;
                    vgmstream.vgmChannel[i].adx_channels           = vgmstream.vgmChannelAtLoop[i].adx_channels;
                    vgmstream.vgmChannel[i].adx_xor  = vgmstream.vgmChannelAtLoop[i].adx_xor;
                    vgmstream.vgmChannel[i].adx_mult = vgmstream.vgmChannelAtLoop[i].adx_mult;
                    vgmstream.vgmChannel[i].adx_add  = vgmstream.vgmChannelAtLoop[i].adx_add;

                    for (j = 0; j < 16; j++)
                    {
                        vgmstream.vgmChannel[i].adpcm_coef[j] = vgmstream.vgmChannelAtLoop[i].adpcm_coef[j];
                    }

                    vgmstream.vgmChannel[i].currentOffset = vgmstream.vgmChannelAtLoop[i].currentOffset;
                }
                vgmstream.vgmSamplePlayed       = vgmstream.vgmSamplePlayedInLoop;
                vgmstream.vgmSamplesIntoBlock   = vgmstream.vgmSamplesIntoBlockInLoop;
                vgmstream.vgmCurrentBlockSize   = vgmstream.vgmCurrentBlockSizeInLoop;
                vgmstream.vgmCurrentBlockOffset = vgmstream.vgmCurrentBlockOffsetInLoop;
                vgmstream.vgmNextBlockOffset    = vgmstream.vgmNextBlockOffsetInLoop;
                return(true);
            }

            // Loop Start ?
            if ((!vgmstream.vgmHitLoop) && (vgmstream.vgmSamplePlayed == vgmstream.vgmLoopStartSample))
            {
                for (i = 0; i < vgmstream.vgmChannelCount; i++)
                {
                    // Save the state of each channel when loop is reached
                    vgmstream.vgmChannelAtLoop[i].adpcm_history_16bits_1 = vgmstream.vgmChannel[i].adpcm_history_16bits_1;
                    vgmstream.vgmChannelAtLoop[i].adpcm_history_16bits_2 = vgmstream.vgmChannel[i].adpcm_history_16bits_2;
                    vgmstream.vgmChannelAtLoop[i].adpcm_history_32bits_1 = vgmstream.vgmChannel[i].adpcm_history_32bits_1;
                    vgmstream.vgmChannelAtLoop[i].adpcm_history_32bits_2 = vgmstream.vgmChannel[i].adpcm_history_32bits_2;

                    vgmstream.vgmChannelAtLoop[i].adx_channels = vgmstream.vgmChannel[i].adx_channels;
                    vgmstream.vgmChannelAtLoop[i].adx_xor      = vgmstream.vgmChannel[i].adx_xor;
                    vgmstream.vgmChannelAtLoop[i].adx_mult     = vgmstream.vgmChannel[i].adx_mult;
                    vgmstream.vgmChannelAtLoop[i].adx_add      = vgmstream.vgmChannel[i].adx_add;

                    for (j = 0; j < 16; j++)
                    {
                        vgmstream.vgmChannelAtLoop[i].adpcm_coef[j] = vgmstream.vgmChannel[i].adpcm_coef[j];
                    }

                    vgmstream.vgmChannelAtLoop[i].currentOffset = vgmstream.vgmChannel[i].currentOffset;
                    vgmstream.vgmCurrentBlockSizeInLoop         = vgmstream.vgmCurrentBlockSize;
                    vgmstream.vgmCurrentBlockOffsetInLoop       = vgmstream.vgmCurrentBlockOffset;
                    vgmstream.vgmNextBlockOffsetInLoop          = vgmstream.vgmNextBlockOffset;
                }
                vgmstream.vgmSamplePlayedInLoop     = vgmstream.vgmSamplePlayed;
                vgmstream.vgmSamplesIntoBlockInLoop = vgmstream.vgmSamplesIntoBlock;
                vgmstream.vgmHitLoop = true;
            }
            return(false);
        }
示例#29
0
 /// <summary>
 /// Calculate the total count of samples of the stream
 /// </summary>
 /// <param name="looptimes">Number of loops</param>
 /// <param name="fadeseconds">Number of seconds used for fading</param>
 /// <param name="fadedelayseconds">Delay beween each fading</param>
 /// <param name="vgmstream">VGM Stream Class previously instantied</param>
 /// <returns>Number of samples (loops include)</returns>
 public static Int32 get_vgmstream_play_samples(double looptimes, double fadeseconds, double fadedelayseconds, VGM_Stream vgmstream)
 {
     if (vgmstream.vgmLoopFlag)
     {
         return((Int32)(vgmstream.vgmLoopStartSample + (vgmstream.vgmLoopEndSample - vgmstream.vgmLoopStartSample) * looptimes + (fadedelayseconds + fadeseconds) * vgmstream.vgmSampleRate));
     }
     else
     {
         return(vgmstream.vgmTotalSamples);
     }
 }