C:> mtp2wav g:\song0003.vr6\take01df.vr6 guitar.wav

    C:> mtp2wav -r 48000 -d 16 g:\song0003.vr6\take01df.vr6 guitar.wav

'-------------------------------------------------------------------------------------------------------
' MTP2WAVBatch.vbs
' Vbscript file to execute the MTP2WAV.EXE file to convert Roland Take VR6 files to WAV files 
' This script will convert all of the take???? vr6 files in a song folder 
' A log file will be put into the song folder with information on the wav files created
' Insert this code into a file with a filetype of vbs
'-------------------------------------------------------------------------------------------------------

Dim oFSO
Dim oCurrentFolder
Dim oStream
Dim oLogFile
Dim sSongPath
DIM sProgramPath

'-------------------------------------------------------------------
' Change the Program Path consistent to where MTP2WAV.EXE is located
'-------------------------------------------------------------------
sProgramPath = "c:\NewStuff\Personal\vs\"

'-----------------------------------------------------
' Change the song path consistent with the song folder
'Change the rate and bit settings as appropriate 
'-----------------------------------------------------
sSongPath = "c:\NewStuff\Personal\vs\SONG0002VR6\"
sRate = "44100"
sBit = "24"

Set oFSO = CreateObject("scripting.filesystemobject")
Set oStream = oFSO.createtextfile(sSongPath + "mtp2wavbatch.log", True)
SearchFolder (oFSO.getfolder(sSongPath)), oStream, sSongPath, sProgramPath, sRate, sBit
MsgBox "Conversion Completed." + vbCr + "Check: " + vbCr + sSongPath + vbCr + "for results."

'-------------------------------------------------------------------------------
' Subroutine : Search the folder for take files and convert
'-------------------------------------------------------------------------------
Sub SearchFolder(oCurrentFolder, oLogFile, sSongPath, sProgramPath, sRate, sBit)
    
    Dim sTemp
    Dim sInName
    Dim sInType
    Dim sOutName
    Dim sOutput
    Dim oInFile
    Dim oStream
    Dim oShell
    
    sInName = "TAKE"   
    sInType = ".VR6"
    
    For Each oInFile In oCurrentFolder.Files
        sTemp = Right(oInFile.Name, 4)
        If UCase(sTemp) = UCase(sInType) Then
           sTemp = Left(oInFile.Name, 4)
           If UCase(sTemp) = UCase(sInName) Then
              sOutName = left(CStr(oInFile.Name), 8) + "." + "WAV"
              sOutput = sSongPath + left(CStr(oInFile.Name), 8) + "." + "WAV" + _
" created by MTP2WAV.EXE on " + CStr(Now())
              Set oShell = WScript.CreateObject( "WScript.Shell" )
              oShell.Run sProgramPath + "mtp2wav" + " -r " + sRate + " -d " + sBit + " " + _
sSongPath + CStr(oInFile.Name) + " " + sSongPath + sOutName, 1, TRUE
              set oShell = nothing 
              oLogFile.writeline sOutput
           End If
        End If
    Next
       
End Sub

    mtp2wav -t 1,2 g:\song0002 track1.wav

This is my C code.

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"
#using <mscorlib.dll>
using namespace System;
#include <stdio.h>
#include <sys/stat.h>

/*
    VS1680 Backup Disc TAKE stripper
	Don Speirs 11/15/06

	Must work on an .iso image of a 1680 roland backup disc 

	Rev 0.0.0
*/

long fsize(const char *const name);
unsigned int FindTAKE0(unsigned int SRIndex, char* SR);
void MakeTakeFileName(char* outFileName,unsigned int InIndex,char* ShiftReg);
unsigned int FindVS1680ET25D(unsigned int SRIndex,char* SR);

