#ifndef __LP64__

#include <iostream></iostream>

#include "texception.h"

#include "tsound.h"

#include "tconvert.h"

#include "tpropertytype.h"

#include "timageinfo.h"

#include "trasterimage.h"

#include "tmachine.h"

#include "tsystem.h"

#include "movsettings.h"

#include "tiio_movM.h"

/* QuickDraw は 10.7 以降なくなった */

//#define HAS_QUICKDRAW

namespace

{

const string firstFrameKey = "frst";

const int firstFrameKeySize = 4 * sizeof(char);

//------------------------------------------------------------------------------

class QuickTimeCleanUp;

class QuickTimeStuff

{

public:

	static QuickTimeStuff *instance()

	{

		if (!m_singleton)

			m_singleton = new QuickTimeStuff();

		return m_singleton;

	}

	OSErr getStatus() { return m_status; }

	~QuickTimeStuff()

	{

	}

private:

	QuickTimeStuff() : m_status(noErr)

	{

		m_status = noErr;

		EnterMovies();

	}

	static QuickTimeStuff *m_singleton;

	OSErr m_status;

	friend class QuickTimeCleanUp; //questa DEVE essere friend, cosi' posso controllare direttamente

								   //lo stato del singleton.

};

class QuickTimeCleanUp

{

public:

	QuickTimeCleanUp() {}

	~QuickTimeCleanUp()

	{ /*

                        Nel caso si arrivasse qui senza il singleton instanziato, e si facesse direttamente

                        'delete QuickTimeStuff::instance();' Quicktime non farebbe in tempo a terminare le

                        sue routine di inizializzazione (che sono ANCHE su altri thread) e la chiamata a

                        TerminateQTML() causerebbe un crash

                        */

		//std::cout << "destroing variable... Thread = " << GetCurrentThreadId() << std::endl;

		//              std::cout <<"~QTCleanup"<< std::endl;

		if (QuickTimeStuff::m_singleton)

			delete QuickTimeStuff::m_singleton;

	}

};

QuickTimeCleanUp cleanUp;

QuickTimeStuff *QuickTimeStuff::m_singleton = 0;

//------------------------------------------------------------------------------

enum QTLibError {

	QTNoError = 0x0000,

	QTNotInstalled,

	QTUnknownError,

	QTUnableToOpenFile,

	QTCantCreateFile,

	QTUnableToGetCompressorNames,

	QTUnableToCreateResource,

	QTUnableToUpdateMovie,

	QTBadTimeValue,

	QTUnableToDoMovieTask,

	QTUnableToSetTimeValue,

	QTUnableToSetMovieGWorld,

	QTUnableToSetMovieBox,

};

} //namespace

////-----------------------------------------------------------

//

//CodecType Tiio::MovWriterProperties::getCurrentCodec()const

//{

//std::map<wstring, codectype="">::const_iterator it;</wstring,>

//

//it = m_codecMap.find(m_codec.getValue());

//assert(it!=m_codecMap.end());

//return it->second;

//}

//

////-----------------------------------------------------------

//

//wstring Tiio::MovWriterProperties::getCurrentNameFromCodec(CodecType &cCodec)const

//{

//std::map<wstring, codectype="">::const_iterator it;</wstring,>

//

//for(it=m_codecMap.begin();it!=m_codecMap.end();++it)

//{

////  CodecType tmp=it->second;

//  if(it->second==cCodec) break;

//}

//assert(it!=m_codecMap.end());

//return it->first;

//}

//

////-----------------------------------------------------------

//

//wstring Tiio::MovWriterProperties::getCurrentQualityFromCodeQ(CodecQ &cCodecQ)const

//{

//std::map<wstring, codecq="">::const_iterator it;</wstring,>

//

//for(it=m_qualityMap.begin();it!=m_qualityMap.end();++it)

//{

////  CodecQ tmp=it->second;

//  if(it->second==cCodecQ) break;

//}

//assert(it!=m_qualityMap.end());

//return it->first;

//}

//

////-----------------------------------------------------------

//

