static FILE *
dpx_open_pk_font_at (const char *ident, unsigned dpi)
{
  FILE  *fp;
  char  *fqpn;
  kpse_glyph_file_type kpse_file_info;

  fqpn = kpse_find_glyph(ident, dpi, kpse_pk_format, &kpse_file_info);
  if (!fqpn)
    return  NULL;
  fp   = MFOPEN(fqpn, FOPEN_RBIN_MODE);
  RELEASE(fqpn);

  return  fp;
}

//////////////////////////////////////////////////////////////////////////////////
//	建立连接的线程
DWORD WINAPI CClient::_ConnectionThread(LPVOID lpParam)
{
	THREADPARAMS_CONNECTION* pParams = (THREADPARAMS_CONNECTION*) lpParam;
	CClient* pClient = (CClient*)pParams->pClient;

	TRACE("_AccpetThread启动，系统监听中...\n");

	pClient->EstablishConnections();

	TRACE(_T("_ConnectionThread线程结束.\n"));

	RELEASE(pParams);	

	return 0;
}

EXTERN_C
BOOL
PALAPI
CryptDestroyKey(
    HCRYPTKEY hKey)
{
    if (hKey == NULL)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    RELEASE(hKey);
    return TRUE;
}

// Destructor
j1App::~j1App()
{
	// release modules
	p2List_item<j1Module*>* item = modules.end;

	while(item != NULL)
	{
		RELEASE(item->data);
		item = item->prev;
	}

	modules.clear();

	config_file.reset();
}

double Trick::MSSharedMem::read_wait(struct timespec *in_start) {
    struct timespec ts_Current, ts_Difference;

    RELEASE();
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Current);
    if ((ts_Current.tv_nsec - in_start->tv_nsec) < 0) {
        ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec - 1;
        ts_Difference.tv_nsec = 1000000000 + ts_Current.tv_nsec - in_start->tv_nsec;
    } else {
        ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec;
        ts_Difference.tv_nsec = ts_Current.tv_nsec - in_start->tv_nsec;
    }
    // return the total elapsed time we've waited since in_start
    return ((double)ts_Difference.tv_nsec / 1000000000.0) + ts_Difference.tv_sec;
}

HRESULT AdjustAudioFrequency(void)
{
    HRESULT hr=NOERROR;
    IDBOXIICapture *pSource=NULL;
    IBaseFilter    *pAudioResampler=NULL;
    IAudioResampler *pIAudioResampler=NULL;

    __int64 val=0;

    if (gpIGraphBuilder==NULL)
        return(E_POINTER);

    if (gpVCap==NULL)
        return(E_POINTER);

    hr=gpVCap->QueryInterface(IID_IDBOXIICapture, (void **)&pSource);

    if (SUCCEEDED(hr))
        hr=pSource->getParameter(CMD_GETAUDIOFREQ, &val, NULL);

    if ( SUCCEEDED(hr) && (val>0) )
        {
        hr = gpIGraphBuilder->FindFilterByName (L"AudioResampler", &pAudioResampler);
        if (SUCCEEDED(hr))
            hr=pAudioResampler->QueryInterface(IID_AudioResampler, (void **)&pIAudioResampler);
        if (SUCCEEDED(hr))
            hr=pIAudioResampler->setParameter(CMD_SOURCE_FREQUENCY, (int)val);
        }


    RELEASE(pIAudioResampler);
    RELEASE(pAudioResampler);
    RELEASE(pSource);

    return(hr);
}

static void release_a_cmap (int id)
{
  struct cid_sysinfo_s *sysinfo;

  if (id >= 2 && id < num_cmaps) {
    if (cmaps[id].CMapName) RELEASE(cmaps[id].CMapName);
    if (cmaps[id].UseCMap) RELEASE(cmaps[id].UseCMap);
    if ((sysinfo = cmaps[id].sysinfo) != NULL) {
      if (sysinfo->registry) RELEASE(sysinfo->registry);
      if (sysinfo->ordering) RELEASE(sysinfo->ordering);
      RELEASE(sysinfo);
    }
    if (cmaps[id].offsets) RELEASE(cmaps[id].offsets);
    if (cmaps[id].map) RELEASE(cmaps[id].map);
    if (cmaps[id].csranges) RELEASE(cmaps[id].csranges);
  }
}

void CqShaderVM::SO_init_illuminance2()
{
	VARFUNC;
	POPV( A );
	POPV( B );
	RESULT(type_float, class_varying);
	if(m_pEnv->IsRunning())
	{
		m_pEnv->InvalidateIlluminanceCache();
		m_pEnv->ValidateIlluminanceCache( A, B, this );
		pResult->SetFloat( m_pEnv->SO_init_illuminance() );
	}
	Push( pResult );
	RELEASE( A );
}

LIB_EXPORT rc_t CC aspera_options(AscpOptions *opt) {
    KConfig *cfg = NULL;
    rc_t rc = 0;
    if (opt == NULL) {
        return RC(rcNS, rcFile, rcVisiting, rcParam, rcNull);
    }
    memset(opt, 0, sizeof *opt);
    rc = KConfigMake(&cfg, NULL);
    if (rc == 0) {
        rc = _KConfigGetAscpRate(cfg, &opt->target_rate);
        opt->disabled = _KConfigAscpDisabled(cfg, false);
    }
    RELEASE(KConfig, cfg);
    return rc;
}

EXTERN_C
BOOL
PALAPI
CryptDestroyHash(
    HCRYPTHASH hHash)
{
    if (hHash == NULL)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    RELEASE(hHash);
    return TRUE;
}

