src/tools/gig2mono.cpp

/***************************************************************************
 *                                                                         *
 *   libgig - C++ cross-platform Gigasampler format file access library    *
 *                                                                         *
 *   Copyright (C) 2003-2014 by Christian Schoenebeck                      *
 *                              <cuse@users.sourceforge.net>               *
 *                                                                         *
 *   This program is part of libgig.                                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/ 

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <errno.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <iostream>
#include <cstdlib>
#include <string>
#include <set>
#include <vector>

#ifdef WIN32
# define DIR_SEPARATOR '\\'
#else
# define DIR_SEPARATOR '/'
#endif

#include "../gig.h"

using namespace std;

/**
 * How the Gigasampler samples shall be converted from stereo to mono.
 */
enum conversion_method_t {
    CONVERT_MIX_CHANNELS,  ///< Mix left & right audio channel together.
    CONVERT_LEFT_CHANNEL,  ///< Only pick left audio channel for mono output.
    CONVERT_RIGHT_CHANNEL  ///< Only pick right audio channel for mono output.
};

static set<string> g_files;

static conversion_method_t g_conversionMethod = CONVERT_MIX_CHANNELS;

static void printUsage() {
    cout << "gig2mono - converts Gigasampler files from stereo to mono." << endl;
    cout << endl;
    cout << "Usage: gig2mono [-r] [--left | --right | --mix] FILE_OR_DIR1 [ FILE_OR_DIR2 ... ]" << endl;
    cout << "       gig2mono -v" << endl;
    cout << endl;
    cout << "   -r       Recurse through subdirectories." << endl;
    cout << endl;
    cout << "   --mix    Convert by mixing left & right audio channels (default)." << endl;
    cout << endl;
    cout << "   --left   Convert by using left audio channel data." << endl;
    cout << endl;
    cout << "   --right  Convert by using right audio channel data." << endl;
    cout << endl;
    cout << "   -v       Print version and exit." << endl;
    cout << endl;
}

static string programRevision() {
    string s = "$Revision$";
    return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
}

static void printVersion() {
    cout << "gig2mono revision " << programRevision() << endl;
    cout << "using " << gig::libraryName() << " " << gig::libraryVersion() << endl;
}

static bool isGigFileName(const string path) {
    const string t = ".gig";
    return path.substr(path.length() - t.length()) == t;
}

static void collectFilesOfDir(string path, bool bRecurse, bool* pbError = NULL) {
    DIR* d = opendir(path.c_str());
    if (!d) {
        if (pbError) *pbError = true;
        cerr << strerror(errno) << " : '" << path << "'" << endl;
        return;
    }

    for (struct dirent* e = readdir(d); e; e = readdir(d)) {
        if (string(e->d_name) == "." || string(e->d_name) == "..")
            continue;

        const string fullName = path + DIR_SEPARATOR + e->d_name;

        struct stat s;
        if (stat(fullName.c_str(), &s)) {
            if (pbError) *pbError = true;
            cerr << strerror(errno) << " : '" << fullName << "'" << endl;
            continue;
        }

        if (S_ISREG(s.st_mode) && isGigFileName(fullName)) {
            g_files.insert(fullName);
        } else if (S_ISDIR(s.st_mode) && bRecurse) {
            collectFilesOfDir(fullName, bRecurse, pbError);
        }
    }

    closedir(d);
}

static void collectFiles(string path, bool bRecurse, bool* pbError = NULL) {
    struct stat s;
    if (stat(path.c_str(), &s)) {
        if (pbError) *pbError = true;
        cerr << strerror(errno) << " : '" << path << "'" << endl;
        return;
    }
    if (S_ISREG(s.st_mode) && isGigFileName(path)) {
        g_files.insert(path);
    } else if (S_ISDIR(s.st_mode)) {
        collectFilesOfDir(path, bRecurse, pbError);
    } else {
        if (pbError) *pbError = true;
        cerr << "Neither a regular (.gig) file nor directory : '" << path << "'" << endl;
    }
}