//CodecQ Tiio::MovWriterProperties::getCurrentQuality() const

//{

//std::map<wstring, codecq="">::const_iterator it;</wstring,>

//

//it = m_qualityMap.find(m_quality.getValue());

//assert(it!=m_qualityMap.end());

//return it->second;

//}

//

////-----------------------------------------------------------

//

//

//TPropertyGroup* Tiio::MovWriterProperties::clone() const

//{

//  MovWriterProperties*g = new MovWriterProperties();

//

//	g->m_codec.setValue(m_codec.getValue());

//	g->m_quality.setValue(m_quality.getValue());

//

//return (TPropertyGroup*)g;

//}

Tiio::MovWriterProperties::MovWriterProperties()

//: m_codec("Codec")

//, m_quality("Quality")

{

	if (QuickTimeStuff::instance()->getStatus() != noErr) {

		return;

	}

	//if (InitializeQTML(0)!=noErr)

	//    return;

	ComponentInstance ci = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);

	QTAtomContainer settings;

	if (SCGetSettingsAsAtomContainer(ci, &settings) != noErr)

		assert(false);

	fromAtomsToProperties(settings, *this);

	/*

CodecNameSpecListPtr codecList;

if (GetCodecNameList(&codecList, 0) !=noErr) return;

TIntEnumeration codecNames;

for (short i = 0; i < codecList->count; ++i)

  {

  CodecNameSpec *codecNameSpec = &(codecList->list[i]);

  // codecNameSpec->typeName contains the name of the codec in Pascal String Format

  // byte 0 = Len

  // byte [1..Len] data

  UCHAR len = codecNameSpec->typeName[0];

  string name((char*)&codecNameSpec->typeName[1], len);

	m_codec.addValue(toWideString(name));

	if (i==0) m_codec.setValue(toWideString(name));

	m_codecMap[toWideString(name)] = codecNameSpec->cType;

  }

DisposeCodecNameList(codecList);

TIntEnumeration  codecQuality;

m_quality.addValue(L"min quality"); 

      m_qualityMap[L"min quality"] = codecMinQuality;

m_quality.addValue(L"low quality");

      m_qualityMap[L"low quality"] = codecLowQuality;

m_quality.addValue(L"normal quality");

      m_qualityMap[L"normal quality"] = codecNormalQuality;

m_quality.addValue(L"high quality");

      m_qualityMap[L"high quality"] = codecHighQuality;

m_quality.addValue(L"max quality");

      m_qualityMap[L"max quality"] = codecMaxQuality;

m_quality.addValue(L"lossless quality");

      m_qualityMap[L"lossless quality"] = codecLosslessQuality;

m_quality.setValue(L"normal quality");

bind(m_codec);

bind(m_quality);

*/

	/*

m_qualityTable.insert(QualityTable::value_type(q++, codecMinQuality));

m_qualityTable.insert(QualityTable::value_type(q++, codecLowQuality));

m_qualityTable.insert(QualityTable::value_type(q++, codecMaxQuality));

m_qualityTable.insert(QualityTable::value_type(q++, codecNormalQuality));

m_qualityTable.insert(QualityTable::value_type(q++, codecHighQuality));

m_qualityTable.insert(QualityTable::value_type(q++, codecLosslessQuality));

addProperty(CodecQualityId, codecQuality,0);*/

}

namespace

{

string buildQTErrorString(int ec)

{

	switch (ec) {

	case QTNotInstalled:

		return "Can't create; ensure that quicktime is correctly installed on your machine";

	case QTUnknownError:

		return "Unknown error";

	case QTUnableToOpenFile:

		return "can't open file";

	case QTCantCreateFile:

		return "can't create movie";

	case QTUnableToGetCompressorNames:

		return "unable to get compressor name";

	case QTUnableToCreateResource:

		return "can't create resource";

	case QTUnableToUpdateMovie:

		return "unable to update movie";

	case QTBadTimeValue:

		return "bad frame number";

	case QTUnableToDoMovieTask:

		return "unable to do movie task";

	case QTUnableToSetTimeValue:

		return "unable to set time value";

	case QTUnableToSetMovieGWorld:

		return "unable to set movie graphic world";

	case QTUnableToSetMovieBox:

		return "unable to set movie box";

	default: {

		return "unknown error ('" + toString(ec) + "')";

	}

	}

}

//-----------------------------------------------------------

#ifdef WIN2

inline LPSTR AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars, UINT acp)

