int main(int argc, char *argv[]) { int ch, del = 0, err; char *fingerprints = NULL; while ((ch = getopt(argc, argv, "f:dh")) != -1) { switch (ch) { case 'f': fingerprints = optarg; break; case 'd': del = 1; break; default: fprintf(stderr, "Usage: %s -f fingerprints -d <del rules> -h\n", argv[0]); return -1; } } if (!fingerprints) { err = -ENOENT; goto err_out_exit; } nfnlh = nfnl_open(); if (!nfnlh) { err = -EINVAL; ulog_err("Failed to create nfnl handler"); goto err_out_exit; } #ifndef NFNL_SUBSYS_OSF #define NFNL_SUBSYS_OSF 5 #endif nfnlssh = nfnl_subsys_open(nfnlh, NFNL_SUBSYS_OSF, OSF_MSG_MAX, 0); if (!nfnlssh) { err = -EINVAL; ulog_err("Faied to create nfnl subsystem"); goto err_out_close; } err = osf_load_entries(fingerprints, del); if (err) goto err_out_close_subsys; nfnl_subsys_close(nfnlssh); nfnl_close(nfnlh); return 0; err_out_close_subsys: nfnl_subsys_close(nfnlssh); err_out_close: nfnl_close(nfnlh); err_out_exit: return err; }
USemaphore::~USemaphore(){ //销毁USemaphore if(pthread_cond_destroy(&mCond)){ ulog_err("USemaphore::~USemaphore:pthread_cond_destroy failed"); } }
static int osf_load_entries(char *path, int del) { FILE *inf; int err = 0; char buf[1024]; inf = fopen(path, "r"); if (!inf) { ulog_err("Failed to open file '%s'", path); return -1; } while(fgets(buf, sizeof(buf), inf)) { int len; if (buf[0] == '#' || buf[0] == '\n' || buf[0] == '\r') continue; len = strlen(buf) - 1; if (len <= 0) continue; buf[len] = '\0'; err = osf_load_line(buf, len, del); if (err) break; memset(buf, 0, sizeof(buf)); } fclose(inf); return err; }
int URendererAudioOpenSLES::createEngine(){ SLresult result; //创建OpenSL ES 音频引擎 result = slCreateEngine(&mEngineObject, 0, NULL, 0, NULL, NULL); if(SL_RESULT_SUCCESS != result){ ulog_err("slCreateEngine failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //调整同步模式 result = (*mEngineObject)->Realize(mEngineObject, SL_BOOLEAN_FALSE); if(SL_RESULT_SUCCESS != result){ ulog_err("(*mEngineObject)->Realize failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //获取引擎接口 result = (*mEngineObject)->GetInterface(mEngineObject, SL_IID_ENGINE, &mEngine); if(SL_RESULT_SUCCESS != result){ ulog_err("Get SL_IID_ENGINE failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //创建音频混合器 const SLInterfaceID ids[1] = {SL_IID_VOLUME}; const SLboolean req[1] = {SL_BOOLEAN_FALSE}; result = (*mEngine)->CreateOutputMix(mEngine, &mOutputMixObject, 1, ids, req); if(SL_RESULT_SUCCESS != result){ ulog_err("CreateOutputMix failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //调整混合器 result = (*mOutputMixObject)->Realize(mOutputMixObject, SL_BOOLEAN_FALSE); if(SL_RESULT_SUCCESS != result){ ulog_err("(*mOutputMixObject)->Realize"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } return NO_ERROR; }
USemaphore::USemaphore(unsigned int value):mValue(value),mLock(ULOCK_TYPE_NORMAL){ //初始化条件变量 if(pthread_cond_init(&mCond,NULL)){ ulog_err("USemaphore::USemaphore:pthread_cond_init failed"); } }
void URendererAudioOpenSLES::AudioPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context){ SLresult result; av_link pcm_pkt; //获取播放器 UPlayer* player = (UPlayer*)context; URendererAudioOpenSLES* audio_renderer = (URendererAudioOpenSLES*)player->mRendererAudio; UThreadID tid = gettid(); if( audio_renderer->mTids[0] != tid && audio_renderer->mTids[1] != tid){ audio_renderer->mTids[1] = tid; player->mCrashHandler.registerTid(audio_renderer->mTids[1]); } //如果播放器已经停止则退出 if(player->isStop())return; //将上一次的PCM缓冲区还回PCM空槽队列 player->mPCMSlotQueue->put(player->mLastPCM); //获取PCM空槽 pcm_pkt = (av_link)player->mPCMQueue->get(); //错误处理 if(!pcm_pkt){ ulog_err("AudioPlayerCallback !pcm_pkt"); return; } //保存这次的PCM缓冲区,留待下一次还回空槽队列,或播放器退出时换回空槽队列 player->mLastPCM = pcm_pkt; //播放声音 result = (*bq)->Enqueue(bq, pcm_pkt->item, pcm_pkt->size); if(SL_RESULT_SUCCESS != result){ player->notifyMsg(MEDIA_INFO_PLAYERROR,ERROR_SOFT_PLAYER_OPENSLES); ulog_err("mPlayerBufferQueue Enqueue failed"); return; } }
void USemaphore::post(){ AutoULock lock(mLock); mValue++; if(pthread_cond_signal(&mCond)){ ulog_err("USemaphore::posts:pthread_cond_signal failed"); } }
URendererAudioLinux::URendererAudioLinux(UPlayer* player,int channels, int samplerate,int samplefmt):\ IRendererAudio(player,channels,samplerate,samplefmt),UThread("AudioRenderer:URendererAudioLinux"){ //设置播放器对象指针 mPlayer = player; if(!mPlayer) ulog_err("URendererAudioLinux::URendererAudioLinux mPlayer == NULL"); }
void UThread::wait(){ if(mRunning){ //等待线程结束 if(pthread_join(mThread, NULL)){ ulog_err("pthread_join %s error",mThreadName?mThreadName:""); } } }
int UThread::start(){ //启动线程函数 if(pthread_create(&mThread, NULL, startThread, this)){ ulog_err("pthread_create %s error",mThreadName?mThreadName:""); return FAILED; } //add by eric mRunning = true; return NO_ERROR; }
void USemaphore::wait(){ AutoULock lock(mLock); while( 0 == mValue ){ //等待 if(pthread_cond_wait(&mCond,mLock.getLock())){ ulog_err("USemaphore::wait:pthread_cond_wait failed"); } } mValue--; }
void URendererAudioOpenSLES::stop(){ SLresult result; if(!mPrepared)return; //释放音频渲染线程 if(mPlayer && mPlayer->mPCMQueue)mPlayer->mPCMQueue->abort(); //错误处理 if(!mPlayerBufferQueue){ ulog_err("URendererAudioOpenSLES release failed"); return; } //设置停止状态 result = (*mPlayerPlay)->SetPlayState(mPlayerPlay, SL_PLAYSTATE_STOPPED); if(SL_RESULT_SUCCESS != result){ ulog_err("SetPlayState stop failed"); } mPlayer->mCrashHandler.unRegisterTid(mTids[1]); }
static int protocol_sctp_connect(protocol_t *p, void *options) { struct sockaddr_storage serv; socklen_t len; const int off = 0; /* * generic_connect() can't be used since the socket options * must be set after calling socket() but before calling connect(). */ uperf_debug("Connecting to %s:%d\n", p->host, p->port); if (name_to_addr(p->host, &serv)) { /* Error is already reported by name_to_addr, so just return */ return (UPERF_FAILURE); } if (generic_socket(p, serv.ss_family, IPPROTO_SCTP) < 0) { return (UPERF_FAILURE); } set_sctp_options(p->fd, serv.ss_family, options); switch (serv.ss_family) { case AF_INET: ((struct sockaddr_in *)&serv)->sin_port = htons(p->port); len = (socklen_t)sizeof(struct sockaddr_in); break; case AF_INET6: ((struct sockaddr_in6 *)&serv)->sin6_port = htons(p->port); len = (socklen_t)sizeof(struct sockaddr_in6); if (setsockopt(p->fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(int)) < 0) { return (UPERF_FAILURE); } break; default: uperf_debug("Unsupported protocol family: %d\n", serv.ss_family); return (UPERF_FAILURE); break; } if (connect(p->fd, (const struct sockaddr *)&serv, len) < 0) { ulog_err("%s: Cannot connect to %s:%d", protocol_to_str(p->type), p->host, p->port); return (UPERF_FAILURE); } return (UPERF_SUCCESS); }
void URendererAudioOpenSLES::start(){ //创建播放引擎和播放对象 if(!mPlayer || createEngine() || createBufferQueueAudioPlayer(this->mChannels,this->mSampleRate)){ //设置出错标记 mPrepared = false; this->mPlayer->notifyMsg(MEDIA_INFO_PREPARE_ERROR,ERROR_SOFT_PLAYER_OPENSLES); ulog_err("URendererAudioOpenSLES::start failed"); }else{ //设置音频渲染器状态 ulog_info("URendererAudioOpenSLES::start\n"); mPrepared = true; this->UThread::start(); //AudioPlayerCallback(this->mPlayerBufferQueue,this->mPlayer); } }
void UTimer::start(){ if(!mFNTimer)return; if(isSettled()){ if(!mIsRunning){ mLastEntryTime = av_gettime(); mIsRunning = true; } return; } utimer_link timer = (utimer_link)malloc(sizeof(struct utimer_node)); timer->timer = this; timer->next = NULL; lock(); if(!timer_head)timer_head = timer; else{ timer->next = timer_head; timer_head = timer; } mIsRunning = true; mLastEntryTime = av_gettime(); if(!timer_thread_started){ //modify by eric timer_thread_started = true; //启动Timer线程 if (pthread_create(&thread, NULL, timerThread, this->mData)) { ulog_err("pthread_create timerThread failed:start"); } } unlock(); }
static int protocol_ssl_connect(protocol_t * p, void *options) { BIO *sbio; int status; ssl_private_t *ssl_p = (ssl_private_t *) p->_protocol_p; flowop_options_t *flowop_options = (flowop_options_t *) options; uperf_debug("ssl - Connecting to %s:%d\n", p->host, p->port); status = generic_connect(p, IPPROTO_TCP); if (status == UPERF_SUCCESS) set_tcp_options(p->fd, flowop_options); if (flowop_options && (strcmp(flowop_options->engine, ""))) { status = load_engine(flowop_options->engine); if (status == -1) { uperf_info( "ssl - Engine %s does NOT exist! Using the default OpenSSL softtoken", flowop_options->engine); } } if ((ssl_p->ssl = SSL_new(ctx)) == NULL) { ulog_err("Error initializng SSL"); return (-1); } sbio = BIO_new_socket(p->fd, BIO_NOCLOSE); SSL_set_bio(ssl_p->ssl, sbio, sbio); status = SSL_connect(ssl_p->ssl); if (status <= 0) { uperf_log_msg(UPERF_LOG_ERROR, 0, "ssl connect error"); return (-1); } return (0); }
URendererVideo::URendererVideo(UPlayer* player) :mPlayer(player), UThread("video renderer") { #if PLATFORM_DEF != LINUX_PLATFORM mGraphics = NULL; #endif //确保播放器引用不为空 assert(player); mLastFrame = (av_link)av_malloc(sizeof(*mLastFrame)); bzero(mLastFrame,sizeof(*mLastFrame)); #if PLATFORM_DEF == IOS_PLATFORM mLockRenderVideo = new ULock(ULOCK_TYPE_NORMAL); if (!mLockRenderVideo) { ulog_err("URendererVideo::mLockRenderVideo error"); return; } mLockRenderVideo->lock(); mRenderVideo = true; mLockRenderVideo->unlock(); #endif }
void URendererAudioLinux::render(){ ulog_info("URendererAudioLinux::render enter"); av_link pcm_pkt; int length; ulog_info("URendererAudioLinux::render enter"); while(!mPlayer->isStop()){ if(mPlayer->isPause()){ usleep(UPLAYER_PAUSE_TIME); continue; } //获取YUV数据包 pcm_pkt = (av_link)mPlayer->mPCMQueue->get(); if(!pcm_pkt){ ulog_err("URendererAudioLinux::render mPCMQueue->get() == NULL"); continue; } //处理数据包 length = 0; if (pcm_pkt->size > 0) { // ulog_info("audio_pts: %f", pcm_pkt->pts); double audio_render_duration = (double)pcm_pkt->size / (mSampleRate * mChannels * mSampleFmt) * 1000 * 1000; //ulog_info("audio_frame_duration: %f", audio_render_duration); usleep(audio_render_duration); } //将数据包还回YUV空槽队列 mPlayer->mPCMSlotQueue->put(pcm_pkt); } ulog_info("URendererAudioLinux::render exit"); }
int URendererAudioOpenSLES::createBufferQueueAudioPlayer(int channels, int samplerate){ ulog_info("in URendererAudioOpenSLES::createBufferQueueAudioPlayer()"); SLresult result; //配置音频播放参数 SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1}; SLDataFormat_PCM pcm; //数据源格式 pcm.formatType = SL_DATAFORMAT_PCM; //声道数 pcm.numChannels = channels;//跟下面的channelMask 要配对,不然会报错 //美妙采样数 pcm.samplesPerSec = samplerate * 1000; //精度 pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16; pcm.containerSize = SL_PCMSAMPLEFORMAT_FIXED_16; if(pcm.numChannels == 2) { //立体声 这是参照audiotrack CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT)得到的 pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT; } else { pcm.channelMask = SL_SPEAKER_FRONT_CENTER; } pcm.endianness = SL_BYTEORDER_LITTLEENDIAN; SLDataSource audioSrc = {&loc_bufq, &pcm}; //音频sink参数 SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, mOutputMixObject}; SLDataSink audioSnk = {&loc_outmix, NULL}; //创建音频播放器 const SLInterfaceID ids[] = {SL_IID_BUFFERQUEUE}; const SLboolean req[] = {SL_BOOLEAN_TRUE}; ulog_info("after call CreateAudioPlayer()"); result = (*mEngine)->CreateAudioPlayer(mEngine, &mPlayerObject, &audioSrc, &audioSnk, sizeof( ids ) / sizeof( *ids ), ids, req); ulog_info("call CreateAudioPlayer() over"); if(SL_RESULT_SUCCESS != result){ ulog_err("CreateAudioPlayer failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //调整播放器 result = (*mPlayerObject)->Realize(mPlayerObject, SL_BOOLEAN_FALSE); if(SL_RESULT_SUCCESS != result){ ulog_err("(*mPlayerObject)->Realize failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //获得播放接口 result = (*mPlayerObject)->GetInterface(mPlayerObject, SL_IID_PLAY, &mPlayerPlay); if(SL_RESULT_SUCCESS != result){ ulog_err("(*mPlayerObject)->GetInterface SL_IID_PLAY failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //获取缓冲队列接口 result = (*mPlayerObject)->GetInterface(mPlayerObject, SL_IID_BUFFERQUEUE, &mPlayerBufferQueue); if(SL_RESULT_SUCCESS != result){ ulog_err("(*mPlayerObject)->GetInterface SL_IID_BUFFERQUEUE failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //注册回调函数 result = (*mPlayerBufferQueue)->RegisterCallback(mPlayerBufferQueue, AudioPlayerCallback, mPlayer); if(SL_RESULT_SUCCESS != result){ ulog_err("mPlayerBufferQueue RegisterCallback failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } //设置播放状态 result = (*mPlayerPlay)->SetPlayState(mPlayerPlay, SL_PLAYSTATE_PLAYING); if(SL_RESULT_SUCCESS != result){ ulog_err("SetPlayState failed"); set_player_error_code(mPlayer,ERROR_SOFT_PLAYER_OPENSLES); return FAILED; } return NO_ERROR; }
void UTimer::unlock(){ if(pthread_mutex_unlock(&Lock)){ ulog_err("UTimer::unlock failed"); } }