static boolean isAmigaDirectory (const char *const name)
{
boolean result = FALSE;
struct FileInfoBlock *const fib = xMalloc (1, struct FileInfoBlock);
if (fib != NULL)
{
const BPTR flock = Lock ((UBYTE *) name, (long) ACCESS_READ);
if (flock != (BPTR) NULL)
{
if (Examine (flock, fib))
result = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE);
UnLock (flock);
}
eFree (fib);
}
return result;
}
void OMXPlayerAudio::Flush()
{
Lock();
LockDecoder();
m_flush = true;
while (!m_packets.empty())
{
OMXPacket *pkt = m_packets.front();
m_packets.pop_front();
OMXReader::FreePacket(pkt);
}
m_iCurrentPts = DVD_NOPTS_VALUE;
m_cached_size = 0;
if(m_decoder)
m_decoder->Flush();
UnLockDecoder();
UnLock();
}
BOOL TInifile::WriteIni()
{
Lock();
BOOL ret = FALSE;
HANDLE hFile = ::CreateFileW(iniFile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE) {
#define MIN_INI_ALLOC (64 * 1024)
#define MAX_INI_ALLOC (10 * 1024 * 1024)
#define MIN_LINE_SIZE (2 * 1024)
VBuf vbuf(MIN_INI_ALLOC, MAX_INI_ALLOC);
char *p = (char *)vbuf.Buf();
for (TIniSection *sec = TopObj(); sec && p; sec = NextObj(sec)) {
TIniKey *key = sec->TopObj();
int len = 0;
if (key) {
if (sec->Name()) {
len = sprintf(p, "[%s]\r\n", sec->Name());
p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
}
while (key) {
if (key->Key()) {
len = sprintf(p, "%s=\"%s\"\r\n", key->Key(), key->Val());
p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
}
else {
len = sprintf(p, "%s\r\n", key->Val());
p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
}
key = sec->NextObj(key);
}
}
}
DWORD size;
ret = ::WriteFile(hFile, vbuf.Buf(), (DWORD)vbuf.UsedSize(), &size, 0);
::CloseHandle(hFile);
}
UnLock();
return ret;
}
// Get disk info
LONG GetDiskInfo(char *device,struct InfoData *info)
{
struct DevProc *proc;
struct DosList *dos;
LONG res=0;
// Get device proc
if (!(proc=GetDeviceProc(device,0)))
return 0;
// Send packet
#ifdef __AROS__
if (((struct Library *)DOSBase)->lib_Version<50)
{
//res=Info(proc->dvp_Lock,info);
BPTR lock;
if ((lock=Lock(device,SHARED_LOCK)))
{
res=Info(lock,info);
UnLock(lock);
}
}
else
#endif
res=DoPkt(proc->dvp_Port,ACTION_DISK_INFO,MKBADDR(info),0,0,0,0);
// Clear "in use" flag to indicate formatting by default
info->id_InUse=0;
// Get doslist pointer
if ((dos=DeviceFromHandler(proc->dvp_Port,NULL)))
{
// Invalid device?
if (!GetDeviceUnit(dos->dol_misc.dol_handler.dol_Startup,NULL,NULL))
{
// Disk can't be formatted
info->id_InUse=1;
}
}
// Free device proc
FreeDeviceProc(proc);
return res;
}
// Delete any temporary files
void delete_temp_files(struct DateStamp *last)
{
struct AnchorPath *anchor;
BPTR old,lock;
// Lock T: and cd
if ((lock=Lock("t:",ACCESS_READ)))
{
// CD to t:
old=CurrentDir(lock);
// Allocate an anchor
if ((anchor=AllocVec(sizeof(struct AnchorPath),MEMF_CLEAR)))
{
short error;
struct FileInfoBlock fibcopy;
// See if any script files already exist
error=MatchFirst("T:dopus#?tmp#?",anchor);
while (!error)
{
// Copy fib
fibcopy=anchor->ap_Info;
// Get next
error=MatchNext(anchor);
// Check datestamp
if (!last ||
CompareDates(&fibcopy.fib_Date,last)>=0)
{
// Try to delete file
DeleteFile(fibcopy.fib_FileName);
}
}
// Cleanup anchor
MatchEnd(anchor);
FreeVec(anchor);
}
UnLock(CurrentDir(old));
}
}
TInt RSignalSession::OnDemandConnection()
{
TInt err = KErrNone;
//On Demand connection
if ( !iIsConnected )
{
Lock();
if ( !iIsConnected )
{
err = Connect ();
if ( KErrNone == err)
{
iIsConnected = ETrue;
}
}
UnLock();
}
return err;
}
//自ストリームのサービス一覧を取得する
//戻り値：
// エラーコード
//引数：
// serviceList [OUT]サービス情報のリスト
DWORD CBonCtrl::GetServiceListActual(
vector<TS_SERVICE_INFO>* serviceList
)
{
if( Lock(L"GetServiceListActual") == FALSE ) return EpgNoData;
DWORD _serviceListSize = 0;
SERVICE_INFO* _serviceList = NULL;
DWORD err = this->tsOut.GetServiceListActual(&_serviceListSize, &_serviceList);
if( err == NO_ERR ){
for( DWORD i=0; i<_serviceListSize; i++ ){
TS_SERVICE_INFO item;
item.ONID = _serviceList[i].original_network_id;
item.TSID = _serviceList[i].transport_stream_id;
item.SID = _serviceList[i].service_id;
if( _serviceList[i].extInfo != NULL ){
item.serviceType = _serviceList[i].extInfo->service_type;
item.partialFlag = _serviceList[i].extInfo->partialReceptionFlag;
if( _serviceList[i].extInfo->service_name != NULL ){
item.serviceName = _serviceList[i].extInfo->service_name;
}else{
item.serviceName = L"";
}
if( _serviceList[i].extInfo->network_name != NULL ){
item.networkName = _serviceList[i].extInfo->network_name;
}else{
item.networkName = L"";
}
item.remoteControlKeyID = _serviceList[i].extInfo->remote_control_key_id;
}else{
item.serviceType = 0;
item.partialFlag = 0;
item.serviceName = L"";
item.networkName = L"";
item.remoteControlKeyID = 0;
}
serviceList->push_back(item);
}
}
UnLock();
return err;
}
void COMXCoreComponent::FlushInput()
{
if(!m_handle)
return;
Lock();
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
omx_err = OMX_SendCommand(m_handle, OMX_CommandFlush, m_input_port, NULL);
if(omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::FlushInput - Error on component %s omx_err(0x%08x)",
m_componentName.c_str(), (int)omx_err);
}
WaitForCommand(OMX_CommandFlush, m_input_port);
UnLock();
}
//ロード中のBonDriverのファイル名を取得する（ロード成功しているかの判定）
//戻り値：
// TRUE（成功）：FALSE（Openに失敗している）
//引数：
// bonDriverFile [OUT]BonDriverのファイル名(NULL可)
BOOL CBonCtrl::GetOpenBonDriver(
wstring* bonDriverFile
)
{
if( Lock(L"GetOpenBonDriver") == FALSE ) return ERR_FALSE;
BOOL ret = FALSE;
if( this->bonUtil.GetOpenBonDriverIndex() != -1 ){
ret = TRUE;
if( bonDriverFile != NULL ){
*bonDriverFile = this->bonUtil.GetOpenBonDriverFileName();
}
}
UnLock();
return ret;
}
bool OMXClock::OMXResume(bool lock /* = true */)
{
if(m_omx_clock.GetComponent() == NULL)
return false;
if(m_pause)
{
if(lock)
Lock();
if (OMXSetSpeed(m_omx_speed, false, true))
m_pause = false;
m_last_media_time = 0.0f;
if(lock)
UnLock();
}
return m_pause == false;
}
BOOL CEpgDBManager::ReloadEpgData()
{
if( Lock() == FALSE ) return FALSE;
BOOL ret = TRUE;
if( this->loadThread == NULL ){
//受信スレッド起動
ClearEpgData();
ResetEvent(this->loadStopEvent);
this->loadThread = (HANDLE)_beginthreadex(NULL, 0, LoadThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
SetThreadPriority( this->loadThread, THREAD_PRIORITY_NORMAL );
ResumeThread(this->loadThread);
}else{
ret = FALSE;
}
UnLock();
return ret;
}
inline s32 Factory::AddVIPC(VIPCDeviceParam & pParam)
{
s32 nId = GetVIPCID();
FactoryDeviceChangeData change;
VDC_DEBUG( "%s GetDeviceID %d\n",__FUNCTION__, nId);
Lock();
pParam.m_Conf.data.conf.nId = nId;
m_VIPCDeviceParamMap[nId] = pParam;
m_Conf.AddVIPC(pParam.m_Conf, nId);
UnLock();
change.id = nId;
change.type = FACTORY_VIPC_ADD;
CallDeviceChange(change);
return nId;
}
/*
=================
Sys_SetBinaryPath
=================
*/
void Sys_SetBinaryPath(const char *path)
{
#ifdef __AROS__
if (!strcmp(path, "."))
{
BPTR lock = Lock("PROGDIR:", ACCESS_READ);
if (lock)
{
NameFromLock(lock, binaryPath, sizeof(binaryPath));
UnLock(lock);
}
}
else
#endif
{
Q_strncpyz(binaryPath, path, sizeof(binaryPath));
}
}
/* return malloc'd version of full pathname of orig_name */
int archdep_expand_path(char **return_path, const char *orig_name)
{
BPTR lock;
lock = Lock(orig_name, ACCESS_READ);
if (lock) {
char name[1024];
LONG rc;
rc = NameFromLock(lock, name, 1024);
UnLock(lock);
if (rc) {
*return_path = lib_stralloc(name);
return 0;
}
}
*return_path = lib_stralloc(orig_name);
return 0;
}
//タイムシフト送信を開始する
//戻り値：
// TRUE（成功）、FALSE（失敗）
BOOL CTimeShiftUtil::StartTimeShift()
{
if( Lock() == FALSE ) return FALSE;
BOOL ret = TRUE;
if( this->filePath.size() == 0 ){
ret = FALSE;
}else{
if( this->readThread == NULL ){
//受信スレッド起動
ResetEvent(this->readStopEvent);
this->readThread = (HANDLE)_beginthreadex(NULL, 0, ReadThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
SetThreadPriority( this->readThread, THREAD_PRIORITY_NORMAL );
ResumeThread(this->readThread);
}
}
UnLock();
return ret;
}
struct List *LoadBlankerEntries( STRPTR Path )
{
struct FileInfoBlock *Blk;
struct List *Entries = 0L;
BlankerEntry *New;
BPTR DirLock;
if(!( Entries = AllocVec( sizeof( struct List ), MEMF_CLEAR )))
return 0L;
else
NewList( Entries );
NumBlankEntries = 0;
if( DirLock = Lock( Path, ACCESS_READ ))
{
if(( Blk = AllocDosObject( DOS_FIB, 0L ))&&( Examine( DirLock, Blk )))
{
while( ExNext( DirLock, Blk ))
{
if(( Blk->fib_FileName )&&
( FileIsModule( Path, Blk->fib_FileName )))
{
if( New = NewBlankerEntry( Path, Blk->fib_FileName,
Blk->fib_Comment ))
{
New->be_Node.ln_Pri = 128 - ( New->be_Name[0] - 'a' );
Enqueue( Entries, ( struct Node * )New );
NumBlankEntries++;
}
}
}
FreeDosObject( DOS_FIB, Blk );
}
UnLock( DirLock );
}
if( New = NewBlankerEntry( ":", "Random", "" ))
AddTail( Entries, ( struct Node * )New );
return Entries;
}
OMX_ERRORTYPE COMXCoreComponent::UseEGLImage(OMX_BUFFERHEADERTYPE** ppBufferHdr, OMX_U32 nPortIndex, OMX_PTR pAppPrivate, void* eglImage)
{
if(!m_handle)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err;
omx_err = OMX_UseEGLImage(m_handle, ppBufferHdr, nPortIndex, pAppPrivate, eglImage);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::UseEGLImage - %s failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
}
UnLock();
return omx_err;
}
OMX_ERRORTYPE COMXCoreComponent::SendCommand(OMX_COMMANDTYPE cmd, OMX_U32 cmdParam, OMX_PTR cmdParamData)
{
if(!m_handle)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err;
omx_err = OMX_SendCommand(m_handle, cmd, cmdParam, cmdParamData);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::SendCommand - %s failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
}
UnLock();
return omx_err;
}
OMX_ERRORTYPE COMXCoreComponent::SetParameter(OMX_INDEXTYPE paramIndex, OMX_PTR paramStruct)
{
if(!m_handle)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err;
omx_err = OMX_SetParameter(m_handle, paramIndex, paramStruct);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::SetParameter - %s failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
}
UnLock();
return omx_err;
}
BOOL Device::StopHdfsRecord()
{
if (m_param.m_Conf.data.conf.HdfsRecording == 1)
{
return FALSE;
}
VDC_DEBUG( "%s Stop Record\n",__FUNCTION__);
StopData();
Lock();
if (m_pHdfsRecord)
{
m_pVHdfsdb.FinishRecord(m_pHdfsRecord);
delete m_pHdfsRecord;
m_pHdfsRecord = NULL;
}
UnLock();
return TRUE;
}
void CBatManager::StartWork()
{
if( Lock() == FALSE ) return ;
this->workFlag = TRUE;
if( this->batWorkThread != NULL ){
if( ::WaitForSingleObject(this->batWorkThread, 0) == WAIT_OBJECT_0 ){
CloseHandle(this->batWorkThread);
this->batWorkThread = NULL;
}
}
if( this->batWorkThread == NULL ){
ResetEvent(this->batWorkStopEvent);
this->batWorkThread = (HANDLE)_beginthreadex(NULL, 0, BatWorkThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
SetThreadPriority( this->batWorkThread, THREAD_PRIORITY_NORMAL );
ResumeThread(this->batWorkThread);
}
UnLock();
}
char *open_dir(const char *dirname)
/* open a directory for examination */
{
struct Dir *d;
if (d = malloc(sizeof(struct Dir))) {
strcpy(d->name,dirname);
if (!strcmp(d->name,".")) { /* current directory? */
d->name[0] = 0;
}
if (d->lock = Lock(d->name,ACCESS_READ)) {
if (Examine(d->lock,&(d->fib))) {
return (char *)d;
}
UnLock(d->lock);
}
free(d);
}
return NULL;
}
//ストリーミングを停止する
//戻り値：
// エラーコード
//引数：
// streamingID [IN]ストリーミング識別ID
DWORD CTwitterMain::StopTweetStreaming(
DWORD streamingID
)
{
if( Lock() == FALSE ) return 0;
DWORD ret = NO_ERR;
map<DWORD, STREAMING_INFO*>::iterator itr;
itr = streamingList.find(streamingID);
if( itr != streamingList.end() ){
itr->second->httpUtil.CloseSession();
SAFE_DELETE(itr->second);
streamingList.erase(itr);
}
UnLock();
return ret;
}
//ロード中のBonDriverのファイル名を取得する（ロード成功しているかの判定）
//戻り値：
// TRUE（成功）：FALSE（Openに失敗している）
//引数：
// bonDriverFile [OUT]BonDriverのファイル名(NULL可)
BOOL CBonCtrl::GetOpenBonDriver(
wstring* bonDriverFile
)
{
if( Lock(L"GetOpenBonDriver") == FALSE ) return ERR_FALSE;
BOOL ret = FALSE;
wstring strBonDriverFile = this->bonUtil.GetOpenBonDriverFileName();
if( strBonDriverFile.empty() == false ){
ret = TRUE;
if( bonDriverFile != NULL ){
*bonDriverFile = strBonDriverFile;
}
}
UnLock();
return ret;
}
inline BOOL Factory::GetVmsById(VSCVmsDataItem &pParam, int nId)
{
VSCVmsData VmsData;
int id = -1;
Lock();
m_Conf.GetVmsData(VmsData);
if (nId < CONF_VMS_NUM_MAX && nId > 0)
{
if (VmsData.data.conf.vms[nId].Used == 1)
{
memcpy(&pParam, &(VmsData.data.conf.vms[nId]), sizeof(VSCVmsDataItem));
}
}else
{
UnLock();
return FALSE;
}
return TRUE;
}
HOOKF(void, ami_menu_item_arexx_entries, APTR, window, struct IntuiMessage *)
{
char *script = hook->h_Data;
char *temp;
struct gui_window_2 *gwin;
GetAttr(WINDOW_UserData, (Object *)window, (ULONG *)&gwin);
if(script) {
if((temp = AllocVecTagList(1024, NULL))) {
BPTR lock;
if((lock = Lock(nsoption_charp(arexx_dir), SHARED_LOCK))) {
DevNameFromLock(lock, temp, 1024, DN_FULLPATH);
AddPart(temp, script, 1024);
ami_arexx_execute(temp);
FreeVec(temp);
UnLock(lock);
}
}
}
}
OMX_ERRORTYPE COMXCoreComponent::GetConfig(OMX_INDEXTYPE configIndex, OMX_PTR configStruct)
{
if(!m_handle)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err;
omx_err = OMX_GetConfig(m_handle, configIndex, configStruct);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::GetConfig - %s failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
}
UnLock();
return omx_err;
}
// Copy a file for the build operation
BOOL theme_copy_file(char *source,char *dest)
{
BPTR in,out;
D_S(struct FileInfoBlock, fib)
BOOL ret=0;
// See if source exists
if ((in=Lock(source,ACCESS_READ)))
{
Examine(in,fib);
UnLock(in);
// Won't try to copy a directory
if (fib->fib_DirEntryType>0) return 1;
}
else return 0;
// Open files
if ((in=Open(source,MODE_OLDFILE)) &&
(out=Open(dest,MODE_NEWFILE)))
{
char *buf;
// Allocate buffer
if ((buf=AllocVec(8192,0)))
{
long len;
// Copy file
while ((len=Read(in,buf,8192))>0)
Write(out,buf,len);
FreeVec(buf);
ret=1;
}
Close(out);
}
if (in) Close(in);
return ret;
}
OMX_ERRORTYPE COMXCoreTunel::Flush()
{
if(!m_DllOMXOpen)
return OMX_ErrorUndefined;
if(!m_src_component || !m_dst_component)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(m_src_component->GetComponent())
{
omx_err = OMX_SendCommand(m_src_component->GetComponent(), OMX_CommandFlush, m_src_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
CLog::Log(LOGERROR, "COMXCoreComponent::Flush - Error flush port %d on component %s omx_err(0x%08x)",
m_src_port, m_src_component->GetName().c_str(), (int)omx_err);
}
}
if(m_dst_component->GetComponent())
{
omx_err = OMX_SendCommand(m_dst_component->GetComponent(), OMX_CommandFlush, m_dst_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
CLog::Log(LOGERROR, "COMXCoreComponent::Flush - Error flush port %d on component %s omx_err(0x%08x)",
m_dst_port, m_dst_component->GetName().c_str(), (int)omx_err);
}
}
if(m_src_component->GetComponent())
omx_err = m_src_component->WaitForCommand(OMX_CommandFlush, m_src_port);
if(m_dst_component->GetComponent())
omx_err = m_dst_component->WaitForCommand(OMX_CommandFlush, m_dst_port);
UnLock();
return OMX_ErrorNone;
}
void dmLogMessage(int level, const char* filename, int lineno, const char *format, ...)
{
va_list ap;
static char s_buffer[2048];
int nWritten = 0;
if(level < g_logLevel)
return;
Lock(&g_LockLog);
s_buffer[2047] = 0;
va_start(ap, format);
if(g_logType == LOG_DRIVER_SYSLOG)
{
#ifdef WIN32
FORMAT_STRING();
OutputDebugString(s_buffer);
#elif defined(ANDROID)
__android_log_vprint(g_logLevelNative[level], dmBaseName(filename), format, ap);
#elif defined(LINUX)
vsyslog(g_logLevelNative[level], format, ap);
#elif defined(__IPHONE__)
FORMAT_STRING();
printf(s_buffer);
#endif
}else if(g_logType == LOG_DRIVER_CONSOLE){
FORMAT_STRING();
printf(s_buffer);
}else if (g_logType == LOG_DRIVER_MMAP){
FORMAT_STRING();
mmapLogWrite(s_buffer, nWritten);
}else if(g_logType == LOG_DRIVER_FILE){
if(g_hLogFile != NULL){
FORMAT_STRING();
fwrite(s_buffer, sizeof(char), nWritten, g_hLogFile);
fflush(g_hLogFile);
}
}
va_end(ap);
UnLock(&g_LockLog);
}