{

	assert(lpw != NULL);

	assert(lpa != NULL);

	// verify that no illegal character present

	// since lpa was allocated based on the size of lpw

	// don't worry about the number of chars

	lpa[0] = '\0';

	WideCharToMultiByte(acp, 0, lpw, -1, lpa, nChars, NULL, NULL);

	return lpa;

}

#endif

//-----------------------------------------------------------

string long2fourchar(TINT32 fcc)

{

	string s;

	s += (char((fcc & 0xff000000) >> 24));

	s += (char((fcc & 0x00ff0000) >> 16));

	s += (char((fcc & 0x0000ff00) >> 8));

	s += (char((fcc & 0x000000ff) >> 0));

	return s;

}

//-------------------------------------------------------------------------------

TimeScale frameRateToTimeScale(double frameRate)

{

	return tround(frameRate * 100.0);

}

//-------------------------------------------------------------------------------

const string CodecNamesId = "PU_CodecName";

const string CodecQualityId = "PU_CodecQuality";

} //namespace

//------------------------------------------------------------------------------

bool IsQuickTimeInstalled()

{

	return QuickTimeStuff::instance()->getStatus() == noErr;

}

//------------------------------------------------------------------------------

//  TImageWriterMov

//------------------------------------------------------------------------------

class TImageWriterMov : public TImageWriter

{

public:

	TImageWriterMov(const TFilePath &, int frameIndex, TLevelWriterMov *);

	~TImageWriterMov() { m_lwm->release(); }

	bool is64bitOutputSupported() { return false; }

private:

	//not implemented

	TImageWriterMov(const TImageWriterMov &);

	TImageWriterMov &operator=(const TImageWriterMov &src);

public:

	void save(const TImageP &);

	int m_frameIndex;

private:

	TLevelWriterMov *m_lwm;

};

//-----------------------------------------------------------

//  TImageReaderMov

//-----------------------------------------------------------

class TImageReaderMov : public TImageReader

{

public:

	TImageReaderMov(const TFilePath &, int frameIndex, TLevelReaderMov *);

	~TImageReaderMov() { m_lrm->release(); }

private:

	//not implemented

	TImageReaderMov(const TImageReaderMov &);

	TImageReaderMov &operator=(const TImageReaderMov &src);

public:

	TImageP load();

	void load(const TRasterP &rasP, const TPoint &pos = TPoint(0, 0), int shrinkX = 1, int shrinkY = 1);

	int m_frameIndex;

	TDimension getSize() const { return m_lrm->getSize(); }

	TRect getBBox() const { return m_lrm->getBBox(); }

private:

	TLevelReaderMov *m_lrm;

};

//-----------------------------------------------------------

//-----------------------------------------------------------

//        TImageWriterMov

//-----------------------------------------------------------

TImageWriterMov::TImageWriterMov(const TFilePath &path, int frameIndex, TLevelWriterMov *lwm)

	: TImageWriter(path), m_lwm(lwm), m_frameIndex(frameIndex)

{

	m_lwm->addRef();

}

//----------

namespace

{

void copy(TRasterP rin, PixelXRGB *bufout, int lx, int ly, unsigned short rowbytes = 0)

{

	rin->lock();

	TRaster32P rin32 = rin;

	assert(rin32);

	int lineOffset = (rowbytes == 0) ? lx : rowbytes / sizeof(PixelXRGB); //in pixelsize, cioe 4 bytes

	PixelXRGB *rowout = &(bufout[(ly - 1) * lineOffset]) /*-startOffset*/;

	for (int y = 0; y < rin32->getLy(); y++) {

		PixelXRGB *pixout = rowout;

		TPixelRGBM32 *pixin = rin32->pixels(y);

		TPixelRGBM32 *pixinEnd = pixin + rin32->getLx();

		while (pixin < pixinEnd) {

			pixout->x = pixin->m;

			pixout->r = pixin->r;

			pixout->g = pixin->g;

			pixout->b = pixin->b;

			pixout++;

			pixin++;

		}

		rowout -= lineOffset;

	}

	rin->unlock();

} //end function

};