//*****************************************************************************
int _tmain(int argc, char **argv)
{

	long WhereAmI;
	unsigned int State = 0;
	unsigned int i;
	char ShiftReg[32];
	unsigned int InIndex = 0;	
    	char* inFileName  = NULL;
	char outFileName[30];
	long FileSize;

	FILE* fin; 
	FILE* fout; 

// Process input file name

    if(inFileName == NULL) 
		inFileName  = argv[1];

	if(inFileName  == NULL &#0124;&#0124; strlen(inFileName)  == 0)
	{
		printf("Usage: rdr <input_file> \n");
		exit(0);
	}

// Open the input file or error out

	if((fin = fopen(inFileName,  "rb")) == NULL)
	{
		printf("INPUT FILE NOT FOUND\n");
		exit(0);
	}

// Binary file so need to know length to check for EOF

	if((FileSize  = fsize(inFileName)) == -1)
	{
		printf("ERROR in deteriming file size\n");
		exit(0);
	}

// When looking for TAKExxxx need to be 5 ahead of store in the shift register

	fread(ShiftReg, 1, 5, fin);
	InIndex = 5;

// Run all the way to file end

	while((WhereAmI = ftell(fin)) < FileSize)
	{

// Stuff incoming data bytes into circular buffer

		ShiftReg[InIndex++] = getc(fin);
		if(InIndex == 32)
			InIndex = 0;

// Run State Machine

		switch(State)
		{
		case 0:

// State0 is looking for a START TAKE delimiter

			State = FindTAKE0(InIndex,ShiftReg);
			break;

		case 1:

// State1 is building the filename for this TAKE (<Songname (12bytes)><TAKExxxx>)

			for(i=0;i<3;i++)
			{
				ShiftReg[InIndex++] = getc(fin);
				if(InIndex == 32)
					InIndex = 0;
			}

			MakeTakeFileName(outFileName,InIndex,ShiftReg);
			if((fout = fopen(outFileName,	"wb")) == NULL)
			{
				printf("ERROR creating output file\n");
				exit(0);
			}

// Don't know why data is so far after the delimiter but it seems to be consistant over several backup discs....

			fseek(fin, 0x5BBD, 1);

// Stay 16 ahead of file write for finding the END OF TAKE delimiter

			fread(ShiftReg, 1, 16, fin);
			InIndex = 16;			

			State = 2;
			break;

		case 2:

// State2 is write the data until the END OF TAKE delimiter found
// When delimiter found close file and start looking for another TAKE until all input bytes processed
// This is 1680 specific??? what do other VS machines look like???

			if(FindVS1680ET25D(InIndex,ShiftReg))
			{
				fclose(fout);
				State = 0;

// When looking for the next TAKExxxx need to be 5 ahead of store in the shift register

				fread(ShiftReg, 1, 5, fin);
				InIndex = 5;
			}
			else			
				putc(ShiftReg[(32 + InIndex - 11)%32],fout);			
			
			break;
		}
	}

    fclose(fin);
    fclose(fout);
}
//*****************************************************************************
unsigned int FindTAKE0(unsigned int SRIndex, char* SR)
{
// Find START OF TAKE delimiter
// Get enough data to build the file name from the buffer while doing it

	unsigned int Index;
	char* Datapntr;

	Index = (32 + SRIndex - 5)%32;

	Datapntr = SR + Index;
	if(*Datapntr != 'T')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'A')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'K')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'E')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

// The word TAKE exists other places but always followed by a space

	Datapntr = SR + Index;
	if(*Datapntr == ' ')
		return(0);

// We have a full TAKEx string in the circular buffer...time to start saving the data

	return(1);
}

unsigned int FindVS1680ET25D(unsigned int SRIndex,char* SR)
{
// END OF TAKE delimiter in a 1680 backup

	unsigned int Index;
	char* Datapntr;

	Index = (32 + SRIndex - 11)%32;

	Datapntr = SR + Index;
	if(*Datapntr != 'V')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'S')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '1')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '6')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '8')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '0')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'E')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'T')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '2')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != '5')
		return(0);

	Index++;
	if(Index == 32)
		Index = 0;

	Datapntr = SR + Index;
	if(*Datapntr != 'D')
		return(0);

	return(1);

}
void MakeTakeFileName(char* outFileName,unsigned int InIndex,char* SR)
{
// Use song name and take# to build a file name (<Songname (12bytes)><TAKExxxx>)

	unsigned int Index,i;
	char* DataPntr;

	Index = (32+InIndex-31)%32;
	DataPntr = SR + Index;

	for(i=0;i<12;i++)
	{
		*outFileName++ = *DataPntr;
		Index++;
		DataPntr++;

		if(Index == 32)
		{
			Index = 0;
			DataPntr -= 32;
		}
	}

	for(i=0;i<10;i++)
	{
		Index++;
		DataPntr++;
		if(Index == 32)
		{
			Index = 0;
			DataPntr -= 32;
		}
	}	

	for(i=0;i<8;i++)
	{
		*outFileName++ = *DataPntr;

		Index++;
		DataPntr++;

		if(Index == 32)
		{
			Index = 0;
			DataPntr -= 32;
		}
	}

	*outFileName++ = '.';
	*outFileName++ = 'V';
	*outFileName++ = 'R';
	*outFileName++ = '6';
}

