bool ConfigManager::loadConfig( const ConstString & _fileGroup, const ConstString & _applicationPath ) { InputStreamInterfacePtr applicationInputStream = FILE_SERVICE(m_serviceProvider)->openInputFile( _fileGroup, _applicationPath, false ); if( applicationInputStream == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ConfigManager::loadConfig Invalid open application settings %s" , _applicationPath.c_str() ); return false; } if( IniUtil::loadIni( m_ini, applicationInputStream, m_serviceProvider ) == false ) { LOGGER_ERROR(m_serviceProvider)("ConfigManager::loadConfig Invalid load application settings %s" , _applicationPath.c_str() ); return false; } return true; }
static void write_out_stream (const char *filename, char *data) { vmbuf_reset(&write_buffer); vmbuf_sprintf(&write_buffer, "{ \"message\": \"%s|%s|", hostname, filename); json_escape_str_vmb(&write_buffer, data); vmbuf_strcpy(&write_buffer, "\" }"); vmbuf_chrcpy(&write_buffer, '\0'); if (write_to_file) { if (0 > file_writer_write(&fw, vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer))) { LOGGER_ERROR("%s", "failed write attempt on outfile| aborting to diagnose!"); abort(); } return; } int threshold = INTERFACE_ONERROR_RETRY_THRESHOLD; while (0 > post_to_interface(vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer)) && (0 < threshold--)) { if (0 == post_to_interface(vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer))) { LOGGER_ERROR("post failed to %s, issuing reattempt#%d", eserv.hostname, threshold); --failure; break; } } }
const RenderMaterialStage * RenderMaterialManager::createRenderStageGroup( const ConstString & _name, const RenderMaterialStage & _stage ) { TMapRenderStage::const_iterator it_found = m_materialStageIndexer.find( _name ); if( it_found != m_materialStageIndexer.end() ) { LOGGER_ERROR(m_serviceProvider)("RenderMaterialManager::createRenderStageGroup '%s' is already created" , _name.c_str() ); return nullptr; } const RenderMaterialStage * cache_stage = this->cacheStage( _stage ); if( cache_stage == nullptr ) { LOGGER_ERROR( m_serviceProvider )("RenderMaterialManager::createRenderStageGroup '%s' invalid cache" , _name.c_str() ); return nullptr; } return cache_stage; }
int http_server_init(struct http_server *server) { /* * one time global initializers */ if (0 > mime_types_init()) return LOGGER_ERROR("failed to initialize mime types"), -1; if (0 > http_headers_init()) return LOGGER_ERROR("failed to initialize http headers"), -1; /* * idle connection handler */ server->idle_ctx = ribs_context_create(SMALL_STACK_SIZE, http_server_idle_handler); server->idle_ctx->data.ptr = server; /* * context pool */ if (0 == server->stack_size || 0 == server->num_stacks) { struct rlimit rlim; if (0 > getrlimit(RLIMIT_STACK, &rlim)) return LOGGER_PERROR("getrlimit(RLIMIT_STACK)"), -1; long total_mem = sysconf(_SC_PHYS_PAGES); if (total_mem < 0) return LOGGER_PERROR("sysconf"), -1; total_mem *= getpagesize(); size_t num_ctx_in_one_map = total_mem / rlim.rlim_cur; /* half of total mem to start with so we don't need to enable overcommit */ num_ctx_in_one_map >>= 1; LOGGER_INFO("http server pool: initial=%zu, grow=%zu", num_ctx_in_one_map, num_ctx_in_one_map); ctx_pool_init(&server->ctx_pool, num_ctx_in_one_map, num_ctx_in_one_map, rlim.rlim_cur, sizeof(struct http_server_context) + server->context_size); } else {
int msi_kill(MSISession *session, Logger *log) { if (session == NULL) { LOGGER_ERROR(log, "Tried to terminate non-existing session"); return -1; } m_callback_msi_packet((struct Messenger *) session->messenger, NULL, NULL); if (pthread_mutex_trylock(session->mutex) != 0) { LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex"); return -1; } if (session->calls) { MSIMessage msg; msg_init(&msg, requ_pop); MSICall *it = get_call(session, session->calls_head); while (it) { send_message(session->messenger, it->friend_number, &msg); MSICall *temp_it = it; it = it->next; kill_call(temp_it); /* This will eventually free session->calls */ } } pthread_mutex_unlock(session->mutex); pthread_mutex_destroy(session->mutex); LOGGER_DEBUG(session->messenger->log, "Terminated session: %p", session); free(session); return 0; }
RenderMaterialInterfacePtr RenderMaterialManager::getMaterial( const ConstString & _materialName , EPrimitiveType _primitiveType , uint32_t _textureCount , const RenderTextureInterfacePtr * _textures ) { TMapRenderStage::const_iterator it_found = m_materialStageIndexer.find( _materialName ); if( it_found == m_materialStageIndexer.end() ) { LOGGER_ERROR( m_serviceProvider )("RenderMaterialManager::getMaterial stage %s not found" , _materialName.c_str() ); return nullptr; } const RenderMaterialStage * stage = it_found->second; for( uint32_t i = 0; i != _textureCount; ++i ) { if( _textures[i] == nullptr ) { LOGGER_ERROR( m_serviceProvider )("RenderMaterialManager::getMaterial stage %s invalid setup texture %d" , _materialName.c_str() , i ); return nullptr; } } RenderMaterialInterfacePtr material = this->getMaterial2( _materialName, stage, _primitiveType, _textureCount, _textures ); return material; }
int msi_hangup(MSICall *call) { if (!call || !call->session) { return -1; } MSISession *session = call->session; LOGGER_DEBUG(session->messenger->log, "Session: %p Hanging up call with friend: %u", call->session, call->friend_number); if (pthread_mutex_trylock(session->mutex) != 0) { LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex"); return -1; } if (call->state == msi_CallInactive) { LOGGER_ERROR(session->messenger->log, "Call is in invalid state!"); pthread_mutex_unlock(session->mutex); return -1; } MSIMessage msg; msg_init(&msg, requ_pop); send_message(session->messenger, call->friend_number, &msg); kill_call(call); pthread_mutex_unlock(session->mutex); return 0; }
/** * @brief Call this at the end of the transmission. * * @param av Handler. * @return int * @retval 0 Success. * @retval ToxAvError On error. */ int toxav_kill_transmission ( ToxAv *av, int32_t call_index ) { if (cii(call_index, av->msi_session)) return ErrorNoCall; CallSpecific *call = &av->calls[call_index]; if ( call->crtps[audio_index] && -1 == rtp_terminate_session(call->crtps[audio_index], av->messenger) ) { LOGGER_ERROR("Error while terminating audio RTP session!\n"); return ErrorTerminatingAudioRtp; } if ( call->crtps[video_index] && -1 == rtp_terminate_session(call->crtps[video_index], av->messenger) ) { LOGGER_ERROR("Error while terminating video RTP session!\n"); return ErrorTerminatingVideoRtp; } call->crtps[audio_index] = NULL; call->crtps[video_index] = NULL; if ( call->j_buf ) { terminate_queue(call->j_buf); call->j_buf = NULL; LOGGER_DEBUG("Terminated j queue"); } else LOGGER_DEBUG("No j queue"); if ( call->cs ) { codec_terminate_session(call->cs); call->cs = NULL; LOGGER_DEBUG("Terminated codec session"); } else LOGGER_DEBUG("No codec session"); return ErrorNone; }
static int init_audio_encoder(CSSession *cs) { int rc = OPUS_OK; cs->audio_encoder = opus_encoder_create(cs->audio_encoder_sample_rate, cs->audio_encoder_channels, OPUS_APPLICATION_AUDIO, &rc); if ( rc != OPUS_OK ) { LOGGER_ERROR("Error while starting audio encoder: %s", opus_strerror(rc)); return -1; } rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_encoder_bitrate)); if ( rc != OPUS_OK ) { LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc)); return -1; } rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_COMPLEXITY(10)); if ( rc != OPUS_OK ) { LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc)); return -1; } return 0; }
ParticleEmitterContainerInterface2Ptr ParticleEngine2::createEmitterContainerFromFile( const ConstString& _fileGroupName, const FilePath & _fileName ) { if( m_available == false ) { return nullptr; } InputStreamInterfacePtr stream = FILE_SERVICE(m_serviceProvider) ->openInputFile( _fileGroupName, _fileName, false ); if( stream == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ParticleEngine2::createEmitterContainerFromFile can't open file %s:%s" , _fileGroupName.c_str() , _fileName.c_str() ); return nullptr; } ParticleEmitterContainerInterface2Ptr container = PARTICLE_SYSTEM2(m_serviceProvider) ->createEmitterContainerFromMemory( stream, m_archivator ); if( container == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ParticleEngine2::createEmitterContainerFromFile can't create emitter container '%s'" , _fileName.c_str() ); return nullptr; } return container; }
AccountInterfacePtr AccountManager::loadAccount_( const WString& _accountID ) { AccountInterfacePtr account = this->newAccount_( _accountID ); if( account == nullptr ) { LOGGER_ERROR(m_serviceProvider)("AccountManager::loadAccount_ invalid create account %ls" , _accountID.c_str() ); return nullptr; } if( m_accountProvider != nullptr ) { m_currentAccount = account; m_accountProvider->onCreateAccount( _accountID ); m_currentAccount = nullptr; } if( account->load() == false ) { LOGGER_ERROR(m_serviceProvider)("AccountManager::loadAccount_ invalid load account %ls" , _accountID.c_str() ); return nullptr; } return account; }
bool SDLFileInputStream::openFile_( const FilePath & _folder, const FilePath & _fileName, Char * _filePath ) { if( SDLLAYER_SERVICE(m_serviceProvider) ->concatenateFilePath( _folder, _fileName, _filePath, MENGINE_MAX_PATH ) == false ) { LOGGER_ERROR(m_serviceProvider)("SDLFileInputStream::open invlalid concatenate filePath '%s':'%s'" , _folder.c_str() , _fileName.c_str() ); return false; } m_rwops = SDL_RWFromFile(_filePath, "rb"); if ( m_rwops == nullptr ) { LOGGER_ERROR(m_serviceProvider)("SDLFileInputStream::open %s invalid open" , _filePath ); return false; } # ifdef _DEBUG if( SERVICE_EXIST( m_serviceProvider, NotificationServiceInterface ) == true ) { NOTIFICATION_SERVICE( m_serviceProvider ) ->notify( NOTIFICATOR_DEBUG_OPEN_FILE, _folder.c_str(), _fileName.c_str() ); } # endif return true; }
int ribs_ssl_set_options(SSL_CTX *ssl_ctx, char *cipher_list) { /* bugs */ SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL); /* almost all bugs */ SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2); /* disable SSLv2 per RFC 6176 */ SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv3); /* disable SSLv3. goodbye IE6 */ SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_COMPRESSION); SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); /* ciphers */ if (!cipher_list) cipher_list = _HTTP_SERVER_SSL_CIPHERS; SSL_CTX_set_options(ssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE); if (0 == SSL_CTX_set_cipher_list(ssl_ctx, cipher_list)) return LOGGER_ERROR("failed to initialize SSL:cipher_list"), -1; /* DH 2048 bits */ SSL_CTX_set_options(ssl_ctx, SSL_OP_SINGLE_DH_USE); DH *dh = DH_new(); dh->p = get_rfc3526_prime_2048(NULL); BN_dec2bn(&dh->g, "2"); if (0 == SSL_CTX_set_tmp_dh(ssl_ctx, dh)) return LOGGER_ERROR("failed to initialize SSL:dh"), -1; DH_free(dh); /* Ecliptic Curve DH */ SSL_CTX_set_options(ssl_ctx, SSL_OP_SINGLE_ECDH_USE); EC_KEY *ecdh = EC_KEY_new_by_curve_name(OBJ_sn2nid("prime256v1")); if (ecdh == NULL) return LOGGER_ERROR("failed to initialize SSL:edch"), -1; SSL_CTX_set_tmp_ecdh(ssl_ctx, ecdh); EC_KEY_free(ecdh); return 0; }
MSISession *msi_new(Messenger *m) { if (m == NULL) { return NULL; } MSISession *retu = (MSISession *)calloc(sizeof(MSISession), 1); if (retu == NULL) { LOGGER_ERROR(m->log, "Allocation failed! Program might misbehave!"); return NULL; } if (create_recursive_mutex(retu->mutex) != 0) { LOGGER_ERROR(m->log, "Failed to init mutex! Program might misbehave"); free(retu); return NULL; } retu->messenger = m; m_callback_msi_packet(m, handle_msi_packet, retu); /* This is called when remote terminates session */ m_callback_connectionstatus_internal_av(m, on_peer_status, retu); LOGGER_DEBUG(m->log, "New msi session: %p ", retu); return retu; }
int msi_change_capabilities(MSICall *call, uint8_t capabilities) { if (!call || !call->session) { return -1; } MSISession *session = call->session; LOGGER_DEBUG(session->messenger->log, "Session: %p Trying to change capabilities to friend %u", call->session, call->friend_number); if (pthread_mutex_trylock(session->mutex) != 0) { LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex"); return -1; } if (call->state != msi_CallActive) { LOGGER_ERROR(session->messenger->log, "Call is in invalid state!"); pthread_mutex_unlock(session->mutex); return -1; } call->self_capabilities = capabilities; MSIMessage msg; msg_init(&msg, requ_push); msg.capabilities.exists = true; msg.capabilities.value = capabilities; send_message(call->session->messenger, call->friend_number, &msg); pthread_mutex_unlock(session->mutex); return 0; }
bool CSocker::createSocket(SOCKET sock) { if( m_socket != INVALID_SOCKET ) { LOGGER_ERROR("create socket failed: socket not invalid %d", m_socket); return false; } m_socket = sock != INVALID_SOCKET ? sock : SocketOps::CreateTCPFileDescriptor(); if( m_socket == INVALID_SOCKET ) { LOGGER_ERROR("create socket failed:%d", SocketOps::GetLastError()); return false; } if( !SocketOps::SetGracefulClose(m_socket) ) { LOGGER_ERROR("SocketOps::SetGracefulClose error:%d, socket=%d", SocketOps::GetLastError(), m_socket); return false; } m_status = Key_Work; return true; }
bool Win32FileGroupDirectory::openInputFile( const FilePath & _fileName, const InputStreamInterfacePtr & _stream, size_t _offset, size_t _size, bool _streaming ) { (void)_streaming; if( _stream == nullptr ) { LOGGER_ERROR(m_serviceProvider)("Win32FileGroupDirectory::openInputFile failed _stream == NULL" ); return false; } FileInputStreamInterface * file = stdex::intrusive_get<FileInputStreamInterface *>(_stream); if( file->open( m_path, _fileName, _offset, _size ) == false ) { LOGGER_ERROR(m_serviceProvider)("Win32FileGroupDirectory::openInputFile failed open file '%s':'%s'" , m_path.c_str() , _fileName.c_str() ); return false; } return true; }
bool ParticleConverterPTCToPTZ::convert() { FileGroupInterfacePtr fileGroup; if( FILE_SERVICE(m_serviceProvider)->hasFileGroup( m_options.pakName, &fileGroup ) == false ) { LOGGER_ERROR(m_serviceProvider)("ParticleConverterPTCToPTZ::convert_: not found file group '%s'" , m_options.pakName.c_str() ); return false; } const ConstString & pakPath = fileGroup->getPath(); ConstString full_input = Helper::concatenationFilePath( m_serviceProvider, pakPath, m_options.inputFileName ); ConstString full_output = Helper::concatenationFilePath( m_serviceProvider, pakPath, m_options.outputFileName ); MemoryCacheBufferInterfacePtr data_cache = Helper::createMemoryCacheFile( m_serviceProvider, STRINGIZE_STRING_LOCAL( m_serviceProvider, "dev" ), full_input, false, "ParticleConverterPTCToPTZ_data" ); if( data_cache == nullptr ) { return false; } const Blobject::value_type * data_memory = data_cache->getMemory(); size_t data_size = data_cache->getSize(); if( data_memory == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ParticleConverterPTCToPTZ::convert_: invalid cache memory '%s'" , full_input.c_str() ); return false; } OutputStreamInterfacePtr output = FILE_SERVICE(m_serviceProvider) ->openOutputFile( STRINGIZE_STRING_LOCAL( m_serviceProvider, "dev" ), full_output ); if( output == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ParticleConverterPTCToPTZ::convert_: invalid open '%s'" , full_output.c_str() ); return false; } if( Helper::writeStreamArchiveData( m_serviceProvider, output, m_archivator, GET_MAGIC_NUMBER(MAGIC_PTZ), GET_MAGIC_VERSION(MAGIC_PTZ), false, data_memory, data_size ) == false ) { LOGGER_ERROR(m_serviceProvider)("ParticleConverterPTCToPTZ::convert_: invalid write '%s'" , full_output.c_str() ); return false; } return true; }
int vc_reconfigure_encoder(VCSession *vc, uint32_t bit_rate, uint16_t width, uint16_t height, int16_t kf_max_dist) { if (!vc) { return -1; } vpx_codec_enc_cfg_t cfg2 = *vc->encoder->config.enc; vpx_codec_err_t rc; if (cfg2.rc_target_bitrate == bit_rate && cfg2.g_w == width && cfg2.g_h == height && kf_max_dist == -1) { return 0; /* Nothing changed */ } if (cfg2.g_w == width && cfg2.g_h == height && kf_max_dist == -1) { /* Only bit rate changed */ LOGGER_INFO(vc->log, "bitrate change from: %u to: %u", (uint32_t)cfg2.rc_target_bitrate, (uint32_t)bit_rate); cfg2.rc_target_bitrate = bit_rate; rc = vpx_codec_enc_config_set(vc->encoder, &cfg2); if (rc != VPX_CODEC_OK) { LOGGER_ERROR(vc->log, "Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc)); return -1; } } else { /* Resolution is changed, must reinitialize encoder since libvpx v1.4 doesn't support * reconfiguring encoder to use resolutions greater than initially set. */ LOGGER_DEBUG(vc->log, "Have to reinitialize vpx encoder on session %p", (void *)vc); vpx_codec_ctx_t new_c; vpx_codec_enc_cfg_t cfg; vc_init_encoder_cfg(vc->log, &cfg, kf_max_dist); cfg.rc_target_bitrate = bit_rate; cfg.g_w = width; cfg.g_h = height; LOGGER_DEBUG(vc->log, "Using VP8 codec for encoder"); rc = vpx_codec_enc_init(&new_c, video_codec_encoder_interface(), &cfg, VPX_CODEC_USE_FRAME_THREADING); if (rc != VPX_CODEC_OK) { LOGGER_ERROR(vc->log, "Failed to initialize encoder: %s", vpx_codec_err_to_string(rc)); return -1; } int cpu_used_value = VP8E_SET_CPUUSED_VALUE; rc = vpx_codec_control(&new_c, VP8E_SET_CPUUSED, cpu_used_value); if (rc != VPX_CODEC_OK) { LOGGER_ERROR(vc->log, "Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc)); vpx_codec_destroy(&new_c); return -1; } vpx_codec_destroy(vc->encoder); memcpy(vc->encoder, &new_c, sizeof(new_c)); } return 0; }
bool SoundConverterFFMPEGToOGG::convert() { FileGroupInterfacePtr fileGroup; if( FILE_SERVICE(m_serviceProvider)->hasFileGroup( m_options.pakName, &fileGroup ) == false ) { LOGGER_ERROR(m_serviceProvider)("SoundConverterFFMPEGToOGG::convert_: not found file group '%s'" , m_options.pakName.c_str() ); return false; } const ConstString & pakPath = fileGroup->getPath(); String full_input = pakPath.c_str(); full_input += m_options.inputFileName.c_str(); String full_output = pakPath.c_str(); full_output += m_options.outputFileName.c_str(); WString unicode_input; if( Helper::utf8ToUnicode( m_serviceProvider, full_input, unicode_input ) == false ) { LOGGER_ERROR(m_serviceProvider)("SoundConverterFFMPEGToOGG::convert_: invalid convert input utf8 to unicode %s" , full_input.c_str() ); return false; } WString unicode_output; if( Helper::utf8ToUnicode( m_serviceProvider, full_output, unicode_output ) == false ) { LOGGER_ERROR(m_serviceProvider)("SoundConverterFFMPEGToOGG::convert_: invalid convert output utf8 to unicode %s" , full_output.c_str() ); return false; } WString buffer = L"ffmpeg.exe -loglevel error -y -threads 4 -i \"" + unicode_input + L"\" -map_metadata -1 -ac 2 -ar 44100 -acodec libvorbis -aq 100 \"" + unicode_output + L"\""; LOGGER_WARNING(m_serviceProvider)( "SoundDecoderConverterFFMPEGToOGG:: converting file '%ls' to '%ls'" , unicode_input.c_str() , unicode_output.c_str() ); if( WINDOWSLAYER_SERVICE(m_serviceProvider) ->cmd( buffer ) == false ) { LOGGER_ERROR(m_serviceProvider)("SoundConverterFFMPEGToOGG::convert_: invalid convert:" ); return false; } return true; }
static bool s_writeAek( const WString & _protocolPath, const WString & _xmlPath, const WString & _aekPath ) { String utf8_protocolPath; Helper::unicodeToUtf8( serviceProvider, _protocolPath, utf8_protocolPath ); String utf8_xmlPath; Helper::unicodeToUtf8( serviceProvider, _xmlPath, utf8_xmlPath ); String utf8_aekPath; Helper::unicodeToUtf8( serviceProvider, _aekPath, utf8_aekPath ); LOADER_SERVICE( serviceProvider ) ->setProtocolPath( Helper::stringizeString( serviceProvider, utf8_protocolPath ) ); String framePackPath( utf8_xmlPath.c_str(), utf8_xmlPath.size() ); String::size_type size = framePackPath.size(); framePackPath[size-3] = L'x'; framePackPath[size-2] = L'm'; framePackPath[size-1] = L'l'; FilePath path_xml = Helper::stringizeString( serviceProvider, framePackPath ); ConverterOptions options; options.pakName = ConstString::none(); options.inputFileName = path_xml; options.outputFileName = Helper::stringizeString(serviceProvider, utf8_aekPath); ConverterInterfacePtr converter = CONVERTER_SERVICE(serviceProvider) ->createConverter( Helper::stringizeString(serviceProvider, "xmlToAekMovie") ); if( converter == nullptr ) { LOGGER_ERROR(serviceProvider)( "writeAek can't create convert '%s'\nfrom: %s\nto: %s\n" , "xmlToAekMovie" , options.inputFileName.c_str() , options.outputFileName.c_str() ); return false; } converter->setOptions( &options ); if( converter->convert() == false ) { LOGGER_ERROR(serviceProvider)( "ConverterEngine::convert can't convert '%s'\nfrom: %s\nto: %s\n" , Helper::stringizeString(serviceProvider, "xmlToAekMovie").c_str() , options.inputFileName.c_str() , options.outputFileName.c_str() ); return false; } return true; }
bool PosixFileInputStream::open( const FilePath & _folder, const FilePath & _fileName, size_t _offset, size_t _size ) { m_folder = _folder; m_filename = _fileName; Char filePath[MENGINE_MAX_PATH]; if( this->concatenateFilePath( _folder, _fileName, filePath, MENGINE_MAX_PATH ) == false ) { LOGGER_ERROR(m_serviceProvider)("PosixFileGroupDirectory::open invalid concatenate '%s':'%s'" , m_folder.c_str() , m_filename.c_str() ); return false; } m_hFile = fopen( filePath, "rb" ); if( m_hFile == nullptr ) { LOGGER_ERROR(m_serviceProvider)("PosixFileGroupDirectory::open s3eFileOpen %s:%s get error" , m_folder.c_str() , m_filename.c_str() ); return false; } fseek( m_hFile, 0, SEEK_END ); long size = (size_t)ftell( m_hFile ); rewind( m_hFile ); if( _offset + _size > (size_t)size ) { LOGGER_ERROR(m_serviceProvider)("PosixFileGroupDirectory::open %ls invalid file range %d:%d size %d" , filePath , _offset , _size , size ); return false; } m_size = _size == 0 ? (size_t)size : _size; m_offset = _offset; m_carriage = 0; m_capacity = 0; m_reading = 0; if( m_offset != 0 ) { this->seek( 0 ); } return true; }
static void trigger_writer ( const char *filename, struct logz_file_def *filedef) { vmbuf_reset(&write_buffer); ssize_t res; char *fn = basename(ribs_strdup(filename)); while(1) { vmbuf_reset(&write_buffer); res = read(filedef->fd, vmbuf_wloc(&write_buffer), (BUFSIZ + 1024) &~ 1024); filedef->size += res; lseek (filedef->fd, filedef->size, SEEK_SET); if (0 > vmbuf_wseek(&write_buffer, res)) { LOGGER_ERROR("%s", "wseek error"); break; } else if (0 > res) { LOGGER_ERROR("%s", "read error"); // EAGAIN is handled by poller break; } else if (0 < res) { // initial sanitizer vmbuf_chrcpy(&write_buffer, '\0'); // kill garbage char *data = ribs_strdup(vmbuf_data(&write_buffer)); //data = strchr(data, '\n') + 1; // skip broken data from initial buffer start. we read from where the file was first observed ssize_t write_depth = res = strlen(data); // line doesn't end here if (data[res - 1] != '\n') { char *datafringe = ribs_strdup((char *)memrchr(data, '\n', res)); if (SSTRISEMPTY(datafringe)) break; write_depth = strlen(data) - strlen(datafringe); *(data + write_depth) = 0; if (filedef->size != 0) { char *rebalanced_data = write_file_fringe(fn, data, filedef->fd); if (NULL != rebalanced_data) { data = rebalanced_data; write_depth = strlen(data); } } thashtable_rec_t *rec = thashtable_lookup(delta_push, &filedef->fd, sizeof(filedef->fd)); struct vmbuf kdelta = *(struct vmbuf *)thashtable_get_val(rec); vmbuf_strcpy(&kdelta, datafringe); vmbuf_chrcpy(&kdelta, '\0'); } vmbuf_reset(&write_buffer); vmbuf_memcpy(&write_buffer, data, write_depth); vmbuf_chrcpy(&write_buffer, '\0'); write_out_stream(fn, ribs_strdup(vmbuf_data(&write_buffer))); } else if (0 == res) { break; } } }
static bool s_writeBin( const WString & _protocolPath, const WString & _xmlPath, const WString & _binPath ) { String utf8_protocolPath; Helper::unicodeToUtf8( serviceProvider, _protocolPath, utf8_protocolPath ); String utf8_xmlPath; Helper::unicodeToUtf8( serviceProvider, _xmlPath, utf8_xmlPath ); String utf8_binPath; Helper::unicodeToUtf8( serviceProvider, _binPath, utf8_binPath ); XmlDecoderInterfacePtr decoder = CODEC_SERVICE(serviceProvider) ->createDecoderT<XmlDecoderInterfacePtr>( Helper::stringizeString(serviceProvider, "xml2bin") ); if( decoder == nullptr ) { LOGGER_ERROR(serviceProvider)("writeBin invalid create decoder xml2bin for %s" , utf8_xmlPath.c_str() ); return false; } if( decoder->prepareData( nullptr ) == false ) { LOGGER_ERROR(serviceProvider)("writeBin invalid initialize decoder xml2bin for %s" , utf8_xmlPath.c_str() ); return false; } XmlCodecOptions options; options.pathProtocol = Helper::stringizeString( serviceProvider, utf8_protocolPath ); options.pathXml = Helper::stringizeString( serviceProvider, utf8_xmlPath ); options.pathBin = Helper::stringizeString( serviceProvider, utf8_binPath ); if( decoder->setOptions( &options ) == false ) { LOGGER_ERROR(serviceProvider)("writeBin invalid setup decoder xml2bin for %s" , utf8_xmlPath.c_str() ); return false; } if( decoder->decode( 0, 0 ) == 0 ) { LOGGER_ERROR(serviceProvider)("writeBin invalid decode %s" , utf8_xmlPath.c_str() ); return false; } return true; }
/** * @brief Must be call before any RTP transmission occurs. * * @param av Handler. * @return int * @retval 0 Success. * @retval ToxAvError On error. */ int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettings *codec_settings, int support_video ) { if ( !av->msi_session || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) { LOGGER_ERROR("Error while starting audio RTP session: invalid call!\n"); return ErrorInternal; } CallSpecific *call = &av->calls[call_index]; call->crtps[audio_index] = rtp_init_session( type_audio, av->messenger, av->msi_session->calls[call_index]->peers[0], av->msi_session->calls[call_index]->key_peer, av->msi_session->calls[call_index]->key_local, av->msi_session->calls[call_index]->nonce_peer, av->msi_session->calls[call_index]->nonce_local); if ( !call->crtps[audio_index] ) { LOGGER_ERROR("Error while starting audio RTP session!\n"); return ErrorStartingAudioRtp; } if ( support_video ) { call->crtps[video_index] = rtp_init_session ( type_video, av->messenger, av->msi_session->calls[call_index]->peers[0], av->msi_session->calls[call_index]->key_peer, av->msi_session->calls[call_index]->key_local, av->msi_session->calls[call_index]->nonce_peer, av->msi_session->calls[call_index]->nonce_local); if ( !call->crtps[video_index] ) { LOGGER_ERROR("Error while starting video RTP session!\n"); return ErrorStartingVideoRtp; } } if ( !(call->j_buf = create_queue(codec_settings->jbuf_capacity)) ) return ErrorInternal; call->cs = codec_init_session(codec_settings->audio_bitrate, codec_settings->audio_frame_duration, codec_settings->audio_sample_rate, codec_settings->audio_channels, codec_settings->video_width, codec_settings->video_height, codec_settings->video_bitrate); return call->cs ? ErrorNone : ErrorInternal; }
bool ThreadTaskPrefetchDataflow::_onRun() { m_group = FILE_SERVICE( m_serviceProvider ) ->getFileGroup( m_pakName ); if( m_group == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ThreadTaskPrefetchDataflow::_onRun can't get group '%s'" , m_pakName.c_str() ); return false; } m_stream = m_group->createInputFile( m_filePath, false ); if( m_stream == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ThreadTaskPrefetchDataflow::_onRun can't create input file '%s'" , m_pakName.c_str() ); return nullptr; } m_dataflow = DATA_SERVICE(m_serviceProvider) ->getDataflow( m_dataflowType ); if( m_dataflow == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ThreadTaskPrefetchDataflow::_onRun: '%s':'%s' invalide get dataflow '%s'" , m_pakName.c_str() , m_filePath.c_str() , m_dataflowType.c_str() ); return false; } m_data = m_dataflow->create(); if( m_data == nullptr ) { LOGGER_ERROR(m_serviceProvider)("ThreadTaskPrefetchDataflow::_onRun: '%s':'%s' dataflow invalid create data '%s'" , m_pakName.c_str() , m_filePath.c_str() , m_dataflowType.c_str() ); return false; } return true; }
bool MovieInternalObject::_compile() { if( m_movie == nullptr ) { LOGGER_ERROR(m_serviceProvider)("MovieInternalObject::_compile '%s' movie not setup" , m_name.c_str() ); return false; } if( m_resourceInternalObject == nullptr ) { LOGGER_ERROR(m_serviceProvider)("MovieInternalObject::_compile '%s' resource not setup" , m_name.c_str() ); return false; } if( m_resourceInternalObject.compile() == false ) { LOGGER_ERROR(m_serviceProvider)("MovieInternalObject::_compile '%s' resource '%s' not compile" , m_name.c_str() , m_resourceInternalObject->getName().c_str() ); return false; } const ConstString & internalGroup = m_resourceInternalObject->getInternalGroup(); const ConstString & internalName = m_resourceInternalObject->getInternalName(); pybind::object py_object = EVENTABLE_METHODR( m_movie, EVENT_MOVIE_GET_INTERNAL, pybind::object() ) ->onMovieGetInternal( internalGroup, internalName ); //pybind::object py_object; //EVENTABLE_ASK( m_serviceProvider, m_movie, EVENT_MOVIE_GET_INTERNAL, py_object )(internalGroup, internalName); if( py_object.is_invalid() == true ) { LOGGER_ERROR(m_serviceProvider)("MovieInternalObject::_compile '%s' resource '%s' can't find internal object '%s:%s'" , m_name.c_str() , m_resourceInternalObject->getName().c_str() , internalGroup.c_str() , internalName.c_str() ); return false; } m_internalObject = py_object; return true; }
ScriptModuleInterfacePtr ScriptEngine::importModule( const ConstString & _name ) { PyObject * py_module = nullptr; bool exist = false; try { py_module = pybind::module_import( _name.c_str(), exist ); } catch( ... ) { ScriptEngine::handleException(); LOGGER_ERROR(m_serviceProvider)( "ScriptEngine: invalid import module '%s'(c-exception)" , _name.c_str() ); return nullptr; } if( exist == false ) { LOGGER_WARNING(m_serviceProvider)( "ScriptEngine: invalid import module '%s'(not exist)" , _name.c_str() ); return nullptr; } if( py_module == nullptr ) { LOGGER_ERROR(m_serviceProvider)( "ScriptEngine: invalid import module '%s'(script)" , _name.c_str() ); return nullptr; } ScriptModulePtr module = m_factoryScriptModule.createObject(); if( module->initialize( pybind::object(py_module) ) == false ) { LOGGER_ERROR( m_serviceProvider )("ScriptEngine: invalid import initialize '%s'(script)" , _name.c_str() ); return nullptr; } return module; }
bool MarmaladeAmplifier::_initialize() { LOGGER_INFO(m_serviceProvider)( "Starting Marmalade Amplifier..." ); int32 available = s3eAudioGetInt( S3E_AUDIO_AVAILABLE ); if( available == 0 ) { LOGGER_ERROR(m_serviceProvider)("Unavailable..." ); return false; } s3eResult result = s3eAudioRegister( S3E_AUDIO_STOP, (s3eCallback)&s_Amplifier_AudioCallback_Stop, this ); if( result != S3E_RESULT_SUCCESS ) { s3eAudioError s3eAudio_error = s3eAudioGetError(); const char * s3eAudio_string = s3eAudioGetErrorString(); LOGGER_ERROR(m_serviceProvider)("Amplifier::initialize: invalid register callback %d [%s]" , s3eAudio_error , s3eAudio_string ); return false; } SOUND_SERVICE(m_serviceProvider) ->addSoundVolumeProvider( this ); # define MARMALADE_AMPLIFIER_SUPPORT_CODEC( Codec )\ LOGGER_WARNING(m_serviceProvider)("Amplifier::initialize: " #Codec " %s"\ , s3eAudioIsCodecSupported( Codec ) ? "support" : "unsupport!" ) MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_MIDI ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_MP3 ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_AAC ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_AACPLUS ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_QCP ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_PCM ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_SPF ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_AMR ); MARMALADE_AMPLIFIER_SUPPORT_CODEC( S3E_AUDIO_CODEC_MP4 ); # undef AMPLIFIER_SUPPORT_CODEC return true; }
OpusEncoder *create_audio_encoder(Logger *log, int32_t bit_rate, int32_t sampling_rate, int32_t channel_count) { int status = OPUS_OK; OpusEncoder *rc = opus_encoder_create(sampling_rate, channel_count, OPUS_APPLICATION_VOIP, &status); if (status != OPUS_OK) { LOGGER_ERROR(log, "Error while starting audio encoder: %s", opus_strerror(status)); return NULL; } status = opus_encoder_ctl(rc, OPUS_SET_BITRATE(bit_rate)); if (status != OPUS_OK) { LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status)); goto FAILURE; } /* Enable in-band forward error correction in codec */ status = opus_encoder_ctl(rc, OPUS_SET_INBAND_FEC(1)); if (status != OPUS_OK) { LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status)); goto FAILURE; } /* Make codec resistant to up to 10% packet loss * NOTE This could also be adjusted on the fly, rather than hard-coded, * with feedback from the receiving client. */ status = opus_encoder_ctl(rc, OPUS_SET_PACKET_LOSS_PERC(10)); if (status != OPUS_OK) { LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status)); goto FAILURE; } /* Set algorithm to the highest complexity, maximizing compression */ status = opus_encoder_ctl(rc, OPUS_SET_COMPLEXITY(10)); if (status != OPUS_OK) { LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status)); goto FAILURE; } return rc; FAILURE: opus_encoder_destroy(rc); return NULL; }