//-----------------------------------------------------------

/*

TWriterInfo *TWriterInfoMov::create(const string &)

{

return new TWriterInfoMov();

}

//-----------------------------------------------------------

TWriterInfoMov::TWriterInfoMov(const TWriterInfoMov&src)

               :TWriterInfo(src)

               ,m_codecTable(src.m_codecTable)

               ,m_qualityTable(src.m_qualityTable)

{

}

//-----------------------------------------------------------

TWriterInfo *TWriterInfoMov::clone() const

{

return new TWriterInfoMov(*this);

}

//-----------------------------------------------------------

TWriterInfoMov::TWriterInfoMov() 

               :TWriterInfo()

{

if (QuickTimeStuff::instance()->getStatus()!=noErr)

  {

  return;

  }

CodecNameSpecListPtr codecList;

if (GetCodecNameList(&codecList, 0) !=noErr)

  {

  return;

  }

TIntEnumeration codecNames;

for (short i = 0; i < codecList->count; ++i)

  {

  CodecNameSpec *codecNameSpec = &(codecList->List[i]);

  // codecNameSpec->typeName contains the name of the codec in Pascal String Format

  // byte 0 = Len

  // byte [1..Len] data

  UCHAR len = codecNameSpec->typeName[0];

  string name((char*)&codecNameSpec->typeName[1], len);

  codecNames.addItem(name, i);

  m_codecTable.insert(CodecTable::value_type(i, codecNameSpec->cType));

  }

DisposeCodecNameList(codecList);

addProperty(CodecNamesId, codecNames, 0);

int q = 0;

TIntEnumeration  codecQuality;

codecQuality.addItem("min quality",q); 

m_qualityTable.insert(QualityTable::value_type(q++, codecMinQuality));

codecQuality.addItem("low quality",q);

m_qualityTable.insert(QualityTable::value_type(q++, codecLowQuality));

codecQuality.addItem("max quality",q);

m_qualityTable.insert(QualityTable::value_type(q++, codecMaxQuality));

codecQuality.addItem("normal quality",q);

m_qualityTable.insert(QualityTable::value_type(q++, codecNormalQuality));

codecQuality.addItem("high quality",q);

m_qualityTable.insert(QualityTable::value_type(q++, codecHighQuality));

codecQuality.addItem("lossless quality",q);

m_qualityTable.insert(QualityTable::value_type(q++, codecLosslessQuality));

addProperty(CodecQualityId, codecQuality,0);

}

TWriterInfoMov::~TWriterInfoMov()

{}

*/

//-----------------------------------------------------------

void TImageWriterMov::save(const TImageP &img)

{

	m_lwm->save(img, m_frameIndex);

}

//-----------------------------------------------------------

namespace

{

bool getFSRefFromPosixPath(const char *filepath, FSRef *fileRef, bool writing)

{

	const UInt8 *filename = (const UInt8 *)filepath;

	if (writing) {

		FILE *fp = fopen(filepath, "wb");

		if (!fp)

			return false;

		fclose(fp);

	}

	OSErr err = FSPathMakeRef(filename, fileRef, 0);

	return err == noErr;

}

bool getFSSpecFromPosixPath(const char *filepath, FSSpec *fileSpec, bool writing)

{

	FSRef fileRef;

	if (!getFSRefFromPosixPath(filepath, &fileRef, writing))

		return false;

	OSErr err = FSGetCatalogInfo(&fileRef, kFSCatInfoNone, 0, 0, fileSpec, 0);

	return err == noErr;

}

}

void TLevelWriterMov::save(const TImageP &img, int frameIndex)

