int mitk::BaseData::GetExternalReferenceCount() const
{
  if(m_CalculatingExternalReferenceCount==false) //this is only needed because a smart-pointer to m_Outputs (private!!) must be created by calling GetOutputs.
  {
    m_CalculatingExternalReferenceCount = true;

    m_ExternalReferenceCount = -1;

    int realReferenceCount = GetReferenceCount();

    if(GetSource().IsNull())
    {
      m_ExternalReferenceCount = realReferenceCount;
      m_CalculatingExternalReferenceCount = false;
      return m_ExternalReferenceCount;
    }

    mitk::BaseProcess::DataObjectPointerArray outputs = m_SmartSourcePointer->GetOutputs();

    unsigned int idx;
    for (idx = 0; idx < outputs.size(); ++idx)
    {
      //references of outputs that are not referenced from someone else (reference additional to the reference from this BaseProcess object) are interpreted as non-existent 
      if(outputs[idx]==this)
        --realReferenceCount;
    }
    m_ExternalReferenceCount = realReferenceCount;
    if(m_ExternalReferenceCount<0)
      m_ExternalReferenceCount=0;
    m_CalculatingExternalReferenceCount = false;
  }
  else
    return -1;
  return m_ExternalReferenceCount;
}

DataItem& DataItem::CreateAndInsert(ItemPointer ptr)
{
    auto x = RawItem::Get<Header>(ptr);

    auto& ret = x.ritem.SplitCreate<DataItem>(
        ptr.offset, x.t, x.ritem.GetSize() - ptr.offset - sizeof(Header));
    if (x.t.length > 0)
        ret.MoveNextToChild(x.t.length);

    NEPTOOLS_ASSERT(ret.GetSize() == sizeof(Header) + x.t.length);

    // hack
    if (!ret.GetChildren().empty())
    {
        auto child = dynamic_cast<RawItem*>(&ret.GetChildren().front());
        if (child && child->GetSize() > sizeof(Gbnl::Header))
        {
            char buf[4];
            child->GetSource().Pread(child->GetSize() - sizeof(Gbnl::Header), buf, 4);
            if (memcmp(buf, "GBNL", 4) == 0)
                GbnlItem::CreateAndInsert({child, 0});
        }
    }
    return ret;
}

    void LoopingSound::InternalUpdate() {
        if (fadingOut and GetCurrentGain() == 0.0f) {
            Stop();
        }

        if (not fadingOut) {
            if (leadingSample) {
                if (GetSource().IsStopped()) {
                    SetupLoopingSound(GetSource());
                    GetSource().Play();
                    leadingSample = nullptr;
                }
            }
            SetSoundGain(effectsVolume.Get());
        }
    }

void HostileReference::updateOnlineStatus()
{
    bool online = false;

    if (!isValid())
        if (Unit* target = ObjectAccessor::GetUnit(*GetSourceUnit(), getUnitGuid()))
            link(target, GetSource());

    // only check for online status if
    // ref is valid
    // target is no player or not gamemaster
    // target is not in flight
    if (isValid()
        && (getTarget()->GetTypeId() != TYPEID_PLAYER || !getTarget()->ToPlayer()->IsGameMaster())
        && !getTarget()->IsInFlight()
        && getTarget()->IsInMap(GetSourceUnit())
        && getTarget()->InSamePhase(GetSourceUnit())
        )
    {
        Creature* creature = GetSourceUnit()->ToCreature();
        online = getTarget()->isInAccessiblePlaceFor(creature);
        if (!online)
        {
            if (creature->IsWithinCombatRange(getTarget(), creature->m_CombatDistance))
                online = true;                              // not accessible but stays online
        }
    }

    setOnlineOfflineState(online);
}

    void RegexPattern::Finalize(bool isShutdown)
    {
        if(isShutdown)
            return;

        const auto scriptContext = GetScriptContext();
        if(!scriptContext)
            return;

#if DBG
        if(!isLiteral && !scriptContext->IsClosed())
        {
            const auto source = GetSource();
            RegexPattern *p;
            Assert(
                !GetScriptContext()->GetDynamicRegexMap()->TryGetValue(
                    RegexKey(source.GetBuffer(), source.GetLength(), GetFlags()),
                    &p) ||
                p != this);
        }
#endif

        if(isShallowClone)
            return;

        rep.unified.program->FreeBody(scriptContext->RegexAllocator());
    }

 void OneShotSound::InternalUpdate() {
     if (GetSource().IsStopped()) {
         Stop();
         return;
     }
     SetSoundGain(effectsVolume.Get());
 }

Rect
Image::GetCoverageBounds ()
{
	// FIXME: SL3 final only supports PixelFormatPbgra32 which makes this optimization
	// obsolete - unless we keep an "has_alpha" flag with each image ?!?
	return Rect ();
#if FALSE
	ImageSource *source = GetSource ();

	if (!source || source->GetPixelFormat () == PixelFormatPbgra32)
		return Rect ();

	Stretch stretch = GetStretch ();
	if (stretch == StretchFill || stretch == StretchUniformToFill)
		return bounds;

	cairo_matrix_t matrix;
	Rect image = Rect (0, 0, source->GetPixelWidth (), source->GetPixelHeight ());
	Rect paint = Rect (0, 0, GetActualWidth (), GetActualHeight ());

	image_brush_compute_pattern_matrix (&matrix, 
					    paint.width, paint.height,
					    image.width, image.height, stretch, 
					    AlignmentXCenter, AlignmentYCenter, NULL, NULL);

	cairo_matrix_invert (&matrix);
	cairo_matrix_multiply (&matrix, &matrix, &absolute_xform);

	image = image.Transform (&matrix);
	image = image.Intersection (bounds);
	
	return image;
#endif
}