static bool convertFileToMono(const string path) {
    try {
        RIFF::File riff(path);
        gig::File gig(&riff);
        
        gig::buffer_t decompressionBuffer;
        unsigned long decompressionBufferSize = 0; // in sample points, not bytes
        vector< vector<uint8_t> > audioBuffers;
        vector<uint8_t> stereoBuffer;
        
        // count the total amount of samples
        int nSamples = 0;
        for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample())
            nSamples++;

        audioBuffers.resize(nSamples);

        // read all original (stereo) sample audio data, convert it to mono and
        // keep the mono audio data in tempoary buffers in RAM
        bool bModified = false;
        int i = 0;
        for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample(), ++i) {
            if (pSample->Channels != 2)
                continue; // ignore samples not being stereo

            // ensure audio conversion buffer is large enough for this sample
            const long neededStereoSize = pSample->SamplesTotal * pSample->FrameSize;
            const long neededMonoSize   = neededStereoSize / 2;
            if (stereoBuffer.size() < neededStereoSize)
                stereoBuffer.resize(neededStereoSize);
            audioBuffers[i].resize(neededMonoSize);

            // read sample's current (stereo) audio data
            if (pSample->Compressed) {
                if (decompressionBufferSize < pSample->SamplesTotal) {
                    decompressionBufferSize = pSample->SamplesTotal;
                    gig::Sample::DestroyDecompressionBuffer(decompressionBuffer);
                    decompressionBuffer = gig::Sample::CreateDecompressionBuffer(pSample->SamplesTotal);
                }
                pSample->Read(&stereoBuffer[0], pSample->SamplesTotal, &decompressionBuffer);
            } else {
                pSample->Read(&stereoBuffer[0], pSample->SamplesTotal);
            }

            const int stereoFrameSize = pSample->FrameSize;
            const int monoFrameSize   = stereoFrameSize / 2;

            // This condition must be satisfied for the conversion for() loops
            // below to not end up beyond buffer boundaries. This check should
            // only fail on corrupt .gig files.
            if (stereoBuffer.size() % stereoFrameSize != 0) {
                cerr << "Internal error: Invalid stereo data length (" << int(stereoBuffer.size()) << " bytes)" << endl;
                return false; // error
            }

            // convert stereo -> mono
            switch (g_conversionMethod) {
                case CONVERT_LEFT_CHANNEL: {
                    const int n = pSample->SamplesTotal;
                    for (int m = 0; m < n; ++m) {
                        for (int k = 0; k < monoFrameSize; ++k) {
                            audioBuffers[i][m * monoFrameSize + k] = stereoBuffer[m * stereoFrameSize + k];
                        }
                    }
                    break;
                }

                case CONVERT_RIGHT_CHANNEL: {
                    const int n = pSample->SamplesTotal;
                    for (int m = 0; m < n; ++m) {
                        for (int k = 0; k < monoFrameSize; ++k) {
                            audioBuffers[i][m * monoFrameSize + k] = stereoBuffer[m * stereoFrameSize + k + monoFrameSize];
                        }
                    }
                    break;
                }

                case CONVERT_MIX_CHANNELS:
                    switch (pSample->BitDepth) {
                        case 16: {
                            int16_t* in  = (int16_t*) &stereoBuffer[0];
                            int16_t* out = (int16_t*) &audioBuffers[i][0];
                            const int n = pSample->SamplesTotal;
                            for (int m = 0; m < n; ++m) {
                                const float l = in[m*2];
                                const float r = in[m*2+1];
                                out[m] = int16_t((l + r) * 0.5f);
                            }
                            break;
                        }

                        case 24: {
                            int8_t* p = (int8_t*) &stereoBuffer[0];
                            int16_t* out = (int16_t*) &audioBuffers[i][0];
                            const int n = pSample->SamplesTotal;
                            for (int t = 0, m = 0; m < n; t += 6, ++m) {
                                #if WORDS_BIGENDIAN
                                const float l = p[t + 0] << 8 | p[t + 1] << 16 | p[t + 2] << 24;
                                const float r = p[t + 3] << 8 | p[t + 4] << 16 | p[t + 5] << 24;
                                #else
                                // 24bit read optimization: 
                                // a misaligned 32bit read and subquent 8 bit shift is faster (on x86)  than reading 3 single bytes and shifting them
                                const float l = (*((int32_t *)(&p[t])))   << 8;
                                const float r = (*((int32_t *)(&p[t+3]))) << 8;
                                #endif
                                out[m] = int16_t((l + r) * 0.5f);
                            }
                            break;
                        }

                        default:
                            cerr << "Internal error: Invalid sample bit depth (" << int(pSample->BitDepth) << " bit)" << endl;
                            return false; // error
                    }
                    break;
                    
                default:
                    cerr << "Internal error: Invalid conversion method (#" << int(g_conversionMethod) << ")" << endl;
                    return false; // error
            }

            // update sample's meta informations for mono
            pSample->Channels = 1;
            if (pSample->FrameSize) pSample->FrameSize /= 2;
            // libgig does not support saving of compressed samples
            pSample->Compressed = false;

            // schedule sample for physical resize operation
            pSample->Resize(pSample->SamplesTotal);

            bModified = true;
        }

        if (!bModified) {
            cout << "[ignored: not stereo] " << flush;
            return true; // success
        }

        // remove all stereo dimensions (if any)
        for (gig::Instrument* instr = gig.GetFirstInstrument(); instr; instr = gig.GetNextInstrument()) {
            for (gig::Region* rgn = instr->GetFirstRegion(); rgn; rgn = instr->GetNextRegion()) {
                for (int k = 0; k < 8; ++k) {
                    if (rgn->pDimensionDefinitions[k].dimension == gig::dimension_samplechannel) {
                        rgn->DeleteDimension(&rgn->pDimensionDefinitions[k]);
                        goto nextRegion;
                    }
                }
                nextRegion:;
            }
        }

        // Make sure sample chunks are resized to the required size on disk,
        // so we can directly write the audio data directly to the file on disk
        // as next step. This is required because in worst case the original
        // stereo sample audio data might be compressed and might be smaller in
        // size than the final (always uncompressed) mono audio data size.
        gig.Save();

        // now convert and write the samples' mono audio data directly to the file
        i = 0;
        for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample(), ++i) {
            if (audioBuffers[i].empty())
                continue; // was not a stereo sample before, so ignore this one

            const int n = audioBuffers[i].size() / pSample->FrameSize;
            pSample->Write(&audioBuffers[i][0], n);
        }
    } catch (RIFF::Exception e) {
        cerr << "Failed converting file:" << endl;
        e.PrintMessage();
        return false; // error
    } catch (...) {
        cerr << "Unknown exception occurred while trying to convert file." << endl;
        return false; // error
    }
    return true; // success
}