{

	m_firstFrame = tmin(frameIndex, m_firstFrame);

	TRasterImageP image(img);

	if (!image)

		throw TImageException(getFilePath(), "Unsupported image type");

	int lx = image->getRaster()->getLx();

	int ly = image->getRaster()->getLy();

	//void *buffer = image->getRaster()->getRawData();

	int pixSize = image->getRaster()->getPixelSize();

	if (pixSize != 4)

		throw TImageException(getFilePath(), "Unsupported pixel type");

	QMutexLocker sl(&m_mutex);

	if (!m_properties)

		m_properties = new Tiio::MovWriterProperties();

	Tiio::MovWriterProperties *prop = (Tiio::MovWriterProperties *)(m_properties);

	/*

const char* codec = toString(prop->m_codec.getValue()).c_str();

const char* qual = toString(prop->m_quality.getValue()).c_str();

*/

	//CodecType codecType;

	//try {

	//codecType = prop->getCurrentCodec();

	//  } catch (...)//boost::bad_any_cast&)

	//    {

	//    throw TImageException(m_path, "bad codec name");

	//    }

	//

	//CodecQ quality = prop->getCurrentQuality();

	QDErr err;

	if (m_videoTrack == 0) {

		QTAtomContainer atoms;

		QTNewAtomContainer(&atoms);

		fromPropertiesToAtoms(*prop, atoms);

		m_ci = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);

		if (SCSetSettingsFromAtomContainer(m_ci, atoms) != noErr) {

			CloseComponent(m_ci);

			assert(!"cannot use that quickTime codec, use default");

			m_ci = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);

		}

		QTDisposeAtomContainer(atoms);

		//FSSpec fspec;

		Rect frame;

		long max_compressed_size;

		if (QuickTimeStuff::instance()->getStatus() != noErr) {

			m_IOError = QTNotInstalled;

			throw TImageException(m_path, buildQTErrorString(m_IOError));

		}

		// First, set the movie's time scale to match a suitable multiple of m_frameRate.

		// The timeScale will be used for both the movie and media.

		TimeScale timeScale = ::frameRateToTimeScale(m_frameRate);

		SetMovieTimeScale(m_movie, timeScale);

		m_videoTrack = NewMovieTrack(m_movie, FixRatio((short)lx, 1), FixRatio((short)ly, 1), kNoVolume);

		if ((err = GetMoviesError() != noErr))

			throw TImageException(getFilePath(), "can't create video track");

		m_videoMedia = NewTrackMedia(m_videoTrack, VideoMediaType, timeScale, 0, 0);

		if ((err = GetMoviesError() != noErr))

			throw TImageException(getFilePath(), "can't create video media");

		frame.left = 0;

		frame.top = 0;

		frame.right = lx;

		frame.bottom = ly;

#if QT_VERSION >= 0x050000

		if ((err = QTNewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0)) != noErr)

#else

		if ((err = NewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0)) != noErr)

#endif

			throw TImageException(getFilePath(), "can't create movie buffer");

		//#ifdef WIN32

		//  LockPixels(m_gworld->portPixMap);

		//  if ((err = GetMaxCompressionSize(m_gworld->portPixMap, &frame, 0,

		//                                quality,  compression,anyCodec,

		//                         	 &max_compressed_size))!=noErr)

		//    throw TImageException(getFilePath(), "can't get max compression size");

		//

		//#else

		//  PixMapHandle pixmapH = GetPortPixMap (m_gworld);

		//

		//  LockPixels(pixmapH);

		//  if ((err = GetMaxCompressionSize(pixmapH, &frame, 0,

		//                                quality,  codecType,anyCodec,

		//				 &max_compressed_size))!=noErr)

		//    throw TImageException(getFilePath(), "can't get max compression size");

		//

		//#endif

		//m_compressedData = NewHandle(max_compressed_size);

		if ((err = MemError()) != noErr)

			throw TImageException(getFilePath(), "can't allocate compressed data for movie");

		//MoveHHi(m_compressedData);

		//HLock(m_compressedData);

		if ((err = MemError()) != noErr)

			throw TImageException(getFilePath(), "can't allocate img handle");