void
MediaBase::SetAllowDownloads (bool allow)
{
	const char *uri;
	Downloader *dl;
	
	if ((allow_downloads && allow) || (!allow_downloads && !allow))
		return;
	
	if (allow && IsAttached () && source_changed) {
		source_changed = false;
		
		if ((uri = GetSource ()) && *uri) {
			if (!(dl = GetDeployment ()->CreateDownloader ())) {
				// we're shutting down
				return;
			}
			
			dl->Open ("GET", uri, GetDownloaderPolicy (uri));
			SetSource (dl, "");
			dl->unref ();
		}
	}
	
	allow_downloads = allow;
}

void
Image::ImageFailed (ImageErrorEventArgs *args)
{
	BitmapSource *source = (BitmapSource*) GetSource ();

	if (source->Is (Type::BITMAPIMAGE)) {
		source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
		source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
		source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
	}
	source->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);


	InvalidateArrange ();
	InvalidateMeasure ();
	UpdateBounds ();
	Invalidate ();

	args = new ImageErrorEventArgs (this, *(MoonError*)args->GetMoonError ());
	if (HasHandlers (ImageFailedEvent)) {
		Emit (ImageFailedEvent, args);
	} else {
		GetDeployment ()->GetSurface ()->EmitError (args);
	}
}

/**
 * \brief Returns the source.
 *
 * \return The source as CString.
 */
CString CBibList::GetSource()
{
	xString* src = xsNew();
	GetSource(src);
	CString res = CString(xsValue(src));
	xsDelete(src);
	return res;
}

   virtual std::vector<unsigned int> EnumImageProperties() const override
   {
      cdHSource hSource = GetSource();

      ImagePropertyAccess p(hSource);

      return p.EnumImageProperties();
   }

/* virtual */ NS_IMETHODIMP
TVSourceListener::NotifyChannelScanStopped(const nsAString& aTunerId,
                                           const nsAString& aSourceType)
{
  RefPtr<TVSource> source = GetSource(aTunerId, aSourceType);
  source->NotifyChannelScanStopped();
  return NS_OK;
}

int I_SoundIsPlaying(int handle)
{
    sndsource_t *src = GetSource(handle);

    if(!initOk || !src) return false;
    if(src->source == NULL) return false;
    return I2_IsSourcePlaying(src);
}

	//------------------------------------------------------------------------------
	bool CBOMRecognizerFilter::Read( unsigned long& ulUnitsRead, unsigned long ulUnitsToRead )
	{
		bool bResult = false;

		//Switch on whether recognition has taken place

		if( m_bRecognized )
		{
			bResult = GetSource()->Read( ulUnitsRead, ulUnitsToRead );
		}
		else
		{
			bResult = GetSource()->Read( ulUnitsRead, sculBOMBytes );
			RecognizeBOM();
		}
		return bResult;
	}

void CField::SaveToFile(CFile *file)
{
	if (!m_Value.IsEmpty()) {
		xString* str = xsNew();
		GetSource(str);
		file->Write(xsValue(str), xsLen(str));
		xsDelete(str);
	}
}

void
RadioBearer::Enqueue (Packet *packet)
{
#ifdef TEST_ENQUEUE_PACKETS
      std::cout << "Enqueue packet on " << GetSource ()->GetIDNetworkNode () << std::endl;
#endif

  GetMacQueue ()->Enqueue(packet);
}

void* mitk::Image::GetData()
{
  if(m_Initialized==false)
  {
    if(GetSource().IsNull())
      return NULL;
    if(GetSource()->Updating()==false)
      GetSource()->UpdateOutputInformation();
  }
  m_CompleteData=GetChannelData();

  // update channel's data
  // if data was not available at creation point, the m_Data of channel descriptor is NULL
  // if data present, it won't be overwritten
  m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());

  return m_CompleteData->GetData();
}

int WAVEFILE::Read(void* lpDest, DWORD dwBytes)
{
	if (dwAccess != WAVE_OPEN_READ) 
		return WAVE_READ_ERROR;
	
	DWORD dwRead=GetSource()->Read(lpDest,dwBytes);
	dwCurrentPos+=dwRead;
	return dwRead;
}

void
Image::Dispose ()
{
	BitmapSource *source = (BitmapSource*)GetSource ();

	if (source)
		source->RemoveAllHandlers (this);

	MediaBase::Dispose ();
}

void I_Update3DSound(int handle, sound3d_t *desc)
{
    sndsource_t *buf = GetSource(handle);

    if(!initOk || !buf) return;
    if(buf->source == NULL) return;
    if(buf->source3D == NULL) return;
    if(!I2_IsSourcePlaying(buf)) IDirectSoundBuffer_Play(buf->source, 0, 0, 0);
    I2_UpdateSource(buf, desc);
}