/** * DataFormat.cpp * This file is part of the YATE Project http://YATE.null.ro * * Yet Another Telephony Engine - a fully featured software PBX and IVR * Copyright (C) 2004-2014 Null Team * * This software is distributed under multiple licenses; * see the COPYING file in the main directory for licensing * information for this specific distribution. * * This use of this software may be subject to additional restrictions. * See the LEGAL file in the main directory for details. * * 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. */ #include "yatephone.h" #include #include namespace TelEngine { static const FormatInfo s_formats[] = { FormatInfo("slin", 160, 10000, "audio", 8000, 1, true), FormatInfo("alaw", 80), FormatInfo("mulaw", 80), FormatInfo("slin/16000", 320, 10000, "audio", 16000, 1, true), FormatInfo("alaw/16000", 160, 10000, "audio", 16000), FormatInfo("mulaw/16000", 160, 10000, "audio", 16000), FormatInfo("slin/32000", 640, 10000, "audio", 32000, 1, true), FormatInfo("alaw/32000", 160, 10000, "audio", 32000), FormatInfo("mulaw/32000", 160, 10000, "audio", 32000), FormatInfo("2*slin", 320, 10000, "audio", 8000, 2), FormatInfo("2*slin/16000", 640, 10000, "audio", 16000, 2), FormatInfo("2*slin/32000", 1280, 10000, "audio", 32000, 2), FormatInfo("2*alaw", 160, 10000, "audio", 8000, 2), FormatInfo("2*mulaw", 160, 10000, "audio", 8000, 2), FormatInfo("gsm", 33, 20000), FormatInfo("ilbc20", 38, 20000), FormatInfo("ilbc30", 50, 30000), // FormatInfo("speex", 0), FormatInfo("g729", 10, 10000), FormatInfo("plain", 0, 0, "text", 0), FormatInfo("raw", 0, 0, "data", 0), }; // FIXME: put proper conversion costs everywhere below static TranslatorCaps s_simpleCaps[] = { { s_formats+0, s_formats+1, 1 }, { s_formats+0, s_formats+2, 1 }, { s_formats+1, s_formats+0, 1 }, { s_formats+1, s_formats+2, 1 }, { s_formats+2, s_formats+0, 1 }, { s_formats+2, s_formats+1, 1 }, { s_formats+9, s_formats+12, 1 }, { s_formats+9, s_formats+13, 1 }, { s_formats+12, s_formats+9, 1 }, { s_formats+13, s_formats+9, 1 }, { s_formats+12, s_formats+13, 1 }, { s_formats+13, s_formats+12, 1 }, { 0, 0, 0 } }; static TranslatorCaps s_simpleCaps16k[] = { { s_formats+3, s_formats+4, 1 }, { s_formats+3, s_formats+5, 1 }, { s_formats+4, s_formats+3, 1 }, { s_formats+4, s_formats+5, 1 }, { s_formats+5, s_formats+3, 1 }, { s_formats+5, s_formats+4, 1 }, { 0, 0, 0 } }; static TranslatorCaps s_simpleCaps32k[] = { { s_formats+6, s_formats+7, 1 }, { s_formats+6, s_formats+8, 1 }, { s_formats+7, s_formats+6, 1 }, { s_formats+7, s_formats+8, 1 }, { s_formats+8, s_formats+6, 1 }, { s_formats+8, s_formats+7, 1 }, { 0, 0, 0 } }; static TranslatorCaps s_resampCaps[] = { { s_formats+0, s_formats+3, 2 }, { s_formats+0, s_formats+6, 2 }, { s_formats+3, s_formats+0, 2 }, { s_formats+3, s_formats+6, 2 }, { s_formats+6, s_formats+0, 2 }, { s_formats+6, s_formats+3, 2 }, { 0, 0, 0 } }; static TranslatorCaps s_stereoCaps[] = { { s_formats+0, s_formats+9, 1 }, { s_formats+9, s_formats+0, 2 }, { s_formats+3, s_formats+10, 1 }, { s_formats+10, s_formats+3, 2 }, { s_formats+6, s_formats+11, 1 }, { s_formats+11, s_formats+6, 2 }, { 0, 0, 0 } }; static Mutex s_dataMutex(true,"DataEndpoint"); static Mutex s_consSrcMutex(false,"DataConsumer::Source"); class ThreadedSourcePrivate : public Thread { friend class ThreadedSource; public: ThreadedSourcePrivate(ThreadedSource* source, const char* name, Thread::Priority prio) : Thread(name,prio), m_source(source) { } protected: virtual void run() { m_source->run(); // execute cleanup from this thread if possible cleanup(); } virtual void cleanup() { RefPointer source = m_source; m_source = 0; if (source) source->cleanup(); } private: RefPointer m_source; }; // slin/alaw/mulaw converter class SimpleTranslator : public DataTranslator { public: SimpleTranslator(const DataFormat& sFormat, const DataFormat& dFormat) : DataTranslator(sFormat,dFormat), m_valid(false) { if (!getTransSource()) return; int nchan = m_format.numChannels(); if (nchan != getTransSource()->getFormat().numChannels()) return; m_valid = true; m_sFmt = m_format; m_dFmt = getTransSource()->getFormat(); if (nchan != 1) { // get rid of the channel prefix m_sFmt >> "*"; m_dFmt >> "*"; } } virtual unsigned long Consume(const DataBlock& data, unsigned long tStamp, unsigned long flags) { if (!ref()) return 0; unsigned long len = 0; if (m_valid && getTransSource() && m_buffer.convert(data,m_sFmt,m_dFmt)) { if (tStamp == invalidStamp()) { unsigned int delta = data.length(); if (delta > m_buffer.length()) delta = m_buffer.length(); tStamp = m_timestamp + delta; } m_timestamp = tStamp; len = getTransSource()->Forward(m_buffer,tStamp,flags); } deref(); return len; } private: bool m_valid; String m_sFmt; String m_dFmt; DataBlock m_buffer; }; // slin basic mono resampler class ResampTranslator : public DataTranslator { private: int m_sRate, m_dRate; short m_last; public: ResampTranslator(const DataFormat& sFormat, const DataFormat& dFormat) : DataTranslator(sFormat,dFormat), m_sRate(sFormat.sampleRate()), m_dRate(dFormat.sampleRate()), m_last(0) { } virtual unsigned long Consume(const DataBlock& data, unsigned long tStamp, unsigned long flags) { unsigned int n = data.length(); if (!n || (n & 1) || !m_sRate || !m_dRate || !ref()) return 0; unsigned long len = 0; n /= 2; DataSource* src = getTransSource(); if (src) { long delta = tStamp - m_timestamp; short* s = (short*) data.data(); DataBlock oblock; if (m_dRate > m_sRate) { int mul = m_dRate / m_sRate; // linear interpolation between existing samples delta *= mul; oblock.assign(0,2*n*mul); short* d = (short*) oblock.data(); while (n--) { short v = *s++; for (int i = 1; i <= mul; i++) *d++ = ((m_last * (mul - i)) + (v * i)) / mul; m_last = v; } } else { int div = m_sRate / m_dRate; // average an integer number of samples delta /= div; n /= div; oblock.assign(0,2*n); short* d = (short*) oblock.data(); while (n--) { int v = 0; for (int i = 0; i < div; i++) v += *s++; v /= div; // saturate average result if (v > 32767) v = 32767; if (v < -32767) v = -32767; *d++ = v; } } if (src->timeStamp() != invalidStamp()) delta += src->timeStamp(); len = src->Forward(oblock, delta, flags); } deref(); return len; } }; // slin simple mono-stereo converter class StereoTranslator : public DataTranslator { private: int m_sChans, m_dChans; public: StereoTranslator(const DataFormat& sFormat, const DataFormat& dFormat) : DataTranslator(sFormat,dFormat), m_sChans(sFormat.numChannels()), m_dChans(dFormat.numChannels()) { } virtual unsigned long Consume(const DataBlock& data, unsigned long tStamp, unsigned long flags) { unsigned int n = data.length(); if (!n || (n & 1) || !ref()) return 0; unsigned long len = 0; n /= 2; if (getTransSource()) { short* s = (short*) data.data(); DataBlock oblock; if ((m_sChans == 1) && (m_dChans == 2)) { oblock.assign(0,n*4); short* d = (short*) oblock.data(); // duplicate the sample for each channel while (n--) { short v = *d++ = *s++; *d++ = v; } } else if ((m_sChans == 2) && (m_dChans == 1)) { n /= 2; oblock.assign(0,2*n); short* d = (short*) oblock.data(); // average the channels while (n--) { int v = *s++; v += *s++; v /= 2; // saturate average result if (v > 32767) v = 32767; if (v < -32767) v = -32767; *d++ = v; } } len = getTransSource()->Forward(oblock, tStamp, flags); } deref(); return len; } }; class SimpleFactory : public TranslatorFactory { public: SimpleFactory(const TranslatorCaps* caps, const char* name) : TranslatorFactory(name), m_caps(caps) { } virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) { return converts(sFormat,dFormat) ? new SimpleTranslator(sFormat,dFormat) : 0; } virtual const TranslatorCaps* getCapabilities() const { return m_caps; } private: const TranslatorCaps* m_caps; }; class ResampFactory : public TranslatorFactory { public: ResampFactory() : TranslatorFactory("resample") { } virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) { return converts(sFormat,dFormat) ? new ResampTranslator(sFormat,dFormat) : 0; } virtual const TranslatorCaps* getCapabilities() const { return s_resampCaps; } }; class StereoFactory : public TranslatorFactory { public: StereoFactory() : TranslatorFactory("stereo") { } virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) { return converts(sFormat,dFormat) ? new StereoTranslator(sFormat,dFormat) : 0; } virtual const TranslatorCaps* getCapabilities() const { return s_stereoCaps; } }; class ChainedFactory : public TranslatorFactory { public: ChainedFactory(TranslatorFactory* factory1, TranslatorFactory* factory2, const FormatInfo* info); virtual ~ChainedFactory(); virtual void removed(const TranslatorFactory* factory); virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat); virtual const TranslatorCaps* getCapabilities() const { return (m_factory1 && m_factory1->getCapabilities() && m_factory2 && m_factory2->getCapabilities()) ? m_capabilities : 0; } virtual unsigned int length() const { return m_length; } virtual const FormatInfo* intermediate() const; virtual bool intermediate(const FormatInfo* info) const; virtual const char* name() const { return m_name.c_str(); } private: TranslatorFactory* m_factory1; TranslatorFactory* m_factory2; String m_name; DataFormat m_format; unsigned int m_length; const TranslatorCaps* m_capabilities; }; }; using namespace TelEngine; int FormatInfo::guessSamples(int len) const { if (!(frameTime && frameSize)) return 0; return (len / frameSize) * sampleRate * (long)frameTime / 1000000; } int FormatInfo::dataRate() const { if (!frameTime) return 0; return frameSize * 1000000 / frameTime; } typedef struct _flist { struct _flist* next; const FormatInfo* info; } flist; static flist* s_flist = 0; const FormatInfo* FormatRepository::getFormat(const String& name) { if (name.null()) return 0; // search in the static list first for (unsigned int i = 0; i < (sizeof(s_formats)/sizeof(FormatInfo)); i++) if (name == s_formats[i].name) return s_formats+i; // then try the installed formats for (flist* l = s_flist; l; l = l->next) if (name == l->info->name) return l->info; return 0; } const FormatInfo* FormatRepository::addFormat(const String& name, int fsize, int ftime, const String& type, int srate, int nchan) { if (name.null() || type.null()) return 0; const FormatInfo* f = getFormat(name); if (f) { // found by name - check if it exactly matches what we have already if ((fsize != f->frameSize) || (ftime != f->frameTime) || (srate != f->sampleRate) || (nchan != f->numChannels) || (type != f->type)) { Debug(DebugWarn,"Tried to register '%s' format '%s' fsize=%d ftime=%d srate=%d nchan=%d", type.c_str(),name.c_str(),fsize,ftime,srate,nchan); return 0; } return f; } // not in list - add a new one to the installed formats DDebug(DebugInfo,"Registering '%s' format '%s' fsize=%d ftime=%d srate=%d nchan=%d", type.c_str(),name.c_str(),fsize,ftime,srate,nchan); f = new FormatInfo(::strdup(name),fsize,ftime,::strdup(type),srate,nchan); flist* l = new flist; l->info = f; l->next = s_flist; s_flist = l; return f; } void DataFormat::changed() { m_parsed = 0; String::changed(); } const FormatInfo* DataFormat::getInfo() const { if (!(m_parsed || null())) m_parsed = FormatRepository::getFormat(*this); return m_parsed; } void DataConsumer::destroyed() { if (m_source || m_override) { // this should not happen - but scream bloody murder if so Debug(DebugFail,"DataConsumer destroyed with source=%p override=%p [%p]", m_source,m_override,this); } if (m_source) m_source->detach(this); if (m_override) m_override->detach(this); DataNode::destroyed(); } void* DataConsumer::getObject(const String& name) const { if (name == YATOM("DataConsumer")) return const_cast(this); return DataNode::getObject(name); } unsigned long DataConsumer::Consume(const DataBlock& data, unsigned long tStamp, unsigned long flags, DataSource* source) { if (source == m_override) tStamp += m_overrideTsDelta; else if (m_override || (source != m_source)) return 0; else tStamp += m_regularTsDelta; u_int64_t tsTime = Time::now(); unsigned long len = Consume(data,tStamp,flags); m_timestamp = tStamp; m_lastTsTime = tsTime; return len; } bool DataConsumer::synchronize(DataSource* source) { if (!source) return false; bool override = false; if (source == m_override) override = true; else if (source != m_source) return false; if (!(m_timestamp || m_regularTsDelta || m_overrideTsDelta)) { // first time m_timestamp = source->timeStamp(); return true; } const FormatInfo* info = getFormat().getInfo(); int64_t dt = 0; if (info) { // adjust timestamp for possible silence or gaps in data, at least 25ms dt = Time::now() - m_lastTsTime; if (dt >= 25000) { dt = (dt * info->sampleRate) / 1000000; DDebug(DebugInfo,"Data gap, offsetting consumer timestamps by " FMT64 " [%p]",dt,this); } else dt = 0; } dt += m_timestamp - source->timeStamp(); DDebug(DebugInfo,"Offsetting consumer %s timestamps by " FMT64 " [%p]", (override ? "override" : "regular"),dt,this); if (override) m_overrideTsDelta = (long int)dt; else m_regularTsDelta = (long int)dt; return true; } bool DataSource::valid() const { Lock mylock(const_cast(this)); if (!m_translator) return true; // this is a translator's source - check if we have at least one valid consumer for (ObjList* l = m_consumers.skipNull(); l; l=l->skipNext()) { DataConsumer* c = static_cast(l->get()); if (c->valid()) return true; } return false; } unsigned long DataSource::Forward(const DataBlock& data, unsigned long tStamp, unsigned long flags) { Lock mylock(this,100000); // we DON'T refcount here, we rely on the mutex to keep us safe if (!(mylock.locked() && alive())) { DDebug(DebugInfo,"Forwarding on a dead DataSource! [%p]",this); return 0; } // try to evaluate amount of samples in this packet const FormatInfo* f = m_format.getInfo(); unsigned long nSamp = f ? f->guessSamples(data.length()) : 0; // if no timestamp provided - try to use next expected if (tStamp == invalidStamp()) tStamp = m_nextStamp; // still no timestamp known - wild guess based on this packet size if (tStamp == invalidStamp()) { DDebug(DebugNote,"Unknown timestamp - assuming %lu + %lu [%p]", m_timestamp,nSamp,this); tStamp = m_timestamp + nSamp; } unsigned long len = invalidStamp(); bool empty = true; ObjList* l = m_consumers.skipNull(); while (l) { DataConsumer* c = static_cast(l->get()); unsigned long ll = c->Consume(data,tStamp,flags,this); if (ll || c->valid()) { // get the minimum data amount forwarded to all consumers if (len > ll) len = ll; l = l->skipNext(); empty = false; } else { DDebug(DebugInfo,"Consumer %p becomes invalid [%p]",c,this); detachInternal(c); // do not advance in list, we just removed the current element l = l->skipNull(); } } if (empty) len = 0; m_timestamp = tStamp; m_nextStamp = nSamp ? (tStamp + nSamp) : invalidStamp(); return len; } bool DataSource::attach(DataConsumer* consumer, bool override) { if (!alive()) { DDebug(DebugFail,"Attaching a dead DataSource! [%p]",this); return false; } DDebug(DebugAll,"DataSource [%p] attaching consumer%s [%p]", this,(override ? " as override" : ""),consumer); if (!(consumer && consumer->ref())) return false; Lock mylock(this); DataSource*& src = override ? consumer->m_override : consumer->m_source; if (src != this) { s_consSrcMutex.lock(); RefPointer src2(src); if (src2 && (this != src2)) { s_consSrcMutex.unlock(); src2->detach(consumer); s_consSrcMutex.lock(); if (src) { Debug(DebugGoOn,"DataSource %p raced us attaching consumer %p [%p]", src,consumer,this); s_consSrcMutex.unlock(); consumer->deref(); return false; } } src = this; s_consSrcMutex.unlock(); } consumer->synchronize(this); m_consumers.append(consumer); return true; } bool DataSource::detach(DataConsumer* consumer) { if (!consumer) return false; if (!ref()) { DDebug(DebugFail,"Detaching a dead DataSource! [%p]",this); return false; } DDebug(DebugAll,"DataSource [%p] detaching consumer [%p]",this,consumer); // lock the source to prevent races with the Forward method lock(); bool ok = detachInternal(consumer); unlock(); deref(); return ok; } bool DataSource::detachInternal(DataConsumer* consumer) { if (!consumer) return false; DataConsumer *temp = static_cast(m_consumers.remove(consumer,false)); if (temp) { s_consSrcMutex.lock(); if (temp->m_source == this) temp->m_source = 0; if (temp->m_override == this) temp->m_override = 0; s_consSrcMutex.unlock(); temp->deref(); return true; } DDebug(DebugInfo,"DataSource [%p] has no consumer [%p]",this,consumer); return false; } void DataSource::destroyed() { m_translator = 0; clear(); DataNode::destroyed(); } void DataSource::clear() { // keep the source locked to prevent races with the Forward method lock(); while (detachInternal(static_cast(m_consumers.get()))) ; unlock(); } void DataSource::synchronize(unsigned long tStamp) { Lock mylock(this,100000); if (!(mylock.locked() && alive())) { DDebug(DebugInfo,"Synchronizing on a dead DataSource! [%p]",this); return; } m_timestamp = tStamp; m_nextStamp = invalidStamp(); ObjList *l = m_consumers.skipNull(); for (; l; l=l->skipNext()) { DataConsumer *c = static_cast(l->get()); c->synchronize(this); } } void* DataSource::getObject(const String& name) const { if (name == YATOM("DataSource")) return const_cast(this); return DataNode::getObject(name); } DataEndpoint::DataEndpoint(CallEndpoint* call, const char* name) : m_name(name), m_source(0), m_consumer(0), m_peer(0), m_call(call), m_peerRecord(0), m_callRecord(0) { DDebug(DebugAll,"DataEndpoint::DataEndpoint(%p,'%s') [%p]",call,name,this); if (m_call) m_call->m_data.append(this); } void DataEndpoint::destroyed() { DDebug(DebugAll,"DataEndpoint::destroyed() '%s' call=%p [%p]", m_name.c_str(),m_call,this); if (m_call) m_call->m_data.remove(this,false); disconnect(); setPeerRecord(); setCallRecord(); clearSniffers(); setSource(); setConsumer(); RefObject::destroyed(); } void* DataEndpoint::getObject(const String& name) const { if (name == YATOM("DataEndpoint")) return const_cast(this); return RefObject::getObject(name); } const String& DataEndpoint::toString() const { return m_name; } Mutex* DataEndpoint::mutex() const { return m_call ? m_call->mutex() : 0; } Mutex& DataEndpoint::commonMutex() { return s_dataMutex; } bool DataEndpoint::connect(DataEndpoint* peer) { if (!peer) { disconnect(); return false; } Lock lock(s_dataMutex); if (peer == m_peer) return true; DDebug(DebugInfo,"DataEndpoint '%s' connecting peer %p to [%p]",m_name.c_str(),peer,this); ref(); peer->ref(); disconnect(); peer->disconnect(); bool native = (name() == peer->name()) && nativeConnect(peer); if (!native) { XDebug(DebugInfo,"DataEndpoint s=%p c=%p peer @%p s=%p c=%p [%p]", getSource(),getConsumer(),peer,peer->getSource(),peer->getConsumer(),this); DataSource* s = getSource(); DataConsumer* c = peer->getConsumer(); if (s && c) DataTranslator::attachChain(s,c); c = peer->getPeerRecord(); if (s && c) DataTranslator::attachChain(s,c); s = peer->getSource(); c = getConsumer(); if (s && c) DataTranslator::attachChain(s,c); c = getPeerRecord(); if (s && c) DataTranslator::attachChain(s,c); } m_peer = peer; peer->m_peer = this; return true; } bool DataEndpoint::disconnect() { Lock lock(s_dataMutex); if (!m_peer) return false; DDebug(DebugInfo,"DataEndpoint '%s' disconnecting peer %p from [%p]",m_name.c_str(),m_peer,this); DataSource* s = getSource(); DataConsumer* c = m_peer->getConsumer(); if (s && c) DataTranslator::detachChain(s,c); c = m_peer->getPeerRecord(); if (s && c) DataTranslator::detachChain(s,c); s = m_peer->getSource(); c = getConsumer(); if (s && c) DataTranslator::detachChain(s,c); c = getPeerRecord(); if (s && c) DataTranslator::detachChain(s,c); DataEndpoint* temp = m_peer; m_peer = 0; temp->m_peer = 0; lock.drop(); temp->deref(); return deref(); } void DataEndpoint::setSource(DataSource* source) { Lock lock(s_dataMutex); if (source == m_source) return; DataConsumer* c1 = m_peer ? m_peer->getConsumer() : 0; DataConsumer* c2 = m_peer ? m_peer->getPeerRecord() : 0; DataSource* temp = m_source; XDebug(DebugInfo,"DataEndpoint::setSource(%p) peer=%p s=%p c1=%p c2=%p cr=%p [%p]", source,m_peer,temp,c1,c2,m_callRecord,this); if (c1) c1->ref(); if (c2) c2->ref(); if (m_callRecord) m_callRecord->ref(); m_source = 0; if (temp) { if (c1) { DataTranslator::detachChain(temp,c1); if (c1->getConnSource()) Debug(DebugWarn,"consumer source not cleared in %p",c1); } if (c2) { DataTranslator::detachChain(temp,c2); if (c2->getConnSource()) Debug(DebugWarn,"consumer source not cleared in %p",c2); } if (m_callRecord) { DataTranslator::detachChain(temp,m_callRecord); if (m_callRecord->getConnSource()) Debug(DebugWarn,"consumer source not cleared in %p",m_callRecord); } ObjList* l = m_sniffers.skipNull(); for (; l; l = l->skipNext()) DataTranslator::detachChain(temp,static_cast(l->get())); temp->attached(false); } if (source) { source->ref(); if (c1) DataTranslator::attachChain(source,c1); if (c2) DataTranslator::attachChain(source,c2); if (m_callRecord) DataTranslator::attachChain(source,m_callRecord); ObjList* l = m_sniffers.skipNull(); for (; l; l = l->skipNext()) DataTranslator::attachChain(source,static_cast(l->get())); source->attached(true); } m_source = source; if (m_callRecord) m_callRecord->deref(); lock.drop(); TelEngine::destruct(temp); TelEngine::destruct(c1); TelEngine::destruct(c2); } void DataEndpoint::setConsumer(DataConsumer* consumer) { Lock lock(s_dataMutex); if (consumer == m_consumer) return; DataSource* source = m_peer ? m_peer->getSource() : 0; DataConsumer* temp = m_consumer; XDebug(DebugInfo,"DataEndpoint::setConsumer(%p) peer=%p c=%p ps=%p [%p]", consumer,m_peer,temp,source,this); if (consumer) { if (consumer->ref()) { if (source) DataTranslator::attachChain(source,consumer); } else consumer = 0; } m_consumer = consumer; if (source && temp) DataTranslator::detachChain(source,temp); if (temp) { s_consSrcMutex.lock(); RefPointer src = temp->getConnSource(); s_consSrcMutex.unlock(); if (src) { src->detach(temp); src = 0; } s_consSrcMutex.lock(); src = temp->getOverSource(); s_consSrcMutex.unlock(); if (src) { src->detach(temp); src = 0; } temp->attached(false); } if (consumer) consumer->attached(true); lock.drop(); TelEngine::destruct(temp); } void DataEndpoint::setPeerRecord(DataConsumer* consumer) { Lock lock(s_dataMutex); if (consumer == m_peerRecord) return; DataSource* source = m_peer ? m_peer->getSource() : 0; DataConsumer* temp = m_peerRecord; XDebug(DebugInfo,"DataEndpoint::setPeerRecord(%p) peer=%p pr=%p ps=%p [%p]", consumer,m_peer,temp,source,this); if (consumer) { if (consumer->ref()) { if (source) DataTranslator::attachChain(source,consumer); } else consumer = 0; } m_peerRecord = consumer; if (source && temp) DataTranslator::detachChain(source,temp); if (temp) temp->attached(false); if (consumer) consumer->attached(true); lock.drop(); TelEngine::destruct(temp); } void DataEndpoint::setCallRecord(DataConsumer* consumer) { Lock lock(s_dataMutex); if (consumer == m_callRecord) return; DataConsumer* temp = m_callRecord; XDebug(DebugInfo,"DataEndpoint::setCallRecord(%p) cr=%p s=%p [%p]", consumer,temp,m_source,this); if (consumer) { if (consumer->ref()) { if (m_source) DataTranslator::attachChain(m_source,consumer); } else consumer = 0; } m_callRecord = consumer; if (temp && m_source) DataTranslator::detachChain(m_source,temp); if (temp) temp->attached(false); if (consumer) consumer->attached(true); lock.drop(); TelEngine::destruct(temp); } bool DataEndpoint::addSniffer(DataConsumer* sniffer) { if (!sniffer) return false; Lock lock(s_dataMutex); if (m_sniffers.find(sniffer)) return false; if (!sniffer->ref()) return false; XDebug(DebugInfo,"DataEndpoint::addSniffer(%p) s=%p [%p]", sniffer,m_source,this); m_sniffers.append(sniffer); if (m_source) DataTranslator::attachChain(m_source,sniffer); sniffer->attached(true); return true; } bool DataEndpoint::delSniffer(DataConsumer* sniffer) { if (!sniffer) return false; Lock lock(s_dataMutex); XDebug(DebugInfo,"DataEndpoint::delSniffer(%p) s=%p [%p]", sniffer,m_source,this); if (!m_sniffers.remove(sniffer,false)) return false; if (m_source) DataTranslator::detachChain(m_source,sniffer); sniffer->attached(false); sniffer->deref(); return true; } void DataEndpoint::clearSniffers() { Lock lock(s_dataMutex); for (;;) { DataConsumer* sniffer = static_cast(m_sniffers.remove(false)); if (!sniffer) return; XDebug(DebugInfo,"DataEndpoint::clearSniffers() sn=%p s=%p [%p]", sniffer,m_source,this); if (m_source) DataTranslator::detachChain(m_source,sniffer); sniffer->attached(false); sniffer->deref(); } } bool DataEndpoint::clearData(DataNode* node) { if (!node) return false; Lock lock(s_dataMutex); bool ok = delSniffer(static_cast(node)); if (m_callRecord == node) { setCallRecord(); ok = true; } if (m_peerRecord == node) { setPeerRecord(); ok = true; } if (m_consumer == node) { setConsumer(); ok = true; } if (m_source == node) { setSource(); ok = true; } return ok; } // Change source(s) or consumer(s) bool DataEndpoint::control(NamedList& params) { // TODO how do we handle this case????? operation-status return (m_source && m_source->control(params)) || (m_consumer && m_consumer->control(params)) || (m_peerRecord && m_peerRecord->control(params)) || (m_callRecord && m_callRecord->control(params)); } void ThreadedSource::destroyed() { if (m_thread) Debug(DebugFail,"ThreadedSource destroyed holding thread %p [%p]",m_thread,this); DataSource::destroyed(); } bool ThreadedSource::start(const char* name, Thread::Priority prio) { Lock mylock(this); if (!m_thread) { ThreadedSourcePrivate* thread = new ThreadedSourcePrivate(this,name,prio); if (thread->startup()) { m_thread = thread; return true; } delete thread; return false; } return m_thread->running(); } void ThreadedSource::stop() { Lock mylock(this); ThreadedSourcePrivate* tmp = m_thread; m_thread = 0; if (!tmp || tmp->running()) return; Debug(DebugInfo,"ThreadedSource deleting stopped thread %p [%p]",tmp,this); mylock.drop(); delete tmp; } void ThreadedSource::cleanup() { lock(); m_thread = 0; unlock(); } Thread* ThreadedSource::thread() const { return m_thread; } bool ThreadedSource::running() const { Lock mylock(const_cast(this)); return m_thread && m_thread->running(); } bool ThreadedSource::looping(bool runConsumers) const { Lock mylock(const_cast(this)); if ((refcount() <= 1) && !(runConsumers && alive() && m_consumers.count())) return false; return m_thread && !m_thread->check(false) && m_thread->isCurrent() && !Engine::exiting(); } DataTranslator::DataTranslator(const char* sFormat, const char* dFormat) : DataConsumer(sFormat) { DDebug(DebugAll,"DataTranslator::DataTranslator('%s','%s') [%p]",sFormat,dFormat,this); m_tsource = new DataSource(dFormat); m_tsource->setTranslator(this); } DataTranslator::DataTranslator(const char* sFormat, DataSource* source) : DataConsumer(sFormat), m_tsource(source) { DDebug(DebugAll,"DataTranslator::DataTranslator('%s',%p) [%p]",sFormat,source,this); m_tsource->setTranslator(this); } DataTranslator::~DataTranslator() { DDebug(DebugAll,"DataTranslator::~DataTranslator() [%p]",this); DataSource *temp = m_tsource; m_tsource = 0; if (temp) { temp->setTranslator(0); temp->deref(); } } void* DataTranslator::getObject(const String& name) const { if (name == YATOM("DataTranslator")) return const_cast(this); return DataConsumer::getObject(name); } DataTranslator* DataTranslator::getFirstTranslator() { DataSource* tsource = getConnSource(); if (!tsource) return this; DataTranslator* trans = tsource->getTranslator(); return trans ? trans->getFirstTranslator() : this; } const DataTranslator* DataTranslator::getFirstTranslator() const { const DataSource* tsource = getConnSource(); if (!tsource) return this; const DataTranslator* trans = tsource->getTranslator(); return trans ? trans->getFirstTranslator() : this; } bool DataTranslator::synchronize(DataSource* source) { if (!DataConsumer::synchronize(source)) return false; if (m_tsource) m_tsource->synchronize(timeStamp()); return true; } Mutex DataTranslator::s_mutex(true,"DataTranslator"); ObjList DataTranslator::s_factories; unsigned int DataTranslator::s_maxChain = 3; static ObjList s_compose; static SimpleFactory s_sFactory(s_simpleCaps,"g711"); static SimpleFactory s_sFactory16k(s_simpleCaps16k,"g711wb"); static SimpleFactory s_sFactory32k(s_simpleCaps32k,"g711uwb"); // FIXME static ResampFactory s_rFactory; static StereoFactory s_stereoFactory; void DataTranslator::setMaxChain(unsigned int maxChain) { if (maxChain < 1) maxChain = 1; if (maxChain > 4) maxChain = 4; s_maxChain = maxChain; } void DataTranslator::install(TranslatorFactory* factory) { if (!factory) return; Lock lock(s_mutex); if (s_factories.find(factory)) return; s_factories.append(factory)->setDelete(false); s_compose.append(factory)->setDelete(false); } void DataTranslator::compose() { for (;;) { TranslatorFactory* factory = static_cast(s_compose.remove(false)); if (!factory) break; compose(factory); } } void DataTranslator::compose(TranslatorFactory* factory) { const TranslatorCaps* caps = factory->getCapabilities(); XDebug(DebugInfo,"Composing TranslatorFactory '%s' (%u,'%s'->'%s'->'%s')", factory->name(),factory->length(),caps ? caps->src->name : "", factory->intermediate() ? factory->intermediate()->name : "", caps ? caps->dest->name : ""); if ((!caps) || (factory->length() >= s_maxChain)) return; Lock lock(s_mutex); // now see if we can build some conversion chains with this factory ListIterator iter(s_factories); while (TranslatorFactory* f2 = static_cast(iter.get())) { // do not combine with itself if (f2 == factory) continue; // don't try to build a too long chain if ((factory->length() + f2->length()) > s_maxChain) { XDebug(DebugAll,"Chain would be too long"); continue; } const FormatInfo* fi; // and avoid loops if (factory->intermediate(fi = f2->intermediate()) || f2->intermediate(fi = factory->intermediate())) { XDebug(DebugAll,"Would directly loop through format '%s'",fi->name); continue; } const TranslatorCaps* c2 = f2->getCapabilities(); XDebug(DebugInfo,"Composing '%s' with '%s' (%u,'%s'->'%s'->'%s')", factory->name(),f2->name(),f2->length(),c2 ? c2->src->name : "", f2->intermediate() ? f2->intermediate()->name : "", c2 ? c2->dest->name : ""); for (; c2 && c2->src && c2->dest; c2++) { if (!(c2->src->converter || c2->dest->converter)) continue; if (factory->intermediate(fi = c2->src) || factory->intermediate(fi = c2->dest)) { XDebug(DebugAll,"Factory '%s' already has intermediate '%s'",factory->name(),fi->name); break; } for (const TranslatorCaps* c = caps; c->src && c->dest; c++) { if (!(c->src->converter || c->dest->converter)) continue; if (f2->intermediate(fi = c->src) || f2->intermediate(fi = c->dest)) { XDebug(DebugAll,"Factory '%s' already has intermediate '%s'",f2->name(),fi->name); break; } if ((c->src == c2->dest) && c->src->converter) { if (canConvert(c2->src,c->dest)) { XDebug(DebugAll,"Can already convert '%s' to '%s'",c2->src->name,c->dest->name); continue; } DDebug(DebugInfo,"Building chain (%s)%s%s -> (%s) -> %s%s(%s)", c2->src->name, f2->intermediate() ? " -> " : "", f2->intermediate() ? f2->intermediate()->name : "", c->src->name, factory->intermediate() ? factory->intermediate()->name : "", factory->intermediate() ? " -> " : "", c->dest->name); new ChainedFactory(f2,factory,c->src); break; } if ((c2->src == c->dest) && c2->src->converter) { if (canConvert(c->src,c2->dest)) { XDebug(DebugAll,"Can already convert '%s' to '%s'",c->src->name,c2->dest->name); continue; } DDebug(DebugInfo,"Building chain (%s)%s%s -> (%s) -> %s%s(%s)", c->src->name, factory->intermediate() ? " -> " : "", factory->intermediate() ? factory->intermediate()->name : "", c->dest->name, f2->intermediate() ? f2->intermediate()->name : "", f2->intermediate() ? " -> " : "", c2->dest->name); new ChainedFactory(factory,f2,c->dest); break; } } } } } void DataTranslator::uninstall(TranslatorFactory* factory) { if (!factory) return; s_mutex.lock(); s_compose.remove(factory,false); s_factories.remove(factory,false); // notify chained factories about the removal ListIterator iter(s_factories); while (TranslatorFactory* f = static_cast(iter.get())) f->removed(factory); s_mutex.unlock(); } ObjList* DataTranslator::srcFormats(const DataFormat& dFormat, int maxCost, unsigned int maxLen, ObjList* lst) { const FormatInfo* fi = dFormat.getInfo(); if (!fi) return lst; s_mutex.lock(); compose(); ObjList* l = s_factories.skipNull(); for (; l; l=l->skipNext()) { TranslatorFactory* f = static_cast(l->get()); if (maxLen && (f->length() > maxLen)) continue; const TranslatorCaps* caps = f->getCapabilities(); for (; caps && caps->src && caps->dest; caps++) { if (caps->dest == fi) { if ((maxCost >= 0) && (caps->cost > maxCost)) continue; if (!lst) lst = new ObjList; else if (lst->find(caps->src->name)) continue; lst->append(new String(caps->src->name)); } } } s_mutex.unlock(); return lst; } ObjList* DataTranslator::destFormats(const DataFormat& sFormat, int maxCost, unsigned int maxLen, ObjList* lst) { const FormatInfo* fi = sFormat.getInfo(); if (!fi) return lst; s_mutex.lock(); compose(); ObjList* l = s_factories.skipNull(); for (; l; l=l->skipNext()) { TranslatorFactory* f = static_cast(l->get()); if (maxLen && (f->length() > maxLen)) continue; const TranslatorCaps* caps = f->getCapabilities(); for (; caps && caps->src && caps->dest; caps++) { if (caps->src == fi) { if ((maxCost >= 0) && (caps->cost > maxCost)) continue; if (!lst) lst = new ObjList; else if (lst->find(caps->dest->name)) continue; lst->append(new String(caps->dest->name)); } } } s_mutex.unlock(); return lst; } // helper function to avoid duplicating large amounts of code static void mergeOne(ObjList*& lst, const ObjList* formats, const DataFormat& fmt, const FormatInfo* fi, bool sameRate, bool sameChans) { if (!fi) return; const DataFormat fmti(fi); if (lst && lst->find(fmti)) return; if (formats->find(fmti)) return; const FormatInfo* fo = fmt.getInfo(); if (fo == fi) return; if (sameRate && (fo->sampleRate != fi->sampleRate)) return; if (sameChans && (fo->numChannels != fi->numChannels)) return; if (DataTranslator::canConvert(fmt,fmti)) { if (!lst) lst = new ObjList; lst->append(new String(fmti)); } } ObjList* DataTranslator::allFormats(const ObjList* formats, bool existing, bool sameRate, bool sameChans) { if (!formats) return 0; ObjList* lst = 0; s_mutex.lock(); compose(); const ObjList* fmts; if (existing) { // put existing formats first for (fmts = formats; fmts; fmts = fmts->next()) { const String* fmt = static_cast(fmts->get()); if (!(fmt && *fmt)) continue; const FormatInfo* fo = FormatRepository::getFormat(*fmt); if (fo) { if (!lst) lst = new ObjList; lst->append(new String(fo->name)); } } } for (fmts = formats; fmts; fmts = fmts->next()) { const String* fmt = static_cast(fmts->get()); if (!(fmt && *fmt)) continue; const FormatInfo* fo = FormatRepository::getFormat(*fmt); if (!fo) continue; const DataFormat fmto(fo); // search in the static list first for (unsigned int i = 0; i < (sizeof(s_formats)/sizeof(FormatInfo)); i++) mergeOne(lst,formats,fmto,s_formats+i,sameRate,sameChans); // then try the installed formats for (flist* l = s_flist; l; l = l->next) mergeOne(lst,formats,fmto,l->info,sameRate,sameChans); } s_mutex.unlock(); return lst; } ObjList* DataTranslator::allFormats(const String& formats, bool existing, bool sameRate, bool sameChans) { ObjList* fmts = formats.split(',',false); if (!fmts) return 0; ObjList* lst = allFormats(fmts,existing,sameRate,sameChans); TelEngine::destruct(fmts); return lst; } bool DataTranslator::canConvert(const DataFormat& fmt1, const DataFormat& fmt2) { if (fmt1 == fmt2) return true; const FormatInfo* fi1 = fmt1.getInfo(); const FormatInfo* fi2 = fmt2.getInfo(); if (!(fi1 && fi2)) return false; Lock lock(s_mutex); compose(); return canConvert(fi1,fi2); } bool DataTranslator::canConvert(const FormatInfo* fmt1, const FormatInfo* fmt2) { if (fmt1 == fmt2) return true; bool ok1 = false, ok2 = false; ObjList* l = s_factories.skipNull(); for (; l; l=l->skipNext()) { TranslatorFactory* f = static_cast(l->get()); const TranslatorCaps* caps = f->getCapabilities(); for (; caps && caps->src && caps->dest; caps++) { if ((!ok1) && (caps->src == fmt1) && (caps->dest == fmt2)) ok1 = true; if ((!ok2) && (caps->src == fmt2) && (caps->dest == fmt1)) ok2 = true; if (ok1 && ok2) return true; } } return false; } int DataTranslator::cost(const DataFormat& sFormat, const DataFormat& dFormat) { int c = -1; const FormatInfo* src = sFormat.getInfo(); const FormatInfo* dest = dFormat.getInfo(); if (!(src && dest)) return c; s_mutex.lock(); compose(); ObjList* l = s_factories.skipNull(); for (; l; l=l->skipNext()) { TranslatorFactory* f = static_cast(l->get()); const TranslatorCaps* caps = f->getCapabilities(); for (; caps && caps->src && caps->dest; caps++) { if ((c == -1) || (c > caps->cost)) { if ((caps->src == src) && (caps->dest == dest)) c = caps->cost; } } } s_mutex.unlock(); return c; } DataTranslator* DataTranslator::create(const DataFormat& sFormat, const DataFormat& dFormat) { if (sFormat == dFormat) { DDebug(DebugAll,"Not creating identity DataTranslator for '%s'",sFormat.c_str()); return 0; } DataTranslator *trans = 0; bool counting = getObjCounting(); NamedCounter* saved = Thread::getCurrentObjCounter(counting); s_mutex.lock(); compose(); ObjList *l = s_factories.skipNull(); for (; l; l=l->skipNext()) { TranslatorFactory* f = static_cast(l->get()); if (counting) Thread::setCurrentObjCounter(f->objectsCounter()); trans = f->create(sFormat,dFormat); if (trans) { Debug(DebugAll,"Created DataTranslator %p for '%s' -> '%s' by factory %p (len=%u)", trans,sFormat.c_str(),dFormat.c_str(),f,f->length()); break; } } s_mutex.unlock(); if (counting) Thread::setCurrentObjCounter(saved); if (!trans) Debug(DebugInfo,"No DataTranslator created for '%s' -> '%s'", sFormat.c_str(),dFormat.c_str()); return trans; } bool DataTranslator::attachChain(DataSource* source, DataConsumer* consumer, bool override) { XDebug(DebugInfo,"DataTranslator::attachChain [%p] '%s' -> [%p] '%s'", source,(source ? source->getFormat().c_str() : ""), consumer,(consumer ? consumer->getFormat().c_str() : "")); if (!source || !consumer) return false; if (!source->getFormat() || !consumer->getFormat()) { Debug(DebugInfo,"DataTranslator::attachChain [%p] '%s' -> [%p] '%s' not possible", source,source->getFormat().c_str(), consumer,consumer->getFormat().c_str()); return false; } bool retv = false; // first attempt to connect directly, changing format if possible if ((source->getFormat() == consumer->getFormat()) || // don't attempt to change consumer format for overrides (!override && consumer->setFormat(source->getFormat())) || source->setFormat(consumer->getFormat())) { source->attach(consumer,override); retv = true; } else { // then try to create a translator or chain of them DataTranslator* trans2 = create(source->getFormat(),consumer->getFormat()); if (trans2) { DataTranslator* trans = trans2->getFirstTranslator(); trans2->getTransSource()->attach(consumer,override); source->attach(trans); trans->deref(); retv = true; } } NDebug(retv ? DebugAll : DebugWarn,"DataTranslator::attachChain [%p] '%s' -> [%p] '%s' %s", source,source->getFormat().c_str(),consumer,consumer->getFormat().c_str(), retv ? "succeeded" : "failed"); return retv; } bool DataTranslator::detachChain(DataSource* source, DataConsumer* consumer) { Debugger debug(DebugAll,"DataTranslator::detachChain","(%p,%p)",source,consumer); if (!source || !consumer) return false; s_consSrcMutex.lock(); RefPointer tsource = consumer->getConnSource(); s_consSrcMutex.unlock(); if (tsource) { if (source->detach(consumer)) return true; tsource->lock(); RefPointer trans = tsource->getTranslator(); tsource->unlock(); if (trans && detachChain(source,trans)) return true; Debug(DebugWarn,"DataTranslator failed to detach chain [%p] -> [%p]",source,consumer); } return false; } TranslatorFactory::~TranslatorFactory() { DataTranslator::uninstall(this); } void TranslatorFactory::removed(const TranslatorFactory* factory) { } unsigned int TranslatorFactory::length() const { return 1; } const FormatInfo* TranslatorFactory::intermediate() const { return 0; } bool TranslatorFactory::intermediate(const FormatInfo* info) const { return false; } bool TranslatorFactory::converts(const DataFormat& sFormat, const DataFormat& dFormat) const { const FormatInfo* src = sFormat.getInfo(); const FormatInfo* dest = dFormat.getInfo(); const TranslatorCaps* caps = getCapabilities(); if (!(src && dest && caps)) return false; for (; caps->src && caps->dest; caps++) { if ((caps->src == src) && (caps->dest == dest)) return true; } return false; } ChainedFactory::ChainedFactory(TranslatorFactory* factory1, TranslatorFactory* factory2, const FormatInfo* info) : TranslatorFactory("chained"), m_factory1(factory1), m_factory2(factory2), m_format(info), m_length(factory1->length()+factory2->length()), m_capabilities(0) { XDebug(DebugInfo,"ChainedFactory::ChainedFactory('%s' (%d,'%s'), '%s' (%d,'%s'),'%s') len=%u [%p]", factory1->name(),factory1->length(),factory1->intermediate() ? factory1->intermediate()->name : "", factory2->name(),factory2->length(),factory2->intermediate() ? factory2->intermediate()->name : "", info->name,m_length,this); m_name << factory1->name() << "(" << info->name << ")" << factory2->name(); if (!info->converter) Debug(DebugMild,"Building chain factory '%s' using non-converter format",m_name.c_str()); const TranslatorCaps* cap1 = factory1->getCapabilities(); const TranslatorCaps* cap2 = factory2->getCapabilities(); int c1 = 0; int c2 = 0; const TranslatorCaps* c; for (c = cap1; c && c->src && c->dest; c++) if ((c->src == info) || (c->dest == info)) c1++; for (c = cap2; c && c->src && c->dest; c++) if ((c->src == info) || (c->dest == info)) c2++; // we overallocate int ccount = c1 * c2; int i = 0; TranslatorCaps* caps = new TranslatorCaps[ccount+1]; for (; cap1 && cap1->src && cap1->dest; cap1++) { if (cap1->src == info) { for (c = cap2; c && c->src && c->dest; c++) if (c->dest == info) { caps[i].src = c->src; caps[i].dest = cap1->dest; caps[i].cost = cap1->cost + c->cost; XDebug(DebugAll,"Capab[%d] '%s' -> '%s' cost %d", i,caps[i].src->name,caps[i].dest->name,caps[i].cost); i++; } } else if (cap1->dest == info) { for (c = cap2; c && c->src && c->dest; c++) if (c->src == info) { caps[i].src = cap1->src; caps[i].dest = c->dest; caps[i].cost = cap1->cost + c->cost; XDebug(DebugAll,"Capab[%d] '%s' -> '%s' cost %d", i,caps[i].src->name,caps[i].dest->name,caps[i].cost); i++; } } } caps[i].src = 0; caps[i].dest = 0; caps[i].cost = 0; m_capabilities = caps; } ChainedFactory::~ChainedFactory() { XDebug(DebugInfo,"ChainedFactory::~ChainedFactory() '%s' [%p]", m_name.c_str(),this); delete[] const_cast(m_capabilities); m_capabilities = 0; } void ChainedFactory::removed(const TranslatorFactory* factory) { if ((factory == m_factory1) || (factory == m_factory2)) destruct(); } const FormatInfo* ChainedFactory::intermediate() const { return m_format.getInfo(); } bool ChainedFactory::intermediate(const FormatInfo* info) const { if (!info) return false; return (m_format.getInfo() == info) || m_factory1->intermediate(info) || m_factory2->intermediate(info); } DataTranslator* ChainedFactory::create(const DataFormat& sFormat, const DataFormat& dFormat) { if (!converts(sFormat,dFormat)) return 0; bool counting = getObjCounting(); NamedCounter* saved = Thread::getCurrentObjCounter(counting); if (counting) Thread::setCurrentObjCounter(m_factory1->objectsCounter()); DataTranslator* trans = m_factory1->create(sFormat,m_format); DataTranslator* trans2 = 0; if (trans) { if (counting) Thread::setCurrentObjCounter(m_factory2->objectsCounter()); trans2 = m_factory2->create(m_format,dFormat); } else { // try the other way around if (counting) Thread::setCurrentObjCounter(m_factory2->objectsCounter()); trans = m_factory2->create(sFormat,m_format); if (!trans) { if (counting) Thread::setCurrentObjCounter(saved); return 0; } if (counting) Thread::setCurrentObjCounter(m_factory1->objectsCounter()); trans2 = m_factory1->create(m_format,dFormat); } if (counting) Thread::setCurrentObjCounter(saved); if (trans2) { XDebug(DebugInfo,"Chaining translators: '%s' %p --(%s)-> %p '%s' [%p]", sFormat.c_str(),trans,m_format.c_str(),trans2,dFormat.c_str(),this); // trans2 may be a chain itself so find the first translator DataTranslator* trans1 = trans2->getFirstTranslator(); trans->getTransSource()->attach(trans1); trans1->deref(); } else // trans may be a chain itself so clear from first translator trans->getFirstTranslator()->destruct(); return trans2; } /* vi: set ts=8 sw=4 sts=4 noet: */