/* FIXME: QuickDraw とともに無くなったようだ */

#if defined(HAS_QUICKDRAW)

		m_pixmap = GetGWorldPixMap(m_gworld);

		if (!LockPixels(m_pixmap))

			throw TImageException(getFilePath(), "can't lock pixels");

		buf = (PixelXRGB *)GetPixBaseAddr(m_pixmap);

#endif

		buf_lx = lx;

		buf_ly = ly;

	}

	if ((err = BeginMediaEdits(m_videoMedia)) != noErr)

		throw TImageException(getFilePath(), "can't begin edit video media");

	unsigned short rowBytes = (unsigned short)(((short)(*(m_pixmap))->rowBytes & ~(3 << 14)));

	Rect frame;

	ImageDescriptionHandle img_descr = 0;

	Handle compressedData = 0;

	frame.left = 0;

	frame.top = 0;

	frame.right = lx;

	frame.bottom = ly;

	TRasterP ras = image->getRaster();

#ifdef WIN32

	compressed_data_ptr = StripAddress(*(m_compressedData));

	copy(ras, buf, buf_lx, buf_ly);

#else

	//compressed_data_ptr  = *m_compressedData;

	copy(ras, buf, buf_lx, buf_ly, rowBytes);

#endif

//img_descr = (ImageDescriptionHandle)NewHandle(4);

#ifdef WIN32

	if ((err = CompressImage(m_gworld->portPixMap,

							 &frame,

							 quality, compression,

							 img_descr, compressed_data_ptr)) != noErr)

		throw TImageException(getFilePath(), "can't compress image");

#else

#if defined(HAS_QUICKDRAW)

	PixMapHandle pixmapH = GetPortPixMap(m_gworld);

	if ((err = SCCompressImage(

			 m_ci,

			 pixmapH,

			 &frame,

			 &img_descr,

			 &compressedData)) != noErr)

		throw TImageException(getFilePath(), "can't compress image");

#endif

// if ((err = CompressImage(pixmapH,

//	                 &frame,

//  			 quality, codecType,

//			 img_descr, compressed_data_ptr))!=noErr)

//  throw TImageException(getFilePath(), "can't compress image");

#endif

	TimeValue sampleTime;

	if ((err = AddMediaSample(m_videoMedia, compressedData, 0,

							  (*img_descr)->dataSize, 100,

							  (SampleDescriptionHandle)img_descr,

							  1, 0, &sampleTime)) != noErr)

		throw TImageException(getFilePath(), "can't add image to movie media");

	if ((err = EndMediaEdits(m_videoMedia)) != noErr)

		throw TImageException(getFilePath(), "can't end edit media");

	DisposeHandle(compressedData);

	DisposeHandle((Handle)img_descr);

	m_savedFrames.push_back(std::pair<int, timevalue="">(frameIndex, sampleTime));</int,>

}

//-----------------------------------------------------------

//        TLevelWriterMov

//-----------------------------------------------------------

TLevelWriterMov::TLevelWriterMov(const TFilePath &path, TPropertyGroup *winfo)

	: TLevelWriter(path, winfo), m_IOError(QTNoError), m_pixmap(0)

	  //,m_compressedData(0)

	  ,

	  m_gworld(0), m_videoMedia(0), m_videoTrack(0), m_soundMedia(0), m_soundTrack(0), m_movie(0), m_firstFrame((std::numeric_limits<int>::max)())</int>

