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");
}
}
