Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
23 kB · 764 lines
C++
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765#include "stdafx.h"
/* SCE CONFIDENTIALPlayStation(R)3 Programmer Tool Runtime Library 430.001* Copyright (C) 2008 Sony Computer Entertainment Inc.* All Rights Reserved.*/#include "SonyVoiceChat.h"#include <arpa/inet.h> /* inet_ntoa() */
/* for displaying extra information */#ifndef _CONTENT_PACKAGE#define AVC2_GAME_DEBUG#endif
#ifdef AVC2_GAME_DEBUG#define INF(...) printf( "INF:" __VA_ARGS__ )#define ERR(...) printf( "ERR:" __VA_ARGS__ )#else#define INF(...)#define ERR(...)#endif
#define UNUSED_VARIABLE(x) (void)(x)
//#define DISABLE_VOICE_CHAT
static CellSysutilAvc2InitParam g_chat_avc2param;
EAVCEvent SonyVoiceChat::sm_event = AVC_EVENT_EPSILON;EAVCState SonyVoiceChat::sm_state = AVC_STATE_IDLE;SQRNetworkManager_PS3* SonyVoiceChat::sm_pNetworkManager;bool SonyVoiceChat::sm_bEnabled = true;uint8_t SonyVoiceChat::sm_micStatus = CELL_AVC2_MIC_STATUS_UNKNOWN;bool SonyVoiceChat::sm_bLoaded = false;bool SonyVoiceChat::sm_bUnloading = false;unordered_map<SceNpMatching2RoomMemberId, bool> SonyVoiceChat::sm_bTalkingMap;bool SonyVoiceChat::sm_bCanStart = false;bool SonyVoiceChat::sm_isChatRestricted = false;int SonyVoiceChat::sm_currentBitrate = 28000;
void SonyVoiceChat::init( SQRNetworkManager_PS3* pNetMan ){ if(sm_state != AVC_STATE_IDLE) return;
sm_pNetworkManager = pNetMan; setState(AVC_STATE_CHAT_INIT); ProfileManager.GetChatAndContentRestrictions(0,false,&sm_isChatRestricted,NULL,NULL);}
void SonyVoiceChat::shutdown(){ if( sm_state == AVC_STATE_IDLE || sm_state == AVC_STATE_CHAT_LEAVE || sm_state == AVC_STATE_CHAT_UNLOAD || sm_state == AVC_STATE_CHAT_RESET ) { // we're either shut down already, or in the process return; }
setEvent(AVC_EVENT_EXIT_GAME);}
void SonyVoiceChat::setEnabled( bool bEnabled ){ if(sm_bEnabled != bEnabled) { if(sm_bCanStart) { if(bEnabled) startStream(); else stopStream(); } sm_bEnabled = bEnabled; }}
int SonyVoiceChat::eventcb_load(CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ int ret = CELL_OK;
UNUSED_VARIABLE( event_param ); UNUSED_VARIABLE( userdata );
if( event_id == CELL_AVC2_EVENT_LOAD_SUCCEEDED ) { INF( "<AVC CB>CELL_AVC2_EVENT_LOAD_SUCCEEDED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_CHAT_LOAD_SUCCEEDED); sm_bLoaded = true;
// set the packet contention value here CellSysutilAvc2Attribute attr; memset( &attr, 0x00, sizeof(attr) ); attr.attr_id = CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_PACKET_CONTENTION; attr.attr_param.int_param = 3; int ret = cellSysutilAvc2SetAttribute(&attr); if( ret != CELL_OK ) { app.DebugPrintf("CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_PACKET_CONTENTION failed !!! 0x%08x\n", ret); }
} else /* if( event_id == CELL_AVC2_EVENT_LOAD_FAILED ) */ { INF( "<AVC CB>CELL_AVC2_EVENT_LOAD_FAILED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_CHAT_LOAD_FAILED); } return ret;}
int SonyVoiceChat::eventcb_join(CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ int ret = CELL_OK;
UNUSED_VARIABLE( event_param ); UNUSED_VARIABLE( userdata );
if( event_id == CELL_AVC2_EVENT_JOIN_SUCCEEDED ) { INF( "<AVC CB>CELL_AVC2_EVENT_JOIN_SUCCEEDED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_CHAT_JOIN_SUCCEEDED); } else /* if( event_id == CELL_AVC2_EVENT_JOIN_FAILED ) */ { INF( "<AVC CB>CELL_AVC2_EVENT_JOIN_FAILED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_ERROR); } sm_bTalkingMap.clear(); return ret;}
int SonyVoiceChat::eventcb_leave( CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ int ret = CELL_OK;
UNUSED_VARIABLE( event_param ); UNUSED_VARIABLE( userdata );
if( event_id == CELL_AVC2_EVENT_LEAVE_SUCCEEDED ) { INF( "<AVC CB>CELL_AVC2_EVENT_LEAVE_SUCCEEDED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setState(AVC_STATE_CHAT_LEAVE); setEvent(AVC_EVENT_CHAT_LEAVE_SUCCEEDED); } else /* if( event_id == CELL_AVC2_EVENT_LEAVE_FAILED ) */ { INF( "<AVC CB>CELL_AVC2_EVENT_LEAVE_FAILED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setState(AVC_STATE_CHAT_LEAVE); setEvent(AVC_EVENT_ERROR); } return ret;}
int SonyVoiceChat::eventcb_unload(CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ int ret = CELL_OK;
UNUSED_VARIABLE( event_param ); UNUSED_VARIABLE( userdata );
if( event_id == CELL_AVC2_EVENT_UNLOAD_SUCCEEDED ) { INF( "<AVC CB>CELL_AVC2_EVENT_UNLOAD_SUCCEEDED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_CHAT_UNLOAD_SUCCEEDED); sm_bLoaded = false; sm_bUnloading = false; } else /* if( event_id == CELL_AVC2_EVENT_UNLOAD_FAILED ) */ { INF( "<AVC CB>CELL_AVC2_EVENT_UNLOAD_FAILED(0x%x), param(0x%x)\n", event_id, (int)event_param ); setEvent(AVC_EVENT_ERROR); } return ret;}
int SonyVoiceChat::eventcb_voiceDetected(CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ UNUSED_VARIABLE( userdata );
// To the upper 32 bits, the room member ID of the player is passed.// In the lower 32 bits, a value of 0 (mute) or a value between 1 (low volume) // and 10 (high volume) is passed as the audio signal value when the notification // method is the level method, or a value of 1 (start of speaking) or 0 (end of speaking) // is stored when the notification method is the trigger method.
SceNpMatching2RoomMemberId roomMemberID = (SceNpMatching2RoomMemberId)(event_param >> 32); uint32_t volume = (uint32_t)(event_param & 0xffffffff);
// The precision of voice detection is not very high. Since the audio signal values may // always be relatively high depending on the audio input device and the noise level in the // room, you should set a large reference value for determining whether or not a player is // speaking. Relatively good results can be obtained when an audio signal value of at // least 9 is used to determine if a player is speaking. bool bTalking = false; if(volume >= 9) bTalking = true;
sm_bTalkingMap[roomMemberID] = bTalking; return CELL_OK;}
/* Callback function for handling AV Chat2 Utility events */void SonyVoiceChat::eventcb( CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata){ static struct _cb_func_tbl { CellSysutilAvc2EventId event; int (*func)( CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, void *userdata ); } event_tbl[] = { { CELL_AVC2_EVENT_LOAD_SUCCEEDED, eventcb_load }, { CELL_AVC2_EVENT_LOAD_FAILED, eventcb_load }, { CELL_AVC2_EVENT_JOIN_SUCCEEDED, eventcb_join }, { CELL_AVC2_EVENT_JOIN_FAILED, eventcb_join }, { CELL_AVC2_EVENT_LEAVE_SUCCEEDED, eventcb_leave }, { CELL_AVC2_EVENT_LEAVE_FAILED, eventcb_leave }, { CELL_AVC2_EVENT_UNLOAD_SUCCEEDED, eventcb_unload }, { CELL_AVC2_EVENT_UNLOAD_FAILED, eventcb_unload }, { CELL_AVC2_EVENT_SYSTEM_NEW_MEMBER_JOINED, NULL }, { CELL_AVC2_EVENT_SYSTEM_MEMBER_LEFT, NULL }, { CELL_AVC2_EVENT_SYSTEM_SESSION_ESTABLISHED, NULL }, { CELL_AVC2_EVENT_SYSTEM_SESSION_CANNOT_ESTABLISHED,NULL }, { CELL_AVC2_EVENT_SYSTEM_SESSION_DISCONNECTED, NULL }, { CELL_AVC2_EVENT_SYSTEM_VOICE_DETECTED, eventcb_voiceDetected },
};
int ret = 0; for( unsigned int i=0; i<sizeof(event_tbl)/sizeof(struct _cb_func_tbl) ; ++i ) { if( event_tbl[ i ].event == event_id && event_tbl[ i ].func ) { ret = (*event_tbl[ i ].func)( event_id, event_param, userdata ); if( ret < 0 ) { ERR("ret=0x%x\n", ret ); } break; } }}
int SonyVoiceChat::load(){ int ret = CELL_OK; INF("----------------------------\n"); INF("| cellSysutilAvc2LoadAsync |\n"); INF("----------------------------\n"); ret = cellSysutilAvc2LoadAsync( sm_pNetworkManager->m_matchingContext, SYS_MEMORY_CONTAINER_ID_INVALID, eventcb, NULL, &g_chat_avc2param ); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2LoadAsync: ret=0x%x\n", ret ); setEvent(AVC_EVENT_ERROR); return ret; } return ret;}
int SonyVoiceChat::join(){ int ret = CELL_OK;
INF("---------------------------------------------------\n"); INF("| cellSysutilAvc2JoinChatRequest \n"); INF("---------------------------------------------------\n"); ret = cellSysutilAvc2JoinChatRequest( &sm_pNetworkManager->m_room ); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2JoinChatRequest: ret=0x%x\n", ret ); setEvent(AVC_EVENT_ERROR); return ret; } return ret;}
int SonyVoiceChat::leave(){ int ret = CELL_OK;
INF("-----------------------------------\n"); INF("| cellSysutilAvc2LeaveChatRequest |\n"); INF("-----------------------------------\n"); ret = cellSysutilAvc2LeaveChatRequest(); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2LeaveChatRequest() = 0x%x\n", ret ); setEvent(AVC_EVENT_ERROR); return ret; } return ret;}
int SonyVoiceChat::unload(){ int ret = CELL_OK;
INF("------------------------------\n"); INF("| cellSysutilAvc2UnloadAsync |\n"); INF("------------------------------\n");
ret = cellSysutilAvc2UnloadAsync(); if( ret != CELL_OK ) { ERR( "cellSysutilAvcUnloadAsync() = 0x%x\n", ret ); setEvent(AVC_EVENT_ERROR); return ret; } sm_bUnloading = true; return ret;}
int SonyVoiceChat::start(){ sm_bCanStart = (sm_isChatRestricted == false);
int ret = CELL_OK; if(sm_bEnabled) ret = startStream();
return ret;}
int SonyVoiceChat::stop(){ sm_bCanStart = false;
int ret = CELL_OK; if(sm_bEnabled) ret = stopStream();
setEvent(AVC_EVENT_CHAT_SESSION_STOPPED);
return ret;}
int SonyVoiceChat::startStream(){ int ret = CELL_OK;
INF("---------------------------------\n"); INF("| cellSysutilAvc2StartStreaming |\n"); INF("---------------------------------\n"); ret = cellSysutilAvc2StartStreaming(); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2StartStreaming: ret=0x%x\n", ret ); }
ret = cellSysutilAvc2StartVoiceDetection(); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2StartVoiceDetection: ret=0x%x\n", ret ); } return ret;}
int SonyVoiceChat::stopStream(){ int ret = cellSysutilAvc2StopVoiceDetection(); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2StopVoiceDetection: ret=0x%x\n", ret ); }
INF("--------------------------------\n"); INF("| cellSysutilAvc2StopStreaming |\n"); INF("--------------------------------\n"); ret = cellSysutilAvc2StopStreaming(); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2StopStreaming: ret=0x%x\n", ret ); } return ret;}
int SonyVoiceChat::initialize(void){ int ret;
/* Must use cellSysutilAvc2InitParam() for clearing CellSysutilAvc2InitParam struct*/ ret = cellSysutilAvc2InitParam(CELL_SYSUTIL_AVC2_INIT_PARAM_VERSION, &g_chat_avc2param); if( ret != CELL_OK ) { ERR( "cellSysutilAvc2InitParam failed (0x%x)\n", ret ); return ret; }
/* Setting application specific parameters */ g_chat_avc2param.media_type = CELL_SYSUTIL_AVC2_VOICE_CHAT; g_chat_avc2param.max_players = AVC2_PARAM_DEFAULT_MAX_PLAYERS; g_chat_avc2param.voice_param.voice_quality = CELL_SYSUTIL_AVC2_VOICE_QUALITY_NORMAL; g_chat_avc2param.voice_param.max_speakers = AVC2_PARAM_DEFAULT_MAX_SPEAKERS; g_chat_avc2param.spu_load_average = 50; g_chat_avc2param.streaming_mode.mode = CELL_SYSUTIL_AVC2_STREAMING_MODE_NORMAL;
setEvent(AVC_EVENT_CHAT_INIT_SUCCEEDED); setState(AVC_STATE_CHAT_INIT);
return ret;}
int SonyVoiceChat::finalize(void){ setEvent(AVC_EVENT_CHAT_FINALIZE_SUCCEEDED); return CELL_OK;}
void SonyVoiceChat::tick(){#ifdef DISABLE_VOICE_CHAT return;#endif
static state_transition_table tbl[] = { /* now state event func after the transition state */ { AVC_STATE_CHAT_INIT, AVC_EVENT_EPSILON, initialize, AVC_STATE_CHAT_INIT }, { AVC_STATE_CHAT_INIT, AVC_EVENT_EXIT_GAME, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_INIT, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_INIT, AVC_EVENT_LAN_DISCONNECT, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_INIT, AVC_EVENT_LAN_DISCONNECT, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_INIT, AVC_EVENT_CHAT_INIT_SUCCEEDED, invoke_epsilon_event, AVC_STATE_CHAT_LOAD }, { AVC_STATE_CHAT_INIT, AVC_EVENT_NP2_ROOM_DESTROY_OR_KICKEDOUT,invoke_epsilon_event, AVC_STATE_CHAT_RESET },
{ AVC_STATE_CHAT_LOAD, AVC_EVENT_EPSILON, load, AVC_STATE_CHAT_LOAD }, { AVC_STATE_CHAT_LOAD, AVC_EVENT_EXIT_GAME, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_LOAD, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_LOAD, AVC_EVENT_LAN_DISCONNECT, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_LOAD, AVC_EVENT_CHAT_LOAD_SUCCEEDED, invoke_epsilon_event, AVC_STATE_CHAT_JOIN }, { AVC_STATE_CHAT_LOAD, AVC_EVENT_NP2_ROOM_DESTROY_OR_KICKEDOUT,invoke_epsilon_event, AVC_STATE_CHAT_RESET },
{ AVC_STATE_CHAT_JOIN, AVC_EVENT_EPSILON, join, AVC_STATE_CHAT_JOIN }, { AVC_STATE_CHAT_JOIN, AVC_EVENT_EXIT_GAME, invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD }, { AVC_STATE_CHAT_JOIN, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD }, { AVC_STATE_CHAT_JOIN, AVC_EVENT_LAN_DISCONNECT, invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD }, { AVC_STATE_CHAT_JOIN, AVC_EVENT_CHAT_JOIN_SUCCEEDED, invoke_epsilon_event, AVC_STATE_CHAT_SESSION_PROCESSING }, { AVC_STATE_CHAT_JOIN, AVC_EVENT_NP2_ROOM_DESTROY_OR_KICKEDOUT,invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD },
{ AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_EPSILON, start, AVC_STATE_CHAT_SESSION_PROCESSING }, { AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_EXIT_GAME, stop, AVC_STATE_CHAT_SESSION_PROCESSING }, { AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_ERROR, stop, AVC_STATE_CHAT_SESSION_PROCESSING }, { AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_LAN_DISCONNECT, stop, AVC_STATE_CHAT_SESSION_PROCESSING }, { AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_CHAT_SESSION_STOPPED, invoke_epsilon_event, AVC_STATE_CHAT_LEAVE }, { AVC_STATE_CHAT_SESSION_PROCESSING,AVC_EVENT_NP2_ROOM_DESTROY_OR_KICKEDOUT,stop, AVC_STATE_CHAT_SESSION_PROCESSING },
{ AVC_STATE_CHAT_LEAVE, AVC_EVENT_EPSILON, leave, AVC_STATE_CHAT_LEAVE }, { AVC_STATE_CHAT_LEAVE, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD }, { AVC_STATE_CHAT_LEAVE, AVC_EVENT_CHAT_LEAVE_SUCCEEDED, invoke_epsilon_event, AVC_STATE_CHAT_UNLOAD },
{ AVC_STATE_CHAT_UNLOAD, AVC_EVENT_EPSILON, unload, AVC_STATE_CHAT_UNLOAD }, { AVC_STATE_CHAT_UNLOAD, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_UNLOAD, AVC_EVENT_CHAT_UNLOAD_SUCCEEDED, invoke_epsilon_event, AVC_STATE_CHAT_RESET },
{ AVC_STATE_CHAT_RESET, AVC_EVENT_EPSILON, finalize, AVC_STATE_CHAT_RESET }, { AVC_STATE_CHAT_RESET, AVC_EVENT_ERROR, invoke_epsilon_event, AVC_STATE_CHAT_LEAVE }, { AVC_STATE_CHAT_RESET, AVC_EVENT_CHAT_FINALIZE_SUCCEEDED, invoke_epsilon_event, AVC_STATE_IDLE },
}; do_state_transition( &tbl[0], sizeof( tbl ) / sizeof( state_transition_table ) );
setBitRate();}
void SonyVoiceChat::do_state_transition( state_transition_table *tbl, int tbl_size ){ int ret = CELL_OK;
// if( sm_event == AVC_EVENT_LAN_DISCONNECT ||// sm_event == AVC_EVENT_EXIT_GAME ||// sm_event == AVC_EVENT_ERROR ||// sm_event == AVC_EVENT_FATAL_ERROR )// {// g_gamedata.finalize = 1;// }// if( sm_event == AVC_EVENT_FATAL_ERROR )// {// g_gamedata.exit = true;// } bool bCalledFunc = false; for( int i = 0; i < tbl_size; i++ ) { if( sm_state == ( tbl + i )->state ) { if( sm_event == ( tbl + i )->event ) { sm_event = AVC_EVENT_NON; ret = (*( tbl + i )->func)(); bCalledFunc = true; if( ret != CELL_OK ) { ERR("ret = 0x%x\n", ret ); }
setState(( tbl + i )->new_state); break; } } } if(bCalledFunc == false) { assert( (sm_event == AVC_EVENT_NON) || (sm_state == AVC_STATE_IDLE && sm_event == AVC_EVENT_EPSILON) ); }}
int SonyVoiceChat::invoke_epsilon_event(void){ setEvent(AVC_EVENT_EPSILON);
return CELL_OK;}
bool SonyVoiceChat::hasMicConnected(const SceNpMatching2RoomMemberId *players_id){ CellSysutilAvc2PlayerInfo players_info; int err = cellSysutilAvc2GetPlayerInfo(players_id, &players_info); if(err == CELL_OK) { if(players_info.connected && players_info.joined) { if(players_info.mic_attached == CELL_AVC2_MIC_STATUS_ATTACHED_ON) return true; } }
return false;}
void SonyVoiceChat::mute( bool bMute ){ if(sm_bLoaded && !sm_bUnloading) { int err = cellSysutilAvc2SetVoiceMuting(bMute); assert(err == CELL_OK); }}
void SonyVoiceChat::mutePlayer( const SceNpMatching2RoomMemberId member_id, bool bMute ) /*Turn chat audio from a specified player on or off */{ if(sm_bLoaded && !sm_bUnloading) { int err = cellSysutilAvc2SetPlayerVoiceMuting(member_id, bMute); assert(err == CELL_OK); }}
void SonyVoiceChat::muteLocalPlayer( bool bMute ) /*Turn microphone input on or off */{ if(sm_bLoaded && !sm_bUnloading) { int err = cellSysutilAvc2SetVoiceMuting(bMute); assert(err == CELL_OK); }}
bool SonyVoiceChat::isMuted(){ if(sm_bLoaded && !sm_bUnloading) { uint8_t bMute; int err = cellSysutilAvc2GetVoiceMuting(&bMute); assert(err == CELL_OK); return bMute; } return false;}
bool SonyVoiceChat::isMutedPlayer( const SceNpMatching2RoomMemberId member_id) { if(sm_bLoaded && !sm_bUnloading) { uint8_t bMute; int err = cellSysutilAvc2GetPlayerVoiceMuting(member_id, &bMute); assert(err == CELL_OK); return bMute; } return false;}
bool SonyVoiceChat::isMutedLocalPlayer() { if(sm_bLoaded && !sm_bUnloading) { uint8_t bMute; int err = cellSysutilAvc2GetVoiceMuting(&bMute); assert(err == CELL_OK); return bMute; } return false;}
void SonyVoiceChat::setVolume( float vol ){ if(sm_bLoaded && !sm_bUnloading) { // The volume level can be set to a value in the range 0.0 to 40.0. // Volume levels are linear values such that if 1.0 is specified, the // volume level will be 1 times the reference power (0dB), and if 0.5 // is specified, the volume level will be 0.5 times the reference power // (-6dB). If 0.0 is specified, chat audio will no longer be audible.
int err =cellSysutilAvc2SetSpeakerVolumeLevel(vol * 40.0f); assert(err==CELL_OK); }}
float SonyVoiceChat::getVolume(){ if(sm_bLoaded && !sm_bUnloading) { float vol; int err = cellSysutilAvc2GetSpeakerVolumeLevel(&vol); assert(err == CELL_OK); return (vol / 40.0f); } return 0;}
bool SonyVoiceChat::isTalking( SceNpMatching2RoomMemberId* players_id ){ AUTO_VAR(it, sm_bTalkingMap.find(*players_id)); if (it != sm_bTalkingMap.end() ) return it->second; return false;}
void SonyVoiceChat::setBitRate(){ if(sm_state != AVC_STATE_CHAT_SESSION_PROCESSING) return;
int numPlayers = sm_pNetworkManager->GetPlayerCount();// This internal attribute represents the maximum voice bit rate. attr_param // is an integer value. The units are bps, and the specifiable values are // 4000, 8000, 16000, 20000, 24000, and 28000. The initial value is 28000.
static int bitRates[8] = { 28000, 28000, 28000, 28000, 24000, 20000, 16000, 16000}; int bitRate = bitRates[numPlayers-1]; if(bitRate == sm_currentBitrate) return;
CellSysutilAvc2Attribute attr; memset( &attr, 0x00, sizeof(attr) ); attr.attr_id = CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_MAX_BITRATE; attr.attr_param.int_param = bitRate; int ret = cellSysutilAvc2SetAttribute(&attr); if( ret == CELL_OK ) { sm_currentBitrate = bitRate; } else { app.DebugPrintf("SonyVoiceChat::setBitRate failed !!! 0x%08x\n", ret); }}
#define CASE_STR_VALUE(s) case s: return #s;
const char* getStateString(EAVCState state){
switch(state) {
CASE_STR_VALUE(AVC_STATE_IDLE); CASE_STR_VALUE(AVC_STATE_CHAT_INIT) CASE_STR_VALUE(AVC_STATE_CHAT_LOAD); CASE_STR_VALUE(AVC_STATE_CHAT_JOIN); CASE_STR_VALUE(AVC_STATE_CHAT_SESSION_PROCESSING); CASE_STR_VALUE(AVC_STATE_CHAT_LEAVE); CASE_STR_VALUE(AVC_STATE_CHAT_RESET); CASE_STR_VALUE(AVC_STATE_CHAT_UNLOAD); CASE_STR_VALUE(AVC_STATE_EXIT); default: return "unknown state"; }}
const char* getEventString(EAVCEvent state){ switch(state) { CASE_STR_VALUE(AVC_EVENT_NON); CASE_STR_VALUE(AVC_EVENT_EPSILON); CASE_STR_VALUE(AVC_EVENT_LAN_DISCONNECT); CASE_STR_VALUE(AVC_EVENT_ONLINE); CASE_STR_VALUE(AVC_EVENT_OFFLINE); CASE_STR_VALUE(AVC_EVENT_EXIT_GAME); CASE_STR_VALUE(AVC_EVENT_ROOM_CREATE); CASE_STR_VALUE(AVC_EVENT_ROOM_SEARCH); CASE_STR_VALUE(AVC_EVENT_ERROR); CASE_STR_VALUE(AVC_EVENT_FATAL_ERROR); CASE_STR_VALUE(AVC_EVENT_NETDIALOG_FINISHED); CASE_STR_VALUE(AVC_EVENT_NETDIALOG_UNLOADED); CASE_STR_VALUE(AVC_EVENT_NP2_INIT_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_NP2_FINALIZE_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_NP2_START_CONTEXT_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_NP2_STOP_CONTEXT_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_NP2_ROOM_DESTROY_OR_KICKEDOUT); CASE_STR_VALUE(AVC_EVENT_NP2_ROOM_MEMBER_LEFT); CASE_STR_VALUE(AVC_EVENT_NP2_ROOM_MEMBER_JOINED); CASE_STR_VALUE(AVC_EVENT_CHAT_LOAD_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_LOAD_FAILED); CASE_STR_VALUE(AVC_EVENT_CHAT_JOIN_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_JOIN_FAILED); CASE_STR_VALUE(AVC_EVENT_CHAT_LEAVE_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_LEAVE_FAILED); CASE_STR_VALUE(AVC_EVENT_CHAT_UNLOAD_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_UNLOAD_FAILED); CASE_STR_VALUE(AVC_EVENT_CHAT_INIT_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_FINALIZE_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_CHAT_SESSION_STOPPED); CASE_STR_VALUE(AVC_EVENT_CREATE_JOIN_ROOM_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_SEARCH_ROOM_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_JOIN_ROOM_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_LEAVE_ROOM_SUCCEEDED); CASE_STR_VALUE(AVC_EVENT_SIGNALING_ESTABLISHED); CASE_STR_VALUE(AVC_EVENT_SIGNALING_DEAD); CASE_STR_VALUE(AVC_EVENT_UI_CLOSE_SUCCEEDED); default: return "unknown event"; }}
void SonyVoiceChat::printStateAndEvent(){ app.DebugPrintf("============== State %20s, Event %20s\n", getStateString(sm_state), getEventString(sm_event));}
void SonyVoiceChat::setEvent( EAVCEvent event ){ sm_event = event; printStateAndEvent();}
void SonyVoiceChat::setState( EAVCState state ){ sm_state = state; printStateAndEvent();}