{

	m_frameRate = 12.;

	QDErr err;

	FSSpec fspec;

	if (QuickTimeStuff::instance()->getStatus() != noErr) {

		m_IOError = QTNotInstalled;

		throw TImageException(m_path, buildQTErrorString(m_IOError));

	}

	//  const char *pStr = toString(m_path.getWideString()).c_str();

	QString qStr = QString::fromStdWString(m_path.getWideString());

	const char *pStr = qStr.toUtf8().data();

	//   std::cout << "TLevelWriterMov costruttore FP: " << toString(m_path.getWideString()) << std::endl;

	//   std::cout << "TLevelWriterMov costruttore char: " << pStr << std::endl;

	if (!getFSSpecFromPosixPath(pStr, &fspec, true)) {

		m_IOError = QTUnableToOpenFile;

		throw TImageException(m_path, buildQTErrorString(m_IOError));

	}

	// Fix: in alcuni rari casi non veniva il mov preesistente

	if (TSystem::doesExistFileOrLevel(m_path))

		TSystem::deleteFile(m_path);

	if ((err = CreateMovieFile(&fspec, 'TVOD', smCurrentScript,

							   createMovieFileDeleteCurFile | createMovieFileDontCreateResFile,

							   &(m_refNum), &(m_movie)) != noErr)) {

		m_IOError = QTCantCreateFile;

		throw TImageException(m_path, buildQTErrorString(m_IOError));

	}

}

//-----------------------------------------------------------

#ifdef _DEBUG

#define FailIf(cond, handler)                                      \

	if (cond) {                                                    \

		/*		DebugStr((ConstStr255Param)#cond " goto " #handler);*/ \

		goto handler;                                              \

	}

#else

#define FailIf(cond, handler) \

	if (cond) {               \

		goto handler;         \

	}

#endif

#ifdef _DEBUG

#define C(cond, action, handler)                                   \

	if (cond) {                                                    \

		/*		DebugStr((ConstStr255Param)#cond " goto " #handler);*/ \

		{                                                          \

			action;                                                \

		}                                                          \

		goto handler;                                              \

	}

#else

#define FailWithAction(cond, action, handler) \

	if (cond) {                               \

		{                                     \

			action;                           \

		}                                     \

		goto handler;                         \

	}

#endif

void TLevelWriterMov::saveSoundTrack(TSoundTrack *st)

{

	OSErr myErr = noErr;

	//int err;

	if (!st)

		throw TException("null reference to soundtrack");

	if (st->getBitPerSample() != 16) {

		throw TImageException(m_path, "Only 16 bits per sample is supported");

	}

	if (m_soundTrack == 0) {

		m_soundTrack = NewMovieTrack(m_movie, 0, 0, kFullVolume);

		myErr = GetMoviesError();

		FailIf(myErr != noErr, CompressErr);

		m_soundMedia = NewTrackMedia(m_soundTrack, SoundMediaType, st->getSampleRate(), NULL, 0); //track->rate >> 16

		myErr = GetMoviesError();

		FailIf(myErr != noErr, Exit);

	}

	SoundDescriptionV1Handle mySampleDesc;

	Handle myDestHandle;

	SoundComponentData sourceInfo;

	SoundComponentData destInfo;

	SoundConverter converter;

	CompressionInfo compressionInfo;

	myDestHandle = NewHandle(0);

	FailWithAction(myDestHandle == NULL, myErr = MemError(), NoDest);

	*myDestHandle = (char *)st->getRawData();

	// start a media editing session

	myErr = BeginMediaEdits(m_soundMedia);

	FailIf(myErr != noErr, Exit);

	sourceInfo.flags = 0x0;

	sourceInfo.format = kSoundNotCompressed;

	sourceInfo.numChannels = st->getChannelCount();

	sourceInfo.sampleSize = st->getBitPerSample();

	sourceInfo.sampleRate = st->getSampleRate();

	sourceInfo.sampleCount = st->getSampleCount();

	sourceInfo.buffer = (unsigned char *)st->getRawData();

	sourceInfo.reserved = 0x0;

	destInfo.flags = kNoSampleRateConversion | kNoSampleSizeConversion |

					 kNoSampleFormatConversion | kNoChannelConversion |

					 kNoDecompression | kNoVolumeConversion |

					 kNoRealtimeProcessing;

	destInfo.format = k16BitNativeEndianFormat;

	destInfo.numChannels = st->getChannelCount();

	destInfo.sampleSize = st->getBitPerSample();

	destInfo.sampleRate = st->getSampleRate();

	destInfo.sampleCount = st->getSampleCount();

	destInfo.buffer = (unsigned char *)st->getRawData();

	destInfo.reserved = 0x0;