///////////////////////////////////////////////////////////////////////////////
//
// Convert
//
// Cette methode convertit une notice en une autre conformement au fichier de
// transco charg‰
//
///////////////////////////////////////////////////////////////////////////////
int TTransFile::Convert( TMarcRecord* MarcIn, TMarcRecord* MarcOut )
{
TMarcField* In;
TMarcField* Out;
// On commence par effectuer la recopie (sans transco) du label
MarcOut->SetLeader(MarcIn->GetLeader());
if (!MarcOut->GetLeader())
{
typestr tmp = "Leader '";
tmp += MarcIn->GetLeader();
tmp += '\'';
mStateManager->SetErrorD(3000, ERROR, tmp.str());
}
// On transcode ensuite chaque champ
In=MarcIn->GetFirstField();
Out=MarcOut->GetFirstField();
while( In!=NULL )
{
// On cree un nouveau champ en sortie
if (Out==NULL)
{
MarcOut->SetFirstField(new TMarcField);
Out=MarcOut->GetFirstField();
}
else
{
Out->SetNextField(new TMarcField);
Out=Out->GetNextField();
}
// On recopie le tag et les indicateurs du champ en entree
Out->SetTag(In->GetTag());
Out->SetIndicators(In->GetIndicators());
// On transcode le libelle
typestr result;
Transcode(In->GetLib1(), result, In->GetLib1(), In->GetTag());
Out->SetLib1(result.str());
Transcode(In->GetLib2(), result, In->GetLib2(), In->GetTag());
Out->SetLib2(result.str());
Out->SetScript(In->GetScript());
if (!Out->GetLib1())
{
typestr tmp = "Field ";
tmp += In->GetTag();
tmp += ": '";
tmp += In->GetLib1() ? In->GetLib1() : "";
tmp += '\'';
mStateManager->SetErrorD(5006, ERROR, tmp.str());
}
// On passe au champ suivant
In=In->GetNextField();
}
return mStateManager->GetErrorCode();
}
//-------------------------------------------------------------------
// EncodeToFile
//
// Builds the transcode topology based on the input source,
// configured transcode profile, and the output container settings.
//-------------------------------------------------------------------
HRESULT CTranscoder::EncodeToFile(const WCHAR *sURL)
{
assert (m_pSession);
assert (m_pSource);
assert (m_pProfile);
if (!sURL)
{
return E_INVALIDARG;
}
HRESULT hr = S_OK;
//Create the transcode topology
hr = MFCreateTranscodeTopology( m_pSource, sURL, m_pProfile, &m_pTopology );
// Set the topology on the media session.
if (SUCCEEDED(hr))
{
hr = m_pSession->SetTopology(0, m_pTopology);
}
//Get media session events. This will start the encoding session.
if (SUCCEEDED(hr))
{
hr = Transcode();
}
return hr;
}
int main(int argc, char* argv[])
{
// the "service name" reported on the tape messages uses CONFIG.m_serviceName
// which also defaults to orkaudio-[hostname] but can be different depending on the
// value set in config.xml
char hostname[40];
ACE_OS::hostname(hostname, 40);
CStdString serviceName = CStdString("orkaudio-") + hostname;
Daemon::Initialize(serviceName, MainThread, StopHandler);
CStdString argument = argv[1];
if (argc>1)
{
if(argument.CompareNoCase("version") == 0)
{
printf("Version my 2\n\n");
}
if (argument.CompareNoCase("debug") == 0)
{
MainThread();
}
else if (argument.CompareNoCase("transcode") == 0)
{
if(argc == 3)
{
Daemon::Singleton()->SetShortLived();
CStdString file = argv[2];
Transcode(file);
}
else
{
printf("Please specify file to transcode\n\n");
}
}
else if (argument.CompareNoCase("install") == 0)
{
Daemon::Singleton()->Install();
}
else if (argument.CompareNoCase("uninstall") == 0)
{
Daemon::Singleton()->Uninstall();
}
else
{
#ifdef WIN32
printf("Argument incorrect. Possibilies are:\ninstall: install NT service\nuninstall: uninstall NT service\ntranscode <file>: convert .mcf file to storage format specified in config.xml\n\n");
#else
printf("Argument incorrect. Possibilies are:\ndebug: run attached to tty\ntranscode <file>: convert .mcf file to storage format specified in config.xml\n\n");
#endif
}
}
else
{
// No arguments, launch the daemon
printf("Starting orkaudio daemon ... (type 'orkaudio debug' if you prefer running attached to tty)\n");
Daemon::Singleton()->Start();
}
return 0;
}
static PyObject *ToBinary(PyObject *self, PyObject *args) {
const char *szDest;
const char *szOriginalName;
PyObject *pFile;
if (!PyArg_ParseTuple(args, "Oss", &pFile, &szDest, &szOriginalName)) {
return NULL;
}
State state(szDest, szOriginalName);
int fd = fileno(PyFile_AsFile(pFile));
lseek(fd, 0, SEEK_SET);
Transcode(fd, &state);
return Py_BuildValue("i", FILETYPE_MZML);
}
// Unfortunately, first parameter needs to be non-const because iconv() takes the inbuf as non-const char**
int Transcode(char* src, int srcBytes, char* dest, int destBytes, Encoding srcEnc, Encoding destEnc)
{
if (srcEnc == None) {
return ERR_INVALID_PARAMETER;
}
if (srcEnc == destEnc || destEnc == None) {
// If we have the same encoding in src and dest, we will just copy.
int len = srcBytes < destBytes ? srcBytes : destBytes;
memcpy(dest, src, len);
if (srcBytes > destBytes) {
return ERR_INSUFFICIENT_BUFFER;
}
return len;
}
if (srcEnc == GXT8) {
// GXT8 -> destEnc conversion is done by converting to ISO-8859-1 first and then to destEnc.
unsigned char* tmp = new unsigned char[destBytes];
int len = srcBytes < destBytes ? srcBytes : destBytes;
for (int i = 0 ; i < len ; i++) {
tmp[i] = GXT8ToISO88591Table[((unsigned char*) src)[i]];
}
int endLen = Transcode((char*) tmp, len, dest, destBytes, ISO8859_1, destEnc);
if (srcBytes > destBytes) {
return ERR_INSUFFICIENT_BUFFER;
}
return endLen;
} else if (srcEnc == GXT16) {
// TODO We assume that GXT16 is just GXT8 with an unused second byte. Don't know if that's true.
int tmpSize = srcBytes%2 == 0 ? srcBytes/2 : (srcBytes+1)/2;
unsigned char* tmp = new unsigned char[tmpSize];
int len = srcBytes < destBytes ? srcBytes : destBytes;
for (int i = 0 ; i < len/2 ; i++) {
tmp[i] = GXT8ToISO88591Table[((unsigned char*) src)[i*2]];
}
int endLen = Transcode((char*) tmp, tmpSize, dest, destBytes, ISO8859_1, destEnc);
return endLen;
}
if (destEnc == GXT8) {
// srcEnc -> GXT8 conversion is done by converting to ISO-8859-1 first and then to GXT8.
unsigned char* tmp = new unsigned char[destBytes];
unsigned char* udest = (unsigned char*) dest;
int len = Transcode(src, srcBytes, (char*) tmp, destBytes, srcEnc, ISO8859_1);
bool insufficient = false;
if (len == ERR_INSUFFICIENT_BUFFER) {
// We will still fill the buffer
len = destBytes;
insufficient = true;
}
for (int i = 0 ; i < len ; i++) {
udest[i] = ISO88591ToGXT8Table[tmp[i]];
}
if (insufficient) {
return ERR_INSUFFICIENT_BUFFER;
}
return len;
} else if (destEnc == GXT16) {
// TODO We assume that GXT16 is just GXT8 with an unused second byte. Don't know if that's true.
int tmpSize = destBytes%2 == 0 ? destBytes/2 : (destBytes+1)/2;
unsigned char* tmp = new unsigned char[tmpSize];
unsigned char* udest = (unsigned char*) dest;
int len = Transcode(src, srcBytes, (char*) tmp, tmpSize, srcEnc, ISO8859_1);
bool insufficient = false;
if (len == ERR_INSUFFICIENT_BUFFER) {
// We will still fill the buffer
len = tmpSize;
insufficient = true;
}
for (int i = 0 ; i < len ; i++) {
udest[i*2] = ISO88591ToGXT8Table[tmp[i]];
udest[i*2+1] = '\0';
}
if (insufficient) {
return ERR_INSUFFICIENT_BUFFER;
}
return len;
}
#ifdef _HAVE_ICONV
// On Linux we use iconv.
const char* iconvSrcEnc;
const char* iconvDestEnc;
size_t inLeft = srcBytes;
size_t outLeft = destBytes;
switch (srcEnc) {
case ASCII:
iconvSrcEnc = "ASCII";
break;
case UTF8:
iconvSrcEnc = "UTF-8";
break;
case UTF16:
iconvSrcEnc = "UTF-16LE"; // "UTF-16" only would prepend a byte order mark (BOM)
break;
case WINDOWS1252:
iconvSrcEnc = "WINDOWS-1252";
break;
case ISO8859_1:
iconvSrcEnc = "ISO8859-1";
break;
default:
// This should never happen
assert(false);
}
switch (destEnc) {
case ASCII:
iconvDestEnc = "ASCII";
break;
case UTF8:
iconvDestEnc = "UTF-8";
break;
case UTF16:
iconvDestEnc = "UTF-16LE"; // "UTF-16" only would prepend a byte order mark (BOM)
break;
case WINDOWS1252:
iconvDestEnc = "WINDOWS-1252";
break;
case ISO8859_1:
iconvDestEnc = "ISO-8859-1";
break;
default:
// This should never happen
assert(false);
}
iconv_t ic = iconv_open(iconvDestEnc, iconvSrcEnc);
size_t len = iconv(ic, &src, &inLeft, &dest, &outLeft);
iconv_close(ic);
if (len == (size_t)-1) {
iconv_close(ic);
switch (errno) {
case EILSEQ:
case EINVAL:
return ERR_INVALID_SEQUENCE;
case E2BIG:
return ERR_INSUFFICIENT_BUFFER;
}
}
// iconv() does NOT return the number of actual bytes written, but decrements outLeft for each byte.
return destBytes-outLeft;
#elif defined(_WIN32)
// On Windows we use The WinAPI Unicode functions.
if (srcEnc == UTF16) {
UINT cp;
switch (destEnc) {
case ASCII:
cp = 20127;
break;
case UTF8:
cp = 65001;
break;
case WINDOWS1252:
cp = 1252;
break;
case ISO8859_1:
cp = 28591;
break;
default:
assert(false);
break;
}
int len = WideCharToMultiByte(cp, 0, (LPWSTR) src, srcBytes/2, dest, destBytes, NULL, NULL);
if (len == 0) {
switch (GetLastError()) {
case ERROR_INSUFFICIENT_BUFFER:
return ERR_INSUFFICIENT_BUFFER;
case ERROR_INVALID_FLAGS:
case ERROR_INVALID_PARAMETER:
return ERR_INVALID_PARAMETER;
case ERROR_NO_UNICODE_TRANSLATION:
return ERR_INVALID_SEQUENCE;
}
}
return len;
} else {
if (destEnc == UTF16) {
UINT cp;
switch (srcEnc) {
case ASCII:
cp = 20127;
break;
case UTF8:
cp = 65001;
break;
case WINDOWS1252:
cp = 1252;
break;
case ISO8859_1:
cp = 28591;
break;
default:
assert(false);
break;
}
int len = MultiByteToWideChar(cp, MB_PRECOMPOSED, src, srcBytes, (LPWSTR) dest, destBytes/2);
if (len == 0) {
switch (GetLastError()) {
case ERROR_INSUFFICIENT_BUFFER:
return ERR_INSUFFICIENT_BUFFER;
case ERROR_INVALID_FLAGS:
case ERROR_INVALID_PARAMETER:
return ERR_INVALID_PARAMETER;
case ERROR_NO_UNICODE_TRANSLATION:
return ERR_INVALID_SEQUENCE;
}
}
return len*2; // MultiByteToWideChar returns the number of CHARACTERS written to dest.
} else {
// Windows does not seem to have a function to directly convert one single-byte-encoding to
// another, so we convert the string to UTF16 and then to destEnc.
char* tmpBuf = new char[srcBytes*2];
int len = Transcode(src, srcBytes, tmpBuf, srcBytes*2, srcEnc, UTF16);
if (len == ERR_INSUFFICIENT_BUFFER) {
// Actually, this should never happen because we choose tmpBuf as twice the size of srcBytes,
// which should always fit perfect when converting a single-byte-encoding to UTF-16.
len = srcBytes*2;
} else if (len < 0) {
return len;
}
len = Transcode(tmpBuf, srcBytes*2, dest, destBytes, UTF16, destEnc);
delete[] tmpBuf;
return len;
}
}
#endif
}