/**
 * grant a stack to an address
 *
 * TODO:
 *  - Keep various heap pointers around instead of incrementign it every time.
 */
void *
stkmgr_grant_stack(spdid_t d_spdid)
{
	struct cos_stk_item *stk_item;
	struct spd_stk_info *info;
	vaddr_t ret;
	int meas = 0;

	TAKE();

	info = get_spd_stk_info(d_spdid);

	DOUT("<stkmgr>: stkmgr_grant_stack for, spdid: %d, thdid %d\n",
	       d_spdid, cos_get_thd_id());
        
	// Make sure we have access to the info page
	if (!SPD_IS_MANAGED(info)) get_cos_info_page(d_spdid);
	assert(SPD_IS_MANAGED(info));
	
	/* 
	 * Is there a stack in the local freelist?  If not, is there
	 * one is the global freelist and we are under quota on
	 * stacks?  Otherwise block!
	 */
	while (NULL == (stk_item = spd_freelist_remove(d_spdid))) {
		if (info->num_allocated < info->num_desired &&
		    NULL != (stk_item = freelist_remove())) {
			stkmgr_stk_add_to_spd(stk_item, info);
			break;
		}
		if (!meas) {
			meas = 1;
			stkmgr_update_stats_block(info, cos_get_thd_id());
		}
		DOUT("Stack list is null, we need to revoke a stack: spdid: %d thdid: %d\n",
		     d_spdid,
		     cos_get_thd_id());
		stkmgr_wait_for_stack(info);
	}
	if (meas) stkmgr_update_stats_wakeup(info, cos_get_thd_id());
	
	ret = stk_item->d_addr + PAGE_SIZE;
	RELEASE();

	//DOUT("Returning Stack address: %X\n",(unsigned int)ret);

	return (void *)ret;
}

/* 
 * FIXME: 1) reference counting so that components can maintain the
 * buffer if they please, 2) asynchronous (shmmem) notification of cb
 * deallocation.
 */
int
cbuf_c_delete(spdid_t spdid, int cbid)
{
	struct spd_tmem_info *sti;
	int ret = 0;  /* return value not used */

	TAKE();

	sti = get_spd_info(spdid);
	assert(sti);

	return_tmem(sti);

	RELEASE();
	return ret;
}

void Paint_vdecor(void)
{
    int	i;
    bool last, more_y;
    
    if (num_vdecor > 0) {
	for (i = 0; i < num_vdecor; i++) {
	    last = (i + 1 == num_vdecor);
	    more_y = (vdecor_ptr[i].yi != vdecor_ptr[i + 1].yi);
	    Gui_paint_decor(vdecor_ptr[i].x, vdecor_ptr[i].y, 
			    vdecor_ptr[i].xi, vdecor_ptr[i].yi,
			    vdecor_ptr[i].type, last, more_y);
	}
	RELEASE(vdecor_ptr, num_vdecor, max_vdecor);
    }
}

////////////////////////////////////////////////////////////////
//	移除某个特定的Context
void CIOCPModel::_RemoveContext( PER_SOCKET_CONTEXT *pSocketContext )
{
	EnterCriticalSection(&m_csContextList);

	for( int i=0;i<m_arrayClientContext.size();i++ )
	{
		if( pSocketContext==m_arrayClientContext.at(i) )
		{
			RELEASE( pSocketContext );			
			m_arrayClientContext.at(i);			
			break;
		}
	}

	LeaveCriticalSection(&m_csContextList);
}

type *type_attributed(type *ty, attribute *attr)
{
	type *attributed;

	if(!attr)
		return ty;

	attributed = type_uptree_find_or_new(
			ty, type_attr,
			eq_attr, init_attr,
			attr);

	RELEASE(attr);

	return attributed;
}

update_status MParticle::PreUpdate()
{

	// Remove all colliders scheduled for deletion
	for (list<Particle*>::iterator it = particles.begin(); it != particles.end();)
	{
		if ((*it)->dead == true)
		{
			RELEASE(*it);
			it = particles.erase(it);
		}
		else
			++it;
	}
	return UPDATE_CONTINUE;
}

pugi::xml_node j1App::LoadConfig()
{
	pugi::xml_node ret;

	char* buffer;
	int size = App->fs->LoadFile("config.xml", &buffer);
	pugi::xml_parse_result result = config_file.load_buffer(buffer, size);
	RELEASE(buffer);

	if (result)
		ret = config_file.child("config");
	else
		LOG("Could not load config.xml, pugi error: %s", result.description());

	return ret;
}

DsProcess::~DsProcess(){

	RELEASE(pBasicAudio);
	RELEASE(pMediaPosition);
	RELEASE(pMediaControl);
	RELEASE(pVideoWindow);
	//解放の順番の関係でここに記述
	RELEASE(pSampleGrabber);
	RELEASE(pSampleGrabberFilter);
	RELEASE(pGraphBuilder);

	// COM終了
	CoUninitialize();
}

void
stkmgr_spd_meas_reset(void)
{
	struct spd_stk_info *ssi;
	int i;

	TAKE();
	for (i = 0 ; i < MAX_NUM_SPDS ; i++) {
		ssi = get_spd_stk_info(i);
		if (!ssi) BUG();
		if (!SPD_IS_MANAGED(ssi)) continue;
		
		stkmgr_reset_stats(ssi);
	}
	RELEASE();
}

EXTERN_C
BOOL
PALAPI
CryptReleaseContext(
    HCRYPTPROV hProv,
    DWORD dwFlags)
{
    if (hProv == NULL)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    RELEASE(hProv);
    return TRUE;
}