int main(int argc, char *argv[]) {
    int nOptions = 0;
    bool bOptionRecurse = false;

    // validate & parse arguments provided to this program
    if (argc <= 1) {
        printUsage();
        return EXIT_FAILURE;
    }
    for (int i = 1; i < argc; ++i) {
        const string opt = argv[i];
        if (opt == "--") { // common for all command line tools: separator between initial option arguments and i.e. subsequent file arguments
            nOptions++;
            break;
        }
        if (opt.substr(0, 1) != "-") break;
        
        if (opt == "-v") {
            printVersion();
            return EXIT_SUCCESS;
        } else if (opt == "-r") {
            nOptions++;
            bOptionRecurse = true;
        } else if (opt == "--left") {
            nOptions++;
            g_conversionMethod = CONVERT_LEFT_CHANNEL;
        } else if (opt == "--right") {
            nOptions++;
            g_conversionMethod = CONVERT_RIGHT_CHANNEL;
        } else if (opt == "--mix") {
            nOptions++;
            g_conversionMethod = CONVERT_MIX_CHANNELS;
        }
    }
    const int nFileArguments = argc - nOptions - 1;
    if (nFileArguments < 1) {
        printUsage();
        return EXIT_FAILURE;
    }

    bool bError = false;

    // assemble list of .gig file names to be converted
    for (int i = nOptions + 1; i < argc; ++i) {
        collectFiles(argv[i], bOptionRecurse, &bError);
    }
    if (g_files.size() < 1) {
        cerr << "No file given to be converted!" << endl;
        return EXIT_FAILURE;
    }
    if (bError) {
        cerr << "Aborted due to error. No file has been changed." << endl;
        return EXIT_FAILURE;
    }

    // convert each file in the assembled list of file names
    {
        int i = 0;
        for (set<string>::const_iterator it = g_files.begin(); it != g_files.end(); ++it, ++i) {
            cout << "Converting file " << (i+1) << "/" << int(g_files.size()) << ": " << *it << " ... " << flush;
            bool bSuccess = convertFileToMono(*it);
            if (!bSuccess) return EXIT_FAILURE;
            cout << "OK" << endl;
        }
    }

    return EXIT_SUCCESS;
}
1	schoenebeck	2484	/***************************************************************************
2			* *
3			* libgig - C++ cross-platform Gigasampler format file access library *
4			* *
5	schoenebeck	2573	* Copyright (C) 2003-2014 by Christian Schoenebeck *
6	schoenebeck	2484	* <cuse@users.sourceforge.net> *
7			* *
8			* This program is part of libgig. *
9			* *
10			* This program is free software; you can redistribute it and/or modify *
11			* it under the terms of the GNU General Public License as published by *
12			* the Free Software Foundation; either version 2 of the License, or *
13			* (at your option) any later version. *
14			* *
15			* This program is distributed in the hope that it will be useful, *
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18			* GNU General Public License for more details. *
19			* *
20			* You should have received a copy of the GNU General Public License *
21			* along with this program; if not, write to the Free Software *
22			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
23			* MA 02111-1307 USA *
24			***************************************************************************/
25
26			#ifdef HAVE_CONFIG_H
27			# include <config.h>
28			#endif
29			#include <errno.h>
30			#include <sys/stat.h>
31			#include <dirent.h>
32			#include <string.h>
33			#include <iostream>
34			#include <cstdlib>
35			#include <string>
36			#include <set>
37			#include <vector>
38
39			#ifdef WIN32
40			# define DIR_SEPARATOR '\\'
41			#else
42			# define DIR_SEPARATOR '/'
43			#endif
44
45	schoenebeck	2573	#include "../gig.h"
46	schoenebeck	2484
47			using namespace std;
48
49			/**
50			* How the Gigasampler samples shall be converted from stereo to mono.
51			*/
52			enum conversion_method_t {
53			CONVERT_MIX_CHANNELS, ///< Mix left & right audio channel together.
54			CONVERT_LEFT_CHANNEL, ///< Only pick left audio channel for mono output.
55			CONVERT_RIGHT_CHANNEL ///< Only pick right audio channel for mono output.
56			};
57
58			static set<string> g_files;
59
60			static conversion_method_t g_conversionMethod = CONVERT_MIX_CHANNELS;
61
62			static void printUsage() {
63			cout << "gig2mono - converts Gigasampler files from stereo to mono." << endl;
64			cout << endl;
65			cout << "Usage: gig2mono [-r] [--left \| --right \| --mix] FILE_OR_DIR1 [ FILE_OR_DIR2 ... ]" << endl;
66			cout << " gig2mono -v" << endl;
67			cout << endl;
68			cout << " -r Recurse through subdirectories." << endl;
69			cout << endl;
70			cout << " --mix Convert by mixing left & right audio channels (default)." << endl;
71			cout << endl;
72			cout << " --left Convert by using left audio channel data." << endl;
73			cout << endl;
74			cout << " --right Convert by using right audio channel data." << endl;
75			cout << endl;
76			cout << " -v Print version and exit." << endl;
77			cout << endl;
78			}
79
80			static string programRevision() {
81	schoenebeck	2493	string s = "$Revision$";
82	schoenebeck	2484	return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
83			}
84
85			static void printVersion() {
86			cout << "gig2mono revision " << programRevision() << endl;
87			cout << "using " << gig::libraryName() << " " << gig::libraryVersion() << endl;
88			}
89
90			static bool isGigFileName(const string path) {
91			const string t = ".gig";
92			return path.substr(path.length() - t.length()) == t;
93			}
94
95			static void collectFilesOfDir(string path, bool bRecurse, bool* pbError = NULL) {
96			DIR* d = opendir(path.c_str());
97			if (!d) {
98			if (pbError) *pbError = true;
99			cerr << strerror(errno) << " : '" << path << "'" << endl;
100			return;
101			}
102
103			for (struct dirent* e = readdir(d); e; e = readdir(d)) {
104			if (string(e->d_name) == "." \|\| string(e->d_name) == "..")
105			continue;
106
107			const string fullName = path + DIR_SEPARATOR + e->d_name;
108
109			struct stat s;
110			if (stat(fullName.c_str(), &s)) {
111			if (pbError) *pbError = true;
112			cerr << strerror(errno) << " : '" << fullName << "'" << endl;
113			continue;
114			}
115
116			if (S_ISREG(s.st_mode) && isGigFileName(fullName)) {
117			g_files.insert(fullName);
118			} else if (S_ISDIR(s.st_mode) && bRecurse) {
119			collectFilesOfDir(fullName, bRecurse, pbError);
120			}
121			}
122
123			closedir(d);
124			}
125
126			static void collectFiles(string path, bool bRecurse, bool* pbError = NULL) {
127			struct stat s;
128			if (stat(path.c_str(), &s)) {
129			if (pbError) *pbError = true;
130			cerr << strerror(errno) << " : '" << path << "'" << endl;
131			return;
132			}
133			if (S_ISREG(s.st_mode) && isGigFileName(path)) {
134			g_files.insert(path);
135			} else if (S_ISDIR(s.st_mode)) {
136			collectFilesOfDir(path, bRecurse, pbError);
137			} else {
138			if (pbError) *pbError = true;
139			cerr << "Neither a regular (.gig) file nor directory : '" << path << "'" << endl;
140			}
141			}
142
143			static bool convertFileToMono(const string path) {
144			try {
145			RIFF::File riff(path);
146			gig::File gig(&riff);
147
148			gig::buffer_t decompressionBuffer;
149			unsigned long decompressionBufferSize = 0; // in sample points, not bytes
150			vector< vector<uint8_t> > audioBuffers;
151			vector<uint8_t> stereoBuffer;
152
153			// count the total amount of samples
154			int nSamples = 0;
155			for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample())
156			nSamples++;
157
158			audioBuffers.resize(nSamples);
159
160			// read all original (stereo) sample audio data, convert it to mono and
161			// keep the mono audio data in tempoary buffers in RAM
162			bool bModified = false;
163			int i = 0;
164			for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample(), ++i) {
165			if (pSample->Channels != 2)
166			continue; // ignore samples not being stereo
167
168			// ensure audio conversion buffer is large enough for this sample
169			const long neededStereoSize = pSample->SamplesTotal * pSample->FrameSize;
170			const long neededMonoSize = neededStereoSize / 2;
171			if (stereoBuffer.size() < neededStereoSize)
172			stereoBuffer.resize(neededStereoSize);
173			audioBuffers[i].resize(neededMonoSize);
174
175			// read sample's current (stereo) audio data
176			if (pSample->Compressed) {
177			if (decompressionBufferSize < pSample->SamplesTotal) {
178			decompressionBufferSize = pSample->SamplesTotal;
179			gig::Sample::DestroyDecompressionBuffer(decompressionBuffer);
180			decompressionBuffer = gig::Sample::CreateDecompressionBuffer(pSample->SamplesTotal);
181			}
182			pSample->Read(&stereoBuffer[0], pSample->SamplesTotal, &decompressionBuffer);
183			} else {
184			pSample->Read(&stereoBuffer[0], pSample->SamplesTotal);
185			}
186
187			const int stereoFrameSize = pSample->FrameSize;
188			const int monoFrameSize = stereoFrameSize / 2;
189
190			// This condition must be satisfied for the conversion for() loops
191			// below to not end up beyond buffer boundaries. This check should
192			// only fail on corrupt .gig files.
193			if (stereoBuffer.size() % stereoFrameSize != 0) {
194			cerr << "Internal error: Invalid stereo data length (" << int(stereoBuffer.size()) << " bytes)" << endl;
195			return false; // error
196			}
197
198			// convert stereo -> mono
199			switch (g_conversionMethod) {
200			case CONVERT_LEFT_CHANNEL: {
201			const int n = pSample->SamplesTotal;
202			for (int m = 0; m < n; ++m) {
203			for (int k = 0; k < monoFrameSize; ++k) {
204			audioBuffers[i][m * monoFrameSize + k] = stereoBuffer[m * stereoFrameSize + k];
205			}
206			}
207			break;
208			}
209
210			case CONVERT_RIGHT_CHANNEL: {
211			const int n = pSample->SamplesTotal;
212			for (int m = 0; m < n; ++m) {
213			for (int k = 0; k < monoFrameSize; ++k) {
214			audioBuffers[i][m * monoFrameSize + k] = stereoBuffer[m * stereoFrameSize + k + monoFrameSize];
215			}
216			}
217			break;
218			}
219
220			case CONVERT_MIX_CHANNELS:
221			switch (pSample->BitDepth) {
222			case 16: {
223			int16_t* in = (int16_t*) &stereoBuffer[0];
224			int16_t* out = (int16_t*) &audioBuffers[i][0];
225			const int n = pSample->SamplesTotal;
226			for (int m = 0; m < n; ++m) {
227			const float l = in[m*2];
228			const float r = in[m*2+1];
229			out[m] = int16_t((l + r) * 0.5f);
230			}
231			break;
232			}
233
234			case 24: {
235			int8_t* p = (int8_t*) &stereoBuffer[0];
236			int16_t* out = (int16_t*) &audioBuffers[i][0];
237			const int n = pSample->SamplesTotal;
238			for (int t = 0, m = 0; m < n; t += 6, ++m) {
239			#if WORDS_BIGENDIAN
240			const float l = p[t + 0] << 8 \| p[t + 1] << 16 \| p[t + 2] << 24;
241			const float r = p[t + 3] << 8 \| p[t + 4] << 16 \| p[t + 5] << 24;
242			#else
243			// 24bit read optimization:
244			// a misaligned 32bit read and subquent 8 bit shift is faster (on x86) than reading 3 single bytes and shifting them
245			const float l = (((int32_t )(&p[t]))) << 8;
246			const float r = (((int32_t )(&p[t+3]))) << 8;
247			#endif
248			out[m] = int16_t((l + r) * 0.5f);
249			}
250			break;
251			}
252
253			default:
254			cerr << "Internal error: Invalid sample bit depth (" << int(pSample->BitDepth) << " bit)" << endl;
255			return false; // error
256			}
257			break;
258
259			default:
260			cerr << "Internal error: Invalid conversion method (#" << int(g_conversionMethod) << ")" << endl;
261			return false; // error
262			}
263
264			// update sample's meta informations for mono
265			pSample->Channels = 1;
266			if (pSample->FrameSize) pSample->FrameSize /= 2;
267			// libgig does not support saving of compressed samples
268			pSample->Compressed = false;
269
270			// schedule sample for physical resize operation
271			pSample->Resize(pSample->SamplesTotal);
272
273			bModified = true;
274			}
275
276			if (!bModified) {
277			cout << "[ignored: not stereo] " << flush;
278			return true; // success
279			}
280
281			// remove all stereo dimensions (if any)
282			for (gig::Instrument* instr = gig.GetFirstInstrument(); instr; instr = gig.GetNextInstrument()) {
283			for (gig::Region* rgn = instr->GetFirstRegion(); rgn; rgn = instr->GetNextRegion()) {
284			for (int k = 0; k < 8; ++k) {
285			if (rgn->pDimensionDefinitions[k].dimension == gig::dimension_samplechannel) {
286			rgn->DeleteDimension(&rgn->pDimensionDefinitions[k]);
287			goto nextRegion;
288			}
289			}
290			nextRegion:;
291			}
292			}
293
294			// Make sure sample chunks are resized to the required size on disk,
295			// so we can directly write the audio data directly to the file on disk
296			// as next step. This is required because in worst case the original
297			// stereo sample audio data might be compressed and might be smaller in
298			// size than the final (always uncompressed) mono audio data size.
299			gig.Save();
300
301			// now convert and write the samples' mono audio data directly to the file
302			i = 0;
303			for (gig::Sample* pSample = gig.GetFirstSample(); pSample; pSample = gig.GetNextSample(), ++i) {
304			if (audioBuffers[i].empty())
305			continue; // was not a stereo sample before, so ignore this one
306
307			const int n = audioBuffers[i].size() / pSample->FrameSize;
308			pSample->Write(&audioBuffers[i][0], n);
309			}
310			} catch (RIFF::Exception e) {
311			cerr << "Failed converting file:" << endl;
312			e.PrintMessage();
313			return false; // error
314			} catch (...) {
315	schoenebeck	3048	cerr << "Unknown exception occurred while trying to convert file." << endl;
316	schoenebeck	2484	return false; // error
317			}
318			return true; // success
319			}
320
321			int main(int argc, char *argv[]) {
322			int nOptions = 0;
323			bool bOptionRecurse = false;
324
325			// validate & parse arguments provided to this program
326			if (argc <= 1) {
327			printUsage();
328			return EXIT_FAILURE;
329			}
330			for (int i = 1; i < argc; ++i) {
331			const string opt = argv[i];
332			if (opt == "--") { // common for all command line tools: separator between initial option arguments and i.e. subsequent file arguments
333			nOptions++;
334			break;
335			}
336			if (opt.substr(0, 1) != "-") break;
337
338			if (opt == "-v") {
339			printVersion();
340			return EXIT_SUCCESS;
341			} else if (opt == "-r") {
342			nOptions++;
343			bOptionRecurse = true;
344			} else if (opt == "--left") {
345			nOptions++;
346			g_conversionMethod = CONVERT_LEFT_CHANNEL;
347			} else if (opt == "--right") {
348			nOptions++;
349			g_conversionMethod = CONVERT_RIGHT_CHANNEL;
350			} else if (opt == "--mix") {
351			nOptions++;
352			g_conversionMethod = CONVERT_MIX_CHANNELS;
353			}
354			}
355			const int nFileArguments = argc - nOptions - 1;
356			if (nFileArguments < 1) {
357			printUsage();
358			return EXIT_FAILURE;
359			}
360
361			bool bError = false;
362
363			// assemble list of .gig file names to be converted
364			for (int i = nOptions + 1; i < argc; ++i) {
365			collectFiles(argv[i], bOptionRecurse, &bError);
366			}
367			if (g_files.size() < 1) {
368			cerr << "No file given to be converted!" << endl;
369			return EXIT_FAILURE;
370			}
371			if (bError) {
372			cerr << "Aborted due to error. No file has been changed." << endl;
373			return EXIT_FAILURE;
374			}
375
376			// convert each file in the assembled list of file names
377			{
378			int i = 0;
379			for (set<string>::const_iterator it = g_files.begin(); it != g_files.end(); ++it, ++i) {
380			cout << "Converting file " << (i+1) << "/" << int(g_files.size()) << ": " << *it << " ... " << flush;
381			bool bSuccess = convertFileToMono(*it);
382			if (!bSuccess) return EXIT_FAILURE;
383			cout << "OK" << endl;
384			}
385			}
386
387			return EXIT_SUCCESS;
388			}