long fsize(const char *const name)
{
// Find the length of the file

    struct stat stbuf;
    if(stat(name, &stbuf) == -1)
        return -1; // The file could not be accessed.
 
    return stbuf.st_size;
}

             out[0]  = MASK_L(in[13], 0x7f, 0);
            out[1]  = MASK_L(in[12], 0x7f, 1) | MASK_R(in[13], 0x80, 7);
            out[2]  = MASK_L(in[9],  0x3f, 1) | MASK_R(in[12], 0x80, 7);
            out[3]  = MASK_L(in[8],  0x3f, 2) | MASK_R(in[9],  0xc0, 6);
            out[4]  = MASK_L(in[5],  0x1f, 2) | MASK_R(in[8],  0xc0, 6);
            out[5]  = MASK_L(in[4],  0x1f, 3) | MASK_R(in[5],  0xe0, 5);
            out[6]  = MASK_L(in[1],  0x0f, 3) | MASK_R(in[4],  0xe0, 5);
            out[7]  = MASK_L(in[0],  0x0f, 4) | MASK_R(in[1],  0xf0, 4);

            out[8]  = MASK_L(in[15], 0x7f, 0);
            out[9]  = MASK_L(in[14], 0x7f, 1) | MASK_R(in[15], 0x80, 7);
            out[10] = MASK_L(in[11], 0x3f, 1) | MASK_R(in[14], 0x80, 7);
            out[11] = MASK_L(in[10], 0x3f, 2) | MASK_R(in[11], 0xc0, 6);
            out[12] = MASK_L(in[7],  0x1f, 2) | MASK_R(in[10], 0xc0, 6);
            out[13] = MASK_L(in[6],  0x1f, 3) | MASK_R(in[7],  0xe0, 5);
            out[14] = MASK_L(in[3],  0x0f, 3) | MASK_R(in[6],  0xe0, 5);
            out[15] = MASK_L(in[2],  0x0f, 4) | MASK_R(in[3],  0xf0, 4);

            SIGN_EXTEND_7(out[0]);  SIGN_EXTEND_8(out[1]);  SIGN_EXTEND_7(out[2]);  SIGN_EXTEND_8(out[3]);
            SIGN_EXTEND_7(out[4]);  SIGN_EXTEND_8(out[5]);  SIGN_EXTEND_7(out[6]);  SIGN_EXTEND_8(out[7]);
            SIGN_EXTEND_7(out[8]);  SIGN_EXTEND_8(out[9]);  SIGN_EXTEND_7(out[10]); SIGN_EXTEND_8(out[11]);
            SIGN_EXTEND_7(out[12]); SIGN_EXTEND_8(out[13]); SIGN_EXTEND_7(out[14]); SIGN_EXTEND_8(out[15]);

            SHIFT_ROUND_17(out[0]);  SHIFT_ROUND_16(out[1]);  SHIFT_ROUND_17(out[2]);  SHIFT_ROUND_16(out[3]);
            SHIFT_ROUND_17(out[4]);  SHIFT_ROUND_16(out[5]);  SHIFT_ROUND_17(out[6]);  SHIFT_ROUND_16(out[7]);
            SHIFT_ROUND_17(out[8]);  SHIFT_ROUND_16(out[9]);  SHIFT_ROUND_17(out[10]); SHIFT_ROUND_16(out[11]);
            SHIFT_ROUND_17(out[12]); SHIFT_ROUND_16(out[13]); SHIFT_ROUND_17(out[14]); SHIFT_ROUND_16(out[15]);

            // 16 linears - but odd samples are doubled
            DECREMENT(out[0]);  DECREMENT(out[1]);  DECREMENT(out[2]);  DECREMENT(out[3]);
            DECREMENT(out[4]);  DECREMENT(out[5]);  DECREMENT(out[6]);  DECREMENT(out[7]);
            DECREMENT(out[8]);  DECREMENT(out[9]);  DECREMENT(out[10]); DECREMENT(out[11]);
            DECREMENT(out[12]); DECREMENT(out[13]); DECREMENT(out[14]); DECREMENT(out[15]);

            LIMIT_24(out[0]);  LIMIT_24(out[1]);  LIMIT_24(out[2]);  LIMIT_24(out[3]);
            LIMIT_24(out[4]);  LIMIT_24(out[5]);  LIMIT_24(out[6]);  LIMIT_24(out[7]);
            LIMIT_24(out[8]);  LIMIT_24(out[9]);  LIMIT_24(out[10]); LIMIT_24(out[11]);
            LIMIT_24(out[12]); LIMIT_24(out[13]); LIMIT_24(out[14]); LIMIT_24(out[15]);