6656 lines
232 KiB
C++
6656 lines
232 KiB
C++
//
|
|
// audio/radiostation.cpp
|
|
//
|
|
// Copyright (C) 1999-2007 Rockstar Games. All Rights Reserved.
|
|
//
|
|
|
|
#include "audiodefines.h"
|
|
|
|
#if NA_RADIO_ENABLED
|
|
|
|
#include "radiostation.h"
|
|
#include "music/musicplayer.h"
|
|
#include "northaudioengine.h"
|
|
#include "radioaudioentity.h"
|
|
#include "radioslot.h"
|
|
|
|
#include "audioengine/engine.h"
|
|
#include "audiosoundtypes/speechsound.h"
|
|
#include "audiohardware/device.h"
|
|
#include "audiohardware/driver.h"
|
|
#include "audiohardware/driverutil.h"
|
|
#include "audiohardware/submix.h"
|
|
#include "audiosynth/synthcore.h"
|
|
#include "grcore/debugdraw.h"
|
|
#include "game/clock.h"
|
|
#include "game/weather.h"
|
|
#include "parser/manager.h"
|
|
#include "parsercore/attribute.h"
|
|
#include "string/stringhash.h"
|
|
#include "spatialdata/sphere.h"
|
|
#include "streaming/streamingengine.h"
|
|
#include "system/bootmgr.h"
|
|
#include "network/NetworkInterface.h"
|
|
#include "network/events/NetworkEventTypes.h"
|
|
#include "network/live/NetworkTelemetry.h"
|
|
|
|
#include "system/filemgr.h"
|
|
|
|
#include "debugaudio.h"
|
|
|
|
AUDIO_MUSIC_OPTIMISATIONS()
|
|
|
|
PARAM(disableradiohistory, "[Audio] Disable radio track history");
|
|
PARAM(disableuserradio, "[Audio] Disable user radio");
|
|
|
|
audWaveSlot *g_RadioDjSpeechWaveSlot = NULL;
|
|
|
|
bool audRadioStation::sm_PlayingEndCredits = false;
|
|
|
|
f32 g_RadioDjDuckingLevelDb = 8.0f;
|
|
f32 g_RadioDjDuckingLevelLin = 0.0f;// computed from duckingleveldb in initclass
|
|
u32 g_RadioDjDuckTimeMs = 150;
|
|
|
|
enum { kMinRadioTracksOutsideHistory = 2};
|
|
|
|
atRangeArray<u8, kMaxNewsStories> audRadioStation::sm_NewsStoryState;
|
|
|
|
audRadioStationHistory audRadioStation::sm_NewsHistory;
|
|
audRadioStationHistory audRadioStation::sm_WeatherHistory;
|
|
audRadioStationHistory audRadioStation::sm_AdvertHistory;
|
|
audRadioStationTrackListCollection audRadioStation::sm_NewsTrackLists;
|
|
audRadioStationTrackListCollection audRadioStation::sm_WeatherTrackLists;
|
|
u32 audRadioStation::sm_PositionedPlayerVehicleRadioLPFCutoff = kVoiceFilterLPFMaxCutoff;
|
|
u32 audRadioStation::sm_PositionedPlayerVehicleRadioHPFCutoff = kVoiceFilterHPFMinCutoff;
|
|
f32 audRadioStation::sm_PositionedPlayerVehicleRadioEnvironmentalLoudness = 0.f;
|
|
f32 audRadioStation::sm_PositionedPlayerVehicleRadioVolume = 0.f;
|
|
f32 audRadioStation::sm_PositionedPlayerVehicleRadioRollOff = 1.f;
|
|
bool audRadioStation::sm_HasSyncedUnlockableDJStation = false;
|
|
|
|
float audRadioStation::sm_CountryTalkRadioSignal = 1.f;
|
|
float audRadioStation::sm_ScriptGlobalRadioSignalLevel = 1.f;
|
|
bool audRadioStation::sm_UpdateLockedStations = false;
|
|
#if RSG_PC
|
|
bool audRadioStation::sm_IsInRecoveryMode = false;
|
|
#endif
|
|
|
|
bool audRadioStation::sm_HasInitialisedStations = false;
|
|
|
|
#define AUD_CLEAR_TRISTATE_VALUE(flagvar, flagid) (flagvar &= ~(0 | ((AUD_GET_TRISTATE_VALUE(flagvar, flagid)&0x03) << (flagid<<1))))
|
|
|
|
#if __BANK && 0
|
|
extern bool g_DrawRadioDebug;
|
|
extern audRadioStation *g_DebugRadioStation;
|
|
#define RADIODEBUG(arg) if(g_DrawRadioDebug && g_DebugRadioStation == this){Printf("[%s] ", GetName());Displayf(arg);}
|
|
#define RADIODEBUG2(arg1,arg2) if(g_DrawRadioDebug && g_DebugRadioStation == this){Printf("[%s] ", GetName());Displayf(arg1, arg2);}
|
|
#define RADIODEBUG3(arg1, arg2, arg3) if(g_DrawRadioDebug && g_DebugRadioStation == this){Printf("[%s] ", GetName());Displayf(arg1, arg2, arg3);}
|
|
#define RADIODEBUG4(arg1, arg2, arg3, arg4) if(g_DrawRadioDebug && g_DebugRadioStation == this){Printf("[%s] ", GetName());Displayf(arg1,arg2,arg3,arg4);}
|
|
#else
|
|
#define RADIODEBUG(arg)
|
|
#define RADIODEBUG2(arg1,arg2)
|
|
#define RADIODEBUG3(arg1, arg2, arg3)
|
|
#define RADIODEBUG4(arg1, arg2, arg3, arg4)
|
|
#endif
|
|
|
|
BANK_ONLY(bool audRadioStation::sm_DebugHistory = false);
|
|
|
|
enum audRadioTrackWeatherContexts
|
|
{
|
|
RADIO_TRACK_WEATHER_CONTEXT_FOG,
|
|
RADIO_TRACK_WEATHER_CONTEXT_RAIN,
|
|
RADIO_TRACK_WEATHER_CONTEXT_WIND,
|
|
RADIO_TRACK_WEATHER_CONTEXT_SUN,
|
|
RADIO_TRACK_WEATHER_CONTEXT_CLOUD,
|
|
NUM_RADIO_TRACK_WEATHER_CONTEXTS
|
|
};
|
|
|
|
static const u32 g_RadioTrackWeatherContextNames[NUM_RADIO_TRACK_WEATHER_CONTEXTS] =
|
|
{
|
|
ATSTRINGHASH("FOG", 0xD61BDE01),//RADIO_TRACK_WEATHER_CONTEXT_FOG,
|
|
ATSTRINGHASH("RAIN", 0x54A69840),//RADIO_TRACK_WEATHER_CONTEXT_RAIN,
|
|
ATSTRINGHASH("WIND", 0x35369828),//RADIO_TRACK_WEATHER_CONTEXT_WIND,
|
|
ATSTRINGHASH("SUN", 0x47AE791A),//RADIO_TRACK_WEATHER_CONTEXT_SUN,
|
|
ATSTRINGHASH("CLOUD", 0x27F49EC9)//RADIO_TRACK_WEATHER_CONTEXT_CLOUD,
|
|
};
|
|
|
|
bank_s32 g_RadioTrackOverlapPlayTimeMs = 1000;
|
|
bank_s32 g_RadioTrackMixtransitionTimeMs = 2000;
|
|
bank_s32 g_RadioTrackMixtransitionOffsetTimeMs = 0;
|
|
bank_s32 g_RadioTrackOverlapTimeMs = 1000;
|
|
bank_s32 g_UserRadioTrackOverlapTimeMs = 500;
|
|
bank_s32 g_RadioTrackPrepareTimeMs = 7000;
|
|
bank_s32 g_RadioTrackSkipEndTimeMs = 7000;
|
|
|
|
bool g_UsePreciseTrackCrossfades = true;
|
|
|
|
bank_u32 g_RadioWheelWindStart = 11000;
|
|
bank_u32 g_RadioWheelWindOffset = 50000;
|
|
bank_u32 g_RadioDjSpeechMinDelayMsMotomami = 10000;
|
|
|
|
bank_float g_RadioDjSpeechProbability = 0.8f; //Prob of DJ speech playing within a valid window.
|
|
bank_float g_RadioDjSpeechProbabilityKult = 0.7f; //Prob of DJ speech playing within a valid window.
|
|
bank_float g_RadioDjOutroSpeechProbabilityMotomami = 0.275f; //Prob of DJ speech playing within a valid window.
|
|
bank_float g_RadioDjTimeProbability = 0.5f; //Prob of time banter playing instead of an intro.
|
|
|
|
const s32 g_RadioDjMinPrepareTimeMs = 3000;
|
|
const s32 g_RadioDjPlayTimeTresholdMs = 500;
|
|
const u8 g_RadioDjMaxVariations = 100;
|
|
|
|
const char *g_RadioDjSpeechCategoryNames[NUM_RADIO_DJ_SPEECH_CATS] =
|
|
{
|
|
"INTRO", //RADIO_DJ_SPEECH_CAT_INTRO
|
|
"OUTRO", //RADIO_DJ_SPEECH_CAT_OUTRO
|
|
"GENERAL", //RADIO_DJ_SPEECH_CAT_GENERAL
|
|
"TIME", //RADIO_DJ_SPEECH_CAT_TIME
|
|
"TO" //RADIO_DJ_SPEECH_CAT_TO
|
|
};
|
|
|
|
//The minimum amount of time that must pass (in milliseconds) between repeated playback of a DJ speech category.
|
|
const u32 g_RadioDjSpeechMinTimeBetweenRepeatedCategories[NUM_RADIO_DJ_SPEECH_CATS] =
|
|
{
|
|
0, //RADIO_DJ_SPEECH_CAT_INTRO
|
|
0, //RADIO_DJ_SPEECH_CAT_OUTRO
|
|
45000, //RADIO_DJ_SPEECH_CAT_GENERAL - 45s, to prevent back to back generals when driven by score
|
|
1800000, //RADIO_DJ_SPEECH_CAT_TIME - 30mins
|
|
0 //RADIO_DJ_SPEECH_CAT_TO
|
|
};
|
|
|
|
const u32 g_RadioDjSpeechMinTimeBetweenRepeatedCategoriesKult[NUM_RADIO_DJ_SPEECH_CATS] =
|
|
{
|
|
540000, //RADIO_DJ_SPEECH_CAT_INTRO - 9 mins
|
|
0, //RADIO_DJ_SPEECH_CAT_OUTRO
|
|
540000, //RADIO_DJ_SPEECH_CAT_GENERAL - 9 mins
|
|
1800000, //RADIO_DJ_SPEECH_CAT_TIME - 30mins
|
|
0 //RADIO_DJ_SPEECH_CAT_TO
|
|
};
|
|
|
|
const u8 g_RadioDjTimeMorningStart = 5;
|
|
const u8 g_RadioDjTimeMorningEnd = 9;
|
|
const u8 g_RadioDjTimeAfternoonStart = 12;
|
|
const u8 g_RadioDjTimeAfternoonEnd = 16;
|
|
const u8 g_RadioDjTimeEveningStart = 17;
|
|
const u8 g_RadioDjTimeEveningEnd = 20;
|
|
const u8 g_RadioDjTimeNightStart = 21;
|
|
const u8 g_RadioDjTimeNightEnd = 3;
|
|
|
|
bool g_DisablePlayTimeCompensation = false;
|
|
|
|
const char *g_RadioDjMorningContext = "MORNING";
|
|
const char *g_RadioDjAfternoonContext = "AFTERNOON";
|
|
const char *g_RadioDjEveningContext = "EVENING";
|
|
const char *g_RadioDjNightContext = "NIGHT";
|
|
|
|
const char *g_RadioDjToAdvertContext = "TO_AD";
|
|
const char *g_RadioDjToNewsContext = "TO_NEWS";
|
|
const char *g_RadioDjToWeatherContext = "TO_WEATHER";
|
|
|
|
static char g_RadioDjVoiceName[g_MaxRadioNameLength];
|
|
static char g_RadioDjContextName[g_MaxRadioNameLength];
|
|
|
|
bool audRadioStation::sm_IsNetworkModeHistoryActive = false;
|
|
|
|
|
|
bool audRadioStation::sm_IMDrivenDjSpeech = false;
|
|
bool audRadioStation::sm_IMDrivenDjSpeechScheduled = false;
|
|
u8 audRadioStation::sm_IMDjSpeechCategory = 0;
|
|
audRadioStation *audRadioStation::sm_IMDjSpeechStation = NULL;
|
|
|
|
const audRadioStation *audRadioStation::sm_DjSpeechStation = NULL;
|
|
u32 audRadioStation::sm_DjSpeechNextTrackCategory = 0;
|
|
|
|
audCurve audRadioStation::sm_VehicleRadioRiseVolumeCurve;
|
|
audSimpleSmoother audRadioStation::sm_DjDuckerVolumeSmoother;
|
|
audSound *audRadioStation::sm_RetuneMonoSound = NULL;
|
|
audSound *audRadioStation::sm_RetunePositionedSound = NULL;
|
|
audSound *audRadioStation::sm_DjSpeechMonoSound = NULL;
|
|
audSound *audRadioStation::sm_DjSpeechPositionedSound = NULL;
|
|
atArray<audRadioStation *> audRadioStation::sm_OrderedRadioStations;
|
|
const RadioTrackCategoryData *audRadioStation::sm_MinTimeBetweenRepeatedCategories = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_RadioTrackCategoryWeightsFromMusic = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_RadioTrackCategoryWeightsFromBackToBackMusic = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_RadioTrackCategoryWeightsNoBackToBackMusic = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_RadioTrackCategoryWeightsFromBackToBackMusicKult = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_RadioTrackCategoryWeightsNoBackToBackMusicKult = NULL;
|
|
#if RSG_PC // user music
|
|
const RadioTrackCategoryData *audRadioStation::sm_MinTimeBetweenRepeatedCategoriesUser = NULL;
|
|
const RadioTrackCategoryData *audRadioStation::sm_UserMusicWeightsFromMusic = NULL;
|
|
#endif
|
|
|
|
#if HEIST3_HIDDEN_RADIO_ENABLED
|
|
u32 audRadioStation::sm_Heist3HiddenRadioBankId = ~0u;
|
|
#endif
|
|
|
|
s32 audRadioStation::sm_ActiveDjSpeechStartTimeMs = 0;
|
|
u32 audRadioStation::sm_ActiveDjSpeechId = 0;
|
|
u8 audRadioStation::sm_ActiveDjSpeechCategory = g_NullDjSpeechCategory;
|
|
u32 audRadioStation::sm_NumRadioStations = 0;
|
|
u32 audRadioStation::sm_NumUnlockedRadioStations = 0;
|
|
u32 audRadioStation::sm_NumUnlockedFavouritedStations = 0;
|
|
u8 audRadioStation::sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
bool audRadioStation::sm_DisableOverlap = false;
|
|
f32 audRadioStation::sm_DjSpeechFrontendVolume = 0.f;
|
|
f32 audRadioStation::sm_DjSpeechFrontendLPF = kVoiceFilterLPFMaxCutoff;
|
|
|
|
// user music additions to pc version
|
|
#if RSG_PC
|
|
bool audRadioStation::sm_ForceUserNextTrack = false;
|
|
bool audRadioStation::sm_ForceUserPrevTrack = false;
|
|
audUserRadioTrackManager audRadioStation::sm_UserRadioTrackManager;
|
|
#endif
|
|
|
|
#if __BANK
|
|
bool g_LogRadio = false;
|
|
bool g_ForceDjSpeech = false;
|
|
bool g_DebugRadioRandom = false;
|
|
u32 g_TestSyncStationIndex = 0;
|
|
extern f32 g_StationDebugDrawYScroll;
|
|
|
|
bool g_DebugDrawUSBStation = false;
|
|
bool g_HasAddedUSBStationWidgets = false;
|
|
u32 g_NumUSBStationTrackLists = 0;
|
|
s32 g_RequestedUSBTrackListComboIndex = -1;
|
|
u32 g_USBStationTrackListOffsetMs = 0;
|
|
atRangeArray<const char*, 20> g_USBTrackListNames;
|
|
bkCombo* g_USBStationTrackListCombo = nullptr;
|
|
bkGroup* g_USBStationGroup = nullptr;
|
|
bkBank* g_USBStationBank = nullptr;
|
|
#endif
|
|
|
|
s32 QSortRadioStationCompareFunc(audRadioStation* const* stationA, audRadioStation* const* stationB)
|
|
{
|
|
return ((*stationA)->GetOrder() - (*stationB)->GetOrder());
|
|
}
|
|
|
|
void audRadioStation::SortRadioStationList()
|
|
{
|
|
sm_OrderedRadioStations.QSort(0, sm_NumRadioStations, QSortRadioStationCompareFunc);
|
|
}
|
|
|
|
s32 audRadioStation::GetOrder() const
|
|
{
|
|
s32 order = 0;
|
|
if(m_StationSettings)
|
|
{
|
|
order = m_StationSettings->Order;
|
|
|
|
// url:bugstar:7186452 - The ordering of the stations on the radio wheel has changed compared to previous builds
|
|
// Slightly hacky fix to restore station ordering now that the off station has changed index. We just take all
|
|
// stations past a set order value and bump them to the back of the list, effectively rotating the station wheel
|
|
if(order < g_RadioWheelWindStart)
|
|
{
|
|
order += g_RadioWheelWindOffset;
|
|
}
|
|
|
|
// url:bugstar:7186089 - On the Radio Wheel, is it possible to keep the Media Player next to the Radio Off option,
|
|
// even when players have begun to thin the radio wheel down using the favourite station feature?
|
|
if(IsUSBMixStation())
|
|
{
|
|
order = 1;
|
|
}
|
|
|
|
if(!m_IsFavourited)
|
|
{
|
|
order += 100000;
|
|
}
|
|
|
|
if(AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED) == AUD_TRISTATE_TRUE)
|
|
{
|
|
order += 2000000;
|
|
}
|
|
else if(AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_HIDDEN) == AUD_TRISTATE_TRUE)
|
|
{
|
|
order += 4000000;
|
|
}
|
|
}
|
|
|
|
return order;
|
|
}
|
|
|
|
enum { kMaxRadioStationLists = 16};
|
|
void audRadioStation::InitClass(void)
|
|
{
|
|
//NOTE: This function must be called AFTER all downloadable audio content has been mounted and all game objects have been combined.
|
|
// Otherwise downloadable radio content will be ignored.
|
|
// HL: This comment was clearly never adhered to! Additional track lists can still be merged via after ::Init has been called. Risky
|
|
// to change so have added ::DLCInit fn to do any deferred processing
|
|
char radioStationListName[64];
|
|
|
|
sm_ActiveDjSpeechStartTimeMs = 0;
|
|
sm_ActiveDjSpeechId = 0;
|
|
sm_ActiveDjSpeechCategory = g_NullDjSpeechCategory;
|
|
sm_NumUnlockedRadioStations = 0;
|
|
sm_NumUnlockedFavouritedStations = 0;
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
|
|
sm_OrderedRadioStations.Resize(g_MaxRadioStations);
|
|
|
|
sm_MinTimeBetweenRepeatedCategories = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_MIN_TIME_BETWEEN_REPEATS", 0x4BFB4679));
|
|
WIN32PC_ONLY(sm_MinTimeBetweenRepeatedCategoriesUser = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_TIMES_SELF", 0x26EE6A9A)));
|
|
sm_RadioTrackCategoryWeightsFromMusic = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_FROM_MUSIC", 0xA3D15F60));
|
|
WIN32PC_ONLY(sm_UserMusicWeightsFromMusic = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_SELF", 0x45F45451)));
|
|
sm_RadioTrackCategoryWeightsFromBackToBackMusic = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_FROM_BACK_TO_BACK_MUSIC", 0xDBA8201E));
|
|
sm_RadioTrackCategoryWeightsNoBackToBackMusic = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_NO_BACK_TO_BACK_MUSIC", 0xB0EA87F1));
|
|
|
|
sm_RadioTrackCategoryWeightsNoBackToBackMusic = sm_RadioTrackCategoryWeightsFromBackToBackMusic;
|
|
|
|
sm_RadioTrackCategoryWeightsFromBackToBackMusicKult = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_FROM_BACK_TO_BACK_MUSIC_KULTFM", 0xAA636584));
|
|
sm_RadioTrackCategoryWeightsNoBackToBackMusicKult = audNorthAudioEngine::GetObject<RadioTrackCategoryData>(ATSTRINGHASH("RADIO_TRACK_CATEGORY_WEIGHTS_FROM_MUSIC_KULTFM", 0x8FC9E246));
|
|
|
|
if (!sm_RadioTrackCategoryWeightsFromBackToBackMusicKult)
|
|
{
|
|
sm_RadioTrackCategoryWeightsFromBackToBackMusicKult = sm_RadioTrackCategoryWeightsFromBackToBackMusic;
|
|
}
|
|
|
|
if (!sm_RadioTrackCategoryWeightsNoBackToBackMusicKult)
|
|
{
|
|
sm_RadioTrackCategoryWeightsNoBackToBackMusicKult = sm_RadioTrackCategoryWeightsNoBackToBackMusic;
|
|
}
|
|
|
|
// Radio initialisation overwrites metadata on init, so prevent RAVE edits from screwing with that
|
|
BANK_ONLY(const_cast<audMetadataManager&>(audNorthAudioEngine::GetMetadataManager()).DisableEditsForObjectType(RadioStationTrackList::TYPE_ID));
|
|
|
|
for(u32 listIndex=0; listIndex<kMaxRadioStationLists; listIndex++)
|
|
{
|
|
strStreamingEngine::GetLoader().CallKeepAliveCallbackIfNecessary();
|
|
formatf(radioStationListName, "RADIO_STATIONS_%02u", listIndex + 1);
|
|
|
|
RadioStationList *radioStationList = audNorthAudioEngine::GetObject<RadioStationList>(radioStationListName);
|
|
if(radioStationList == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(listIndex == 0)
|
|
{
|
|
//This is the list of shipped radio stations.
|
|
InitRadioStationList(radioStationList);
|
|
}
|
|
else
|
|
{
|
|
//This a list of downloaded radio stations that needs to be merged into the master list.
|
|
MergeRadioStationList(radioStationList);
|
|
}
|
|
}
|
|
|
|
sm_VehicleRadioRiseVolumeCurve.Init(ATSTRINGHASH("VEHICLE_RADIO_RISE", 0x5B9052BA));
|
|
|
|
f32 increaseDecreaseRate = 1.0f / (f32)g_RadioDjDuckTimeMs;
|
|
sm_DjDuckerVolumeSmoother.Init(increaseDecreaseRate);
|
|
g_RadioDjDuckingLevelLin = audDriverUtil::ComputeLinearVolumeFromDb(g_RadioDjDuckingLevelDb);
|
|
g_RadioDjSpeechWaveSlot = audWaveSlot::FindWaveSlot(ATSTRINGHASH("DJ_SPEECH", 0x06b9d8c6a));
|
|
|
|
const RadioStationTrackList *trackList = NULL;
|
|
|
|
// Locked news track lists are dealt with differently than others
|
|
sm_NewsTrackLists.SetLockingEnabled(false);
|
|
|
|
for(u32 index = 1; index < 64; index++)
|
|
{
|
|
char buf[16];
|
|
formatf(buf, "RADIO_NEWS_%02d", index);
|
|
trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(buf);
|
|
if(trackList)
|
|
{
|
|
Displayf("Adding news track list: %s (%u tracks)", buf, trackList->numTracks);
|
|
Assert(trackList->Category == RADIO_TRACK_CAT_NEWS);
|
|
sm_NewsTrackLists.AddTrackList(trackList);
|
|
}
|
|
}
|
|
|
|
trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(ATSTRINGHASH("RADIO_WEATHER_01", 0x09a5d886f));
|
|
Assert(trackList && trackList->Category == RADIO_TRACK_CAT_WEATHER);
|
|
|
|
sm_WeatherTrackLists.AddTrackList(trackList);
|
|
|
|
for(u32 index = 2; index < 64; index++)
|
|
{
|
|
char buf[32];
|
|
formatf(buf, "RADIO_WEATHER_%02d", index);
|
|
trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(buf);
|
|
if(trackList)
|
|
{
|
|
Displayf("Adding weather track list: %s (%u tracks)", buf, trackList->numTracks);
|
|
Assert(trackList->Category == RADIO_TRACK_CAT_WEATHER);
|
|
sm_WeatherTrackLists.AddTrackList(trackList);
|
|
}
|
|
}
|
|
|
|
Assert(sm_NewsTrackLists.ComputeNumTracks() < kMaxNewsStories);
|
|
|
|
#if RSG_PC
|
|
sm_ForceUserNextTrack = false;
|
|
sm_ForceUserPrevTrack = false;
|
|
|
|
sm_UserRadioTrackManager.Initialise();
|
|
if( CPauseMenu::GetMenuPreference(PREF_UR_AUTOSCAN) )
|
|
{
|
|
// Quick scan only on boot
|
|
sm_UserRadioTrackManager.StartMediaScan(false);
|
|
|
|
while(sm_UserRadioTrackManager.IsScanning())
|
|
{
|
|
sysIpcSleep(10);
|
|
}
|
|
|
|
sm_UserRadioTrackManager.UpdateScanningUI(false);
|
|
}
|
|
sm_UserRadioTrackManager.LoadFileLookup();
|
|
|
|
// Create a user music station
|
|
RadioStationSettings *stationSettings = audNorthAudioEngine::GetObject<RadioStationSettings>("RADIO_19_USER");
|
|
if(stationSettings)
|
|
{
|
|
sm_OrderedRadioStations[sm_NumRadioStations] = rage_new audRadioStation(stationSettings);
|
|
sm_OrderedRadioStations[sm_NumRadioStations]->SetLocked(!HasUserTracks() || PARAM_disableuserradio.Get());
|
|
sm_NumRadioStations++;
|
|
}
|
|
|
|
#endif // RSG_PC
|
|
|
|
//Order radio stations.
|
|
sm_OrderedRadioStations.QSort(0, sm_NumRadioStations, QSortRadioStationCompareFunc);
|
|
|
|
for(u32 stationIndex=0; stationIndex < sm_NumRadioStations; stationIndex++)
|
|
{
|
|
if(sm_OrderedRadioStations[stationIndex])
|
|
{
|
|
sm_OrderedRadioStations[stationIndex]->Init();
|
|
|
|
if(!sm_OrderedRadioStations[stationIndex]->IsLocked() && !sm_OrderedRadioStations[stationIndex]->IsHidden())
|
|
{
|
|
sm_NumUnlockedRadioStations++;
|
|
|
|
if(sm_OrderedRadioStations[stationIndex]->IsFavourited())
|
|
{
|
|
sm_NumUnlockedFavouritedStations++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Flag that any stations added after this point (ie via DLC rather than patch packs/core) require explicit init
|
|
sm_HasInitialisedStations = true;
|
|
|
|
#if __BANK
|
|
if (!sysBootManager::IsPackagedBuild())
|
|
{
|
|
FileHandle fi = CFileMgr::OpenFileForWriting("common:/RadioLog.csv");
|
|
if(fi != INVALID_FILE_HANDLE)
|
|
{
|
|
const char *header = "Station,TimeInMs,Category,Index,Context,Sound\r\n";
|
|
CFileMgr::Write(fi, header, istrlen(header));
|
|
CFileMgr::CloseFile(fi);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
void audRadioStation::PostLoad()
|
|
{
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
sm_UserRadioTrackManager.PostLoad();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if RSG_PC
|
|
bool audRadioStation::HasUserTracks()
|
|
{
|
|
return sm_UserRadioTrackManager.HasTracks();
|
|
}
|
|
#endif
|
|
|
|
s32 QSortBeatMarkerCompareFunc(audRadioStation::MixBeatMarker const* beatMarkerA, audRadioStation::MixBeatMarker const* beatMarkerB)
|
|
{
|
|
s32 playTimeA = (*beatMarkerA).playtimeMs;
|
|
s32 playTimeB = (*beatMarkerB).playtimeMs;
|
|
|
|
s32 trackA = (s32)((*beatMarkerA).trackIndex);
|
|
s32 trackB = (s32)((*beatMarkerB).trackIndex);
|
|
|
|
if (playTimeA != playTimeB)
|
|
{
|
|
return playTimeA - playTimeB;
|
|
}
|
|
else
|
|
{
|
|
return trackA - trackB;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ConstructMixStationBeatMarkerList()
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
|
|
if (trackLists)
|
|
{
|
|
const u32 numTracks = trackLists->ComputeNumTracks(0u, true);
|
|
|
|
for (u32 trackIndex = 0; trackIndex < numTracks; trackIndex++)
|
|
{
|
|
const u32 soundRef = trackLists->GetTrack(trackIndex, 0u, true)->SoundRef;
|
|
u32 totalStationDuration = 0;
|
|
u32 trackStartOffsetMs = 0;
|
|
u32 thisTrackDuration = 0;
|
|
|
|
// Iterate over all the tracks and grab the total station duration, duration of the given track, and offset of the given track
|
|
for (u32 i = 0; i < numTracks; i++)
|
|
{
|
|
const StreamingSound *streamingSound = SOUNDFACTORY.DecompressMetadata<StreamingSound>(trackLists->GetTrack(i, 0u, true)->SoundRef);
|
|
|
|
if (streamingSound)
|
|
{
|
|
if (i < trackIndex)
|
|
{
|
|
trackStartOffsetMs += streamingSound->Duration;
|
|
}
|
|
|
|
if (i == trackIndex)
|
|
{
|
|
thisTrackDuration = streamingSound->Duration;
|
|
}
|
|
|
|
totalStationDuration += streamingSound->Duration;
|
|
m_MixStationBeatMarkerTrackDurations.PushAndGrow(streamingSound->Duration);
|
|
}
|
|
}
|
|
|
|
char textIdObjName[16];
|
|
formatf(textIdObjName, "RTB_%08X", audRadioTrack::GetBeatSoundName(soundRef));
|
|
const RadioTrackTextIds *beatMarkers = audNorthAudioEngine::GetObject<RadioTrackTextIds>(textIdObjName);
|
|
|
|
if (beatMarkers)
|
|
{
|
|
u32 numBeatMarkers = beatMarkers->numTextIds;
|
|
|
|
// Now add all the beat markers for the current track, offset by the tracks position into the mix
|
|
for (u32 i = 0; i < numBeatMarkers; i++)
|
|
{
|
|
MixBeatMarker mixBeatMarker;
|
|
mixBeatMarker.numBeats = beatMarkers->TextId[i].TextId;
|
|
mixBeatMarker.playtimeMs = beatMarkers->TextId[i].OffsetMs + trackStartOffsetMs;
|
|
mixBeatMarker.trackIndex = trackIndex;
|
|
m_MixStationBeatMarkers.PushAndGrow(mixBeatMarker);
|
|
}
|
|
|
|
// Duplicate all the first track's beat markers at the end of the beat marker list
|
|
if (trackIndex == 0)
|
|
{
|
|
for (u32 i = 0; i < numBeatMarkers; i++)
|
|
{
|
|
MixBeatMarker mixBeatMarker;
|
|
mixBeatMarker.numBeats = beatMarkers->TextId[i].TextId;
|
|
mixBeatMarker.playtimeMs = beatMarkers->TextId[i].OffsetMs + totalStationDuration;
|
|
mixBeatMarker.trackIndex = trackIndex;
|
|
m_MixStationBeatMarkers.PushAndGrow(mixBeatMarker);
|
|
}
|
|
}
|
|
|
|
// Duplicate all the last track's beat markers at the beginning of the beat marker list
|
|
if (trackIndex == numTracks - 1)
|
|
{
|
|
for (u32 i = 0; i < numBeatMarkers; i++)
|
|
{
|
|
MixBeatMarker mixBeatMarker;
|
|
mixBeatMarker.numBeats = beatMarkers->TextId[i].TextId;
|
|
mixBeatMarker.playtimeMs = beatMarkers->TextId[i].OffsetMs - thisTrackDuration;
|
|
mixBeatMarker.trackIndex = trackIndex;
|
|
m_MixStationBeatMarkers.PushAndGrow(mixBeatMarker);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_MixStationBeatMarkers.QSort(0, m_MixStationBeatMarkers.GetCount(), QSortBeatMarkerCompareFunc);
|
|
}
|
|
|
|
#if __BANK
|
|
void audRadioStation::DebugDrawMixBeatMarkers() const
|
|
{
|
|
char tempString[256];
|
|
|
|
f32 yStepRate = 0.015f;
|
|
f32 xCoord = 0.05f;
|
|
f32 yCoord = 0.05f - g_StationDebugDrawYScroll;
|
|
f32 yCoordUnscrolled = 0.05f;
|
|
|
|
const audRadioTrack& beatTrack = GetMixStationBeatTrack();
|
|
|
|
formatf(tempString, "Currently audible track: %s (ZiT: %u)", beatTrack.GetBankName(), beatTrack.GetTextId());
|
|
grcDebugDraw::Text(Vector2(0.2f, yCoordUnscrolled), Color32(255, 255, 255), tempString);
|
|
yCoordUnscrolled += yStepRate;
|
|
|
|
formatf(tempString, "(Play time: %d/%u, %.02f%%, %d remaining)", beatTrack.GetPlayTime(), beatTrack.GetDuration(), (beatTrack.GetPlayTime() / (f32)beatTrack.GetDuration()) * 100.f, beatTrack.GetDuration() - beatTrack.GetPlayTime());
|
|
grcDebugDraw::Text(Vector2(0.2f, yCoordUnscrolled), Color32(255, 255, 255), tempString);
|
|
yCoordUnscrolled += yStepRate;
|
|
|
|
float bpm;
|
|
s32 beatNumber;
|
|
float beatTimeS;
|
|
if (beatTrack.GetNextBeat(beatTimeS, bpm, beatNumber))
|
|
{
|
|
formatf(tempString, "Audible beat: %.2f (%u/4 %.1f BPM)", beatTimeS, beatNumber, bpm);
|
|
grcDebugDraw::Text(Vector2(0.2f, yCoordUnscrolled), Color32(255, 255, 255), tempString);
|
|
}
|
|
else
|
|
{
|
|
formatf(tempString, "No audible beat found!");
|
|
grcDebugDraw::Text(Vector2(0.2f, yCoordUnscrolled), Color32(255, 255, 255), tempString);
|
|
}
|
|
|
|
yCoordUnscrolled += yStepRate;
|
|
s32 currentPlaytimeInMs = beatTrack.GetPlayTime();
|
|
|
|
for (u32 i = 0; i < beatTrack.GetTrackIndex(); i++)
|
|
{
|
|
currentPlaytimeInMs += m_MixStationBeatMarkerTrackDurations[i];
|
|
}
|
|
|
|
s32 nearestEarlierMarkerTimeMs = -INT_MAX;
|
|
s32 nearestLaterMarkerTimeMs = INT_MAX;
|
|
s32 nearestEarlierMarkerIndex = -1;
|
|
s32 nearestLaterMarkerIndex = -1;
|
|
|
|
for (u32 i = 0; i < m_MixStationBeatMarkers.GetCount(); i++)
|
|
{
|
|
if (m_MixStationBeatMarkers[i].playtimeMs >= nearestEarlierMarkerTimeMs && m_MixStationBeatMarkers[i].playtimeMs <= currentPlaytimeInMs)
|
|
{
|
|
nearestEarlierMarkerTimeMs = m_MixStationBeatMarkers[i].playtimeMs;
|
|
nearestEarlierMarkerIndex = i;
|
|
}
|
|
else if (m_MixStationBeatMarkers[i].playtimeMs > currentPlaytimeInMs && m_MixStationBeatMarkers[i].playtimeMs < nearestLaterMarkerTimeMs)
|
|
{
|
|
nearestLaterMarkerTimeMs = m_MixStationBeatMarkers[i].playtimeMs;
|
|
nearestLaterMarkerIndex = i;
|
|
}
|
|
}
|
|
|
|
formatf(tempString, "Track Relative Play Time: %d", currentPlaytimeInMs);
|
|
grcDebugDraw::Text(Vector2(0.2f, yCoordUnscrolled), Color32(255, 255, 255), tempString);
|
|
yCoordUnscrolled += yStepRate;
|
|
|
|
for (s32 i = 0; i < m_MixStationBeatMarkers.GetCount(); i++)
|
|
{
|
|
Color32 color = Color32(255, 255, 255);
|
|
|
|
if (i == nearestEarlierMarkerIndex) { color = Color32(255, 128, 255); }
|
|
else if (i == nearestLaterMarkerIndex) { color = Color32(128, 255, 255); }
|
|
|
|
formatf(tempString, "%d : %d (Track %d)", m_MixStationBeatMarkers[i].playtimeMs, m_MixStationBeatMarkers[i].numBeats, m_MixStationBeatMarkers[i].trackIndex);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), color, tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
const audRadioTrack& audRadioStation::GetMixStationBeatTrack() const
|
|
{
|
|
// Detect when we've transitioned to the next track already
|
|
if (!GetCurrentTrack().IsStreamingSoundValid() && GetNextTrack().IsStreamingSoundValid())
|
|
{
|
|
return GetNextTrack();
|
|
}
|
|
|
|
return GetCurrentTrack();
|
|
}
|
|
|
|
bool audRadioStation::GetNextMixStationBeat(f32& beatTimeS, f32& bpm, s32& beatNumber)
|
|
{
|
|
const audRadioTrack& beatTrack = GetMixStationBeatTrack();
|
|
u32 trackIndex = beatTrack.GetTrackIndex();
|
|
s32 currentPlaytimeInMs = Max(0, beatTrack.GetPlayTime());
|
|
|
|
// Convert our local play time into mix play time
|
|
if (trackIndex < m_MixStationBeatMarkerTrackDurations.GetCount())
|
|
{
|
|
for (u32 i = 0; i < trackIndex; i++)
|
|
{
|
|
currentPlaytimeInMs += m_MixStationBeatMarkerTrackDurations[i];
|
|
}
|
|
|
|
const f32 currentPlaytimeInSeconds = currentPlaytimeInMs*0.001f;
|
|
s32 nearestEarlierMarkerTimeMs = -INT_MAX;
|
|
s32 nearestLaterMarkerTimeMs = INT_MAX;
|
|
u32 numBeats = 0;
|
|
|
|
for (u32 i = 0; i < m_MixStationBeatMarkers.GetCount(); i++)
|
|
{
|
|
s32 markerPlayTimeMs = m_MixStationBeatMarkers[i].playtimeMs;
|
|
|
|
// If this is the next track in the sequence, treat it as though it started 1000ms earlier to cope with the overlap period
|
|
if (m_MixStationBeatMarkers[i].trackIndex == trackIndex + 1 % m_MixStationBeatMarkerTrackDurations.GetCount())
|
|
{
|
|
markerPlayTimeMs -= g_RadioTrackOverlapTimeMs;
|
|
}
|
|
// If this is the previous track in the sequence, treat it as though it started 1000ms later to cope with the overlap period
|
|
else if(m_MixStationBeatMarkers[i].trackIndex == (trackIndex + m_MixStationBeatMarkerTrackDurations.GetCount() - 1) % m_MixStationBeatMarkerTrackDurations.GetCount())
|
|
{
|
|
markerPlayTimeMs += g_RadioTrackOverlapTimeMs;
|
|
}
|
|
|
|
if (markerPlayTimeMs >= nearestEarlierMarkerTimeMs && markerPlayTimeMs <= currentPlaytimeInMs)
|
|
{
|
|
nearestEarlierMarkerTimeMs = markerPlayTimeMs;
|
|
numBeats = m_MixStationBeatMarkers[i].numBeats;
|
|
}
|
|
else if (markerPlayTimeMs > currentPlaytimeInMs && markerPlayTimeMs < nearestLaterMarkerTimeMs)
|
|
{
|
|
nearestLaterMarkerTimeMs = markerPlayTimeMs;
|
|
}
|
|
}
|
|
|
|
const f32 nearestBarTimeInSeconds = nearestEarlierMarkerTimeMs*0.001f;
|
|
const f32 timeSinceBar = currentPlaytimeInSeconds - nearestBarTimeInSeconds;
|
|
|
|
if (numBeats == 0)
|
|
{
|
|
bpm = 0.f;
|
|
beatNumber = 0;
|
|
beatTimeS = 0.f;
|
|
return false;
|
|
}
|
|
|
|
// markers occur n beats
|
|
const f32 beatDuration = (nearestLaterMarkerTimeMs - nearestEarlierMarkerTimeMs) / (numBeats * 1000.f);
|
|
bpm = 60.f / beatDuration;
|
|
const f32 beatsPastLastBar = timeSinceBar / beatDuration;
|
|
const f32 currentBeat = Floorf(beatsPastLastBar);
|
|
beatNumber = 1 + ((u32)currentBeat) % 4;
|
|
const f32 timeSinceLastBeat = (beatsPastLastBar - currentBeat) * beatDuration;
|
|
beatTimeS = beatDuration - timeSinceLastBeat;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void audRadioStation::InitRadioStationList(RadioStationList *radioStationList)
|
|
{
|
|
for(u32 stationIndex=0; stationIndex < radioStationList->numStations; stationIndex++)
|
|
{
|
|
RadioStationSettings *stationSettings =
|
|
audNorthAudioEngine::GetObject<RadioStationSettings>(radioStationList->Station[stationIndex].StationSettings);
|
|
|
|
if(stationSettings)
|
|
{
|
|
//Create a new radio station using these settings.
|
|
sm_OrderedRadioStations[sm_NumRadioStations] = rage_new audRadioStation(stationSettings);
|
|
sm_NumRadioStations++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::MergeRadioStationList(const RadioStationList *radioStationList)
|
|
{
|
|
bool needSort = false;
|
|
for(u32 stationIndex = 0; stationIndex < radioStationList->numStations; stationIndex++)
|
|
{
|
|
RadioStationSettings *stationSettings =
|
|
audNorthAudioEngine::GetObject<RadioStationSettings>(radioStationList->Station[stationIndex].StationSettings);
|
|
|
|
audRadioStation *station = FindStation(stationSettings->Name);
|
|
if(station)
|
|
{
|
|
//These are additional tracks for an existing station.
|
|
|
|
//Append the tracklists.
|
|
for(u32 trackListIndex = 0; trackListIndex < stationSettings->numTrackLists; trackListIndex++)
|
|
{
|
|
const RadioStationTrackList *trackList =
|
|
audNorthAudioEngine::GetObject<RadioStationTrackList>(stationSettings->TrackList[trackListIndex].TrackListRef);
|
|
|
|
if (trackList && trackList->Category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
station->AddMusicTrackList(trackList, stationSettings->TrackList[trackListIndex].TrackListRef);
|
|
}
|
|
else
|
|
{
|
|
station->AddTrackList(trackList);
|
|
}
|
|
|
|
if (trackList->Category != RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
if(sm_IsNetworkModeHistoryActive)
|
|
{
|
|
station->m_HasTakeoverContent |= (trackList->Category == RADIO_TRACK_CAT_TAKEOVER_MUSIC);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(station->m_HasTakeoverContent)
|
|
{
|
|
station->m_UseRandomizedStrideSelection = true;
|
|
}
|
|
|
|
if(station->m_UseRandomizedStrideSelection)
|
|
{
|
|
station->RandomizeCategoryStrides(true, false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//This is a new station.
|
|
|
|
//Create a new radio station using these settings.
|
|
audRadioStation *station = rage_new audRadioStation(stationSettings);
|
|
|
|
if(sm_OrderedRadioStations.GetCount() == 0)
|
|
{
|
|
sm_OrderedRadioStations.Resize(g_MaxRadioStations);
|
|
}
|
|
|
|
sm_OrderedRadioStations[sm_NumRadioStations] = station;
|
|
sm_NumRadioStations++;
|
|
|
|
if(sm_HasInitialisedStations)
|
|
{
|
|
station->Init();
|
|
needSort = true;
|
|
}
|
|
}
|
|
}
|
|
if(needSort)
|
|
{
|
|
sm_OrderedRadioStations.QSort(0, sm_NumRadioStations, QSortRadioStationCompareFunc);
|
|
}
|
|
|
|
#if HEIST3_HIDDEN_RADIO_ENABLED
|
|
sm_Heist3HiddenRadioBankId = audWaveSlot::FindBankId(HEIST3_HIDDEN_RADIO_BANK_HASH);
|
|
#endif
|
|
|
|
BANK_ONLY(audRadioAudioEntity::PopulateRetuneWidgetStationNames();)
|
|
}
|
|
|
|
void audRadioStation::RemoveRadioStationList(const RadioStationList *radioStationList)
|
|
{
|
|
for(u32 stationIndex = 0; stationIndex < radioStationList->numStations; stationIndex++)
|
|
{
|
|
const RadioStationSettings *stationSettings =
|
|
audNorthAudioEngine::GetObject<RadioStationSettings>(radioStationList->Station[stationIndex].StationSettings);
|
|
|
|
audRadioStation *station = FindStation(stationSettings->Name);
|
|
|
|
if(station)
|
|
{
|
|
audMetadataObjectInfo objectInfo;
|
|
bool isCoreStation = audNorthAudioEngine::GetMetadataManager().GetObjectInfoFromSpecificChunk(station->GetNameHash(), 0, objectInfo);
|
|
|
|
audRadioSlot *slot = audRadioSlot::FindSlotByStation(station);
|
|
if(slot)
|
|
{
|
|
audWarningf("Stopping associated slot");
|
|
slot->InvalidateStation();
|
|
}
|
|
|
|
if (isCoreStation)
|
|
{
|
|
// url:bugstar:6846455
|
|
// If the station existed in core and DLC data, we want to fall back to the core version
|
|
// of the station rather than deleting it completely (as the core data will never be re-mounted)
|
|
audWarningf("Reverting DLC station %s to core version", stationSettings->Name);
|
|
const s32 index = sm_OrderedRadioStations.Find(station);
|
|
|
|
station->Shutdown();
|
|
delete station;
|
|
|
|
if (audVerifyf(index >= 0, "Failed to find deleted station in station settings list!"))
|
|
{
|
|
RadioStationSettings* coreStationSettings = const_cast<RadioStationSettings*>(objectInfo.GetObject<RadioStationSettings>());
|
|
sm_OrderedRadioStations[index] = rage_new audRadioStation(coreStationSettings);
|
|
sm_OrderedRadioStations[index]->Init();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audWarningf("Removing DLC station %s", stationSettings->Name);
|
|
|
|
// This was a new station, so just remove it
|
|
sm_OrderedRadioStations.DeleteMatches(station);
|
|
sm_OrderedRadioStations.Resize(g_MaxRadioStations);
|
|
station->Shutdown();
|
|
delete station;
|
|
sm_NumRadioStations--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::AddMusicTrackList(const RadioStationTrackList *trackList, audMetadataRef metadataRef)
|
|
{
|
|
audDisplayf("Adding music track list %s on station %s", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset), GetName());
|
|
|
|
u32 trackListHash = audNorthAudioEngine::GetMetadataManager().GetObjectHashFromMetadataRef(metadataRef);
|
|
audAssert(trackListHash == atStringHash(audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset)));
|
|
|
|
f32 trackListProbability = 1.f;
|
|
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, trackListHash, trackListProbability))
|
|
{
|
|
audDisplayf("Custom first track probability tuneable (%.02f) found for track list %s on station %s",
|
|
trackListProbability,
|
|
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset),
|
|
GetName());
|
|
}
|
|
|
|
AddTrackList(trackList, trackListProbability);
|
|
}
|
|
|
|
void audRadioStation::AddTrackList(const RadioStationTrackList *trackList, f32 firstTrackProbability)
|
|
{
|
|
if(!audVerifyf(trackList, "NULL tracklist passed to %s", GetName()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
audDisplayf("Adding %s track list %s on station %s", TrackCats_ToString((TrackCats)trackList->Category), audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset), GetName());
|
|
|
|
switch(trackList->Category)
|
|
{
|
|
case RADIO_TRACK_CAT_DJSOLO:
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
case RADIO_TRACK_CAT_ADVERTS:
|
|
case RADIO_TRACK_CAT_TO_AD:
|
|
case RADIO_TRACK_CAT_TO_NEWS:
|
|
case RADIO_TRACK_CAT_USER_INTRO:
|
|
case RADIO_TRACK_CAT_INTRO_MORNING:
|
|
case RADIO_TRACK_CAT_INTRO_EVENING:
|
|
case RADIO_TRACK_CAT_USER_OUTRO:
|
|
case RADIO_TRACK_CAT_TAKEOVER_MUSIC:
|
|
case RADIO_TRACK_CAT_TAKEOVER_DJSOLO:
|
|
case RADIO_TRACK_CAT_TAKEOVER_IDENTS:
|
|
{
|
|
audRadioStationTrackListCollection *trackLists = const_cast<audRadioStationTrackListCollection*>(FindTrackListsForCategory(static_cast<s32>(trackList->Category)));
|
|
if(trackLists)
|
|
{
|
|
audVerifyf(trackLists->AddTrackList(trackList, firstTrackProbability), "Failed to add tracklist %s to station %s (duplicate?)",
|
|
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset),
|
|
GetName());
|
|
}
|
|
}
|
|
|
|
if(trackList->Category != RADIO_TRACK_CAT_ADVERTS)
|
|
{
|
|
m_OnlyPlayAds = false;
|
|
}
|
|
break;
|
|
|
|
// Shared track lists are handled separately
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void audRadioStation::ResetHistoryForNewGame()
|
|
{
|
|
audDebugf1("Radio: Resetting history for new game");
|
|
// Reset news state based on track lists
|
|
u32 curIndex = 0;
|
|
for(s32 listIndex = 0; listIndex < sm_NewsTrackLists.GetListCount(); listIndex++)
|
|
{
|
|
const RadioStationTrackList *trackList = sm_NewsTrackLists.GetList(listIndex);
|
|
|
|
for(u32 i = 0; i < trackList->numTracks; i++)
|
|
{
|
|
Assign(sm_NewsStoryState[i + curIndex], (AUD_GET_TRISTATE_VALUE(trackList->Flags, FLAG_ID_RADIOSTATIONTRACKLIST_LOCKED) == AUD_TRISTATE_TRUE ? RADIO_NEWS_ONCE_ONLY : RADIO_NEWS_UNLOCKED));
|
|
}
|
|
curIndex += trackList->numTracks;
|
|
}
|
|
|
|
for(s32 stationIndex = 0; stationIndex < sm_OrderedRadioStations.GetCount(); stationIndex++)
|
|
{
|
|
audRadioStation *station = GetStation(stationIndex);
|
|
if(station)
|
|
{
|
|
for(s32 category = RADIO_TRACK_CAT_ADVERTS; category < NUM_RADIO_TRACK_CATS; category++)
|
|
{
|
|
audRadioStationTrackListCollection *trackLists = const_cast<audRadioStationTrackListCollection*>(station->FindTrackListsForCategory(category));
|
|
if(trackLists)
|
|
{
|
|
trackLists->ResetLockState();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sm_PlayingEndCredits = false;
|
|
Reset();
|
|
}
|
|
|
|
void audRadioStation::ResetHistoryForNetworkGame()
|
|
{
|
|
// Only reset when transitioning into MP from SP
|
|
if(!sm_IsNetworkModeHistoryActive)
|
|
{
|
|
audDebugf1("Radio: Resetting history for network game");
|
|
sm_IsNetworkModeHistoryActive = true;
|
|
for(u32 index=0; index<sm_NumRadioStations; index++)
|
|
{
|
|
audRadioStation *station = GetStation(index);
|
|
if(station WIN32PC_ONLY(&& !station->IsUserStation()) && station->GetNameHash() != ATSTRINGHASH("RADIO_22_DLC_BATTLE_MIX1_RADIO", 0xF8BEAA16))
|
|
{
|
|
if(!station->m_PlaySequentialMusicTracks && !station->m_UseRandomizedStrideSelection)
|
|
{
|
|
station->m_MusicTrackHistory.Reset();
|
|
}
|
|
|
|
s32 activeTrackIndex = station->GetMusicTrackListActiveTrackIndex();
|
|
f32 trackOffset = station->GetCurrentPlayFractionOfActiveTrack();
|
|
|
|
// Need to shutdown active tracks to ensure we generate network compatible track IDs for history
|
|
// This also resets the FirstTrack flag ensuring we randomise the start position on the first track (important for mix stations)
|
|
station->Shutdown();
|
|
|
|
if (station->m_PlaySequentialMusicTracks)
|
|
{
|
|
bool trackListStateChanged = false;
|
|
|
|
// Probably safe to do this for all tracks, but I'm paranoid about accidentally unlocking something that was intentionally locked!
|
|
if (station->GetNameHash() == ATSTRINGHASH("RADIO_14_DANCE_02", 0xC7A2843A) || station->GetNameHash() == ATSTRINGHASH("RADIO_13_JAZZ", 0x5A254955))
|
|
{
|
|
const audRadioStationTrackListCollection* trackLists = station->FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
|
|
for (s32 trackListIndex = 0; trackListIndex < trackLists->GetListCount(); trackListIndex++)
|
|
{
|
|
if (trackLists->GetListFirstTrackProbability(trackListIndex) == -1)
|
|
{
|
|
if (!trackLists->IsListLocked(trackListIndex))
|
|
{
|
|
audDisplayf("%s is locking unlocked track list %d due to tuneable", station->GetName(), trackListIndex);
|
|
station->LockTrackList(trackLists->GetList(trackListIndex));
|
|
trackListStateChanged = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (trackLists->IsListLocked(trackListIndex))
|
|
{
|
|
audDisplayf("%s is unlocking locked track list %d due to tuneable", station->GetName(), trackListIndex);
|
|
station->UnlockTrackList(trackLists->GetList(trackListIndex));
|
|
trackListStateChanged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (trackListStateChanged)
|
|
{
|
|
audDisplayf("Track list state changed on %s, re-randomizing", station->GetName());
|
|
station->RandomizeSequentialStationPlayPosition();
|
|
}
|
|
else
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(station->FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
(*history)[0] = activeTrackIndex;
|
|
station->m_FirstTrackStartOffset = trackOffset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// GTA V nextgen B*2118827 fix
|
|
audRadioStation *radioStation = audRadioStation::FindStation(ATSTRINGHASH("RADIO_16_SILVERLAKE", 0x5E61F5CF));
|
|
if(audVerifyf(radioStation, "Invalid radio station name - RADIO_16_SILVERLAKE"))
|
|
{
|
|
if(!radioStation->UnlockTrackList("MIRRORPARK_LOCKED"))
|
|
{
|
|
audWarningf("Failed to unlock tracklist MIRRORPARK_LOCKED on RADIO_16_SILVERLAKE");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ResetHistoryForSPGame()
|
|
{
|
|
audDebugf1("Radio: Resetting history for SP game");
|
|
if(sm_IsNetworkModeHistoryActive)
|
|
{
|
|
sm_IsNetworkModeHistoryActive = false;
|
|
Reset();
|
|
}
|
|
|
|
// GTA V nextgen B*2118827 fix
|
|
audRadioStation *radioStation = audRadioStation::FindStation(ATSTRINGHASH("RADIO_16_SILVERLAKE", 0x5E61F5CF));
|
|
if(audVerifyf(radioStation, "Invalid radio station name - RADIO_16_SILVERLAKE"))
|
|
{
|
|
if(!radioStation->LockTrackList("MIRRORPARK_LOCKED"))
|
|
{
|
|
audWarningf("Failed to lock tracklist MIRRORPARK_LOCKED on RADIO_16_SILVERLAKE");
|
|
}
|
|
}
|
|
|
|
MaintainHeist4SPStationState();
|
|
|
|
for (u32 i = 0; i < sm_NumRadioStations; i++)
|
|
{
|
|
if (GetStation(i)->m_PlaySequentialMusicTracks)
|
|
{
|
|
GetStation(i)->RandomizeSequentialStationPlayPosition();
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::MaintainHeist4SPStationState()
|
|
{
|
|
audDisplayf("Maintaining WWFM/Flylo Radio state for SP");
|
|
|
|
// TEMP - Force SP stations to remain in their original configuration regardless of what the tunables say
|
|
// url:bugstar:6819975 - Block FlyLo and WWFM additional content in SP
|
|
audRadioStation* radioStation = audRadioStation::FindStation(ATSTRINGHASH("RADIO_14_DANCE_02", 0xC7A2843A));
|
|
|
|
if (radioStation)
|
|
{
|
|
radioStation->UnlockTrackList(ATSTRINGHASH("RADIO_14_DANCE_02_MUSIC", 0xA53FB7D7));
|
|
radioStation->LockTrackList(ATSTRINGHASH("FLYLO_ISLAND_UPDATE_MUSIC_MUSIC", 0x5DD0DB99));
|
|
}
|
|
|
|
radioStation = audRadioStation::FindStation(ATSTRINGHASH("RADIO_13_JAZZ", 0x5A254955));
|
|
|
|
if (radioStation)
|
|
{
|
|
radioStation->UnlockTrackList(ATSTRINGHASH("RADIO_13_JAZZ_MUSIC_EDITED", 0x3E56DC28));
|
|
radioStation->LockTrackList(ATSTRINGHASH("WWFM_ISLAND_UPDATE_MUSIC_MUSIC", 0x81757B19));
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ShutdownClass(void)
|
|
{
|
|
Reset();
|
|
sm_OrderedRadioStations.Reset();
|
|
sm_NumRadioStations = 0;
|
|
sm_NumUnlockedRadioStations = 0;
|
|
sm_NumUnlockedFavouritedStations = 0;
|
|
}
|
|
|
|
bool audRadioStation::IsRandomizedStrideCategory(const u32 category)
|
|
{
|
|
// Takeover station stores the last chosen track for each valid category into the sync packet history slot array. Because
|
|
// we have more categories than we have history slots (we also need to steal some slots for storing next takeover time, .etc),
|
|
// we need to selectively sync only those categories that we actually need, otherwise we'll run out of space
|
|
if (category == RADIO_TRACK_CAT_MUSIC ||
|
|
category == RADIO_TRACK_CAT_IDENTS ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_DJSOLO ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_IDENTS ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_MUSIC ||
|
|
category == RADIO_TRACK_CAT_DJSOLO)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
audRadioStation::audRadioStationSyncData g_TestSyncData;
|
|
|
|
void audRadioStation::SyncStation(const audRadioStationSyncData &data)
|
|
{
|
|
if(!sm_IsNetworkModeHistoryActive)
|
|
{
|
|
audDisplayf("Radio station attempting to sync, but not in network history mode. Resetting history for network game");
|
|
ResetHistoryForNetworkGame();
|
|
}
|
|
|
|
if(m_OnlyPlayAds || IsUSBMixStation() || IsLocalPlayerNewsStation() WIN32PC_ONLY(|| m_IsUserStation))
|
|
return;
|
|
|
|
if(m_IsFrozen)
|
|
{
|
|
audDisplayf("%s - skipping sync as station is currently frozen", GetName());
|
|
return;
|
|
}
|
|
|
|
if(!audVerifyf(sm_IsNetworkModeHistoryActive, "Attempting to sync radio station %s, but we're not in network radio mode! Aborting.", GetName()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
audDisplayf("Received radio station sync data for station %s (Local Player: %s, Host: %s, Synced Time: %u):", GetName(), NetworkInterface::GetLocalGamerName(), NetworkInterface::GetHostName(), NetworkInterface::GetSyncedTimeInMilliseconds());
|
|
|
|
// Play a burst of retune noise to cover the transition
|
|
if(g_RadioAudioEntity.IsPlayerRadioActive() && g_RadioAudioEntity.GetPlayerRadioStation() == this)
|
|
{
|
|
UpdateRetuneSounds();
|
|
}
|
|
|
|
m_Random.Reset(data.randomSeed);
|
|
|
|
m_IsFirstTrack = false;
|
|
|
|
s32 category;
|
|
u32 index;
|
|
|
|
if (m_UseRandomizedStrideSelection)
|
|
{
|
|
u32 historyIndex = 0;
|
|
|
|
// Current track is stored in history index 0
|
|
category = 0xFFFF & UnpackCategoryFromNetwork(data.trackHistory[historyIndex].category);
|
|
index = data.trackHistory[historyIndex++].index;
|
|
|
|
audRadioStationPackedInt packedAccumulatedPlayTime;
|
|
audRadioStationPackedInt packedLastTakeoverTime;
|
|
|
|
// History index 1-8 store some additional packed data required for takeover stations
|
|
packedAccumulatedPlayTime.PackedData.m_Byte0 = data.trackHistory[historyIndex].index;
|
|
m_MusicRunningCount = data.trackHistory[historyIndex++].category;
|
|
|
|
packedAccumulatedPlayTime.PackedData.m_Byte1 = data.trackHistory[historyIndex].index;
|
|
m_TakeoverMusicTrackCounter = data.trackHistory[historyIndex++].category;
|
|
|
|
packedAccumulatedPlayTime.PackedData.m_Byte2 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_MUSIC] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
packedAccumulatedPlayTime.PackedData.m_Byte3 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_IDENTS] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
packedLastTakeoverTime.PackedData.m_Byte0 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_DJSOLO] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
packedLastTakeoverTime.PackedData.m_Byte1 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_IDENTS] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
packedLastTakeoverTime.PackedData.m_Byte2 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_MUSIC] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
packedLastTakeoverTime.PackedData.m_Byte3 = data.trackHistory[historyIndex].index;
|
|
m_CategoryStride[RADIO_TRACK_CAT_DJSOLO] = ((s8)data.trackHistory[historyIndex++].category - 8);
|
|
|
|
m_StationAccumulatedPlayTimeMs = packedAccumulatedPlayTime.m_Value;
|
|
m_TakeoverLastTimeMs = packedLastTakeoverTime.m_Value;
|
|
|
|
audDisplayf("Accumulated Play Time: %u", m_StationAccumulatedPlayTimeMs);
|
|
audDisplayf("Last Takeover Time: %u", m_TakeoverLastTimeMs);
|
|
audDisplayf("Takeover Music Track Count: %u", m_TakeoverMusicTrackCounter);
|
|
audDisplayf("Music Run Count: %u", m_MusicRunningCount);
|
|
|
|
// The rest of the history stores our actual per-category data
|
|
for (; historyIndex < data.trackHistory.GetMaxCount(); historyIndex++)
|
|
{
|
|
const u32 unpackedCategory = 0xFFFF & UnpackCategoryFromNetwork(data.trackHistory[historyIndex].category);
|
|
|
|
if(unpackedCategory == 0xffff)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
audRadioStationHistory* history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(unpackedCategory));
|
|
|
|
if (history)
|
|
{
|
|
history->Reset();
|
|
(*history)[0] = data.trackHistory[historyIndex].index != 0xff ? data.trackHistory[historyIndex].index : ~0u;
|
|
history->SetWriteIndex(1);
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const audRadioStationTrackListCollection* trackList = unpackedCategory < NUM_RADIO_TRACK_CATS ? FindTrackListsForCategory(unpackedCategory) : NULL;
|
|
|
|
if (trackList && data.trackHistory[historyIndex].index < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(data.trackHistory[historyIndex].index)->SoundRef;
|
|
}
|
|
|
|
audDisplayf("History %d: %s (%s track %u)", historyIndex, SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), unpackedCategory >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)unpackedCategory), data.trackHistory[historyIndex].index);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Also reset history
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
if (history)
|
|
{
|
|
history->Reset();
|
|
|
|
// We only receive one history record (representing the currently playing track) for sequential music stations
|
|
for (s32 i = 0; i < (m_PlaySequentialMusicTracks ? 1 : data.trackHistory.GetMaxCount()); i++)
|
|
{
|
|
// category in low 16bits, index in high 16 bits
|
|
const u32 category = 0xFFFF & UnpackCategoryFromNetwork(data.trackHistory[i].category);
|
|
const u32 trackIndex = (data.trackHistory[i].index << 16);
|
|
(*history)[i] = (category) | trackIndex;
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const u32 unpackedCategory = UnpackCategoryFromNetwork(data.trackHistory[i].category);
|
|
const audRadioStationTrackListCollection* trackList = unpackedCategory < NUM_RADIO_TRACK_CATS ? FindTrackListsForCategory(unpackedCategory) : NULL;
|
|
|
|
if (trackList && data.trackHistory[i].index < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(data.trackHistory[i].index)->SoundRef;
|
|
}
|
|
|
|
audDisplayf("History %d: %s (%s track %u)", i, SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), unpackedCategory >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)unpackedCategory), data.trackHistory[i].index);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
history->SetWriteIndex(1);
|
|
|
|
// set up the current track
|
|
category = (*history)[0] & 0xffff;
|
|
index = (*history)[0] >> 16;
|
|
}
|
|
|
|
if (GetNameHash() == ATSTRINGHASH("RADIO_22_DLC_BATTLE_MIX1_RADIO", 0xF8BEAA16))
|
|
{
|
|
const audRadioStationTrackListCollection* trackList = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
|
|
if (trackList)
|
|
{
|
|
u32 maxTrackIndex = Max(index, (u32)data.nextTrack.index);
|
|
|
|
u32 numTracks = trackList->ComputeNumTracks();
|
|
|
|
// Its possible that we get a sync request before the tuneables are loaded to unlock the station, so we need to unlock the appropriate tracks if we currently have them locked
|
|
if (maxTrackIndex >= numTracks)
|
|
{
|
|
audDisplayf("Syncing RADIO_22_DLC_BATTLE_MIX1_RADIO, track list %u is beyond the number of available tracks (%u), unlocking BATTLE_MIX2_RADIO", maxTrackIndex, numTracks);
|
|
UnlockTrackList("BATTLE_MIX2_RADIO");
|
|
|
|
numTracks = trackList->ComputeNumTracks();
|
|
|
|
if (maxTrackIndex >= numTracks)
|
|
{
|
|
audDisplayf("Syncing RADIO_22_DLC_BATTLE_MIX1_RADIO, track list %u is beyond the number of available tracks (%u), unlocking BATTLE_MIX3_RADIO", maxTrackIndex, numTracks);
|
|
UnlockTrackList("BATTLE_MIX3_RADIO");
|
|
|
|
numTracks = trackList->ComputeNumTracks();
|
|
|
|
if (maxTrackIndex >= numTracks)
|
|
{
|
|
audDisplayf("Syncing RADIO_22_DLC_BATTLE_MIX1_RADIO, track list %u is beyond the number of available tracks (%u), unlocking BATTLE_MIX4_RADIO", maxTrackIndex, numTracks);
|
|
UnlockTrackList("BATTLE_MIX4_RADIO");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sm_HasSyncedUnlockableDJStation = true;
|
|
}
|
|
|
|
// Sequential music stations should just store track index directly
|
|
if(m_PlaySequentialMusicTracks)
|
|
{
|
|
(*(const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC))))[0] = index;
|
|
}
|
|
|
|
if(category < NUM_RADIO_TRACK_CATS)
|
|
{
|
|
const RadioStationTrackList::tTrack *trackMetadata = GetTrack(category, kNullContext, index);
|
|
if(trackMetadata)
|
|
{
|
|
s32 desiredTracKPlaytimeMS = (s32)(data.currentTrackPlaytime * m_Tracks[m_ActiveTrackIndex].GetDuration());
|
|
|
|
// If we're already playing the desired track and we're within a certain error range of the desired playback point,
|
|
// then just keep it playing rather than shutting down and restarting (as this will cause an audible drop out)
|
|
if(m_Tracks[m_ActiveTrackIndex].GetSoundRef() == trackMetadata->SoundRef && Abs(m_Tracks[m_ActiveTrackIndex].GetPlayTime() - desiredTracKPlaytimeMS) < 5000)
|
|
{
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
audDisplayf("Station %s is already synced to the active track - ignoring sync data", GetName());
|
|
}
|
|
else
|
|
{
|
|
m_ActiveTrackIndex = 0;
|
|
m_Tracks[0].Shutdown();
|
|
m_Tracks[1].Shutdown();
|
|
m_Tracks[1].Init(category, index, trackMetadata->SoundRef, data.currentTrackPlaytime, m_IsMixStation && !IsUSBMixStation(), m_IsReverbStation, m_NameHash);
|
|
audAssertf(m_Tracks[1].GetDuration() > 0, "Invalid track/sound metadata: %s (%s : %u)", GetName(), GetTrackCategoryName(category), index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audWarningf("%s - Failed to sync current network radio track %u / %u", GetName(), category, index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audWarningf("%s - Failed to sync current network radio track; invalid category %u / %u", GetName(), category, index);
|
|
}
|
|
|
|
PrepareNextTrack();
|
|
|
|
m_NetworkNextTrack = data.nextTrack;
|
|
m_NetworkNextTrack.category = static_cast<u8>(UnpackCategoryFromNetwork(data.nextTrack.category));
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const audRadioStationTrackListCollection* trackList = UnpackCategoryFromNetwork(data.nextTrack.category) < NUM_RADIO_TRACK_CATS ? FindTrackListsForCategory(m_NetworkNextTrack.category) : NULL;
|
|
|
|
if(trackList && m_NetworkNextTrack.index < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(m_NetworkNextTrack.index)->SoundRef;
|
|
}
|
|
|
|
audDisplayf("Next Track: %s (%s track %u)", SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), category >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)m_NetworkNextTrack.category), m_NetworkNextTrack.index);
|
|
#endif
|
|
|
|
audDisplayf("Random Seed: %u", data.randomSeed);
|
|
audDisplayf("Current Track Playtime: %f", data.currentTrackPlaytime);
|
|
|
|
if(m_NetworkNextTrack.category >= NUM_RADIO_TRACK_CATS)
|
|
{
|
|
// remote host hadn't picked a track when we grabbed the state
|
|
m_NetworkNextTrack.category = 0xff;
|
|
}
|
|
else if(!IsUSBMixStation())
|
|
{
|
|
ASSERT_ONLY(const RadioStationTrackList::tTrack *nextTrackPtr = GetTrack(m_NetworkNextTrack.category, kNullContext, m_NetworkNextTrack.index));
|
|
audAssertf(nextTrackPtr, "%s - Failed to find next track (%u / %s, %u)", GetName(), m_NetworkNextTrack.category, TrackCats_ToString((TrackCats)m_NetworkNextTrack.category), m_NetworkNextTrack.index);
|
|
}
|
|
|
|
// TODO: track valid selection times?
|
|
|
|
// TODO: deal with sequential music stations if we have any
|
|
}
|
|
|
|
void audRadioStation::PopulateSyncData(audRadioStationSyncData &syncData) const
|
|
{
|
|
audDisplayf("Populating radio station sync data for station %s (Local Player: %s, Host: %s, Synced Time: %u):", GetName(), NetworkInterface::GetLocalGamerName(), NetworkInterface::GetHostName(), NetworkInterface::GetSyncedTimeInMilliseconds());
|
|
|
|
syncData.nameHash = GetNameHash();
|
|
|
|
if(m_PlaySequentialMusicTracks)
|
|
{
|
|
// we want the sync history index 0 to be the currently playing track
|
|
|
|
// Sequential stations only ever use history slot 0, and it'll actually contain the index of the *next* track due
|
|
// to play at this point, which is of no use - instead, just query the track index directly from the track object itself
|
|
syncData.trackHistory[0].category = static_cast<u8>(PackCategoryForNetwork(m_Tracks[m_ActiveTrackIndex].GetCategory()));
|
|
syncData.trackHistory[0].index = static_cast<u8>(m_Tracks[m_ActiveTrackIndex].GetTrackIndex());
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const audRadioStationTrackListCollection* trackList = m_Tracks[m_ActiveTrackIndex].GetCategory() < NUM_RADIO_TRACK_CATS ? FindTrackListsForCategory(m_Tracks[m_ActiveTrackIndex].GetCategory()) : NULL;
|
|
|
|
if(trackList && m_Tracks[m_ActiveTrackIndex].GetTrackIndex() < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(m_Tracks[m_ActiveTrackIndex].GetTrackIndex())->SoundRef;
|
|
}
|
|
|
|
audDisplayf("History %d: %s (%s track %u)", 0, SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), m_Tracks[m_ActiveTrackIndex].GetCategory() >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)m_Tracks[m_ActiveTrackIndex].GetCategory()), m_Tracks[m_ActiveTrackIndex].GetTrackIndex());
|
|
#endif
|
|
|
|
// Just populate the rest of the history with 'invalid'
|
|
u32 trackId = 0xffffffff;
|
|
const u32 category = static_cast<u32>(trackId & 0xffff);
|
|
trackId = trackId >> 16;
|
|
|
|
for(s32 index = 1; index < audRadioStationHistory::kRadioHistoryLength; index++)
|
|
{
|
|
syncData.trackHistory[index].category = static_cast<u8>(PackCategoryForNetwork(category));
|
|
syncData.trackHistory[index].index = static_cast<u8>(trackId);
|
|
}
|
|
}
|
|
else if (m_UseRandomizedStrideSelection)
|
|
{
|
|
u32 historyIndex = 0;
|
|
syncData.trackHistory[historyIndex].category = static_cast<u8>(PackCategoryForNetwork(m_Tracks[m_ActiveTrackIndex].GetCategory()));
|
|
syncData.trackHistory[historyIndex++].index = static_cast<u8>(m_Tracks[m_ActiveTrackIndex].GetTrackIndex());
|
|
|
|
audRadioStationPackedInt packedAccumulatedPlayTime;
|
|
audRadioStationPackedInt packedLastTakeoverTime;
|
|
|
|
packedAccumulatedPlayTime.m_Value = m_StationAccumulatedPlayTimeMs;
|
|
packedLastTakeoverTime.m_Value = m_TakeoverLastTimeMs;
|
|
|
|
// Takeover station requires syncing some extra data, but we don't need to sync every category so we can re-purpose some history slots
|
|
// We've got 8 bits per index, so pack our u32s across a set of history slots
|
|
// We've got 4 bits per category, so store our u8s in these
|
|
syncData.trackHistory[historyIndex].index = packedAccumulatedPlayTime.PackedData.m_Byte0;
|
|
Assign(syncData.trackHistory[historyIndex++].category, m_MusicRunningCount);
|
|
|
|
syncData.trackHistory[historyIndex].index = packedAccumulatedPlayTime.PackedData.m_Byte1;
|
|
syncData.trackHistory[historyIndex++].category = m_TakeoverMusicTrackCounter;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedAccumulatedPlayTime.PackedData.m_Byte2;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_MUSIC] + 8;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedAccumulatedPlayTime.PackedData.m_Byte3;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_IDENTS] + 8;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedLastTakeoverTime.PackedData.m_Byte0;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_DJSOLO] + 8;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedLastTakeoverTime.PackedData.m_Byte1;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_IDENTS] + 8;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedLastTakeoverTime.PackedData.m_Byte2;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_TAKEOVER_MUSIC] + 8;
|
|
|
|
syncData.trackHistory[historyIndex].index = packedLastTakeoverTime.PackedData.m_Byte3;
|
|
syncData.trackHistory[historyIndex++].category = (u8)m_CategoryStride[RADIO_TRACK_CAT_DJSOLO] + 8;
|
|
|
|
audDisplayf("Accumulated Play Time: %u", m_StationAccumulatedPlayTimeMs);
|
|
audDisplayf("Last Takeover Time Time: %u", m_TakeoverLastTimeMs);
|
|
audDisplayf("Takeover Music Track Count: %u", m_TakeoverMusicTrackCounter);
|
|
audDisplayf("Music Run Count: %u", m_MusicRunningCount);
|
|
|
|
for (u32 category = 0; category < TRACKCATS_MAX; category++)
|
|
{
|
|
if (IsRandomizedStrideCategory(category))
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(category));
|
|
syncData.trackHistory[historyIndex].category = static_cast<u8>(PackCategoryForNetwork(category));
|
|
syncData.trackHistory[historyIndex].index = static_cast<u8>(history ? history->GetPreviousEntry() : 0xff);
|
|
historyIndex++;
|
|
}
|
|
}
|
|
|
|
// Just populate the rest of the history with 'invalid'
|
|
u32 trackId = 0xffffffff;
|
|
const u32 category = static_cast<u32>(trackId & 0xffff);
|
|
trackId = trackId >> 16;
|
|
|
|
for (; historyIndex < audRadioStationHistory::kRadioHistoryLength; historyIndex++)
|
|
{
|
|
syncData.trackHistory[historyIndex].category = static_cast<u8>(PackCategoryForNetwork(category));
|
|
syncData.trackHistory[historyIndex].index = static_cast<u8>(trackId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
if(history)
|
|
{
|
|
for(s32 index = 0; index < audRadioStationHistory::kRadioHistoryLength; index++)
|
|
{
|
|
// we want the sync history index 0 to be the currently playing track, ie the previous write index
|
|
const u32 i = (index + history->GetWriteIndex() + audRadioStationHistory::kRadioHistoryLength - 1) % audRadioStationHistory::kRadioHistoryLength;
|
|
u32 trackId = (*history)[i];
|
|
|
|
const u32 category = static_cast<u32>(trackId & 0xffff);
|
|
trackId = trackId >> 16;
|
|
|
|
syncData.trackHistory[index].category = static_cast<u8>(PackCategoryForNetwork(category));
|
|
syncData.trackHistory[index].index = static_cast<u8>(trackId);
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const audRadioStationTrackListCollection* trackList = category < NUM_RADIO_TRACK_CATS? FindTrackListsForCategory(category) : NULL;
|
|
|
|
if(trackList && trackId < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(trackId)->SoundRef;
|
|
}
|
|
|
|
audDisplayf("History %d: %s (%s track %u)", index, SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), category >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)category), trackId);
|
|
#endif
|
|
|
|
// we will generate sync asserts if category or index are invalid
|
|
// if these errors are generated, we may need to increase the number of bits
|
|
if(static_cast<unsigned>(syncData.trackHistory[index].category) > audRadioStationSyncData::TrackId::CATEGORY_MASK)
|
|
{
|
|
audErrorf("%d has invalid category value of %u. Clamping to %u", index, syncData.trackHistory[index].category, audRadioStationSyncData::TrackId::CATEGORY_MASK);
|
|
syncData.trackHistory[index].category = audRadioStationSyncData::TrackId::CATEGORY_MASK;
|
|
}
|
|
|
|
if(static_cast<unsigned>(syncData.trackHistory[index].index) > audRadioStationSyncData::TrackId::INDEX_MASK)
|
|
{
|
|
audErrorf("%d has invalid index value of %u. Clamping to %u", index, syncData.trackHistory[index].index, audRadioStationSyncData::TrackId::INDEX_MASK);
|
|
syncData.trackHistory[index].index = audRadioStationSyncData::TrackId::INDEX_MASK;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audDisplayf("No history");
|
|
}
|
|
}
|
|
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex+1)&1;
|
|
|
|
syncData.nextTrack.category = static_cast<u8>(PackCategoryForNetwork(m_Tracks[nextTrackIndex].GetCategory()));
|
|
syncData.nextTrack.index = static_cast<u8>(m_Tracks[nextTrackIndex].GetTrackIndex());
|
|
|
|
#if __BANK
|
|
u32 soundHash = g_NullSoundHash;
|
|
const audRadioStationTrackListCollection* trackList = m_Tracks[nextTrackIndex].GetCategory() < NUM_RADIO_TRACK_CATS ? FindTrackListsForCategory(m_Tracks[nextTrackIndex].GetCategory()) : NULL;
|
|
|
|
if(trackList && m_Tracks[nextTrackIndex].GetTrackIndex() < trackList->ComputeNumTracks())
|
|
{
|
|
soundHash = trackList->GetTrack(m_Tracks[nextTrackIndex].GetTrackIndex())->SoundRef;
|
|
}
|
|
|
|
audDisplayf("Next Track: %s (%s track %u)", SOUNDFACTORY.GetMetadataManager().GetObjectName(soundHash), m_Tracks[nextTrackIndex].GetCategory() >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)m_Tracks[nextTrackIndex].GetCategory()), m_Tracks[nextTrackIndex].GetTrackIndex());
|
|
#endif
|
|
|
|
syncData.randomSeed = m_Random.GetSeed();
|
|
|
|
audDisplayf("Random Seed: %u", syncData.randomSeed);
|
|
|
|
const u32 trackDuration = m_Tracks[m_ActiveTrackIndex].GetDuration();
|
|
syncData.currentTrackPlaytime = trackDuration > 0 ? Clamp(m_Tracks[m_ActiveTrackIndex].GetPlayTime() / (float)(trackDuration), 0.f, 1.f) : 0.f;
|
|
|
|
audDisplayf("Current Track Playtime: %f", syncData.currentTrackPlaytime);
|
|
}
|
|
|
|
void audRadioStation::Reset(void)
|
|
{
|
|
StopRetuneSounds();
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
sm_DjSpeechMonoSound = NULL;
|
|
}
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
sm_DjSpeechPositionedSound = NULL;
|
|
}
|
|
|
|
for(u32 i = 0; i < sm_NumRadioStations; i++)
|
|
{
|
|
GetStation(i)->Shutdown();
|
|
}
|
|
}
|
|
|
|
audRadioStation *audRadioStation::FindStation(const char *name)
|
|
{
|
|
return FindStation(atStringHash(name));
|
|
}
|
|
|
|
audRadioStation *audRadioStation::FindStation(u32 nameHash)
|
|
{
|
|
s32 stationIndex = FindIndexOfStationWithHash(nameHash);
|
|
if (stationIndex >= 0)
|
|
{
|
|
return sm_OrderedRadioStations[stationIndex];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
u32 audRadioStation::GetStationIndex() const
|
|
{
|
|
for(s32 stationIndex=0; stationIndex<sm_NumRadioStations; stationIndex++)
|
|
{
|
|
if(sm_OrderedRadioStations[stationIndex] == this)
|
|
{
|
|
return stationIndex;
|
|
}
|
|
}
|
|
return g_OffRadioStation;
|
|
}
|
|
|
|
s32 audRadioStation::GetStationImmutableIndex(audRadioStationImmutableIndexType indexType) const
|
|
{
|
|
return m_StationImmutableIndex[indexType];
|
|
}
|
|
|
|
s32 audRadioStation::FindIndexOfStationWithHash(u32 nameHash)
|
|
{
|
|
for(s32 stationIndex=0; stationIndex<sm_NumRadioStations; stationIndex++)
|
|
{
|
|
if(sm_OrderedRadioStations[stationIndex] && (sm_OrderedRadioStations[stationIndex]->GetNameHash() == nameHash))
|
|
{
|
|
return stationIndex;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
audRadioStation *audRadioStation::GetStation(u32 index)
|
|
{
|
|
return ((index < sm_NumRadioStations) ? sm_OrderedRadioStations[index] : NULL);
|
|
}
|
|
|
|
audRadioStation *audRadioStation::FindStationWithImmutableIndex(u32 index, audRadioStationImmutableIndexType indexType)
|
|
{
|
|
for(u32 stationIndex = 0; stationIndex < sm_NumRadioStations; stationIndex++)
|
|
{
|
|
audRadioStation* radioStation = sm_OrderedRadioStations[stationIndex];
|
|
|
|
if(radioStation && radioStation->m_StationImmutableIndex[indexType] == (s32)index)
|
|
{
|
|
return radioStation;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void audRadioStation::StartEndCredits()
|
|
{
|
|
sm_PlayingEndCredits = true;
|
|
}
|
|
|
|
void audRadioStation::StopEndCredits()
|
|
{
|
|
sm_PlayingEndCredits = false;
|
|
}
|
|
|
|
void audRadioStation::SetHidden(bool isHidden)
|
|
{
|
|
AUD_CLEAR_TRISTATE_VALUE(const_cast<RadioStationSettings*>(m_StationSettings)->Flags, FLAG_ID_RADIOSTATIONSETTINGS_HIDDEN);
|
|
AUD_SET_TRISTATE_VALUE(const_cast<RadioStationSettings*>(m_StationSettings)->Flags, FLAG_ID_RADIOSTATIONSETTINGS_HIDDEN, isHidden ? AUD_TRISTATE_TRUE : AUD_TRISTATE_FALSE);
|
|
}
|
|
|
|
bool audRadioStation::IsFavourited() const
|
|
{
|
|
return m_IsFavourited || !CNetwork::IsGameInProgress();
|
|
}
|
|
|
|
void audRadioStation::SetLocked(const bool isLocked)
|
|
{
|
|
if(!isLocked && AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED) == AUD_TRISTATE_TRUE)
|
|
{
|
|
audDisplayf("Unlocking radio station %s", GetName());
|
|
const_cast<RadioStationSettings*>(m_StationSettings)->Flags &= ~(0x03 << (FLAG_ID_RADIOSTATIONSETTINGS_LOCKED * 2));
|
|
AUD_SET_TRISTATE_VALUE(const_cast<RadioStationSettings*>(m_StationSettings)->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED, AUD_TRISTATE_FALSE);
|
|
|
|
FlagLockedStationChange();
|
|
}
|
|
else if(isLocked && AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED) != AUD_TRISTATE_TRUE)
|
|
{
|
|
audDisplayf("Locking radio station %s", GetName());
|
|
const_cast<RadioStationSettings*>(m_StationSettings)->Flags &= ~(0x03 << (FLAG_ID_RADIOSTATIONSETTINGS_LOCKED * 2));
|
|
AUD_SET_TRISTATE_VALUE(const_cast<RadioStationSettings*>(m_StationSettings)->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED, AUD_TRISTATE_TRUE);
|
|
|
|
FlagLockedStationChange();
|
|
}
|
|
}
|
|
|
|
void audRadioStation::SetFavourited(bool isFavourited)
|
|
{
|
|
if(isFavourited != m_IsFavourited)
|
|
{
|
|
// Any station that is able to be be set as a favorite station should be entered into the FIXED_ORDER_RADIO_STATION_HASH_LIST_TUNEABLE
|
|
// list, which is used as the index of a bitset by telemetry code to track favorite-ed stations. NB. if adding a station to the above
|
|
// list, it must be done at the end to ensure existing station indices are not altered.
|
|
audAssertf(!audNorthAudioEngine::GetObject<GameObjectHashList>(ATSTRINGHASH("FIXED_ORDER_RADIO_STATION_HASH_LIST_TUNEABLE", 0x616CE649)) || GetStationImmutableIndex(IMMUTABLE_INDEX_TUNEABLE) >= 0, "Non-tuneable station %s has no immutable index set up", GetName());
|
|
m_IsFavourited = isFavourited;
|
|
FlagLockedStationChange();
|
|
}
|
|
}
|
|
|
|
void audRadioStation::GetFavouritedStations(u32 &favourites1, u32 &favourites2)
|
|
{
|
|
favourites1 = 0;
|
|
favourites2 = 0;
|
|
for(u32 stationIndex = 0; stationIndex < sm_NumRadioStations; stationIndex++)
|
|
{
|
|
audRadioStation* radioStation = sm_OrderedRadioStations[stationIndex];
|
|
if(radioStation && radioStation->m_IsFavourited)
|
|
{
|
|
s32 immutableIndex = radioStation->m_StationImmutableIndex[IMMUTABLE_INDEX_TUNEABLE];
|
|
if(immutableIndex < 0) continue;
|
|
|
|
if(audVerifyf(immutableIndex < 64, "IMMUTABLE_INDEX_TUNEABLE index exceeds bitset size"))
|
|
{
|
|
if(immutableIndex < 32)
|
|
{
|
|
favourites1 |= (u32)(1u << immutableIndex);
|
|
}
|
|
else
|
|
{
|
|
favourites2 |= (u32)(1u << (immutableIndex - 32));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::GameUpdate()
|
|
{
|
|
const Vec3V s_CountryTalkRadioEmitter(752.0f, 4900.f, 0.f);
|
|
const float s_CountryTalkRadioRadius = 4000.f;
|
|
const float s_CountryTalkRadioHysterisis = 65.f;
|
|
audRadioStation *talkStation1 = FindStation(ATSTRINGHASH("RADIO_05_TALK_01", 0x406F56EC));
|
|
audRadioStation *talkStation2 = FindStation(ATSTRINGHASH("RADIO_11_TALK_02", 0xE6598737));
|
|
bool isSpectating = false;
|
|
|
|
if(talkStation1 && talkStation2)
|
|
{
|
|
CPed *player = CGameWorld::FindLocalPlayer();
|
|
|
|
if (NetworkInterface::IsGameInProgress() && NetworkInterface::IsLocalPlayerOnSCTVTeam())
|
|
{
|
|
CPed* followplayer = CGameWorld::FindFollowPlayer();
|
|
if (followplayer)
|
|
{
|
|
player = followplayer;
|
|
isSpectating = true;
|
|
}
|
|
}
|
|
|
|
if(player)
|
|
{
|
|
const Vec3V playerPosition = player->GetTransform().GetPosition();
|
|
const float distToEmitter = Dist(playerPosition, s_CountryTalkRadioEmitter).Getf();
|
|
if(distToEmitter < s_CountryTalkRadioRadius)
|
|
{
|
|
if(distToEmitter < s_CountryTalkRadioRadius - s_CountryTalkRadioHysterisis)
|
|
{
|
|
if(talkStation2->IsLocked())
|
|
{
|
|
talkStation2->SetLocked(false);
|
|
audDisplayf("Unlocking %s due to player position (Player:%.02f, %.02f, %.02f) - distance %.02f. Spectating: %s", talkStation2->GetName(), playerPosition.GetXf(), playerPosition.GetYf(), playerPosition.GetZf(), distToEmitter, isSpectating? "true" : "false");
|
|
}
|
|
if(!talkStation1->IsLocked())
|
|
{
|
|
talkStation1->SetLocked(true);
|
|
audDisplayf("Locking %s due to player position (Player:%.02f, %.02f, %.02f) - distance %.02f. Spectating: %s", talkStation1->GetName(), playerPosition.GetXf(), playerPosition.GetYf(), playerPosition.GetZf(), distToEmitter, isSpectating? "true" : "false");
|
|
}
|
|
sm_CountryTalkRadioSignal = 1.f;
|
|
}
|
|
else
|
|
{
|
|
sm_CountryTalkRadioSignal = (s_CountryTalkRadioRadius - distToEmitter) / s_CountryTalkRadioHysterisis;
|
|
}
|
|
}
|
|
else if(distToEmitter > s_CountryTalkRadioRadius)
|
|
{
|
|
if(!talkStation2->IsLocked())
|
|
{
|
|
talkStation2->SetLocked(true);
|
|
audDisplayf("Locking %s due to player position (Player:%.02f, %.02f, %.02f) - distance %.02f. Spectating: %s", talkStation2->GetName(), playerPosition.GetXf(), playerPosition.GetYf(), playerPosition.GetZf(), distToEmitter, isSpectating? "true" : "false");
|
|
sm_CountryTalkRadioSignal = 0.f;
|
|
}
|
|
if(talkStation1->IsLocked())
|
|
{
|
|
talkStation1->SetLocked(false);
|
|
audDisplayf("Unlocking %s due to player position (Player:%.02f, %.02f, %.02f) - distance %.02f. Spectating: %s", talkStation1->GetName(), playerPosition.GetXf(), playerPosition.GetYf(), playerPosition.GetZf(), distToEmitter, isSpectating? "true" : "false");
|
|
}
|
|
}
|
|
}
|
|
|
|
f32 signalLevel = 1.f;
|
|
|
|
if(!g_AudioEngine.GetSoundManager().IsPaused(2) && !g_RadioAudioEntity.IsRetuningVehicleRadio() && !g_RadioAudioEntity.IsRadioFadedOut() && g_RadioAudioEntity.IsPlayerRadioActive())
|
|
{
|
|
if(g_RadioAudioEntity.GetPlayerRadioStationPendingRetune() == talkStation2)
|
|
{
|
|
signalLevel = sm_CountryTalkRadioSignal;
|
|
}
|
|
else if(g_RadioAudioEntity.GetPlayerRadioStationPendingRetune() == talkStation1)
|
|
{
|
|
signalLevel = 1.f - sm_CountryTalkRadioSignal;
|
|
}
|
|
|
|
signalLevel = Min(signalLevel, sm_ScriptGlobalRadioSignalLevel);
|
|
}
|
|
|
|
g_AudioEngine.GetEnvironment().GetMusicSubmix()->SetEffectParam(0, ATSTRINGHASH("signalLevel", 0xFAF72E9), signalLevel);
|
|
g_AudioEngine.GetEnvironment().GetMusicSubmix()->SetEffectParam(0, ATSTRINGHASH("Bypass", 0x10F3D95C), signalLevel < 1.f? false : true);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::UpdateStations(u32 timeInMs)
|
|
{
|
|
#if RSG_PC
|
|
#if __BANK
|
|
if(g_RadioAudioEntity.sm_DebugUserMusic)
|
|
DebugDrawUserMusic();
|
|
#endif
|
|
audRadioStation *userStation = FindStation(ATSTRINGHASH("RADIO_19_USER", 0xF74D5272));
|
|
if(userStation)
|
|
{
|
|
userStation->SetLocked(!HasUserTracks() || PARAM_disableuserradio.Get());
|
|
}
|
|
sm_UserRadioTrackManager.UpdateScanningUI();
|
|
#endif // _WIN32PC
|
|
|
|
u32 numUnlocked = 0;
|
|
u32 numUnlockedFavourited = 0;
|
|
|
|
for(u32 index=0; index<sm_NumRadioStations; index++)
|
|
{
|
|
audRadioStation *station = GetStation(index);
|
|
if(station)
|
|
{
|
|
station->Update(timeInMs);
|
|
if(!station->IsLocked() && !station->IsHidden())
|
|
{
|
|
numUnlocked++;
|
|
|
|
if(station->IsFavourited())
|
|
{
|
|
numUnlockedFavourited++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UpdateDjSpeech(timeInMs);
|
|
|
|
if(numUnlocked != sm_NumUnlockedRadioStations || numUnlockedFavourited != sm_NumUnlockedFavouritedStations || sm_UpdateLockedStations)
|
|
{
|
|
// Re-sort the list to ensure unlocked stations are first in the list.
|
|
audDisplayf("Number of unlocked radio stations changed; was %u (%u favourited) now %u (%u favourited)", sm_NumUnlockedRadioStations, sm_NumUnlockedFavouritedStations, numUnlocked, numUnlockedFavourited);
|
|
|
|
sm_OrderedRadioStations.QSort(0, sm_NumRadioStations, QSortRadioStationCompareFunc);
|
|
sm_NumUnlockedRadioStations = numUnlocked;
|
|
sm_NumUnlockedFavouritedStations = numUnlockedFavourited;
|
|
sm_UpdateLockedStations = false;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::UpdateRetuneSounds(void)
|
|
{
|
|
#if GTA_REPLAY
|
|
if(CReplayMgr::IsEditModeActive())
|
|
{
|
|
StopRetuneSounds();
|
|
return;
|
|
}
|
|
#endif //GTA_REPLAY
|
|
|
|
//Ensure the retune sounds are active.
|
|
audSoundInitParams initParams;
|
|
initParams.TimerId = 2;
|
|
if(sm_RetuneMonoSound == NULL)
|
|
{
|
|
g_RadioAudioEntity.CreateAndPlaySound_Persistent(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("RetuneFrontend", 0xC46D20A)),
|
|
&sm_RetuneMonoSound, &initParams);
|
|
}
|
|
if(sm_RetunePositionedSound == NULL)
|
|
{
|
|
g_RadioAudioEntity.CreateAndPlaySound_Persistent(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("RetunePositioned", 0x1B5588EC)),
|
|
&sm_RetunePositionedSound, &initParams);
|
|
}
|
|
|
|
f32 playerVehicleInsideFactor = g_RadioAudioEntity.GetPlayerVehicleInsideFactor();
|
|
|
|
if(sm_RetuneMonoSound)
|
|
{
|
|
f32 volumeDbMono = 0.f;
|
|
// use full volume retune loop when in frontend/lobby radio
|
|
if(!g_RadioAudioEntity.IsMobilePhoneRadioActive())
|
|
{
|
|
f32 volumeLinearMono = Max<f32>(sm_VehicleRadioRiseVolumeCurve.CalculateValue(playerVehicleInsideFactor),
|
|
g_SilenceVolumeLin);
|
|
volumeDbMono = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinearMono);
|
|
volumeDbMono += g_RadioAudioEntity.GetVolumeOffset();
|
|
}
|
|
sm_RetuneMonoSound->SetRequestedVolume(volumeDbMono);
|
|
}
|
|
|
|
if(sm_RetunePositionedSound)
|
|
{
|
|
f32 volumeLinearPos = Max<f32>(sm_VehicleRadioRiseVolumeCurve.CalculateValue(1.0f - playerVehicleInsideFactor),
|
|
g_SilenceVolumeLin);
|
|
f32 volumeDbPos = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinearPos);
|
|
volumeDbPos += g_RadioAudioEntity.GetVolumeOffset();
|
|
sm_RetunePositionedSound->SetRequestedVolume(volumeDbPos);
|
|
|
|
CVehicle *lastPlayerVehicle = g_RadioAudioEntity.GetLastPlayerVehicle();
|
|
if(lastPlayerVehicle != NULL)
|
|
{
|
|
//Attach positioned retune sound to the current or last player vehicle.
|
|
Vector3 vehiclePosition = VEC3V_TO_VECTOR3(lastPlayerVehicle->GetTransform().GetPosition());
|
|
sm_RetunePositionedSound->SetRequestedPosition(vehiclePosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::StopRetuneSounds(void)
|
|
{
|
|
if(sm_RetuneMonoSound)
|
|
{
|
|
sm_RetuneMonoSound->StopAndForget();
|
|
sm_RetuneMonoSound = NULL;
|
|
}
|
|
if(sm_RetunePositionedSound)
|
|
{
|
|
sm_RetunePositionedSound->StopAndForget();
|
|
sm_RetunePositionedSound = NULL;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::SkipForwardStations(u32 timeToSkipMs)
|
|
{
|
|
for(u32 index=0; index<sm_NumRadioStations; index++)
|
|
{
|
|
audRadioStation *station = GetStation(index);
|
|
if(station && station->IsStreamingVirtually())
|
|
{
|
|
station->SkipForward(timeToSkipMs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::SkipForward(u32 timeToSkip)
|
|
{
|
|
if(IsFrozen())
|
|
{
|
|
audWarningf("%s ignoring skip request (%ums) due to being frozen", GetName(), timeToSkip);
|
|
}
|
|
else
|
|
{
|
|
audDisplayf("Radio station %s is skipping forward by %ums (current track: %u)", GetName(), timeToSkip, m_Tracks[m_ActiveTrackIndex].GetSoundRef());
|
|
|
|
u32 timeLeft = m_Tracks[m_ActiveTrackIndex].GetDuration() - (u32)m_Tracks[m_ActiveTrackIndex].GetPlayTime();
|
|
if(timeToSkip > timeLeft && !PARAM_disableradiohistory.Get())
|
|
{
|
|
// skip a random amount into the next track too
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
if(m_Tracks[nextTrackIndex].IsInitialised())
|
|
{
|
|
u32 nextDuration = m_Tracks[nextTrackIndex].GetDuration();
|
|
u32 min = Min(10000U, nextDuration);
|
|
u32 max = Min(nextDuration, nextDuration - 20000U);
|
|
m_Tracks[nextTrackIndex].SkipForward((u32)GetRandomNumberInRange((s32)min, (s32)max));
|
|
}
|
|
}
|
|
m_Tracks[m_ActiveTrackIndex].SkipForward(timeToSkip);
|
|
}
|
|
}
|
|
|
|
#if RSG_PC // user music
|
|
void audRadioStation::NextTrack()
|
|
{
|
|
if(m_IsUserStation && !sm_IsInRecoveryMode && sm_UserRadioTrackManager.GetRadioMode() != USERRADIO_PLAY_MODE_RADIO)
|
|
{
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised() && m_Tracks[m_ActiveTrackIndex].GetPlayTime() > 2000)
|
|
{
|
|
sm_ForceUserNextTrack = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::PrevTrack()
|
|
{
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised() && m_Tracks[m_ActiveTrackIndex].GetPlayTime() > 2000 && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_SEQUENTIAL)
|
|
{
|
|
sm_ForceUserPrevTrack = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
void audRadioStation::UpdateDjSpeech(u32 timeInMs)
|
|
{
|
|
const audRadioStation *playerStation = g_RadioAudioEntity.GetPlayerRadioStation();
|
|
if(sm_IMDrivenDjSpeech)
|
|
{
|
|
playerStation = sm_IMDjSpeechStation;
|
|
}
|
|
|
|
if(playerStation && (sm_IMDrivenDjSpeech || (playerStation->IsStreamingPhysically() && !g_RadioAudioEntity.IsRetuning() && !IsPlayingEndCredits() REPLAY_ONLY(&& !CReplayMgr::IsEditModeActive()))))
|
|
{
|
|
//Update DJ speech for the player's radio station.
|
|
s32 trackPlayTimeMs = sm_IMDrivenDjSpeech ? g_InteractiveMusicManager.GetCurPlayTimeMs() :
|
|
playerStation->GetCurrentPlayTimeOfActiveTrack();
|
|
|
|
bool isPlayingSpeech = false;
|
|
bool isDummySpeech = false;
|
|
|
|
u32 clientVar = 0;
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->GetClientVariable(clientVar);
|
|
isDummySpeech |= (clientVar == 0xdeadbeef);
|
|
}
|
|
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->GetClientVariable(clientVar);
|
|
isDummySpeech |= (clientVar == 0xdeadbeef);
|
|
}
|
|
|
|
f32 playerVehicleInsideFactor;
|
|
switch(sm_DjSpeechState)
|
|
{
|
|
case RADIO_DJ_SPEECH_STATE_PREPARING:
|
|
if(sm_DjSpeechMonoSound && (sm_IMDrivenDjSpeech || trackPlayTimeMs <= (sm_ActiveDjSpeechStartTimeMs + g_RadioDjPlayTimeTresholdMs)))
|
|
{
|
|
bool isPrepared = false;
|
|
switch(sm_DjSpeechMonoSound->Prepare(g_RadioDjSpeechWaveSlot, true))
|
|
{
|
|
case AUD_PREPARE_FAILED:
|
|
Warningf("Failed to prepare DJ speech for station %s", playerStation->GetName());
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
break;
|
|
|
|
case AUD_PREPARED:
|
|
isPrepared = true;
|
|
break;
|
|
|
|
case AUD_PREPARING:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(isPrepared)
|
|
{
|
|
//Ensure that the positioned speech sound (with the same wave reference) is also prepared.
|
|
switch(sm_DjSpeechPositionedSound->Prepare(g_RadioDjSpeechWaveSlot, true))
|
|
{
|
|
case AUD_PREPARE_FAILED:
|
|
naWarningf("Failed to prepare DJ speech for station %s", playerStation->GetName());
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
break;
|
|
|
|
case AUD_PREPARED:
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_PREPARED;
|
|
break;
|
|
|
|
case AUD_PREPARING:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//We are out of time to prepare and play our DJ speech, so stop trying and cleanup.
|
|
naDisplayf("Failed to prepare Dj speech in time");
|
|
if(sm_DjSpeechMonoSound)
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
if(sm_DjSpeechPositionedSound)
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
}
|
|
|
|
break;
|
|
|
|
case RADIO_DJ_SPEECH_STATE_PREPARED:
|
|
if(!sm_IMDrivenDjSpeech || sm_IMDrivenDjSpeechScheduled)
|
|
{
|
|
if(trackPlayTimeMs >= (sm_ActiveDjSpeechStartTimeMs - g_RadioDjPlayTimeTresholdMs))
|
|
{
|
|
bool isDJSpeechRetriggerTimeValid = true;
|
|
|
|
if(playerStation->GetNameHash() == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) && !isDummySpeech)
|
|
{
|
|
if(g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2) - playerStation->m_LastTimeDJSpeechPlaying < g_RadioDjSpeechMinDelayMsMotomami)
|
|
{
|
|
isDJSpeechRetriggerTimeValid = false;
|
|
}
|
|
}
|
|
|
|
const u32 nextTrackCategory = playerStation->GetNextTrack().GetCategory();
|
|
const u32 currentTrackCategory = playerStation->GetCurrentTrack().GetCategory();
|
|
if(isDJSpeechRetriggerTimeValid && trackPlayTimeMs <= (sm_ActiveDjSpeechStartTimeMs + g_RadioDjPlayTimeTresholdMs) && (sm_IMDrivenDjSpeech || (sm_DjSpeechStation == playerStation && sm_DjSpeechNextTrackCategory == nextTrackCategory && (currentTrackCategory == RADIO_TRACK_CAT_MUSIC || currentTrackCategory == RADIO_TRACK_CAT_TAKEOVER_MUSIC))))
|
|
{
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->Play();
|
|
}
|
|
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->Play();
|
|
}
|
|
|
|
const_cast<audRadioStation*>(playerStation)->AddActiveDjSpeechToHistory(timeInMs);
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_PLAYING;
|
|
sm_DjSpeechStation = NULL;
|
|
}
|
|
else
|
|
{
|
|
//We are out of time to play our DJ speech, so cleanup.
|
|
if(!sm_IMDrivenDjSpeech && sm_DjSpeechStation != playerStation)
|
|
{
|
|
audWarningf("Cancelled DJ speech due to station change; scheduled on %s now %s", sm_DjSpeechStation ? sm_DjSpeechStation->GetName() : "null", playerStation ? playerStation->GetName() : "null");
|
|
}
|
|
else if(!sm_IMDrivenDjSpeech && sm_DjSpeechNextTrackCategory != nextTrackCategory)
|
|
{
|
|
audWarningf("Cancelled DJ speech due to next track category change; scheduled for %s now %s", TrackCats_ToString((TrackCats)sm_DjSpeechNextTrackCategory), TrackCats_ToString((TrackCats)nextTrackCategory));
|
|
}
|
|
else if(!isDJSpeechRetriggerTimeValid)
|
|
{
|
|
audWarningf("Cancelled DJ speech due to triggering within min retrigger time");
|
|
}
|
|
else
|
|
{
|
|
audWarningf("Failed to play Dj speech in time");
|
|
}
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// intentional fall through if the speech is now playing so it doesn't go a frame without valid volume/filter
|
|
|
|
case RADIO_DJ_SPEECH_STATE_PLAYING:
|
|
//Update volumes (and position) of DJ speech sounds.
|
|
playerVehicleInsideFactor = g_RadioAudioEntity.GetPlayerVehicleInsideFactor();
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
isPlayingSpeech = true;
|
|
sm_DjSpeechMonoSound->SetRequestedVolume(sm_DjSpeechFrontendVolume);
|
|
sm_DjSpeechMonoSound->SetRequestedLPFCutoff(sm_DjSpeechFrontendLPF);
|
|
}
|
|
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
isPlayingSpeech = true;
|
|
f32 volumeLinearPos = Max<f32>(sm_VehicleRadioRiseVolumeCurve.CalculateValue(1.0f - playerVehicleInsideFactor),
|
|
g_SilenceVolumeLin);
|
|
f32 volumeDbPos = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinearPos);
|
|
volumeDbPos += g_RadioAudioEntity.GetVolumeOffset();
|
|
|
|
CVehicle *lastPlayerVehicle = g_RadioAudioEntity.GetLastPlayerVehicle();
|
|
if(lastPlayerVehicle != NULL)
|
|
{
|
|
//Attach positioned retune sound to the current or last player vehicle.
|
|
Vector3 vehiclePosition = VEC3V_TO_VECTOR3(lastPlayerVehicle->GetTransform().GetPosition());
|
|
sm_DjSpeechPositionedSound->SetRequestedPosition(vehiclePosition);
|
|
volumeDbPos += lastPlayerVehicle->GetVehicleAudioEntity()->GetAmbientRadioVolume();
|
|
}
|
|
else
|
|
{
|
|
// silence the dj if we dont have a vehicle to attach them to
|
|
volumeDbPos = -100.f;
|
|
}
|
|
// Prevent a harmless assert
|
|
volumeDbPos = Clamp(volumeDbPos + sm_PositionedPlayerVehicleRadioVolume, -100.f, 20.f);
|
|
|
|
sm_DjSpeechPositionedSound->SetRequestedVolume(0.f);
|
|
sm_DjSpeechPositionedSound->SetRequestedPostSubmixVolumeAttenuation(volumeDbPos);
|
|
sm_DjSpeechPositionedSound->SetRequestedHPFCutoff(sm_PositionedPlayerVehicleRadioHPFCutoff);
|
|
sm_DjSpeechPositionedSound->SetRequestedLPFCutoff(sm_PositionedPlayerVehicleRadioLPFCutoff);
|
|
sm_DjSpeechPositionedSound->SetRequestedEnvironmentalLoudnessFloat(sm_PositionedPlayerVehicleRadioEnvironmentalLoudness);
|
|
sm_DjSpeechPositionedSound->SetRequestedVolumeCurveScale(sm_PositionedPlayerVehicleRadioRollOff);
|
|
}
|
|
|
|
if(!isPlayingSpeech)
|
|
{
|
|
//The DJ speech has finished.
|
|
sm_IMDrivenDjSpeech = false;
|
|
sm_IMDrivenDjSpeechScheduled = false;
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
}
|
|
else if(!isDummySpeech && sm_DjSpeechState == RADIO_DJ_SPEECH_STATE_PLAYING)
|
|
{
|
|
const_cast<audRadioStation*>(playerStation)->m_LastTimeDJSpeechPlaying = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2);
|
|
}
|
|
break;
|
|
|
|
case RADIO_DJ_SPEECH_STATE_IDLE: //Intentional fall-through.
|
|
default:
|
|
// Don't play DJ speech if we're playing a custom tracklist, rather than standard radio content
|
|
if(!sm_IMDrivenDjSpeech && trackPlayTimeMs >= 0 && !playerStation->HasQueuedTrackList() && playerStation->GetNextTrack().IsInitialised())
|
|
{
|
|
s32 introStartTimeMs = 0;
|
|
s32 introEndTimeMs = 0;
|
|
s32 outroStartTimeMs = 0;
|
|
s32 outroEndTimeMs = 0;
|
|
if(playerStation->ExtractDjMarkers(introStartTimeMs, introEndTimeMs, outroStartTimeMs, outroEndTimeMs))
|
|
{
|
|
//We found some active DJ markers, so check if they are within our time window.
|
|
|
|
u8 preferredDjSpeechCategory = RADIO_DJ_SPEECH_CAT_GENERAL;
|
|
s32 windowStartTimeMs = 0;
|
|
s32 windowLengthMs = -1;
|
|
|
|
s32 timeToWindowMs = introStartTimeMs - trackPlayTimeMs;
|
|
const u32 minPrepareTimeMs = playerStation->GetNameHash() == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) ? 500 : g_RadioDjMinPrepareTimeMs;
|
|
if(timeToWindowMs > minPrepareTimeMs)
|
|
{
|
|
windowStartTimeMs = introStartTimeMs;
|
|
windowLengthMs = introEndTimeMs - introStartTimeMs;
|
|
if(windowLengthMs > 0)
|
|
{
|
|
preferredDjSpeechCategory = RADIO_DJ_SPEECH_CAT_INTRO;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audDebugf1("DJSPEECH: Intro time to window too short: %d", timeToWindowMs);
|
|
}
|
|
|
|
// We want to block Outro speech before a DJSOLO on MOTOMAMI as we're pushing the outro regions to the end of the tracks, and the energy levels can be very different between general and
|
|
// DJSOLO
|
|
const bool allowOutroVO = !(playerStation->GetNameHash() == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) && playerStation->GetNextTrack().GetCategory() == RADIO_TRACK_CAT_DJSOLO);
|
|
|
|
timeToWindowMs = outroStartTimeMs - trackPlayTimeMs;
|
|
if(allowOutroVO && (windowLengthMs <= 0) && (timeToWindowMs > g_RadioDjMinPrepareTimeMs))
|
|
{
|
|
windowStartTimeMs = outroStartTimeMs;
|
|
windowLengthMs = outroEndTimeMs - outroStartTimeMs;
|
|
if(windowLengthMs > 0)
|
|
{
|
|
preferredDjSpeechCategory = RADIO_DJ_SPEECH_CAT_OUTRO;
|
|
}
|
|
}
|
|
|
|
if(windowLengthMs > 0)
|
|
{
|
|
//Decide if we want to attempt to play DJ speech at all.
|
|
const u32 nextTrackCategory = playerStation->GetNextTrack().GetCategory();
|
|
|
|
const bool isValidCategoryToSelect = timeInMs >= playerStation->m_DjSpeechCategoryNextValidSelectionTime[preferredDjSpeechCategory];
|
|
|
|
f32 djSpeechProbability = g_RadioDjSpeechProbability;
|
|
|
|
if (playerStation->m_NameHash == ATSTRINGHASH("RADIO_34_DLC_HEI4_KULT", 0xE3442163))
|
|
{
|
|
djSpeechProbability = g_RadioDjSpeechProbabilityKult;
|
|
}
|
|
else if (playerStation->GetNameHash() == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) && (preferredDjSpeechCategory == RADIO_DJ_SPEECH_CAT_OUTRO || preferredDjSpeechCategory == RADIO_DJ_SPEECH_CAT_GENERAL))
|
|
{
|
|
djSpeechProbability = g_RadioDjOutroSpeechProbabilityMotomami;
|
|
}
|
|
|
|
// always speak when going to news or weather
|
|
// always speak intros for takeover music
|
|
// NOTE: using global random stream for dj speech
|
|
if(BANK_ONLY(g_ForceDjSpeech || ) (playerStation->m_HasTakeoverContent && preferredDjSpeechCategory==RADIO_DJ_SPEECH_CAT_INTRO) || nextTrackCategory == RADIO_TRACK_CAT_WEATHER || nextTrackCategory == RADIO_TRACK_CAT_NEWS || (isValidCategoryToSelect && audEngineUtil::ResolveProbability(djSpeechProbability)))
|
|
{
|
|
u32 speechLengthMs = playerStation->CreateCompatibleDjSpeech(timeInMs, preferredDjSpeechCategory, windowLengthMs, windowStartTimeMs);
|
|
if((speechLengthMs > 0) && sm_DjSpeechMonoSound && sm_DjSpeechPositionedSound)
|
|
{
|
|
//Log the game time that this DJ speech is intended to be played at.
|
|
//NOTE: Align intro and outro speech to the end of the window.
|
|
sm_ActiveDjSpeechStartTimeMs = windowStartTimeMs + (windowLengthMs - (s32)speechLengthMs);
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_PREPARING;
|
|
sm_DjSpeechStation = playerStation;
|
|
sm_DjSpeechNextTrackCategory = nextTrackCategory;
|
|
|
|
audDebugf1("DJ Speech start time: %u (window %u, length %u, speechLength %u", sm_ActiveDjSpeechStartTimeMs, windowStartTimeMs, windowLengthMs, speechLengthMs);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Play a dummy (wrapper) speech sound to prevent valid DJ speech from being selected.
|
|
audSoundInitParams initParams;
|
|
initParams.TimerId = 2;
|
|
initParams.u32ClientVar = 0xdeadbeef;
|
|
g_RadioAudioEntity.CreateSound_PersistentReference(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("DjSpeechDummy", 0x94D36E43)),
|
|
&sm_DjSpeechMonoSound, &initParams);
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
g_RadioAudioEntity.CreateSound_PersistentReference(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("DjSpeechDummy", 0x94D36E43)),
|
|
&sm_DjSpeechPositionedSound, &initParams);
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_ActiveDjSpeechStartTimeMs = windowStartTimeMs + windowLengthMs;
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_PREPARING;
|
|
sm_DjSpeechStation = playerStation;
|
|
sm_DjSpeechNextTrackCategory = nextTrackCategory;
|
|
}
|
|
else
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//The player is not listening to a radio station, so clean up DJ speech.
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
}
|
|
}
|
|
|
|
audRadioStation::audRadioStation(RadioStationSettings *stationSettings) :
|
|
m_StationSettings(stationSettings),
|
|
m_ForceNextTrackIndex(0xffff),
|
|
m_ForceNextTrackCategory(0xff),
|
|
m_ForceNextTrackContext(kNullContext),
|
|
m_ActiveTrackIndex(0),
|
|
m_DjSpeechHistoryWriteIndex(0),
|
|
m_SoundBucketId(0xff),
|
|
m_ShouldStreamPhysically(false),
|
|
m_IsPlayingOverlappedTrack(false),
|
|
m_IsPlayingMixTransition(false),
|
|
m_IsRequestingOverlappedTrackPrepare(false),
|
|
m_HasJustPlayedBackToBackMusic(false),
|
|
m_ShouldPlayFullRadio(false),
|
|
m_ScriptSetMusicOnly(false),
|
|
m_IsFirstMusicTrackSinceBoot(true),
|
|
m_IsMixStation(false),
|
|
m_IsFavourited(true),
|
|
m_IsReverbStation(false),
|
|
m_HasConstructedMixStationBeatMap(false)
|
|
{
|
|
for(u32 trackIndex = 0; trackIndex < 2; trackIndex++)
|
|
{
|
|
m_WaveSlots[trackIndex] = NULL;
|
|
}
|
|
|
|
m_NameHash = atStringHash(m_StationSettings->Name);
|
|
audAssertf(m_NameHash == atStringHash(audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(m_StationSettings->NameTableOffset)), "RadioStationSettings %s's name field (%s) does not match the gameobject name", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(m_StationSettings->NameTableOffset), m_StationSettings->Name);
|
|
|
|
for(u32 i = 0; i < IMMUTABLE_INDEX_TYPE_MAX; i++)
|
|
{
|
|
m_StationImmutableIndex[i] = -1;
|
|
}
|
|
|
|
if(!IsHidden())
|
|
{
|
|
if(GameObjectHashList* tuneableStationHashList = audNorthAudioEngine::GetObject<GameObjectHashList>(ATSTRINGHASH("FIXED_ORDER_RADIO_STATION_HASH_LIST_TUNEABLE", 0x616CE649)))
|
|
{
|
|
for(u32 i = 0; i < tuneableStationHashList->numGameObjectHashes; i++)
|
|
{
|
|
if(tuneableStationHashList->GameObjectHashes[i].GameObjectHash == m_NameHash)
|
|
{
|
|
m_StationImmutableIndex[IMMUTABLE_INDEX_TUNEABLE] = i;
|
|
}
|
|
}
|
|
|
|
audAssertf(m_StationImmutableIndex[IMMUTABLE_INDEX_TUNEABLE] >= 0, "Non-hidden station %s has not been assigned an immutable index - please add it *at the end*<-(IMPORTANT!) of FIXED_ORDER_RADIO_STATION_HASH_LIST_TUNEABLE", GetName());
|
|
}
|
|
}
|
|
|
|
if(GameObjectHashList* stationHashList = audNorthAudioEngine::GetObject<GameObjectHashList>(ATSTRINGHASH("FIXED_ORDER_RADIO_STATION_HASH_LIST_GLOBAL", 0xEE10457C)))
|
|
{
|
|
for(u32 i = 0; i < stationHashList->numGameObjectHashes; i++)
|
|
{
|
|
if(stationHashList->GameObjectHashes[i].GameObjectHash == m_NameHash)
|
|
{
|
|
m_StationImmutableIndex[IMMUTABLE_INDEX_GLOBAL] = i;
|
|
}
|
|
}
|
|
|
|
audAssertf(m_StationImmutableIndex[IMMUTABLE_INDEX_GLOBAL] >= 0, "Station %s has not been assigned a global immutable index - please add it *at the end*<-(IMPORTANT!) of FIXED_ORDER_RADIO_STATION_HASH_LIST_GLOBAL", GetName());
|
|
}
|
|
|
|
for(u32 djHistoryIndex=0; djHistoryIndex<g_MaxDjSpeechInHistory; djHistoryIndex++)
|
|
{
|
|
m_DjSpeechHistory[djHistoryIndex] = 0;
|
|
}
|
|
|
|
//Randomly distribute the valid start times for each category across the stations.
|
|
for(u32 djCatIndex=0; djCatIndex<NUM_RADIO_DJ_SPEECH_CATS; djCatIndex++)
|
|
{
|
|
// NOTE: using global random stream for DJ Speech
|
|
const u32 repeatTime = (m_NameHash == ATSTRINGHASH("RADIO_34_DLC_HEI4_KULT", 0xE3442163)) ? g_RadioDjSpeechMinTimeBetweenRepeatedCategoriesKult[djCatIndex] : g_RadioDjSpeechMinTimeBetweenRepeatedCategories[djCatIndex];
|
|
m_DjSpeechCategoryNextValidSelectionTime[djCatIndex] = static_cast<u32>(audEngineUtil::GetRandomNumberInRange(static_cast<s32>(g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2)),
|
|
static_cast<s32>(repeatTime)));
|
|
}
|
|
|
|
m_NoBackToBackMusic = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_NOBACK2BACKMUSIC) == AUD_TRISTATE_TRUE);
|
|
m_PlaysBackToBackAds = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_BACK2BACKADS) == AUD_TRISTATE_TRUE);
|
|
m_PlayWeather = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_PLAYWEATHER) == AUD_TRISTATE_TRUE);
|
|
m_PlayNews = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_PLAYNEWS) == AUD_TRISTATE_TRUE);
|
|
m_PlaySequentialMusicTracks = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_SEQUENTIALMUSIC) == AUD_TRISTATE_TRUE);
|
|
m_PlayIdentsInsteadOfAds = (AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_IDENTSINSTEADOFADS) == AUD_TRISTATE_TRUE);
|
|
m_IsFrozen = false;
|
|
m_IsFirstTrack = true;
|
|
m_HasTakeoverContent = false;
|
|
m_UseRandomizedStrideSelection = false;
|
|
m_LastTimeDJSpeechPlaying = 0u;
|
|
m_AmbientVolume = 0.0f;
|
|
|
|
WIN32PC_ONLY(m_IsUserStation = AUD_GET_TRISTATE_VALUE(stationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_PLAYSUSERSMUSIC) == AUD_TRISTATE_TRUE);
|
|
}
|
|
|
|
audRadioStation::~audRadioStation()
|
|
{
|
|
for(u32 trackIndex = 0; trackIndex < 2; trackIndex++)
|
|
{
|
|
m_Tracks[trackIndex].Shutdown();
|
|
}
|
|
}
|
|
|
|
void audRadioStation::Init()
|
|
{
|
|
const RadioStationSettings *stationSettings = m_StationSettings;
|
|
|
|
m_Random.Reset(audEngineUtil::GetRandomInteger());
|
|
|
|
// Start by assuming we don't have a full set of content
|
|
m_OnlyPlayAds = true;
|
|
|
|
for(s32 i = 0; i < NUM_RADIO_TRACK_CATS; i++)
|
|
{
|
|
//Randomly distribute the valid start times for each category across the stations.
|
|
const s32 nextValidSelectionTime = GetRandomNumberInRange(static_cast<s32>(g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2)),
|
|
static_cast<s32>(sm_MinTimeBetweenRepeatedCategories->Category[i].Value));
|
|
|
|
m_NextValidSelectionTime[i] = static_cast<u32>(nextValidSelectionTime);
|
|
m_CategoryStride[i] = 0;
|
|
}
|
|
|
|
m_DLCInitialized = false;
|
|
m_LastForcedMusicTrackList = 0u;
|
|
|
|
for(u32 trackListIndex = 0; trackListIndex < stationSettings->numTrackLists; trackListIndex++)
|
|
{
|
|
RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(stationSettings->TrackList[trackListIndex].TrackListRef);
|
|
if(trackList)
|
|
{
|
|
if (trackList->Category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
AddMusicTrackList(trackList, stationSettings->TrackList[trackListIndex].TrackListRef);
|
|
}
|
|
else
|
|
{
|
|
AddTrackList(trackList);
|
|
}
|
|
|
|
if (trackList->Category != RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
if(sm_IsNetworkModeHistoryActive)
|
|
{
|
|
m_HasTakeoverContent |= (trackList->Category == RADIO_TRACK_CAT_TAKEOVER_MUSIC);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_HasTakeoverContent)
|
|
{
|
|
m_UseRandomizedStrideSelection = true;
|
|
}
|
|
|
|
if(m_NameHash == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) ||
|
|
m_NameHash == ATSTRINGHASH("RADIO_03_HIPHOP_NEW", 0xFA17DE37) ||
|
|
m_NameHash == ATSTRINGHASH("RADIO_09_HIPHOP_OLD", 0x572C04))
|
|
{
|
|
m_UseRandomizedStrideSelection = true;
|
|
}
|
|
|
|
if(m_UseRandomizedStrideSelection)
|
|
{
|
|
RandomizeCategoryStrides(true, false);
|
|
}
|
|
|
|
if (m_NameHash == ATSTRINGHASH("RADIO_22_DLC_BATTLE_MIX1_CLUB", 0x7E78FD4E) ||
|
|
m_NameHash == ATSTRINGHASH("RADIO_23_DLC_BATTLE_MIX2_CLUB", 0x1FDBE6BE) ||
|
|
m_NameHash == ATSTRINGHASH("RADIO_24_DLC_BATTLE_MIX3_CLUB", 0xB48221E3) ||
|
|
m_NameHash == ATSTRINGHASH("RADIO_25_DLC_BATTLE_MIX4_CLUB", 0x7E95A6DD) ||
|
|
m_NameHash == ATSTRINGHASH("DLC_BATTLE_MIX1_CLUB_PRIV", 0x34BF5EC8) ||
|
|
m_NameHash == ATSTRINGHASH("DLC_BATTLE_MIX2_CLUB_PRIV", 0x6703639B) ||
|
|
m_NameHash == ATSTRINGHASH("DLC_BATTLE_MIX3_CLUB_PRIV", 0x841DDC99) ||
|
|
m_NameHash == ATSTRINGHASH("DLC_BATTLE_MIX4_CLUB_PRIV", 0xEC2974F9))
|
|
{
|
|
m_IsMixStation = true;
|
|
}
|
|
|
|
if(m_NameHash == ATSTRINGHASH("RADIO_03_HIPHOP_NEW", 0xFA17DE37))
|
|
{
|
|
m_NewTrackBias = 1.2f;
|
|
m_FirstBootNewTrackBias = 2.f;
|
|
}
|
|
else
|
|
{
|
|
m_NewTrackBias = 1.f;
|
|
m_FirstBootNewTrackBias = 1.f;
|
|
}
|
|
|
|
m_IsMixStation |= AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_ISMIXSTATION) == AUD_TRISTATE_TRUE;
|
|
|
|
if (m_NameHash == ATSTRINGHASH("RADIO_30_DLC_HEI4_MIX1_REVERB", 0xCEE7651B))
|
|
{
|
|
m_IsReverbStation = true;
|
|
}
|
|
|
|
m_TakeoverMusicTrackCounter = 0;
|
|
|
|
// Load tuning for iFruit station from Cloud Tunables to allow late tweaking
|
|
if(m_NameHash == ATSTRINGHASH("RADIO_23_DLC_XM19_RADIO", 0x6D1C6C45))
|
|
{
|
|
m_TakeoverProbability = 0.4f;
|
|
m_TakeoverMinTimeMs = 9 * 60000;
|
|
m_TakeoverLastTimeMs = 0;
|
|
m_TakeoverMinTracks = 3;
|
|
m_TakeoverMaxTracks = 4;
|
|
m_TakeoverDjSoloProbability = 0.55f;
|
|
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, ATSTRINGHASH("RADIO_23_TAKEOVER_PROB", 0xD0D6E614), m_TakeoverProbability))
|
|
{
|
|
audDisplayf("RADIO_23_DLC_XM19_RADIO: Tunable defined TakeOver Probability: %f", m_TakeoverProbability);
|
|
}
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, ATSTRINGHASH("RADIO_23_TAKEOVER_MINTIME", 0xF374152), m_TakeoverMinTimeMs))
|
|
{
|
|
audDisplayf("RADIO_23_DLC_XM19_RADIO: Tunable defined TakeOver MinTime: %u", m_TakeoverMinTimeMs);
|
|
}
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, ATSTRINGHASH("RADIO_23_TAKEOVER_MINTRACKS", 0x5273ED4E), m_TakeoverMinTracks))
|
|
{
|
|
audDisplayf("RADIO_23_DLC_XM19_RADIO: Tunable defined TakeOver MinTracks: %u", m_TakeoverMinTracks);
|
|
}
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, ATSTRINGHASH("RADIO_23_TAKEOVER_MAXTRACKS", 0x5F217590), m_TakeoverMaxTracks))
|
|
{
|
|
audDisplayf("RADIO_23_DLC_XM19_RADIO: Tunable defined TakeOver MaxTracks: %u", m_TakeoverMaxTracks);
|
|
}
|
|
if (Tunables::GetInstance().Access(BASE_GLOBALS_HASH, ATSTRINGHASH("RADIO_23_TAKEOVER_DJSOLO_PROB", 0x6A820BD6), m_TakeoverDjSoloProbability))
|
|
{
|
|
audDisplayf("RADIO_23_DLC_XM19_RADIO: Tunable defined TakeOver DjSolo Probability: %f", m_TakeoverDjSoloProbability);
|
|
}
|
|
}
|
|
|
|
// Initialise as if we had a takeover in recent history, so we don't rule out hearing one in the first 10 minutes
|
|
m_StationAccumulatedPlayTimeMs = GetRandomNumberInRange(0, m_TakeoverMinTimeMs);
|
|
|
|
m_ListenTimer = 0.f;
|
|
m_Genre = (RadioGenre)m_StationSettings->Genre;
|
|
m_AmbientVolume = (f32)m_StationSettings->AmbientRadioVol;
|
|
|
|
m_QueuedTrackList = NULL;
|
|
m_QueuedTrackListIndex = 0;
|
|
m_NetworkNextTrack.category = 0xff;
|
|
|
|
#if RSG_PC // user music
|
|
m_LastPlayedTrackIndex = ~0U;
|
|
m_CurrentlyPlayingTrackIndex = ~0U;
|
|
m_BadTrackCount = 0;
|
|
sm_IsInRecoveryMode = false;
|
|
#endif
|
|
|
|
m_FirstTrackStartOffset = GetRandomNumberInRange(0.1f, 0.8f);
|
|
|
|
/// Mix Station now unlocked by default, unlock all tracks immediately
|
|
if (m_NameHash == ATSTRINGHASH("RADIO_22_DLC_BATTLE_MIX1_RADIO", 0xF8BEAA16))
|
|
{
|
|
UnlockTrackList("BATTLE_MIX1_RADIO");
|
|
UnlockTrackList("BATTLE_MIX2_RADIO");
|
|
UnlockTrackList("BATTLE_MIX3_RADIO");
|
|
UnlockTrackList("BATTLE_MIX4_RADIO");
|
|
}
|
|
|
|
#if __BANK
|
|
u32 totalNumTracks = 0;
|
|
for(s32 i = 0; i < NUM_RADIO_TRACK_CATS; i++)
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(i);
|
|
if(trackLists)
|
|
{
|
|
const u32 numTracks = trackLists->ComputeNumTracks();
|
|
audDisplayf("%s %s: %u tracks", GetName(), TrackCats_ToString((TrackCats)i), numTracks);
|
|
totalNumTracks += numTracks;
|
|
}
|
|
}
|
|
|
|
audDebugf1("%s has %u total tracks", GetName(), totalNumTracks);
|
|
#endif
|
|
|
|
m_MusicRunningCount = 0;
|
|
|
|
/* Mix Station now unlocked by default, no longer required
|
|
// Lock DJ music station by default, relies on script mechanism to unlock
|
|
if (m_NameHash == ATSTRINGHASH("RADIO_22_DLC_BATTLE_MIX1_RADIO", 0xF8BEAA16))
|
|
{
|
|
SetLocked(true);
|
|
}
|
|
*/
|
|
}
|
|
|
|
void audRadioStation::RandomizeCategoryStrides(bool randomizeStartTrack, bool maintainDirection)
|
|
{
|
|
// Assign a random start index and stride for all required track categories
|
|
for (u32 category = 0; category < NUM_RADIO_TRACK_CATS; category++)
|
|
{
|
|
RandomizeCategoryStride((TrackCats)category, randomizeStartTrack, maintainDirection);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::RandomizeCategoryStride(TrackCats category, bool randomizeStartTrack, bool maintainDirection)
|
|
{
|
|
if (IsRandomizedStrideCategory(category))
|
|
{
|
|
u32 numTracksAvailable = ComputeNumTracksAvailable(category);
|
|
|
|
if(numTracksAvailable > 0)
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
|
|
// If this station has old and new music we want to generate separate stride/index values for both the
|
|
// track lists so that we can step through them independently (as if we just treat it as one big list
|
|
// we're going to hear all the old then all the new music if we have a stride value if +1/-1
|
|
if(trackLists && trackLists->GetUnlockedListCount() == 2)
|
|
{
|
|
audDisplayf("Station %s is in old/new stride mode for category %s", GetName(), TrackCats_ToString(category));
|
|
|
|
u32 unlockedListIndex = 0;
|
|
|
|
for(u32 i = 0; i < trackLists->GetListCount(); i++)
|
|
{
|
|
if(trackLists->IsTrackListUnlocked(trackLists->GetList(i)))
|
|
{
|
|
if(unlockedListIndex == 0)
|
|
{
|
|
RandomizeCategoryStride(category, trackLists->GetList(i)->numTracks, randomizeStartTrack, maintainDirection);
|
|
}
|
|
else
|
|
{
|
|
TrackCats takeoverCategory= TRACKCATS_MAX;
|
|
if(category == RADIO_TRACK_CAT_MUSIC) { takeoverCategory = RADIO_TRACK_CAT_TAKEOVER_MUSIC; }
|
|
if(category == RADIO_TRACK_CAT_IDENTS) { takeoverCategory = RADIO_TRACK_CAT_TAKEOVER_IDENTS; }
|
|
if(category == RADIO_TRACK_CAT_DJSOLO) { takeoverCategory = RADIO_TRACK_CAT_TAKEOVER_DJSOLO; }
|
|
RandomizeCategoryStride(takeoverCategory, trackLists->GetList(i)->numTracks, randomizeStartTrack, maintainDirection);
|
|
}
|
|
|
|
unlockedListIndex++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RandomizeCategoryStride(category, numTracksAvailable, randomizeStartTrack, maintainDirection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::RandomizeCategoryStride(TrackCats category, u32 numTracksAvailable, bool randomizeStartTrack, bool maintainDirection)
|
|
{
|
|
if (numTracksAvailable > 0)
|
|
{
|
|
// Pick a random stride per-category (current either just steps forwards or backwards through the tracks)
|
|
// Nb. Don't go +/- 8! This gets packed into a 4 bit value for network syncing
|
|
if(!maintainDirection)
|
|
{
|
|
m_CategoryStride[category] = GetRandomNumberInRange(0.0f, 1.0f) >= 0.5f ? -1 : 1;
|
|
}
|
|
// Normalize back to -1 or 1 depending on previously picked direction
|
|
else
|
|
{
|
|
m_CategoryStride[category] = m_CategoryStride[category] > 0 ? 1 : -1;
|
|
}
|
|
|
|
// If we've got an odd number of tracks, we can step through two at a time for extra variety without repeating
|
|
if (numTracksAvailable % 2 == 1 && GetRandomNumberInRange(0.0f, 1.0f) >= 0.5f)
|
|
{
|
|
m_CategoryStride[category] *= 2;
|
|
}
|
|
|
|
if (audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(category)))
|
|
{
|
|
if(randomizeStartTrack || (*history)[0] == -1)
|
|
{
|
|
// Pick a random start track per-category
|
|
(*history)[0] = GetRandomNumberInRange(0, numTracksAvailable - 1);
|
|
history->SetWriteIndex(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Any logic that needs to be applied after DLC tracks have been merged should go here
|
|
void audRadioStation::DLCInit()
|
|
{
|
|
if (!m_DLCInitialized)
|
|
{
|
|
// USB station track lists are all locked by default
|
|
if (IsUSBMixStation())
|
|
{
|
|
#if __BANK
|
|
g_NumUSBStationTrackLists = 0;
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
for (u32 i = 0; i < trackListCollection->GetListCount(); i++)
|
|
{
|
|
g_USBTrackListNames[g_NumUSBStationTrackLists++] = audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackListCollection->GetList(i)->NameTableOffset);
|
|
}
|
|
}
|
|
|
|
if(g_USBStationTrackListCombo)
|
|
{
|
|
g_USBStationTrackListCombo->UpdateCombo("Track List", &g_RequestedUSBTrackListComboIndex, g_NumUSBStationTrackLists, g_USBTrackListNames.GetElements());
|
|
}
|
|
#endif
|
|
|
|
ForceMusicTrackList(ATSTRINGHASH("TUNER_AP_SILENCE_MUSIC", 0x68865F9), 0u);
|
|
}
|
|
|
|
// USB tracks are all locked by default so no point randomizing
|
|
if (m_PlaySequentialMusicTracks && !IsUSBMixStation())
|
|
{
|
|
RandomizeSequentialStationPlayPosition();
|
|
}
|
|
|
|
m_DLCInitialized = true;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::RandomizeSequentialStationPlayPosition()
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
const s32 numTracks = ComputeNumTracksAvailable(RADIO_TRACK_CAT_MUSIC);
|
|
|
|
bool hasValidTracks = history && numTracks >= 1;
|
|
audAssertf(hasValidTracks || IsUSBMixStation(), "Attempting to play sequential music tracks but track list is invalid or the list has less than one track");
|
|
|
|
if (hasValidTracks)
|
|
{
|
|
u32 firstTrackIndex = 0;
|
|
u32 lastTrackIndex = 0;
|
|
s32 tuneablePrioritizedTrackListIndex = IsNetworkModeHistoryActive() ? GetTuneablePrioritizedMusicTrackListIndex(firstTrackIndex, lastTrackIndex) : -1;
|
|
m_FirstTrackStartOffset = GetRandomNumberInRange(0.1f, 0.8f);
|
|
|
|
if (tuneablePrioritizedTrackListIndex >= 0)
|
|
{
|
|
(*history)[0] = (u32)GetRandomNumberInRange((s32)firstTrackIndex, (s32)lastTrackIndex);
|
|
audDisplayf("Radio station %s has randomised to %.02f%% through track %u/%u (prioritized track list %d)", GetName(), m_FirstTrackStartOffset * 100.f, (*history)[0], numTracks, tuneablePrioritizedTrackListIndex);
|
|
}
|
|
else
|
|
{
|
|
(*history)[0] = (u32)GetRandomNumberInRange(0, numTracks - 1);
|
|
audDisplayf("Radio station %s has randomised to %.02f%% through track %u/%u", GetName(), m_FirstTrackStartOffset * 100.f, (*history)[0], numTracks);
|
|
}
|
|
|
|
history->SetWriteIndex(1);
|
|
}
|
|
}
|
|
|
|
s32 audRadioStation::GetTuneablePrioritizedMusicTrackListIndex(u32& firstTrackIndex, u32& lastTrackIndex)
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
f32* trackListProbabilities = Alloca(f32, trackLists->GetListCount());
|
|
bool foundCustomProbabilityValue = false;
|
|
f32 probabilitySum = 0.f;
|
|
|
|
for (u32 trackListIndex = 0; trackListIndex < trackLists->GetListCount(); trackListIndex++)
|
|
{
|
|
f32 trackListProbability = 0.0f;
|
|
|
|
if (!trackLists->IsListLocked(trackListIndex))
|
|
{
|
|
trackListProbability = Max(0.0f, trackLists->GetListFirstTrackProbability(trackListIndex));
|
|
foundCustomProbabilityValue |= trackListProbability != 1.f;
|
|
}
|
|
|
|
trackListProbabilities[trackListIndex] = trackListProbability;
|
|
probabilitySum += trackListProbability;
|
|
}
|
|
|
|
if (foundCustomProbabilityValue)
|
|
{
|
|
audDisplayf("Found first music track probability modifier on station %s (%u tracks total)", GetName(), ComputeNumTracksAvailable(RADIO_TRACK_CAT_MUSIC));
|
|
f32 randomTrackIndex = audEngineUtil::GetRandomNumberInRange(0.f, probabilitySum);
|
|
|
|
#if __BANK
|
|
for (u32 trackListIndex = 0; trackListIndex < trackLists->GetListCount(); trackListIndex++)
|
|
{
|
|
const bool trackListLocked = trackLists->IsListLocked(trackListIndex);
|
|
|
|
audDisplayf("Track List %d (%s) probability: %.02f, %u tracks %s",
|
|
trackListIndex,
|
|
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackLists->GetList(trackListIndex)->NameTableOffset),
|
|
trackLists->GetListFirstTrackProbability(trackListIndex),
|
|
trackListLocked ? 0 : trackLists->GetList(trackListIndex)->numTracks,
|
|
trackListLocked ? "(locked)" : "");
|
|
}
|
|
|
|
audDisplayf("Random track list index: %.02f", randomTrackIndex);
|
|
#endif
|
|
|
|
for (u32 trackListIndex = 0; trackListIndex < trackLists->GetListCount(); trackListIndex++)
|
|
{
|
|
const RadioStationTrackList* trackList = trackLists->GetList(trackListIndex);
|
|
const bool trackListLocked = trackLists->IsListLocked(trackListIndex);
|
|
const u32 numTracks = trackListLocked ? 0 : trackList->numTracks;
|
|
|
|
if (trackListProbabilities[trackListIndex] > 0.f)
|
|
{
|
|
randomTrackIndex -= trackListProbabilities[trackListIndex];
|
|
|
|
if (randomTrackIndex <= 0.f)
|
|
{
|
|
lastTrackIndex = firstTrackIndex + numTracks - 1;
|
|
return trackListIndex;
|
|
}
|
|
}
|
|
|
|
firstTrackIndex += numTracks;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void audRadioStation::Shutdown(void)
|
|
{
|
|
for(u32 trackIndex = 0; trackIndex < 2; trackIndex++)
|
|
{
|
|
m_Tracks[trackIndex].Shutdown();
|
|
}
|
|
m_IsFirstTrack = true;
|
|
m_LastTimeDJSpeechPlaying = 0u;
|
|
}
|
|
|
|
void audRadioStation::LogTrack(const u32 BANK_ONLY(category), const u32 BANK_ONLY(context), const u32 BANK_ONLY(index), const u32 BANK_ONLY(soundRef))
|
|
{
|
|
#if __BANK
|
|
char buf[256];
|
|
formatf(buf, "%s,%u,%s,%u,%u,%s\r\n",
|
|
GetName(),
|
|
g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2),
|
|
TrackCats_ToString((TrackCats)category),
|
|
index,
|
|
context,
|
|
g_AudioEngine.GetSoundManager().GetFactory().GetMetadataManager().GetObjectName(soundRef));
|
|
|
|
if(g_LogRadio && m_ShouldStreamPhysically)
|
|
{
|
|
FileHandle fi = CFileMgr::OpenFileForAppending("common:/RadioLog.csv");
|
|
if(fi != INVALID_FILE_HANDLE)
|
|
{
|
|
CFileMgr::Write(fi, buf, istrlen(buf));
|
|
CFileMgr::CloseFile(fi);
|
|
}
|
|
}
|
|
if(IsNetworkModeHistoryActive())
|
|
{
|
|
audDebugf1("NETRADIO,%s", buf);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
u32 audRadioStation::PackCategoryForNetwork(const u32 category)
|
|
{
|
|
if(category >= NUM_RADIO_TRACK_CATS)
|
|
{
|
|
return 0;
|
|
}
|
|
return category+1;
|
|
}
|
|
|
|
u32 audRadioStation::UnpackCategoryFromNetwork(const u32 category)
|
|
{
|
|
if(category == 0)
|
|
{
|
|
return 0xFFFF;
|
|
}
|
|
return category - 1;
|
|
}
|
|
|
|
bool audRadioStation::ShouldAddCategoryToNetworkHistory(const u32 category)
|
|
{
|
|
return (category == RADIO_TRACK_CAT_MUSIC || category == RADIO_TRACK_CAT_DJSOLO || category == RADIO_TRACK_CAT_ADVERTS
|
|
|| category == RADIO_TRACK_CAT_TAKEOVER_MUSIC || category == RADIO_TRACK_CAT_TAKEOVER_DJSOLO);
|
|
}
|
|
|
|
void audRadioStation::Update(u32 timeInMs)
|
|
{
|
|
// Need to defer doing this until the sound data has been loaded for a given pack
|
|
if (m_IsMixStation && !IsUSBMixStation() && !m_HasConstructedMixStationBeatMap)
|
|
{
|
|
ConstructMixStationBeatMarkerList();
|
|
m_HasConstructedMixStationBeatMap = true;
|
|
}
|
|
|
|
bool disableNetworkModeForStation = m_UseRandomizedStrideSelection;
|
|
WIN32PC_ONLY(disableNetworkModeForStation |= m_IsUserStation);
|
|
|
|
//Reset the TrackChanged flag
|
|
m_bHasTrackChanged = false;
|
|
|
|
if(!m_ShouldStreamPhysically)
|
|
{
|
|
//We can always select full radio content when this station is streaming virtually.
|
|
m_ShouldPlayFullRadio = true;
|
|
}
|
|
|
|
if(!m_Tracks[m_ActiveTrackIndex].IsInitialised())
|
|
{
|
|
if(m_IsPlayingOverlappedTrack)
|
|
{
|
|
//Our active track has finished, but we're already overlapping playback of the next track.
|
|
|
|
//Make the overlapped track our active track.
|
|
m_bHasTrackChanged = true;
|
|
m_ActiveTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
m_IsPlayingOverlappedTrack = false;
|
|
m_IsRequestingOverlappedTrackPrepare = false;
|
|
|
|
if(!disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
if(history)
|
|
{
|
|
if(m_Tracks[m_ActiveTrackIndex].GetSoundRef() != ATSTRINGHASH("dlc_ch_finale_radio_djsolo", 0x14F5707))
|
|
{
|
|
if(ShouldAddCategoryToNetworkHistory(m_Tracks[m_ActiveTrackIndex].GetCategory()))
|
|
{
|
|
history->AddToHistory(m_Tracks[m_ActiveTrackIndex].GetRefForHistory());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Give the management code a frame to catch the track transition before attempting to select
|
|
//and prepare the next track.
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
|
|
//We need to prepare a track to get us started.
|
|
if(!m_Tracks[nextTrackIndex].IsInitialised())
|
|
{
|
|
InitialiseNextTrack(timeInMs);
|
|
}
|
|
audPrepareState state = PrepareNextTrack();
|
|
|
|
switch(state)
|
|
{
|
|
case AUD_PREPARED:
|
|
m_bHasTrackChanged = true;
|
|
m_ActiveTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
m_Tracks[m_ActiveTrackIndex].Play();
|
|
|
|
if(!disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
if(history)
|
|
{
|
|
if(ShouldAddCategoryToNetworkHistory(m_Tracks[m_ActiveTrackIndex].GetCategory()))
|
|
{
|
|
history->AddToHistory(m_Tracks[m_ActiveTrackIndex].GetRefForHistory());
|
|
}
|
|
}
|
|
}
|
|
|
|
#if RSG_PC
|
|
m_LastPlayedTrackIndex = m_CurrentlyPlayingTrackIndex;
|
|
m_CurrentlyPlayingTrackIndex = m_Tracks[m_ActiveTrackIndex].GetTrackIndex();
|
|
m_BadTrackCount = 0; // Reset bad track count. We got a good one.
|
|
#endif
|
|
break;
|
|
|
|
case AUD_PREPARE_FAILED:
|
|
{
|
|
OUTPUT_ONLY(char* nextTrackName = (char *)m_Tracks[nextTrackIndex].GetBankName();)
|
|
|
|
naErrorf("Failed to prepare a track (%s) for a radio station (%s)", nextTrackName ? nextTrackName : "Unknown", GetName());
|
|
|
|
//Kill the next track and try to prepare another next frame.
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
m_BadTrackCount++;
|
|
Warningf("BadTrackCount: %u", m_BadTrackCount);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//Intentional fall-through.
|
|
case AUD_PREPARING:
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if(IsNetworkModeHistoryActive() && m_Tracks[m_ActiveTrackIndex].IsInitialised() && m_Tracks[m_ActiveTrackIndex].IsDormant())
|
|
{
|
|
// B*1504812
|
|
audWarningf("%s - Should be playing but track state is dormant, requesting play", GetName());
|
|
m_Tracks[m_ActiveTrackIndex].PlayWhenReady();
|
|
}
|
|
|
|
m_Tracks[m_ActiveTrackIndex].Update(timeInMs, IsFrozen());
|
|
|
|
//
|
|
//We're playing an active track, so prepare the next track.
|
|
//
|
|
|
|
#if RSG_PC // user music
|
|
if(m_IsUserStation)
|
|
{
|
|
USERRADIO_PLAYMODE playMode = sm_UserRadioTrackManager.GetRadioMode();
|
|
if(playMode == USERRADIO_PLAY_MODE_SEQUENTIAL && (sm_ForceUserPrevTrack || sm_ForceUserNextTrack))
|
|
{
|
|
const s32 numTracks = sm_UserRadioTrackManager.GetNumTracks();
|
|
if(numTracks > 0)
|
|
{
|
|
if(sm_ForceUserPrevTrack)
|
|
{
|
|
sm_UserRadioTrackManager.SetNextTrack((m_Tracks[m_ActiveTrackIndex].GetTrackIndex() + numTracks - 1) % numTracks);
|
|
}
|
|
else
|
|
{
|
|
sm_UserRadioTrackManager.SetNextTrack((m_Tracks[m_ActiveTrackIndex].GetTrackIndex() + 1) % numTracks);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_ShouldPlayFullRadio = (sm_IsInRecoveryMode || playMode == USERRADIO_PLAY_MODE_RADIO);
|
|
|
|
// ditch current track
|
|
if(sm_ForceUserNextTrack || sm_ForceUserPrevTrack)
|
|
{
|
|
m_Tracks[m_ActiveTrackIndex].Shutdown();
|
|
}
|
|
|
|
// if we're going backwards, ditch the next track too
|
|
if(sm_ForceUserPrevTrack || (playMode == USERRADIO_PLAY_MODE_SEQUENTIAL && sm_ForceUserNextTrack))
|
|
{
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex+1)%2;
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
}
|
|
|
|
if(sm_ForceUserNextTrack || sm_ForceUserPrevTrack)
|
|
{
|
|
sm_ForceUserNextTrack = false;
|
|
sm_ForceUserPrevTrack = false;
|
|
return;
|
|
}
|
|
|
|
sm_ForceUserNextTrack = false;
|
|
sm_ForceUserPrevTrack = false;
|
|
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised() && m_Tracks[m_ActiveTrackIndex].IsStreamingPhysically() && m_Tracks[m_ActiveTrackIndex].GetPlayTime() > 1000 && m_Tracks[m_ActiveTrackIndex].GetCategory() == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
// we've succesfully played a user track; recovery mode is no longer required
|
|
sm_IsInRecoveryMode = false;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
u8 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
if(m_IsPlayingOverlappedTrack)
|
|
{
|
|
//Sanity-check that we are playing a track of the correct category.
|
|
if(ShouldOnlyPlayMusic() && m_Tracks[nextTrackIndex].GetCategory() != RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
//We should only choose music.
|
|
Assert(!IsFrozen());
|
|
//Stop playing this track and allow a music track to be selected next frame.
|
|
audDisplayf("Station %s should only play music, but overlapped track (%u) is not music - shutting down", GetName(), m_Tracks[nextTrackIndex].GetSoundRef());
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
m_IsPlayingOverlappedTrack = false;
|
|
m_IsRequestingOverlappedTrackPrepare = false;
|
|
return;
|
|
}
|
|
|
|
m_Tracks[nextTrackIndex].Update(timeInMs, IsFrozen());
|
|
}
|
|
else
|
|
{
|
|
//Sanity-check that we are playing a track of the correct category.
|
|
if(ShouldOnlyPlayMusic() && m_Tracks[m_ActiveTrackIndex].GetCategory() != RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
//We should only choose music.
|
|
Assert(!IsFrozen());
|
|
//Stop playing this track and allow a music track to be selected next frame.
|
|
audDisplayf("Station %s should only play music, but active track (%u) is not music - shutting down", GetName(), m_Tracks[m_ActiveTrackIndex].GetSoundRef());
|
|
m_Tracks[m_ActiveTrackIndex].Shutdown();
|
|
return;
|
|
}
|
|
|
|
if(!m_Tracks[nextTrackIndex].IsInitialised())
|
|
{
|
|
InitialiseNextTrack(timeInMs);
|
|
}
|
|
|
|
//Prepare the next track.
|
|
audRadioTrack &activeTrack = m_Tracks[m_ActiveTrackIndex];
|
|
s32 playTime = activeTrack.GetPlayTime();
|
|
s32 duration = activeTrack.GetDuration();
|
|
|
|
// Wait until the active track is in a playing state before attempting to prepare the next track for the overlap, otherwise
|
|
// retuning to a track within the overlap window can cause problems.
|
|
if(activeTrack.IsPlayingPhysicallyOrVirtually() && playTime >= (duration - g_RadioTrackPrepareTimeMs) && !sm_DisableOverlap)
|
|
{
|
|
if(m_IsRequestingOverlappedTrackPrepare)
|
|
{
|
|
audPrepareState state = PrepareNextTrack();
|
|
if(state == AUD_PREPARED)
|
|
{
|
|
s32 compensatedPlayTime = playTime;
|
|
|
|
if(!g_DisablePlayTimeCompensation && !m_IsMixStation && !m_PlaySequentialMusicTracks && !disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
{
|
|
// compensate for drift by sliding the overlap
|
|
compensatedPlayTime = Clamp(static_cast<s32>(audDriver::GetMixer()->GetMixerTimeMs() - activeTrack.GetTimePlayed()),
|
|
playTime - 500,
|
|
playTime + 500);
|
|
|
|
// TODO: accumulate error when >500ms
|
|
}
|
|
|
|
m_IsPlayingMixTransition = m_Tracks[nextTrackIndex].IsFlyloPart1() != m_Tracks[m_ActiveTrackIndex].IsFlyloPart1();
|
|
u32 overlapTimeMs = WIN32PC_ONLY(m_IsUserStation ? g_UserRadioTrackOverlapTimeMs : )g_RadioTrackOverlapTimeMs;
|
|
u32 overlapTimePlayMs = overlapTimeMs;
|
|
|
|
if (g_UsePreciseTrackCrossfades && m_PlaySequentialMusicTracks && m_Tracks[nextTrackIndex].GetStreamingSound())
|
|
{
|
|
overlapTimePlayMs += g_RadioTrackOverlapPlayTimeMs;
|
|
}
|
|
|
|
if(compensatedPlayTime >= (duration - overlapTimePlayMs))
|
|
{
|
|
if (g_UsePreciseTrackCrossfades && m_PlaySequentialMusicTracks && m_Tracks[nextTrackIndex].GetStreamingSound())
|
|
{
|
|
u32 trackTimeRemaining = duration - playTime;
|
|
u32 trackTimeCalculationFrame = activeTrack.GetPlayTimeCalculationMixerFrame();
|
|
f32 trackStartMixerFrames = trackTimeCalculationFrame + ((trackTimeRemaining - overlapTimeMs) / (g_SecondsPerMixBuffer * 1000));
|
|
|
|
#if RSG_ORBIS
|
|
trackStartMixerFrames += 1168 / (f32)kMixBufNumSamples;
|
|
#endif
|
|
|
|
u32 startOffsetFrames = (u32)floor(trackStartMixerFrames);
|
|
u16 subFrameOffset = (u16)((trackStartMixerFrames - startOffsetFrames) * kMixBufNumSamples);
|
|
m_Tracks[nextTrackIndex].GetStreamingSound()->SetRequestedMixerPlayTimeAbsolute(startOffsetFrames, subFrameOffset);
|
|
}
|
|
|
|
m_Tracks[nextTrackIndex].Play();
|
|
m_IsPlayingOverlappedTrack = true;
|
|
#if RSG_PC
|
|
m_LastPlayedTrackIndex = m_CurrentlyPlayingTrackIndex;
|
|
m_CurrentlyPlayingTrackIndex = m_Tracks[nextTrackIndex].GetTrackIndex();
|
|
m_BadTrackCount = 0;
|
|
#endif
|
|
}
|
|
}
|
|
#if RSG_PC // this block came from GTA IV user music, is it still needed? SORR
|
|
else if(state == AUD_PREPARE_FAILED)
|
|
{
|
|
//Kill the next track and try to prepare another next frame.
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
|
|
m_BadTrackCount++;
|
|
Warningf("BadTrackCount: %u", m_BadTrackCount);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
m_IsRequestingOverlappedTrackPrepare = true;
|
|
}
|
|
else
|
|
{
|
|
m_IsRequestingOverlappedTrackPrepare = false;
|
|
}
|
|
}
|
|
|
|
if(m_ShouldStreamPhysically)
|
|
{
|
|
if(audRadioSlot::FindSlotByStation(this) == NULL)
|
|
{
|
|
naWarningf("Station %s playing physically with no valid slot; forcing virtual streaming", GetName());
|
|
SetPhysicalStreamingState(false);
|
|
}
|
|
}
|
|
|
|
#if __BANK
|
|
if(m_bHasTrackChanged)
|
|
{
|
|
audDisplayf("Track changed on radio station %s - new track %s (%s track %d) - offset %.02f, network time %u", GetName(), SOUNDFACTORY.GetMetadataManager().GetObjectName(m_Tracks[m_ActiveTrackIndex].GetSoundRef()), m_Tracks[m_ActiveTrackIndex].GetCategory() >= NUM_RADIO_TRACK_CATS ? "Invalid" : TrackCats_ToString((TrackCats)m_Tracks[m_ActiveTrackIndex].GetCategory()), m_Tracks[m_ActiveTrackIndex].GetTrackIndex(), m_Tracks[m_ActiveTrackIndex].GetPlayFraction(), NetworkInterface::GetSyncedTimeInMilliseconds());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool audRadioStation::IsStreamingPhysically() const
|
|
{
|
|
for(u32 trackIndex = 0; trackIndex < 2; trackIndex++)
|
|
{
|
|
if(m_Tracks[trackIndex].IsInitialised())
|
|
{
|
|
if(m_Tracks[trackIndex].IsStreamingPhysically())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool audRadioStation::IsStreamingVirtually() const
|
|
{
|
|
bool isStreamingVirtually = false;
|
|
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised())
|
|
{
|
|
isStreamingVirtually = m_Tracks[m_ActiveTrackIndex].IsStreamingVirtually();
|
|
}
|
|
|
|
//Also check the next track if need be.
|
|
u8 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
if(isStreamingVirtually && m_Tracks[nextTrackIndex].IsInitialised())
|
|
{
|
|
isStreamingVirtually = m_Tracks[nextTrackIndex].IsStreamingVirtually();
|
|
}
|
|
|
|
return isStreamingVirtually;
|
|
}
|
|
|
|
void audRadioStation::SetStreamSlots(audStreamSlot **streamSlots)
|
|
{
|
|
m_WaveSlots[0] = NULL;
|
|
m_WaveSlots[1] = NULL;
|
|
|
|
if(streamSlots)
|
|
{
|
|
if(streamSlots[0])
|
|
{
|
|
m_WaveSlots[0] = streamSlots[0]->GetWaveSlot();
|
|
}
|
|
|
|
if(streamSlots[1])
|
|
{
|
|
m_WaveSlots[1] = streamSlots[1]->GetWaveSlot();
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::SetPhysicalStreamingState(bool shouldStreamPhysically, audStreamSlot **streamSlots, u8 soundBucketId)
|
|
{
|
|
m_ShouldStreamPhysically = shouldStreamPhysically;
|
|
m_SoundBucketId = soundBucketId;
|
|
|
|
m_WaveSlots[0] = NULL;
|
|
m_WaveSlots[1] = NULL;
|
|
|
|
if(streamSlots)
|
|
{
|
|
if(streamSlots[0])
|
|
{
|
|
m_WaveSlots[0] = streamSlots[0]->GetWaveSlot();
|
|
}
|
|
|
|
if(streamSlots[1])
|
|
{
|
|
m_WaveSlots[1] = streamSlots[1]->GetWaveSlot();
|
|
}
|
|
}
|
|
bool disableNetworkModeForStation = false;
|
|
WIN32PC_ONLY(disableNetworkModeForStation = m_IsUserStation);
|
|
|
|
audRadioTrack &activeTrack = m_Tracks[m_ActiveTrackIndex];
|
|
if(activeTrack.IsInitialised())
|
|
{
|
|
bool shouldSkipEnd = false;
|
|
s32 playTime = activeTrack.GetPlayTime();
|
|
s32 duration = (s32)activeTrack.GetDuration();
|
|
if(!disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
{
|
|
shouldSkipEnd = playTime >= (duration - 2000U);
|
|
}
|
|
else if(playTime >= (duration - g_RadioTrackSkipEndTimeMs))
|
|
{
|
|
shouldSkipEnd = true;
|
|
}
|
|
|
|
if(!IsFrozen() && m_ShouldStreamPhysically && (shouldSkipEnd || m_IsPlayingOverlappedTrack))
|
|
{
|
|
//We are about to physically stream the end of a track or an overlap,
|
|
//so stop the finishing track to prevent startup problems.
|
|
activeTrack.Shutdown();
|
|
}
|
|
else
|
|
{
|
|
activeTrack.SetPhysicalStreamingState(shouldStreamPhysically, m_WaveSlots[m_ActiveTrackIndex], soundBucketId);
|
|
}
|
|
}
|
|
|
|
const u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
audRadioTrack &nextTrack = m_Tracks[nextTrackIndex];
|
|
if(nextTrack.IsInitialised())
|
|
{
|
|
nextTrack.SetPhysicalStreamingState(shouldStreamPhysically, m_WaveSlots[nextTrackIndex], soundBucketId);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::AddActiveDjSpeechToHistory(u32 timeInMs)
|
|
{
|
|
//Make sure we didn't already add this track.
|
|
u8 previousHistoryWriteIndex = (m_DjSpeechHistoryWriteIndex + g_MaxDjSpeechInHistory - 1) %
|
|
g_MaxDjSpeechInHistory;
|
|
if(m_DjSpeechHistory[previousHistoryWriteIndex] != sm_ActiveDjSpeechId)
|
|
{
|
|
// Speech category could potentially be invalid if we've chosen to trigger some dummy DJ speech
|
|
if(sm_ActiveDjSpeechCategory < NUM_RADIO_DJ_SPEECH_CATS)
|
|
{
|
|
RADIODEBUG3("DjSpeech %s:%u", g_RadioDjSpeechCategoryNames[sm_ActiveDjSpeechCategory], sm_ActiveDjSpeechId);
|
|
|
|
m_DjSpeechHistory[m_DjSpeechHistoryWriteIndex] = sm_ActiveDjSpeechId;
|
|
m_DjSpeechHistoryWriteIndex = (m_DjSpeechHistoryWriteIndex + 1) % g_MaxDjSpeechInHistory;
|
|
|
|
const u32 repeatTime = (m_NameHash == ATSTRINGHASH("RADIO_34_DLC_HEI4_KULT", 0xE3442163)) ? g_RadioDjSpeechMinTimeBetweenRepeatedCategoriesKult[sm_ActiveDjSpeechCategory] : g_RadioDjSpeechMinTimeBetweenRepeatedCategories[sm_ActiveDjSpeechCategory];
|
|
|
|
//Log the next time that this category can be selected.
|
|
m_DjSpeechCategoryNextValidSelectionTime[sm_ActiveDjSpeechCategory] = timeInMs + repeatTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 audRadioStation::CreateCompatibleDjSpeech(u32 timeInMs, u8 preferredCategory, s32 windowLengthMs, const s32 windowStartTime) const
|
|
{
|
|
naCErrorf(preferredCategory < NUM_RADIO_DJ_SPEECH_CATS, "Invalid preferred category passed into CreateCompatibleDjSpeech");
|
|
|
|
audDebugf1("DJSPEECH CreateCompatibleDjSpeech: %s, %d, %d", g_RadioDjSpeechCategoryNames[preferredCategory], windowLengthMs, windowStartTime);
|
|
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
u32 nextTrackCategory = m_Tracks[nextTrackIndex].GetCategory();
|
|
const bool inTakeoverState = m_Tracks[m_ActiveTrackIndex].GetCategory() == RADIO_TRACK_CAT_TAKEOVER_MUSIC;
|
|
|
|
// no TIME DJ speech for iFruit in takeover mode or MOTOMAMI
|
|
const bool disableTimeCategory = inTakeoverState || m_NameHash == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC);
|
|
|
|
if(preferredCategory == RADIO_DJ_SPEECH_CAT_INTRO)
|
|
{
|
|
//Check if we should try and play time of day banter, ensuring that we don't hear this too often.
|
|
// NOTE: using global random stream for dj speech
|
|
if(!disableTimeCategory && audEngineUtil::ResolveProbability(g_RadioDjTimeProbability) &&
|
|
(timeInMs >= m_DjSpeechCategoryNextValidSelectionTime[RADIO_DJ_SPEECH_CAT_TIME]))
|
|
{
|
|
preferredCategory = RADIO_DJ_SPEECH_CAT_TIME;
|
|
}
|
|
}
|
|
else if(preferredCategory == RADIO_DJ_SPEECH_CAT_OUTRO) //NOTE: We don't currently have track-specific outros.
|
|
{
|
|
//Override outro speech with to... speech if we are playing a relevant track category next.
|
|
if((nextTrackCategory == RADIO_TRACK_CAT_ADVERTS) || (nextTrackCategory == RADIO_TRACK_CAT_NEWS) ||
|
|
(nextTrackCategory == RADIO_TRACK_CAT_WEATHER))
|
|
{
|
|
preferredCategory = RADIO_DJ_SPEECH_CAT_TO;
|
|
}
|
|
//Check if we should try and play time of day banter, ensuring that we don't hear this too often.
|
|
// NOTE: using global random stream for dj speech
|
|
else if(!inTakeoverState && audEngineUtil::ResolveProbability(g_RadioDjTimeProbability) &&
|
|
(timeInMs >= m_DjSpeechCategoryNextValidSelectionTime[RADIO_DJ_SPEECH_CAT_TIME]))
|
|
{
|
|
preferredCategory = RADIO_DJ_SPEECH_CAT_TIME;
|
|
}
|
|
else
|
|
{
|
|
preferredCategory = RADIO_DJ_SPEECH_CAT_GENERAL;
|
|
}
|
|
}
|
|
|
|
const char *categoryName = g_RadioDjSpeechCategoryNames[preferredCategory];
|
|
|
|
// Override GENERAL with TAKEOVER_GENERAL if we're in a takeover state, or DD_GENERAL for WCC launch event
|
|
if(preferredCategory == RADIO_DJ_SPEECH_CAT_GENERAL)
|
|
{
|
|
if(inTakeoverState)
|
|
{
|
|
categoryName = "TAKEOVER_GENERAL";
|
|
}
|
|
else if((m_NameHash == ATSTRINGHASH("RADIO_09_HIPHOP_OLD", 0x572C04) && IsTrackListUnlocked(ATSTRINGHASH("RADIO_09_HIPHOP_OLD_DD_MUSIC_LAUNCH", 0x2018C9AF))) ||
|
|
(m_NameHash == ATSTRINGHASH("RADIO_03_HIPHOP_NEW", 0xFA17DE37) && IsTrackListUnlocked(ATSTRINGHASH("RADIO_03_HIPHOP_NEW_DD_MUSIC_LAUNCH", 0x773C7204))))
|
|
{
|
|
categoryName = "DD_GENERAL";
|
|
}
|
|
else if((m_NameHash == ATSTRINGHASH("RADIO_09_HIPHOP_OLD", 0x572C04) && IsTrackListUnlocked(ATSTRINGHASH("RADIO_09_HIPHOP_OLD_DD_MUSIC_POST_LAUNCH", 0x9ACEDFBE))) ||
|
|
(m_NameHash == ATSTRINGHASH("RADIO_03_HIPHOP_NEW", 0xFA17DE37) && IsTrackListUnlocked(ATSTRINGHASH("RADIO_03_HIPHOP_NEW_DD_MUSIC_POST_LAUNCH", 0x3ED8B9F2))))
|
|
{
|
|
categoryName = "PL_GENERAL";
|
|
}
|
|
}
|
|
|
|
formatf(g_RadioDjVoiceName, "DJ_%s_%s", GetName(), categoryName);
|
|
|
|
//Determine the correct context name.
|
|
s32 gameHours = CClock::GetHour();
|
|
g_RadioDjContextName[0] = '\0';
|
|
char *bankName;
|
|
|
|
switch(preferredCategory)
|
|
{
|
|
case RADIO_DJ_SPEECH_CAT_INTRO:
|
|
case RADIO_DJ_SPEECH_CAT_OUTRO: //Intentional fall-through.
|
|
//The context name is the name of the streaming wave bank for specific intros and outros.
|
|
// If the current track has multiple text Ids then we fall back to using the text id, rather than bank name (ie mix stations)
|
|
if(m_Tracks[m_ActiveTrackIndex].GetNumTextIds() > 1)
|
|
{
|
|
char trackName[64];
|
|
formatf(trackName, "TRACK%u", m_Tracks[m_ActiveTrackIndex].GetTextId(static_cast<u32>(windowStartTime)));
|
|
strncpy(g_RadioDjContextName, trackName, g_MaxRadioNameLength);
|
|
}
|
|
else
|
|
{
|
|
bankName = (char *)m_Tracks[m_ActiveTrackIndex].GetBankName();
|
|
if(bankName)
|
|
{
|
|
const char *trackName = (const char *)strrchr(bankName, '\\');
|
|
if(trackName)
|
|
{
|
|
strncpy(g_RadioDjContextName, trackName + 1, g_MaxRadioNameLength);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RADIO_DJ_SPEECH_CAT_TIME:
|
|
if((gameHours >= (s32)g_RadioDjTimeMorningStart) &&
|
|
(gameHours < (s32)g_RadioDjTimeMorningEnd))
|
|
{
|
|
strncpy(g_RadioDjContextName, g_RadioDjMorningContext, g_MaxRadioNameLength);
|
|
}
|
|
else if((gameHours >= (s32)g_RadioDjTimeAfternoonStart) &&
|
|
(gameHours < (s32)g_RadioDjTimeAfternoonEnd))
|
|
{
|
|
strncpy(g_RadioDjContextName, g_RadioDjAfternoonContext, g_MaxRadioNameLength);
|
|
}
|
|
else if((gameHours >= (s32)g_RadioDjTimeEveningStart) &&
|
|
(gameHours < (s32)g_RadioDjTimeEveningEnd))
|
|
{
|
|
strncpy(g_RadioDjContextName, g_RadioDjEveningContext, g_MaxRadioNameLength);
|
|
}
|
|
else if((gameHours >= (s32)g_RadioDjTimeNightStart) ||
|
|
(gameHours < (s32)g_RadioDjTimeNightEnd))
|
|
{
|
|
strncpy(g_RadioDjContextName, g_RadioDjNightContext, g_MaxRadioNameLength);
|
|
}
|
|
break;
|
|
|
|
case RADIO_DJ_SPEECH_CAT_TO:
|
|
switch(nextTrackCategory)
|
|
{
|
|
case RADIO_TRACK_CAT_ADVERTS:
|
|
strncpy(g_RadioDjContextName, g_RadioDjToAdvertContext, g_MaxRadioNameLength);
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
strncpy(g_RadioDjContextName, g_RadioDjToNewsContext, g_MaxRadioNameLength);
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
strncpy(g_RadioDjContextName, g_RadioDjToWeatherContext, g_MaxRadioNameLength);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//case RADIO_DJ_SPEECH_CAT_GENERAL:
|
|
default:
|
|
strncpy(g_RadioDjContextName, categoryName, g_MaxRadioNameLength);
|
|
}
|
|
|
|
|
|
u32 variationNum;
|
|
u32 speechLengthMs = FindCompatibleDjSpeechVariation(g_RadioDjVoiceName, g_RadioDjContextName, -1, windowLengthMs, variationNum,
|
|
preferredCategory, false);
|
|
|
|
if(speechLengthMs > 0)
|
|
{
|
|
CreateDjSpeechSounds(variationNum);
|
|
}
|
|
else
|
|
{
|
|
switch(preferredCategory)
|
|
{
|
|
case RADIO_DJ_SPEECH_CAT_GENERAL:
|
|
//No additional fall-back categories.
|
|
break;
|
|
|
|
//case RADIO_DJ_SPEECH_CAT_INTRO:
|
|
//case RADIO_DJ_SPEECH_CAT_OUTRO:
|
|
//case RADIO_DJ_SPEECH_CAT_TIME:
|
|
//case RADIO_DJ_SPEECH_CAT_TO:
|
|
default:
|
|
if(!inTakeoverState)
|
|
{
|
|
//See if we have any general banter that is compatible as a fall-back.
|
|
// Don't want to do this if in a takeover segment as the takeover generals haven't been written to
|
|
// work as intros following a handover.
|
|
speechLengthMs = CreateCompatibleDjSpeech(timeInMs, RADIO_DJ_SPEECH_CAT_GENERAL, windowLengthMs, windowStartTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
return speechLengthMs;
|
|
}
|
|
|
|
void audRadioStation::PrepareIMDrivenDjSpeech(const u32 category, const u32 variationNum)
|
|
{
|
|
// TODO: deal with playing?
|
|
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
|
|
formatf(g_RadioDjVoiceName, "DJ_%s_%s", GetName(), g_RadioDjSpeechCategoryNames[category]);
|
|
formatf(g_RadioDjContextName, "%s", g_RadioDjSpeechCategoryNames[category]);
|
|
sm_IMDrivenDjSpeech = true;
|
|
sm_IMDrivenDjSpeechScheduled = false;
|
|
sm_IMDjSpeechStation = this;
|
|
|
|
audDisplayf("IM Dj Speech: Preparing %s / %s variation %u", g_RadioDjVoiceName, g_RadioDjContextName, variationNum);
|
|
|
|
CreateDjSpeechSounds(variationNum);
|
|
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_PREPARING;
|
|
}
|
|
|
|
void audRadioStation::TriggerIMDrivenDjSpeech(const u32 startTimeMs)
|
|
{
|
|
sm_ActiveDjSpeechStartTimeMs = startTimeMs;
|
|
sm_IMDrivenDjSpeechScheduled = true;
|
|
}
|
|
|
|
void audRadioStation::CancelIMDrivenDjSpeech()
|
|
{
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
}
|
|
|
|
sm_DjSpeechState = RADIO_DJ_SPEECH_STATE_IDLE;
|
|
|
|
sm_IMDrivenDjSpeechScheduled = false;
|
|
sm_IMDrivenDjSpeech = false;
|
|
}
|
|
|
|
bool audRadioStation::ChooseDjSpeechVariation(const u32 category, u32 &variationNum, u32 &lengthMs, const bool ignoreHistory)
|
|
{
|
|
char voiceName[g_MaxRadioNameLength];
|
|
char contextName[g_MaxRadioNameLength];
|
|
|
|
formatf(voiceName, "DJ_%s_%s", GetName(), g_RadioDjSpeechCategoryNames[category]);
|
|
formatf(contextName, "%s", g_RadioDjSpeechCategoryNames[category]);
|
|
|
|
lengthMs = FindCompatibleDjSpeechVariation(voiceName, contextName, 5000, 20000, variationNum, (u8)category, ignoreHistory);
|
|
if(lengthMs)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::CreateDjSpeechSounds(const u32 variationNum)
|
|
{
|
|
audSoundInitParams initParams;
|
|
initParams.TimerId = 2;
|
|
g_RadioAudioEntity.CreateSound_PersistentReference(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("DjSpeechFrontend", 0x5924EF1)),
|
|
&sm_DjSpeechMonoSound, &initParams);
|
|
if(sm_DjSpeechMonoSound)
|
|
{
|
|
//sm_DjSpeechMonoSound->SetPredelay(g_RadioDjDuckTimeMs / 2);
|
|
if(((audSpeechSound *)sm_DjSpeechMonoSound)->InitSpeech(g_RadioDjVoiceName, g_RadioDjContextName, variationNum))
|
|
{
|
|
//Initiate the preparation of this speech.
|
|
sm_DjSpeechMonoSound->Prepare(g_RadioDjSpeechWaveSlot, true);
|
|
|
|
g_RadioAudioEntity.CreateSound_PersistentReference(g_RadioAudioEntity.GetRadioSounds().Find(ATSTRINGHASH("DjSpeechPositioned", 0xD5115C83)),
|
|
&sm_DjSpeechPositionedSound, &initParams);
|
|
if(sm_DjSpeechPositionedSound)
|
|
{
|
|
//sm_DjSpeechPositionedSound->SetPredelay(g_RadioDjDuckTimeMs / 2);
|
|
if(!((audSpeechSound *)sm_DjSpeechPositionedSound)->InitSpeech(g_RadioDjVoiceName, g_RadioDjContextName, variationNum))
|
|
{
|
|
sm_DjSpeechPositionedSound->StopAndForget();
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sm_DjSpeechMonoSound->StopAndForget();
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 audRadioStation::FindCompatibleDjSpeechVariation(const char *voiceName, const char *contextName, s32 minLengthMs, s32 maxLengthMs, u32 &variationNum,
|
|
u8 djSpeechCategory, const bool ignoreHistory) const
|
|
{
|
|
u32 selectedLengthMs = 0;
|
|
|
|
|
|
audDebugf1("DJSPEECH: FindCompatibleDjSpeechVariation voice name: %s, contextName %s, minLength %d, maxLength %d", voiceName, contextName, minLengthMs, maxLengthMs);
|
|
|
|
u32 numVariations;
|
|
u8 variationData[g_RadioDjMaxVariations];
|
|
u32 variationUids[g_RadioDjMaxVariations];
|
|
audSpeechSound::FindVariationInfoForVoiceAndContext(voiceName, contextName, numVariations, variationData, variationUids);
|
|
|
|
if(numVariations > 0)
|
|
{
|
|
//See if any of the variations fit within our window.
|
|
s32 numCompatibleVariations = 0;
|
|
u32 compatibleVariationIndices[g_RadioDjMaxVariations];
|
|
for(u32 i=0; i<numVariations; i++)
|
|
{
|
|
u32 speechLengthMs = (u32)(variationData[i]) * 100;
|
|
if((s32)speechLengthMs < maxLengthMs && minLengthMs <= (s32)speechLengthMs)
|
|
{
|
|
//Check if this DJ speech is in the history.
|
|
// - Make sure we don't look over too much history???
|
|
u8 historyLength = g_MaxDjSpeechInHistory;
|
|
bool isSpeechInHistory = false;
|
|
|
|
if(!ignoreHistory)
|
|
{
|
|
for(u8 historyOffset=0; historyOffset<historyLength; historyOffset++)
|
|
{
|
|
u8 historyIndex = (m_DjSpeechHistoryWriteIndex + g_MaxDjSpeechInHistory - 1 - historyOffset) %
|
|
g_MaxDjSpeechInHistory;
|
|
if(m_DjSpeechHistory[historyIndex] == variationUids[i])
|
|
{
|
|
isSpeechInHistory = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!isSpeechInHistory)
|
|
{
|
|
// url:bugstar:7459269 - MOTOMAMI Los Santos - incorrect DJ line[Arca - KLK]
|
|
// Prevent variation _01 from being selected
|
|
if (i == 0 && m_NameHash == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC) && djSpeechCategory == RADIO_DJ_SPEECH_CAT_INTRO && atStringHash(contextName) == ATSTRINGHASH("KLK", 0xC2A78E3B))
|
|
{
|
|
audDebugf1("DJSPEECH: FindCompatibleDjSpeechVariation ignoring variation 1 for RADIO_DJ_SPEECH_CAT_INTRO context KLK");
|
|
continue;
|
|
}
|
|
|
|
compatibleVariationIndices[numCompatibleVariations] = i;
|
|
numCompatibleVariations++;
|
|
}
|
|
}
|
|
}
|
|
|
|
audDebugf1("DJSPEECH found %u variations, %u compatible", numVariations, numCompatibleVariations);
|
|
|
|
if(numCompatibleVariations > 0)
|
|
{
|
|
//Choose a random variation from those that are compatible.
|
|
// NOTE: currently using global random stream for DJ speech, rather than per-station stream
|
|
s32 randomVariationIndex = audEngineUtil::GetRandomNumberInRange(0, numCompatibleVariations - 1);
|
|
u32 variationIndex = compatibleVariationIndices[randomVariationIndex];
|
|
//Variations are not zero-based, so add one.
|
|
variationNum = variationIndex + 1;
|
|
selectedLengthMs = (u32)(variationData[variationIndex]) * 100;
|
|
|
|
sm_ActiveDjSpeechId = variationUids[variationIndex];
|
|
sm_ActiveDjSpeechCategory = djSpeechCategory;
|
|
|
|
audDebugf1("Chose variation %u for context %s (voice %s). Length: %u (varData: %u)", variationNum, contextName, voiceName, selectedLengthMs, variationData[variationIndex]);
|
|
}
|
|
}
|
|
|
|
return selectedLengthMs;
|
|
}
|
|
|
|
void audRadioStation::UpdateStereoEmitter(f32 volumeFactor, f32 cutoff)
|
|
{
|
|
//Calculate the volume to be applied.
|
|
f32 volumeLinear = Max<f32>(sm_VehicleRadioRiseVolumeCurve.CalculateValue(volumeFactor), g_SilenceVolumeLin);
|
|
|
|
//Apply a smoothed duck when DJ speech is active.
|
|
|
|
#if __BANK
|
|
//Recompute the linear ducking level and smoothing rate, as they might have changed via widgets.
|
|
g_RadioDjDuckingLevelLin = audDriverUtil::ComputeLinearVolumeFromDb(g_RadioDjDuckingLevelDb);
|
|
f32 increaseDecreaseRate = 1.0f / (f32)g_RadioDjDuckTimeMs;
|
|
sm_DjDuckerVolumeSmoother.SetRate(increaseDecreaseRate);
|
|
#endif // __BANK
|
|
|
|
f32 djDuckingOffsetLin = sm_DjDuckerVolumeSmoother.CalculateValue(isDjSpeaking() ? g_RadioDjDuckingLevelLin : 1.0f,
|
|
g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2));
|
|
|
|
// Store stereo emitter volume for player station
|
|
if(this == g_RadioAudioEntity.GetPlayerRadioStation())
|
|
{
|
|
f32 djVolumeDb = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinear);
|
|
djVolumeDb += g_RadioAudioEntity.GetVolumeOffset();
|
|
|
|
sm_DjSpeechFrontendVolume = djVolumeDb;
|
|
sm_DjSpeechFrontendLPF = cutoff;
|
|
}
|
|
|
|
// don't apply ducking to Dj
|
|
volumeLinear /= djDuckingOffsetLin;
|
|
|
|
//Apply the volume.
|
|
for(u8 trackIndex=0; trackIndex<2; trackIndex++)
|
|
{
|
|
f32 volumeDb = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinear * GetMixTransitionVolumeLinear(trackIndex));
|
|
volumeDb += g_RadioAudioEntity.GetVolumeOffset();
|
|
m_Tracks[trackIndex].UpdateStereoEmitter(volumeDb,cutoff);
|
|
}
|
|
}
|
|
|
|
f32 audRadioStation::GetMixTransitionVolumeLinear(u32 trackIndex) const
|
|
{
|
|
if (m_IsPlayingMixTransition)
|
|
{
|
|
s32 playTime = m_Tracks[trackIndex].GetPlayTime();
|
|
|
|
if (playTime < g_RadioTrackMixtransitionTimeMs)
|
|
{
|
|
return Max(0, (playTime - g_RadioTrackMixtransitionOffsetTimeMs)) / (f32)g_RadioTrackMixtransitionTimeMs;
|
|
}
|
|
else if (playTime >= m_Tracks[trackIndex].GetDuration() - g_RadioTrackMixtransitionTimeMs)
|
|
{
|
|
s32 timeRemaining = Max(0, (s32)m_Tracks[trackIndex].GetDuration() - g_RadioTrackMixtransitionOffsetTimeMs - playTime);
|
|
return timeRemaining / (f32)g_RadioTrackMixtransitionTimeMs;
|
|
}
|
|
}
|
|
|
|
return 1.f;
|
|
}
|
|
|
|
#if RSG_ASSERT
|
|
void audRadioStation::ValidateEnvironmentMetric(const audEnvironmentGameMetric *occlusionMetric) const
|
|
{
|
|
char extraInfo[128];
|
|
formatf(extraInfo, "metric: %p", occlusionMetric);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetReverbLarge(), "ReverbLarge", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetReverbMedium(), "ReverbMedium", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetReverbSmall(), "ReverbSmall", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetDryLevel(), "DryLevel", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetLeakageFactor(), "LeakageFactor", extraInfo);
|
|
naAssertf(FPIsFinite(occlusionMetric->GetRolloffFactor()), "Non-finite RolloffFactor, %s", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetDistanceAttenuationDamping(), "DistanceAttenuationDamping", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetOcclusionAttenuationLin(), "OcclusionAttenuationLin", extraInfo);
|
|
ValidateEnvironmentMetricInRange(occlusionMetric->GetOcclusionFilterCutoffLin(), "OcclusionFilterCutoffLin", extraInfo);
|
|
if(occlusionMetric->GetUseOcclusionPath())
|
|
{
|
|
naAssertf(FPIsFinite(occlusionMetric->GetOcclusionPathDistance()), "Non-finite occlusion path distance, %s", extraInfo);
|
|
naAssertf(FPIsFinite(MagSquared(occlusionMetric->GetOcclusionPathPosition()).Getf()), "Non-finite occlusion path position, %s [%f,%f,%f]", extraInfo, occlusionMetric->GetOcclusionPathPosition().GetX().Getf(), occlusionMetric->GetOcclusionPathPosition().GetY().Getf(), occlusionMetric->GetOcclusionPathPosition().GetZ().Getf());
|
|
}
|
|
|
|
}
|
|
|
|
void audRadioStation::ValidateEnvironmentMetricInRange(const float val, const char *valName, const char *extraInfo) const
|
|
{
|
|
naAssertf(val >= 0.f && val <= 1.f, "Invalid %s value %f. %s", valName, val, extraInfo);
|
|
}
|
|
|
|
#endif // RSG_ASSERT
|
|
|
|
void audRadioStation::UpdatePositionedEmitter(const u32 emitterIndex, const f32 emittedVolume, const f32 volumeFactor,
|
|
const Vector3 &position, const u32 LPFCutoff, const u32 HPFCutoff, const audEnvironmentGameMetric *occlusionMetric, const u32 emitterType, const f32 environmentalLoudness, bool isPlayerVehicleRadioEmitter)
|
|
{
|
|
ASSERT_ONLY(ValidateEnvironmentMetric(occlusionMetric));
|
|
|
|
//Calculate the volume to be applied.
|
|
f32 volumeLinear = Max<f32>(sm_VehicleRadioRiseVolumeCurve.CalculateValue(volumeFactor), g_SilenceVolumeLin);
|
|
|
|
//Apply a smoothed duck when DJ speech is active.
|
|
|
|
#if __BANK
|
|
//Recompute the linear ducking level and smoothing rate, as they might have changed via widgets.
|
|
g_RadioDjDuckingLevelLin = audDriverUtil::ComputeLinearVolumeFromDb(g_RadioDjDuckingLevelDb);
|
|
f32 increaseDecreaseRate = 1.0f / (f32)g_RadioDjDuckTimeMs;
|
|
sm_DjDuckerVolumeSmoother.SetRate(increaseDecreaseRate);
|
|
#endif // __BANK
|
|
|
|
if(this == g_RadioAudioEntity.GetPlayerRadioStation() && g_RadioAudioEntity.GetLastPlayerVehicle())
|
|
{
|
|
// only duck for player station emitters
|
|
f32 djDuckingOffsetLin = sm_DjDuckerVolumeSmoother.CalculateValue(isDjSpeaking() ? g_RadioDjDuckingLevelLin : 1.0f,
|
|
g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(2));
|
|
volumeLinear /= djDuckingOffsetLin;
|
|
}
|
|
|
|
if(isPlayerVehicleRadioEmitter)
|
|
{
|
|
sm_PositionedPlayerVehicleRadioLPFCutoff = LPFCutoff;
|
|
sm_PositionedPlayerVehicleRadioHPFCutoff = HPFCutoff;
|
|
sm_PositionedPlayerVehicleRadioEnvironmentalLoudness = environmentalLoudness;
|
|
sm_PositionedPlayerVehicleRadioVolume = emittedVolume;
|
|
sm_PositionedPlayerVehicleRadioRollOff = occlusionMetric->GetRolloffFactor();
|
|
}
|
|
|
|
//Apply the volume, cutoff and position to the emitter.
|
|
for(u8 trackIndex=0; trackIndex<2; trackIndex++)
|
|
{
|
|
f32 volumeOffsetDb = audDriverUtil::ComputeDbVolumeFromLinear(volumeLinear * GetMixTransitionVolumeLinear(trackIndex));
|
|
volumeOffsetDb += g_RadioAudioEntity.GetVolumeOffset();
|
|
m_Tracks[trackIndex].UpdatePositionedEmitter(emitterIndex, emittedVolume, volumeOffsetDb, LPFCutoff, HPFCutoff, position, occlusionMetric, emitterType, environmentalLoudness);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::MuteEmitters()
|
|
{
|
|
for(u8 trackIndex=0; trackIndex<2; trackIndex++)
|
|
{
|
|
m_Tracks[trackIndex].MuteEmitters();
|
|
}
|
|
}
|
|
|
|
const RadioStationTrackList::tTrack *audRadioStation::GetTrack(const s32 category, const u32 context, const s32 trackIndex, bool ignoreLocking) const
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
#if RSG_PC
|
|
if(category == RADIO_TRACK_CAT_MUSIC && m_IsUserStation)
|
|
{
|
|
return trackLists->GetTrack(0);
|
|
}
|
|
#endif
|
|
if(!trackLists)
|
|
{
|
|
return NULL;
|
|
}
|
|
return trackLists->GetTrack(trackIndex, context, ignoreLocking);
|
|
}
|
|
|
|
void audRadioStation::AddActiveTrackToHistory()
|
|
{
|
|
bool disableNetworkModeForStation = m_UseRandomizedStrideSelection;
|
|
WIN32PC_ONLY(disableNetworkModeForStation = m_IsUserStation);
|
|
|
|
if(!disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised())
|
|
{
|
|
const s32 category = m_Tracks[m_ActiveTrackIndex].GetCategory();
|
|
|
|
// only on player station...
|
|
if(category == RADIO_TRACK_CAT_NEWS)
|
|
{
|
|
if(g_RadioAudioEntity.IsPlayerRadioActive() &&
|
|
g_RadioAudioEntity.GetPlayerRadioStation() == this)
|
|
{
|
|
const u32 newsStoryId = m_Tracks[m_ActiveTrackIndex].GetTrackIndex();
|
|
naAssertf(newsStoryId < sm_NewsTrackLists.ComputeNumTracks(), "Track index is out of bounds");
|
|
if(sm_NewsStoryState[newsStoryId] == (RADIO_NEWS_ONCE_ONLY|RADIO_NEWS_UNLOCKED))
|
|
{
|
|
naDisplayf("Locking news story %u", newsStoryId+1);
|
|
sm_NewsStoryState[newsStoryId] = RADIO_NEWS_ONCE_ONLY;
|
|
}
|
|
|
|
// Generic news plays sequentially, so update the last played index
|
|
if((sm_NewsStoryState[newsStoryId] & RADIO_NEWS_ONCE_ONLY) == 0 && sm_NewsHistory[0] != static_cast<u32>(m_Tracks[m_ActiveTrackIndex].GetTrackIndex()))
|
|
{
|
|
audDisplayf("Generic news story - history index was %d, now %d", sm_NewsHistory[0] + 1, newsStoryId + 1);
|
|
sm_NewsHistory[0] = m_Tracks[m_ActiveTrackIndex].GetTrackIndex();
|
|
}
|
|
}
|
|
// News doesn't rely on normal history tracking - if the player isn't explicitly listening to this track then we don't want to lock it
|
|
return;
|
|
}
|
|
|
|
if(m_UseRandomizedStrideSelection || (category == RADIO_TRACK_CAT_MUSIC && m_PlaySequentialMusicTracks))
|
|
{
|
|
// we update the sequential index when we pick a track
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(category));
|
|
if(history)
|
|
{
|
|
u32 trackId = m_Tracks[m_ActiveTrackIndex].GetRefForHistory();
|
|
#if RSG_PC // user music - this was tracked differently in GTA IV this may need fixed SORR
|
|
if(m_IsUserStation && category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
trackId = m_Tracks[m_ActiveTrackIndex].GetTrackIndex();
|
|
}
|
|
#endif
|
|
//Make sure we didn't already add this track.
|
|
if(history->GetPreviousEntry() != trackId)
|
|
{
|
|
history->AddToHistory(trackId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const audRadioStationHistory *audRadioStation::FindHistoryForCategory(const s32 category) const
|
|
{
|
|
#if RSG_PC
|
|
if(m_IsUserStation && category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
return sm_UserRadioTrackManager.GetHistory();
|
|
}
|
|
#endif
|
|
// We use a single history per station for network synched radio
|
|
if(!m_UseRandomizedStrideSelection && (PARAM_disableradiohistory.Get() || IsNetworkModeHistoryActive()))
|
|
{
|
|
return &m_MusicTrackHistory;
|
|
}
|
|
|
|
switch(category)
|
|
{
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
return &sm_WeatherHistory;
|
|
case RADIO_TRACK_CAT_ADVERTS:
|
|
return &sm_AdvertHistory;
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
return &m_MusicTrackHistory;
|
|
case RADIO_TRACK_CAT_TAKEOVER_MUSIC:
|
|
// NOTE: We dont support network sync for Takeover music in Sequential mode; this is purely to allow us to capture
|
|
// the station in sequential mode, and isnt expected to be used in final.
|
|
if(m_PlaySequentialMusicTracks)
|
|
{
|
|
return &m_TakeoverMusicTrackHistory;
|
|
}
|
|
else if (m_HasTakeoverContent || m_UseRandomizedStrideSelection)
|
|
{
|
|
return &m_TakeoverMusicTrackHistory;
|
|
}
|
|
else
|
|
{
|
|
return &m_MusicTrackHistory;
|
|
}
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
return &m_IdentTrackHistory;
|
|
case RADIO_TRACK_CAT_TAKEOVER_IDENTS:
|
|
return &m_TakeoverIdentTrackHistory;
|
|
case RADIO_TRACK_CAT_DJSOLO:
|
|
return &m_DjSoloTrackHistory;
|
|
case RADIO_TRACK_CAT_TAKEOVER_DJSOLO:
|
|
return &m_TakeoverDjSoloTrackHistory;
|
|
case RADIO_TRACK_CAT_TO_AD:
|
|
return &m_ToAdTrackHistory;
|
|
case RADIO_TRACK_CAT_TO_NEWS:
|
|
return &m_ToNewsTrackHistory;
|
|
case RADIO_TRACK_CAT_USER_INTRO:
|
|
return &m_UserIntroTrackHistory;
|
|
case RADIO_TRACK_CAT_USER_OUTRO:
|
|
return &m_UserOutroTrackHistory;
|
|
case RADIO_TRACK_CAT_INTRO_MORNING:
|
|
return &m_UserIntroMorningTrackHistory;
|
|
case RADIO_TRACK_CAT_INTRO_EVENING:
|
|
return &m_UserIntroEveningTrackHistory;
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
default:
|
|
audAssertf(false, "Invalid track category %u", category);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
bool audRadioStation::IsTrackInHistory(const u32 trackId, const s32 category, const s32 historyLength) const
|
|
{
|
|
const audRadioStationHistory *history = FindHistoryForCategory(category);
|
|
if(history)
|
|
{
|
|
const bool ret = history->IsInHistory(trackId, historyLength);
|
|
#if __BANK
|
|
if(g_DebugRadioRandom && ret)
|
|
{
|
|
naDebugf1("%s - skipping track id %08X (%s) due to history", GetName(), trackId, TrackCats_ToString((TrackCats)category));
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool audRadioStation::IsLocked() const
|
|
{
|
|
bool stationLocked = AUD_GET_TRISTATE_VALUE(m_StationSettings->Flags, FLAG_ID_RADIOSTATIONSETTINGS_LOCKED) == AUD_TRISTATE_TRUE;
|
|
return stationLocked;
|
|
}
|
|
|
|
s32 audRadioStation::GetRandomNumberInRange(const s32 min, const s32 max)
|
|
{
|
|
BANK_ONLY(u32 seed = m_Random.GetSeed());
|
|
|
|
s32 ret = m_Random.GetRanged(min, max);
|
|
|
|
#if __BANK
|
|
if(g_DebugRadioRandom)
|
|
naDebugf1("%s - GetRandomNumberInRange(%d, %d) - %d (seed was %u)", GetName(), min, max, ret, seed);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
float audRadioStation::GetRandomNumberInRange(const float min, const float max)
|
|
{
|
|
BANK_ONLY(u32 seed = m_Random.GetSeed());
|
|
float ret = m_Random.GetRanged(min, max);
|
|
#if __BANK
|
|
if(g_DebugRadioRandom)
|
|
naDebugf1("%s - GetRandomNumberInRange(%f, %f) - %f (seed was %u)", GetName(), min, max, ret, seed);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
bool audRadioStation::ResolveProbability(const float Probability)
|
|
{
|
|
if (Probability >= 1.0f)
|
|
{
|
|
#if __BANK
|
|
if(g_DebugRadioRandom)
|
|
naDebugf1("%s - ResolveProbability(%f) - true", GetName(), Probability);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
float r = GetRandomNumberInRange(0.0f, 1.0f);
|
|
#if __BANK
|
|
if(g_DebugRadioRandom)
|
|
naDebugf1("%s - ResolveProbability(%f) - %f (%s)", GetName(), Probability, r, r < Probability ? "true" : "false");
|
|
#endif
|
|
return (r < Probability);
|
|
}
|
|
|
|
bool audRadioStation::IsValidCategoryForStation(const TrackCats category, const bool playNews) const
|
|
{
|
|
switch(category)
|
|
{
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
return playNews;
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
return m_PlayWeather;
|
|
|
|
case RADIO_TRACK_CAT_INTRO_MORNING:
|
|
case RADIO_TRACK_CAT_INTRO_EVENING:
|
|
#if RSG_PC
|
|
if(m_IsUserStation && m_MusicRunningCount > 1 && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO)
|
|
{
|
|
const s32 gameHours = CClock::GetHour();
|
|
if(category == RADIO_TRACK_CAT_INTRO_MORNING)
|
|
{
|
|
return (gameHours >= (s32)g_RadioDjTimeMorningStart && gameHours < (s32)g_RadioDjTimeMorningEnd);
|
|
}
|
|
else
|
|
{
|
|
// Evening
|
|
return (gameHours >= (s32)g_RadioDjTimeEveningStart && gameHours < (s32)g_RadioDjTimeEveningEnd);
|
|
}
|
|
}
|
|
#endif
|
|
return false;
|
|
|
|
case RADIO_TRACK_CAT_USER_INTRO:
|
|
#if RSG_PC
|
|
return m_IsUserStation && m_MusicRunningCount > 1 && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO;
|
|
#else
|
|
return false;
|
|
#endif // RSG_PC
|
|
case RADIO_TRACK_CAT_TO_AD:
|
|
case RADIO_TRACK_CAT_TO_NEWS:
|
|
#if RSG_PC
|
|
return m_IsUserStation && m_MusicRunningCount > 1 && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO;
|
|
#else
|
|
return false;
|
|
#endif // RSG_PC
|
|
|
|
case RADIO_TRACK_CAT_USER_OUTRO:
|
|
#if RSG_PC
|
|
// avoid outro after only one song.
|
|
return m_IsUserStation && m_MusicRunningCount > 1 && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO;
|
|
#else
|
|
return false;
|
|
#endif
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
#if RSG_PC
|
|
// prevent runs longer than 3 songs
|
|
// TODO: factor in time
|
|
if(m_IsUserStation && sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO && m_MusicRunningCount >= 3)
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
return true;
|
|
case RADIO_TRACK_CAT_DJSOLO:
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
return sm_UserRadioTrackManager.GetRadioMode() == USERRADIO_PLAY_MODE_RADIO && m_MusicRunningCount > 1;
|
|
}
|
|
#endif
|
|
return true;
|
|
|
|
case RADIO_TRACK_CAT_TAKEOVER_DJSOLO:
|
|
case RADIO_TRACK_CAT_TAKEOVER_IDENTS:
|
|
case RADIO_TRACK_CAT_TAKEOVER_MUSIC:
|
|
return m_HasTakeoverContent;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
u8 audRadioStation::ComputeNextTrackCategoryForTakeoverStation(u32 timeInMs, u32 activeTrackCategory)
|
|
{
|
|
audDisplayf("Takeover station calculating next category at %ums, active track category %u, seed %u, takeover time %u, music count %u", timeInMs, activeTrackCategory, m_Random.GetSeed(), m_TakeoverLastTimeMs, m_MusicRunningCount);
|
|
|
|
u8 nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
switch(activeTrackCategory)
|
|
{
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
// Should we go into a takeover state?
|
|
if(timeInMs >= m_TakeoverLastTimeMs + m_TakeoverMinTimeMs && ResolveProbability(m_TakeoverProbability))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_TAKEOVER_IDENTS;
|
|
}
|
|
else
|
|
{
|
|
// check music running counter
|
|
if(m_MusicRunningCount > 2 || (m_MusicRunningCount>1&&ResolveProbability(0.35f)))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
}
|
|
else
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
// DJSOLOs are only going to follow IDENTs on this station
|
|
nextTrackCategory = (u8)(ResolveProbability(0.75f) ? RADIO_TRACK_CAT_DJSOLO : RADIO_TRACK_CAT_MUSIC);
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_TAKEOVER_IDENTS:
|
|
if(ResolveProbability(m_TakeoverDjSoloProbability))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_TAKEOVER_DJSOLO;
|
|
}
|
|
else
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_TAKEOVER_MUSIC;
|
|
}
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_TAKEOVER_DJSOLO:
|
|
nextTrackCategory = RADIO_TRACK_CAT_TAKEOVER_MUSIC;
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_TAKEOVER_MUSIC:
|
|
if(m_TakeoverMusicTrackCounter == 0)
|
|
{
|
|
// End the takeover
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
}
|
|
else
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_TAKEOVER_MUSIC;
|
|
}
|
|
break;
|
|
|
|
//case g_NullRadioTrackCategory: - Start on music.
|
|
default:
|
|
//Transition to music only.
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
break;
|
|
|
|
}
|
|
|
|
audDisplayf("Takeover station calculated next category as %s", TrackCats_ToString((TrackCats)nextTrackCategory));
|
|
return nextTrackCategory;
|
|
}
|
|
|
|
bool audRadioStation::PlayIdentsInsteadOfAds() const
|
|
{
|
|
// Special case, we want to play idents instead of adverts on West Coast Classics during the launch event. Safer to link this to the actual track list collection
|
|
// being unlocked rather than the tuneable so that we can ensure we stay in sync with whatever script is doing in terms of maintaining the station's SP/MP state
|
|
if(m_NameHash == ATSTRINGHASH("RADIO_09_HIPHOP_OLD", 0x572C04) && IsTrackListUnlocked(ATSTRINGHASH("RADIO_09_HIPHOP_OLD_DD_MUSIC_LAUNCH", 0x2018C9AF)))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return m_PlayIdentsInsteadOfAds;
|
|
}
|
|
|
|
u8 audRadioStation::ComputeNextTrackCategory(u32 timeInMs)
|
|
{
|
|
u8 nextTrackCategory = 0;
|
|
const RadioTrackCategoryData *weights;
|
|
f32 weightSum = 0.0f;
|
|
f32 r = 0.0f;
|
|
|
|
if(m_ForceNextTrackCategory != 0xff)
|
|
{
|
|
const u8 ret = m_ForceNextTrackCategory;
|
|
m_ForceNextTrackCategory = 0xff;
|
|
return ret;
|
|
}
|
|
|
|
#if RSG_PC
|
|
if(m_BadTrackCount > 4)
|
|
{
|
|
Warningf("Forcing an advert as bad track count is > 4");
|
|
m_ShouldPlayFullRadio = true;
|
|
sm_IsInRecoveryMode = true;
|
|
return RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
if(sm_IsInRecoveryMode)
|
|
{
|
|
// keep trying to play music until we are either successful or bad track count hits
|
|
// the limit
|
|
return RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
#endif
|
|
|
|
u32 activeTrackCategory = m_Tracks[m_ActiveTrackIndex].GetCategory();
|
|
|
|
if(m_OnlyPlayAds)
|
|
{
|
|
//@@: location AUDRADIOSTATION_COMPUTENEXTTRACKCATEGORY_RETURN_ADVERTISEMENTS
|
|
return RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
|
|
if(ShouldOnlyPlayMusic())
|
|
{
|
|
return RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
|
|
// see if there are any unlocked mission stories; no back to back news however
|
|
// only for player station
|
|
bool hasUnlockedNews = false;
|
|
if(!IsNetworkModeHistoryActive())
|
|
{
|
|
for(u32 i = 0; i < kMaxNewsStories; i++)
|
|
{
|
|
if(sm_NewsStoryState[i] == (RADIO_NEWS_UNLOCKED|RADIO_NEWS_ONCE_ONLY))
|
|
{
|
|
hasUnlockedNews = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// only play news on the player station
|
|
const bool playNews = m_PlayNews && !IsNetworkModeHistoryActive() && !PARAM_disableradiohistory.Get() &&
|
|
g_RadioAudioEntity.IsPlayerRadioActive() && g_RadioAudioEntity.GetPlayerRadioStation() == this;
|
|
|
|
if(playNews && activeTrackCategory != RADIO_TRACK_CAT_NEWS &&
|
|
hasUnlockedNews &&
|
|
timeInMs >= GetNextValidSelectionTime(RADIO_TRACK_CAT_NEWS))
|
|
{
|
|
m_HasJustPlayedBackToBackMusic = false;
|
|
m_HasJustPlayedBackToBackAds = false;
|
|
#if RSG_PC
|
|
if(m_IsUserStation && activeTrackCategory != RADIO_TRACK_CAT_TO_NEWS)
|
|
{
|
|
return RADIO_TRACK_CAT_TO_NEWS;
|
|
}
|
|
#endif
|
|
return RADIO_TRACK_CAT_NEWS;
|
|
}
|
|
|
|
#if RSG_PC
|
|
if(m_IsUserStation && !HasUserTracks() && activeTrackCategory == RADIO_TRACK_CAT_IDENTS)
|
|
{
|
|
// act like we have just played music so we can transition to anything
|
|
activeTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
#endif
|
|
|
|
if(m_HasTakeoverContent)
|
|
{
|
|
nextTrackCategory = ComputeNextTrackCategoryForTakeoverStation(m_StationAccumulatedPlayTimeMs, activeTrackCategory);
|
|
}
|
|
else
|
|
{
|
|
switch(activeTrackCategory)
|
|
{
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
|
|
|
|
//Transition to any category.
|
|
if(m_NoBackToBackMusic && activeTrackCategory == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
// we just played a music track so don't want to allow another music track
|
|
weights = sm_RadioTrackCategoryWeightsNoBackToBackMusic;
|
|
}
|
|
else if(m_HasJustPlayedBackToBackMusic)
|
|
{
|
|
//We already played back-to-back music, so prevent another music track (or ident->music) being chosen.
|
|
weights = m_NameHash == ATSTRINGHASH("RADIO_34_DLC_HEI4_KULT", 0xE3442163) ? sm_RadioTrackCategoryWeightsFromBackToBackMusicKult : sm_RadioTrackCategoryWeightsFromBackToBackMusic;
|
|
}
|
|
else
|
|
{
|
|
weights = m_NameHash == ATSTRINGHASH("RADIO_34_DLC_HEI4_KULT", 0xE3442163) ? sm_RadioTrackCategoryWeightsNoBackToBackMusicKult : sm_RadioTrackCategoryWeightsFromMusic;
|
|
}
|
|
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
weights = sm_UserMusicWeightsFromMusic;
|
|
// Default to music if we've temporarily exhausted all other valid categories.
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
#endif
|
|
//Compute sum of weights; only for valid track cats.
|
|
{
|
|
#if RSG_PC
|
|
const u32 lastCat = m_IsUserStation ? RADIO_TRACK_CAT_INTRO_EVENING : RADIO_TRACK_CAT_DJSOLO;
|
|
#else
|
|
const u32 lastCat = RADIO_TRACK_CAT_DJSOLO;
|
|
#endif
|
|
bool validTimeForCategory = true;
|
|
for(u32 i = 0; i <= lastCat; i++) // TODO: re-enable new categories after audio sync
|
|
{
|
|
if(weights)
|
|
{
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
validTimeForCategory = timeInMs >= GetNextValidSelectionTime(weights->Category[i].Category);
|
|
}
|
|
#endif
|
|
if(IsValidCategoryForStation((TrackCats)weights->Category[i].Category, playNews) && validTimeForCategory)
|
|
{
|
|
f32 modifiedWeight = (float)weights->Category[i].Value;
|
|
weightSum += modifiedWeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Compute random r in range [0.0f, weightSum].
|
|
r = GetRandomNumberInRange(0.0f, weightSum);
|
|
|
|
//Find where r falls in weight range to pick category.
|
|
for(u32 i = 0; i <= lastCat; i++) // TODO: re-enable new categories after audio sync
|
|
{
|
|
if(weights)
|
|
{
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
validTimeForCategory = timeInMs >= GetNextValidSelectionTime(weights->Category[i].Category);
|
|
}
|
|
#endif
|
|
if(IsValidCategoryForStation((TrackCats)weights->Category[i].Category, playNews) && validTimeForCategory)
|
|
{
|
|
|
|
f32 modifiedWeight = (float)weights->Category[i].Value;
|
|
r -= modifiedWeight;
|
|
|
|
if((weights->Category[i].Value > 0.0f) && (r <= 0.0f))
|
|
{
|
|
nextTrackCategory = weights->Category[i].Category;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// only choose news if we don't have any unlocked mission stories waiting to go (since we only want to play them on
|
|
// the player station; picking news here will mean we don't play another news for a few mins even if this plays virtually)
|
|
if(nextTrackCategory == RADIO_TRACK_CAT_NEWS && hasUnlockedNews)
|
|
{
|
|
RADIODEBUG("Playing an advert instead of news since not player station and there is a pending mission news story");
|
|
nextTrackCategory = RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
else
|
|
{
|
|
//Ensure that we don't hear news and weather too often on this station.
|
|
if((nextTrackCategory == RADIO_TRACK_CAT_NEWS) ||
|
|
(nextTrackCategory == RADIO_TRACK_CAT_WEATHER))
|
|
{
|
|
if(timeInMs < GetNextValidSelectionTime(nextTrackCategory))
|
|
{
|
|
//We heard this category too recently, so play something else instead.
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
BANK_ONLY(audDisplayf("%s - falling back to music rather than %s due to selection time", GetName(), GetTrackCategoryName(nextTrackCategory)));
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
else
|
|
#endif
|
|
nextTrackCategory = RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case RADIO_TRACK_CAT_INTRO_MORNING:
|
|
case RADIO_TRACK_CAT_INTRO_EVENING:
|
|
case RADIO_TRACK_CAT_USER_INTRO:
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
break;
|
|
case RADIO_TRACK_CAT_TO_AD:
|
|
nextTrackCategory = RADIO_TRACK_CAT_ADVERTS;
|
|
break;
|
|
case RADIO_TRACK_CAT_TO_NEWS:
|
|
nextTrackCategory = RADIO_TRACK_CAT_NEWS;
|
|
break;
|
|
case RADIO_TRACK_CAT_USER_OUTRO:
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
break;
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
//Transition to music only.
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_ADVERTS:
|
|
// No back-to-back adverts in the network game to maximise history usage for songs
|
|
if(!IsNetworkModeHistoryActive() && m_PlaysBackToBackAds && !m_HasJustPlayedBackToBackAds && ResolveProbability(0.25f))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
else
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
}
|
|
break;
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
break;
|
|
|
|
//case g_NullRadioTrackCategory: - Start on music.
|
|
default:
|
|
//Transition to music only.
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
#if RSG_PC // user music
|
|
if(m_IsUserStation && activeTrackCategory != RADIO_TRACK_CAT_DJSOLO && ResolveProbability(0.5f))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_USER_INTRO;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if(nextTrackCategory == RADIO_TRACK_CAT_ADVERTS && PlayIdentsInsteadOfAds())
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
}
|
|
|
|
if(m_NameHash == ATSTRINGHASH("RADIO_37_MOTOMAMI", 0x97074FCC))
|
|
{
|
|
if(m_MusicRunningCount < 2)
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_MUSIC;
|
|
}
|
|
else if(nextTrackCategory == RADIO_TRACK_CAT_DJSOLO)
|
|
{
|
|
if(ResolveProbability(0.2f))
|
|
{
|
|
nextTrackCategory = RADIO_TRACK_CAT_IDENTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_HasJustPlayedBackToBackMusic = (activeTrackCategory == RADIO_TRACK_CAT_MUSIC) && (nextTrackCategory == RADIO_TRACK_CAT_MUSIC);
|
|
m_HasJustPlayedBackToBackAds = (activeTrackCategory == RADIO_TRACK_CAT_ADVERTS && nextTrackCategory == RADIO_TRACK_CAT_ADVERTS);
|
|
|
|
// Update this along with m_TakeoverMusicTrackCounter for takeover stations
|
|
if(!m_HasTakeoverContent)
|
|
{
|
|
if(nextTrackCategory == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
m_MusicRunningCount++;
|
|
}
|
|
else
|
|
{
|
|
m_MusicRunningCount = 0;
|
|
}
|
|
}
|
|
|
|
return nextTrackCategory;
|
|
}
|
|
|
|
const RadioStationTrackList::tTrack *audRadioStation::ComputeRandomTrack(s32 &category, s32 &index)
|
|
{
|
|
naCErrorf(category < NUM_RADIO_TRACK_CATS, "Category for random track (%d) is invalid", category);
|
|
|
|
if(/* m_ForceNextTrackContext != kNullContext && */ m_ForceNextTrackIndex != 0xffff)
|
|
{
|
|
naDisplayf("Forcing track index %u context %u category %d", m_ForceNextTrackIndex, m_ForceNextTrackContext, category);
|
|
const RadioStationTrackList::tTrack *ret = GetTrack(category, m_ForceNextTrackContext, m_ForceNextTrackIndex, true);
|
|
Assign(index, m_ForceNextTrackIndex);
|
|
m_ForceNextTrackIndex = 0xffff;
|
|
m_ForceNextTrackContext = kNullContext;
|
|
|
|
return ret;
|
|
}
|
|
|
|
u32 requiredContext = kNullContext;
|
|
if(m_ForceNextTrackContext != kNullContext)
|
|
{
|
|
requiredContext = m_ForceNextTrackContext;
|
|
m_ForceNextTrackContext = kNullContext;
|
|
}
|
|
else
|
|
{
|
|
//Deal with custom News and Weather contexts.
|
|
const bool isNightTime = (CClock::GetHour() > 18 || CClock::GetHour() < 6);
|
|
const CWeatherType& weatherType = (g_weather.GetInterp() > 0.5f ? g_weather.GetNextType() : g_weather.GetPrevType());
|
|
if(category == RADIO_TRACK_CAT_WEATHER)
|
|
{
|
|
//@@: location AUDRADIOSTATION_COMPUTERANDOMTRACK_ON_WEATHER_TRACK
|
|
if(weatherType.m_fog>0.5f)
|
|
{
|
|
requiredContext = g_RadioTrackWeatherContextNames[RADIO_TRACK_WEATHER_CONTEXT_FOG];
|
|
}
|
|
else if(weatherType.m_rain>0.0f)
|
|
{
|
|
requiredContext = g_RadioTrackWeatherContextNames[RADIO_TRACK_WEATHER_CONTEXT_RAIN];
|
|
}
|
|
else if(!isNightTime && (weatherType.m_sun>0.6f))
|
|
{
|
|
requiredContext = g_RadioTrackWeatherContextNames[RADIO_TRACK_WEATHER_CONTEXT_SUN];
|
|
}
|
|
else if(weatherType.m_lightning)
|
|
{
|
|
requiredContext = g_RadioTrackWeatherContextNames[RADIO_TRACK_WEATHER_CONTEXT_WIND];
|
|
}
|
|
// inhibit cloudy reports at night
|
|
else if(!isNightTime && weatherType.m_cloud>0.7f)
|
|
{
|
|
requiredContext = g_RadioTrackWeatherContextNames[RADIO_TRACK_WEATHER_CONTEXT_CLOUD];
|
|
}
|
|
else
|
|
{
|
|
//We don't support the current weather type, so play an advert instead.
|
|
RADIODEBUG("Current weather type unsupported; playing advert");
|
|
category = RADIO_TRACK_CAT_ADVERTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 numTracks = 0;
|
|
const bool isNetworkGameInProgress = IsNetworkModeHistoryActive();
|
|
// Don't play mission news in the network game
|
|
if(category == RADIO_TRACK_CAT_NEWS)
|
|
{
|
|
numTracks = 0;
|
|
|
|
if(!isNetworkGameInProgress && !PARAM_disableradiohistory.Get())
|
|
{
|
|
// see if there are any unlocked mission stories
|
|
u32 firstGenericStory = ~0U;
|
|
u32 lastPlayedGenericNewsStory = sm_NewsHistory[0];
|
|
u32 nextGenericNewsStory = ~0U;
|
|
for(s32 i = 0; i < kMaxNewsStories; i++)
|
|
{
|
|
if(sm_NewsStoryState[i] & RADIO_NEWS_UNLOCKED && (sm_NewsStoryState[i]&RADIO_NEWS_ONCE_ONLY) == 0)
|
|
{
|
|
// Find the earliest unlocked generic story
|
|
u32 storyId = (u32)i;
|
|
if(storyId < firstGenericStory)
|
|
{
|
|
firstGenericStory = storyId;
|
|
}
|
|
// Find the first unlocked generic story after the last one played
|
|
if(storyId > lastPlayedGenericNewsStory && nextGenericNewsStory == ~0U)
|
|
{
|
|
nextGenericNewsStory = storyId;
|
|
}
|
|
}
|
|
if(sm_NewsStoryState[i] == (RADIO_NEWS_UNLOCKED|RADIO_NEWS_ONCE_ONLY))
|
|
{
|
|
// relock this story only when played phys on the player station
|
|
index = i;
|
|
return GetTrack(category, kNullContext, i);
|
|
}
|
|
}
|
|
|
|
const u32 numNewsStoriesAvailable = sm_NewsTrackLists.ComputeNumTracks();
|
|
if(nextGenericNewsStory >= numNewsStoriesAvailable)
|
|
{
|
|
nextGenericNewsStory = firstGenericStory;
|
|
}
|
|
if(nextGenericNewsStory < numNewsStoriesAvailable)
|
|
{
|
|
index = (s32)nextGenericNewsStory;
|
|
return GetTrack(category, kNullContext, index);
|
|
}
|
|
}// !isNetworkGameInProgress
|
|
|
|
// else - fall back to something else below
|
|
}
|
|
else
|
|
{
|
|
numTracks = ComputeNumTracksAvailable(category, requiredContext);
|
|
}
|
|
|
|
|
|
//audRadioStationTrackInfo &trackInfo = m_TrackInfoForCategory[*category];
|
|
if(numTracks == 0)
|
|
{
|
|
//We don't have any tracks for this category/context...
|
|
switch(category)
|
|
{
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
RADIODEBUG("Failed to get ident; falling back to music");
|
|
category = RADIO_TRACK_CAT_MUSIC;
|
|
numTracks = ComputeNumTracksAvailable(category);
|
|
break;
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
case RADIO_TRACK_CAT_WEATHER: // "
|
|
case RADIO_TRACK_CAT_DJSOLO:
|
|
//Try and play an advert instead.
|
|
RADIODEBUG2("Wanted %s, falling back to advert", TrackCats_ToString((TrackCats)category));
|
|
|
|
category = RADIO_TRACK_CAT_ADVERTS;
|
|
numTracks = ComputeNumTracksAvailable(category);
|
|
|
|
if(numTracks == 0)
|
|
{
|
|
//We should always have music as a fallback.
|
|
RADIODEBUG("Failed to get advert; falling back to music");
|
|
category = RADIO_TRACK_CAT_MUSIC;
|
|
numTracks = ComputeNumTracksAvailable(category);
|
|
}
|
|
break;
|
|
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
#if RSG_PC // user music
|
|
if(m_IsUserStation)
|
|
{
|
|
// Fall back to advert
|
|
category = RADIO_TRACK_CAT_ADVERTS;
|
|
numTracks = ComputeNumTracksAvailable(category);
|
|
}
|
|
else if(!IsUSBMixStation())
|
|
{
|
|
naAssertf(numTracks > 0, "No music tracks for radio station %s", GetName());
|
|
}
|
|
#endif
|
|
return NULL;
|
|
|
|
//case RADIO_TRACK_CAT_ADVERTS:
|
|
default:
|
|
//We should always have music as a fallback.
|
|
category = RADIO_TRACK_CAT_MUSIC;
|
|
numTracks = ComputeNumTracksAvailable(category);
|
|
}
|
|
|
|
requiredContext = kNullContext;
|
|
}
|
|
|
|
naCErrorf(IsUSBMixStation() || numTracks > 0, "No available tracks for category %d in ComputeRandomTrack", category);
|
|
const RadioStationTrackList::tTrack *track = NULL;
|
|
if((category == RADIO_TRACK_CAT_MUSIC || category == RADIO_TRACK_CAT_TAKEOVER_MUSIC) && m_PlaySequentialMusicTracks)
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(category));
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
if(naVerifyf(history && trackLists, "Failed to get history or track lists for category RADIO_TRACK_CAT_MUSIC"))
|
|
{
|
|
// need this mod here in case we've loaded a save game that had a different number of tracks
|
|
const s32 numTracks = trackLists->ComputeNumTracks();
|
|
|
|
if (numTracks > 0)
|
|
{
|
|
u32 trackIndexToPlay = (*history)[0] % numTracks;
|
|
(*history)[0] = (trackIndexToPlay + 1) % numTracks;
|
|
history->SetWriteIndex(1);
|
|
track = trackLists->GetTrack(trackIndexToPlay);
|
|
naCErrorf(track, "Failed to get track for category RADIO_TRACK_CAT_MUSIC at index %d", trackIndexToPlay);
|
|
index = trackIndexToPlay;
|
|
}
|
|
}
|
|
}
|
|
else if(m_UseRandomizedStrideSelection && IsRandomizedStrideCategory(category))
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(category));
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
|
|
// If we're using takeover mode or we only have one set of data (rather than old/new data) then we can just do a simple
|
|
// selection from any of the tracks
|
|
if(m_HasTakeoverContent || trackLists->GetUnlockedListCount() == 1)
|
|
{
|
|
if(naVerifyf(history && trackLists, "Failed to get history or track lists for category %s", TrackCats_ToString((TrackCats)category)))
|
|
{
|
|
const s32 numTracks = trackLists->ComputeNumTracks();
|
|
const u32 previousTrack = history->GetPreviousEntry();
|
|
|
|
u32 trackIndexToPlay = (previousTrack + numTracks + m_CategoryStride[category]) % numTracks;
|
|
(*history)[0] = trackIndexToPlay;
|
|
history->SetWriteIndex(1);
|
|
track = trackLists->GetTrack(trackIndexToPlay);
|
|
naCErrorf(track, "Failed to get track for category %s at index %d", TrackCats_ToString((TrackCats)category), trackIndexToPlay);
|
|
audDisplayf("Setting category %s to %u (num tracks: %u)", TrackCats_ToString((TrackCats)category), trackIndexToPlay, numTracks);
|
|
index = trackIndexToPlay;
|
|
}
|
|
}
|
|
// If we have old/new data then we need to first select which track list to play from and then pick which track from that track list
|
|
// to play, using the per-track list stride/history (stored in the takeover state slot for the new data)
|
|
else if(audVerifyf(trackLists->GetUnlockedListCount() == 2, "Station %s is in stride mode with %d unlocked track lists", GetName(), trackLists->GetUnlockedListCount()))
|
|
{
|
|
u32 numTracks = 0;
|
|
u32 numNewTracks = 0;
|
|
u32 unlockedListIndex = 0;
|
|
|
|
for(u32 i = 0; i < trackLists->GetListCount(); i++)
|
|
{
|
|
if(trackLists->IsTrackListUnlocked(trackLists->GetList(i)))
|
|
{
|
|
const u32 thisTrackListNumTracks = trackLists->GetList(i)->numTracks;
|
|
numTracks += thisTrackListNumTracks;
|
|
|
|
if(unlockedListIndex == 1)
|
|
{
|
|
numNewTracks = thisTrackListNumTracks;
|
|
}
|
|
|
|
unlockedListIndex++;
|
|
}
|
|
}
|
|
|
|
// work out probability of picking new track based on normal distribution
|
|
const float normalProbability = numNewTracks / static_cast<float>(numTracks);
|
|
const float scaledProbability = normalProbability * (m_IsFirstMusicTrackSinceBoot ? m_FirstBootNewTrackBias : m_NewTrackBias);
|
|
m_IsFirstMusicTrackSinceBoot = false;
|
|
|
|
u32 trackListIndex = ResolveProbability(scaledProbability) ? 1 : 0;
|
|
s32 adjustedCategory = category;
|
|
|
|
if(trackListIndex == 1)
|
|
{
|
|
if(category == RADIO_TRACK_CAT_MUSIC) { adjustedCategory = RADIO_TRACK_CAT_TAKEOVER_MUSIC; }
|
|
if(category == RADIO_TRACK_CAT_IDENTS) { adjustedCategory = RADIO_TRACK_CAT_TAKEOVER_IDENTS; }
|
|
if(category == RADIO_TRACK_CAT_DJSOLO) { adjustedCategory = RADIO_TRACK_CAT_TAKEOVER_DJSOLO; }
|
|
history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(adjustedCategory));
|
|
}
|
|
|
|
unlockedListIndex = 0;
|
|
|
|
for(u32 i = 0; i < trackLists->GetListCount(); i++)
|
|
{
|
|
if(trackLists->IsTrackListUnlocked(trackLists->GetList(i)))
|
|
{
|
|
if(unlockedListIndex == trackListIndex)
|
|
{
|
|
const RadioStationTrackList* trackList = trackLists->GetList(i);
|
|
const s32 numTracks = trackList->numTracks;
|
|
const u32 previousTrack = history->GetPreviousEntry();
|
|
|
|
u32 localTrackIndexToPlay = (previousTrack + numTracks + m_CategoryStride[adjustedCategory]) % numTracks;
|
|
(*history)[0] = localTrackIndexToPlay;
|
|
history->SetWriteIndex(1);
|
|
|
|
// Map our track list specific index back to a global index
|
|
u32 trackIndexToPlay = FindTrackId(category, trackList->Track[localTrackIndexToPlay].SoundRef);
|
|
track = trackLists->GetTrack(trackIndexToPlay);
|
|
naCErrorf(track, "Failed to get track for category %s at index %d", TrackCats_ToString((TrackCats)category), trackIndexToPlay);
|
|
audDisplayf("Setting category %s to %u (num tracks: %u)", TrackCats_ToString((TrackCats)category), trackIndexToPlay, numTracks);
|
|
index = trackIndexToPlay;
|
|
break;
|
|
}
|
|
|
|
unlockedListIndex++;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s32 firstTrackIndex = 0;
|
|
s32 endTrackIndex = (s32)numTracks - 1;
|
|
|
|
// favor new tracks slightly (those not in the first playlist)
|
|
if(WIN32PC_ONLY(!m_IsUserStation && )
|
|
category == RADIO_TRACK_CAT_MUSIC &&
|
|
numTracks > 0)
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
if(m_IsFirstMusicTrackSinceBoot && trackLists->GetUnlockedListCount() > 1)
|
|
{
|
|
u32 numNewTracks = 0;
|
|
|
|
// see how many new tracks we have
|
|
bool haveMultipleTrackListsAvailable = false;
|
|
for(s32 trackListIndex = 1; trackListIndex < trackLists->GetListCount(); trackListIndex++)
|
|
{
|
|
if(!trackLists->IsListLocked(trackListIndex))
|
|
{
|
|
haveMultipleTrackListsAvailable = true;
|
|
numNewTracks += trackLists->GetList(trackListIndex)->numTracks;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(haveMultipleTrackListsAvailable)
|
|
{
|
|
// work out probability of picking new track based on normal distribution
|
|
const float normalProbability = numNewTracks / static_cast<float>(numTracks);
|
|
const float scaledProbability = normalProbability * (m_IsFirstMusicTrackSinceBoot ? m_FirstBootNewTrackBias : m_NewTrackBias);
|
|
m_IsFirstMusicTrackSinceBoot = false;
|
|
if(ResolveProbability(scaledProbability))
|
|
{
|
|
audDisplayf("%s Forcing new track (first music track since boot: %s", GetName(), m_IsFirstMusicTrackSinceBoot? "TRUE" : "FALSE");
|
|
firstTrackIndex = static_cast<s32>(trackLists->GetList(0)->numTracks);
|
|
}
|
|
else
|
|
{
|
|
endTrackIndex = static_cast<s32>(trackLists->GetList(0)->numTracks - 1);
|
|
}
|
|
|
|
numTracks = (endTrackIndex - firstTrackIndex) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if RSG_PC
|
|
if(m_IsUserStation && category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
index = sm_UserRadioTrackManager.GetNextTrack();
|
|
return GetTrack(category, requiredContext, index);
|
|
}
|
|
#endif // RSG_PC
|
|
//Make sure we don't look over too much history.
|
|
const s32 historyLength = Max<s32>((1 + endTrackIndex - firstTrackIndex) - kMinRadioTracksOutsideHistory, 0);
|
|
|
|
bool isTrackInHistory = false;
|
|
do
|
|
{
|
|
const s32 trackIndex = GetRandomNumberInRange(firstTrackIndex, endTrackIndex);
|
|
track = GetTrack(category, requiredContext, trackIndex);
|
|
index = trackIndex;
|
|
//Check that this track hasn't just been played/selected (to cover virtually streaming stations that are not adding
|
|
//selected tracks to the history.
|
|
#if RSG_PC
|
|
if(m_IsUserStation && category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
// Track index is used as history identifier for user music
|
|
// Should instead use hash of file path?
|
|
isTrackInHistory = IsTrackInHistory(trackIndex, category, historyLength);
|
|
}
|
|
else
|
|
#endif // RSG_PC
|
|
|
|
if(audVerifyf(track, "NULL track!"))
|
|
{
|
|
if(numTracks > 1 && audRadioTrack::MakeTrackId(category, trackIndex, track->SoundRef) == m_Tracks[m_ActiveTrackIndex].GetRefForHistory())
|
|
{
|
|
isTrackInHistory = true;
|
|
}
|
|
else
|
|
{
|
|
isTrackInHistory = IsTrackInHistory(audRadioTrack::MakeTrackId(category, trackIndex, track->SoundRef), category, historyLength);
|
|
}
|
|
}
|
|
} while(isTrackInHistory);
|
|
}
|
|
|
|
return track;
|
|
}
|
|
|
|
const audRadioStationTrackListCollection *audRadioStation::FindTrackListsForCategory(const s32 category) const
|
|
{
|
|
switch(category)
|
|
{
|
|
case RADIO_TRACK_CAT_MUSIC:
|
|
return &m_MusicTrackLists;
|
|
case RADIO_TRACK_CAT_DJSOLO:
|
|
return &m_DjSoloTrackLists;
|
|
case RADIO_TRACK_CAT_IDENTS:
|
|
return &m_IdentTrackLists;
|
|
case RADIO_TRACK_CAT_ADVERTS:
|
|
return &m_AdvertTrackLists;
|
|
case RADIO_TRACK_CAT_NEWS:
|
|
return &sm_NewsTrackLists;
|
|
case RADIO_TRACK_CAT_WEATHER:
|
|
return &sm_WeatherTrackLists;
|
|
case RADIO_TRACK_CAT_TO_AD:
|
|
return &m_ToAdTrackLists;
|
|
case RADIO_TRACK_CAT_TO_NEWS:
|
|
return &m_ToNewsTrackLists;
|
|
case RADIO_TRACK_CAT_USER_INTRO:
|
|
return &m_UserIntroTrackLists;
|
|
case RADIO_TRACK_CAT_USER_OUTRO:
|
|
return &m_UserOutroTrackLists;
|
|
case RADIO_TRACK_CAT_INTRO_MORNING:
|
|
return &m_UserIntroMorningTrackLists;
|
|
case RADIO_TRACK_CAT_INTRO_EVENING:
|
|
return &m_UserIntroEveningTrackLists;
|
|
case RADIO_TRACK_CAT_TAKEOVER_DJSOLO:
|
|
return &m_TakeoverDjSoloTrackLists;
|
|
case RADIO_TRACK_CAT_TAKEOVER_IDENTS:
|
|
return &m_TakeoverIdentTrackLists;
|
|
case RADIO_TRACK_CAT_TAKEOVER_MUSIC:
|
|
return &m_TakeoverMusicTrackLists;
|
|
default:
|
|
audAssertf(false, "Invalid category: %d", category);
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
|
|
s32 audRadioStation::ComputeNumTracksAvailable(const s32 category, u32 context) const
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
if(!trackLists)
|
|
{
|
|
return 0;
|
|
}
|
|
#if RSG_PC
|
|
if(m_IsUserStation && category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
return sm_UserRadioTrackManager.GetNumTracks();
|
|
}
|
|
#endif
|
|
return trackLists->ComputeNumTracks(context);
|
|
}
|
|
|
|
void audRadioStation::ForceTrack(const char *trackSettingsName, s32 startOffsetMs)
|
|
{
|
|
naDisplayf("Forcing track %s on %s with start offset %u", trackSettingsName, GetName(), startOffsetMs);
|
|
RadioTrackSettings *trackSettings = audNorthAudioEngine::GetObject<RadioTrackSettings>(trackSettingsName);
|
|
|
|
if(trackSettings)
|
|
{
|
|
ForceTrack(trackSettings, startOffsetMs);
|
|
}
|
|
else
|
|
{
|
|
ForceTrack(atStringHash(trackSettingsName), startOffsetMs);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ForceTrack(u32 soundHash, s32 startOffsetMs)
|
|
{
|
|
u32 forcedTrackIndex = 0;
|
|
|
|
// For the battle mix stations, if we set a start offset past the end of the given track,
|
|
// we want to wrap around to the next track in the sequence
|
|
if (m_IsMixStation)
|
|
{
|
|
const RadioStationTrackList* trackList = m_MusicTrackLists.GetList(0);
|
|
|
|
if (trackList)
|
|
{
|
|
bool allTracksValid = true;
|
|
u32 selectedTrackOffset = 0;
|
|
u32 totalDuration = 0;
|
|
const StreamingSound** streamingSounds = Alloca(const StreamingSound*, trackList->numTracks);
|
|
|
|
for (u32 trackIndex = 0; trackIndex < trackList->numTracks; trackIndex++)
|
|
{
|
|
streamingSounds[trackIndex] = SOUNDFACTORY.DecompressMetadata<StreamingSound>(trackList->Track[trackIndex].SoundRef);
|
|
|
|
if (!streamingSounds[trackIndex])
|
|
{
|
|
allTracksValid = false;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (soundHash == trackList->Track[trackIndex].SoundRef)
|
|
{
|
|
selectedTrackOffset = totalDuration;
|
|
}
|
|
|
|
totalDuration += streamingSounds[trackIndex]->Duration;
|
|
}
|
|
}
|
|
|
|
if (allTracksValid)
|
|
{
|
|
u32 adjustedOffset = (selectedTrackOffset + startOffsetMs) % totalDuration;
|
|
u32 trackEnd = 0;
|
|
u32 trackStart = 0;
|
|
|
|
for (u32 trackIndex = 0; trackIndex < trackList->numTracks; trackIndex++)
|
|
{
|
|
trackStart = trackEnd;
|
|
trackEnd += streamingSounds[trackIndex]->Duration;
|
|
|
|
if (adjustedOffset < trackEnd)
|
|
{
|
|
startOffsetMs = adjustedOffset - trackStart;
|
|
|
|
if (soundHash != trackList->Track[trackIndex].SoundRef)
|
|
{
|
|
naDisplayf("Requested track offset is beyond requested track length - wrapping around to track index %u, offset %u", trackIndex, startOffsetMs);
|
|
}
|
|
|
|
soundHash = trackList->Track[trackIndex].SoundRef;
|
|
forcedTrackIndex = trackIndex;
|
|
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
(*history)[0] = (trackIndex + 1) % trackList->numTracks;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
audMetadataObjectInfo objectInfo;
|
|
|
|
if (SOUNDFACTORY.GetMetadataManager().GetObjectInfo(soundHash, objectInfo) && objectInfo.GetType() == StreamingSound::TYPE_ID)
|
|
{
|
|
RadioTrackSettings tempTrackSettings;
|
|
tempTrackSettings.Sound = soundHash;
|
|
tempTrackSettings.History.Category = RADIO_TRACK_CAT_MUSIC;
|
|
tempTrackSettings.History.Sound = soundHash;
|
|
ForceTrack(&tempTrackSettings, startOffsetMs, forcedTrackIndex);
|
|
}
|
|
else
|
|
{
|
|
audAssertf(false, "Failed to get streaming sound from hash: %d", soundHash);
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ForceTrack(const RadioTrackSettings *trackSettings, s32 startOffsetMs, u32 trackIndex)
|
|
{
|
|
if(naVerifyf(IsFrozen(), "Attempting to force track on %s but the station is not frozen", GetName()))
|
|
{
|
|
if(m_Tracks[m_ActiveTrackIndex].IsInitialised())
|
|
{
|
|
m_Tracks[m_ActiveTrackIndex].Shutdown();
|
|
|
|
f32 startOffset = trackSettings->StartOffset;
|
|
|
|
if (startOffsetMs >= 0)
|
|
{
|
|
const StreamingSound *streamingSound = SOUNDFACTORY.DecompressMetadata<StreamingSound>(trackSettings->Sound);
|
|
|
|
if (streamingSound && streamingSound->Duration > 0)
|
|
{
|
|
startOffset = Min(1.f, startOffsetMs / (f32)streamingSound->Duration);
|
|
}
|
|
}
|
|
|
|
audAssertf(trackSettings->History.Category != RADIO_TRACK_CAT_NEWS, "Forced radio track set to NEWS - this is not supported");
|
|
m_Tracks[m_ActiveTrackIndex].Init( trackSettings->History.Category,
|
|
trackIndex,
|
|
trackSettings->Sound,
|
|
startOffset,
|
|
m_IsMixStation && !IsUSBMixStation(),
|
|
m_IsReverbStation,
|
|
m_NameHash
|
|
);
|
|
|
|
// Override the sound ref used for history if specified, otherwise default to the actual track sound
|
|
const u32 soundRefForHistory = trackSettings->History.Sound != 0 ? trackSettings->History.Sound : trackSettings->Sound;
|
|
const u32 trackHistoryId = FindTrackId(trackSettings->History.Category, soundRefForHistory);
|
|
if(trackHistoryId != ~0U)
|
|
{
|
|
m_Tracks[m_ActiveTrackIndex].SetRefForHistory(audRadioTrack::MakeTrackId(trackSettings->History.Category, trackHistoryId, soundRefForHistory));
|
|
}
|
|
// We need to support forcing a track on a station that isn't playing physically, in which case don't forcibly prepare
|
|
// the track.
|
|
if(m_ShouldStreamPhysically)
|
|
{
|
|
Assert(m_WaveSlots[m_ActiveTrackIndex]);
|
|
m_Tracks[m_ActiveTrackIndex].Prepare(0);
|
|
}
|
|
m_Tracks[m_ActiveTrackIndex].PlayWhenReady();
|
|
|
|
if(m_UseRandomizedStrideSelection)
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(trackSettings->History.Category));
|
|
|
|
if(history)
|
|
{
|
|
(*history)[0] = trackHistoryId;
|
|
history->SetWriteIndex(1);
|
|
}
|
|
}
|
|
|
|
#if RSG_PC
|
|
m_LastPlayedTrackIndex = m_CurrentlyPlayingTrackIndex;
|
|
m_CurrentlyPlayingTrackIndex = m_Tracks[m_ActiveTrackIndex].GetTrackIndex();
|
|
#endif
|
|
|
|
// Also shutdown the next track if we've already initialised it, to ensure we haven't already queued the same track
|
|
u32 nextIndex = (m_ActiveTrackIndex+1) & 1;
|
|
if(m_Tracks[nextIndex].IsInitialised())
|
|
{
|
|
m_Tracks[nextIndex].Shutdown();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
audWarningf("Attempting to force radio track, but active track is not initialised");
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 audRadioStation::FindTrackId(const s32 category, const u32 soundRef) const
|
|
{
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(category);
|
|
u32 numTracks = 0;
|
|
if(trackLists)
|
|
{
|
|
numTracks = trackLists->ComputeNumTracks();
|
|
for(u32 i = 0 ; i < numTracks; i++)
|
|
{
|
|
if(soundRef == trackLists->GetTrack(i)->SoundRef)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ~0U;
|
|
}
|
|
|
|
audPrepareState audRadioStation::PrepareNextTrack()
|
|
{
|
|
audPrepareState prepareState = AUD_PREPARE_FAILED;
|
|
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
|
|
audRadioTrack &nextTrack = m_Tracks[nextTrackIndex];
|
|
nextTrack.SetPhysicalStreamingState(m_ShouldStreamPhysically, m_WaveSlots[nextTrackIndex], m_SoundBucketId);
|
|
|
|
if(nextTrack.IsInitialised())
|
|
{
|
|
//Sanity-check that we are preparing a track of the correct category.
|
|
//@@: location AUDRADIOSTATION_PREPARENEXTTRACK_SANITY_CHECK
|
|
if(ShouldOnlyPlayMusic() && nextTrack.GetCategory() != RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
//We should only choose music.
|
|
Assert(!IsFrozen());
|
|
//Stop preparing this track and allow a music track to be selected next frame.
|
|
nextTrack.Shutdown();
|
|
return AUD_PREPARING;
|
|
}
|
|
|
|
//We are already in the process of preparing this track, so query it directly.
|
|
if(m_ShouldStreamPhysically)
|
|
{
|
|
audAssertf(nextTrack.GetPlayTime() >= 0, "Negative start offset on radio track %s: %d ", GetName(), nextTrack.GetPlayTime());
|
|
s32 playTime = nextTrack.GetPlayTime() >= 0 ? nextTrack.GetPlayTime() : 0;
|
|
prepareState = nextTrack.Prepare(playTime);
|
|
}
|
|
else
|
|
{
|
|
prepareState = AUD_PREPARED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
prepareState = AUD_PREPARING;
|
|
}
|
|
|
|
return prepareState;
|
|
}
|
|
|
|
bool audRadioStation::InitialiseNextTrack(const u32 timeInMs)
|
|
{
|
|
if(g_RadioAudioEntity.IsInControlOfRadio())
|
|
{
|
|
u32 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
audRadioTrack &nextTrack = m_Tracks[nextTrackIndex];
|
|
|
|
s32 category = RADIO_TRACK_CAT_MUSIC;
|
|
s32 index = 0;
|
|
const RadioStationTrackList::tTrack *trackMetadata = NULL;
|
|
bool wasNetworkSelectedTrack = false;
|
|
|
|
if(m_QueuedTrackList)
|
|
{
|
|
trackMetadata = &m_QueuedTrackList->Track[m_QueuedTrackListIndex++];
|
|
if(m_QueuedTrackListIndex >= m_QueuedTrackList->numTracks)
|
|
{
|
|
m_QueuedTrackList = NULL;
|
|
m_QueuedTrackListIndex = 0;
|
|
}
|
|
}
|
|
else if(m_NetworkNextTrack.category != 0xff)
|
|
{
|
|
trackMetadata = GetTrack(m_NetworkNextTrack.category, kNullContext, m_NetworkNextTrack.index);
|
|
index = m_NetworkNextTrack.index;
|
|
category = m_NetworkNextTrack.category;
|
|
|
|
m_NetworkNextTrack.category = 0xff;
|
|
|
|
// For sequential music stations, ensure consistency by configuring the history state to be the same as if this
|
|
// track was chosen next by the single player track selection logic
|
|
if(m_PlaySequentialMusicTracks)
|
|
{
|
|
audRadioStationHistory *history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
if(naVerifyf(history && trackLists, "Failed to get history or track lists for category RADIO_TRACK_CAT_MUSIC"))
|
|
{
|
|
const s32 numTracks = trackLists->ComputeNumTracks();
|
|
(*history)[0] = numTracks > 0 ? ((index + 1) % numTracks) : 0;
|
|
history->SetWriteIndex(1);
|
|
}
|
|
}
|
|
|
|
wasNetworkSelectedTrack = true;
|
|
}
|
|
else
|
|
{
|
|
category = ComputeNextTrackCategory(timeInMs);
|
|
trackMetadata = ComputeRandomTrack(category, index);
|
|
|
|
//#if RSG_PC
|
|
// // this would be used for sequential non random user music
|
|
// if(m_IsUserStation && /*isSequentialMode*/)
|
|
// {
|
|
// index = audRadioStation::GetUserRadioTrackManagaer()->GetNextTrack();
|
|
// }
|
|
//#endif
|
|
}
|
|
|
|
if(!trackMetadata)
|
|
{
|
|
// this can happen if all of the tracks in the chosen category are already in history, which is more likely for weather/news etc
|
|
// fall back to music in this case
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
RADIODEBUG2("No valid tracks for %s, falling back to adverts", TrackCats_ToString((TrackCats)category));
|
|
category = RADIO_TRACK_CAT_ADVERTS;
|
|
trackMetadata = ComputeRandomTrack(category, index);
|
|
}
|
|
else
|
|
#endif // RSG_PC
|
|
{
|
|
RADIODEBUG2("No valid tracks for %s, falling back to music", TrackCats_ToString((TrackCats)category));
|
|
category = RADIO_TRACK_CAT_MUSIC;
|
|
trackMetadata = ComputeRandomTrack(category, index);
|
|
}
|
|
|
|
}
|
|
|
|
// Valid to have no tracks on the USB station until something is unlocked
|
|
if (!IsUSBMixStation())
|
|
{
|
|
audAssertf(trackMetadata, "%s failed to compute random track from RADIO_TRACK_CAT_MUSIC category", GetName());
|
|
}
|
|
|
|
if(trackMetadata)
|
|
{
|
|
// randomise start offset if this is the first track we're playing
|
|
nextTrack.Init(category, index, trackMetadata->SoundRef, m_IsFirstTrack ? m_FirstTrackStartOffset : 0.f, m_IsMixStation && !IsUSBMixStation(), m_IsReverbStation, m_NameHash);
|
|
|
|
audAssertf(nextTrack.GetDuration() > 0, "Invalid track/sound metadata: %s (%s : %u)", GetName(), TrackCats_ToString((TrackCats)category), index);
|
|
m_IsFirstTrack = false;
|
|
|
|
LogTrack(category, 0, index, trackMetadata->SoundRef);
|
|
|
|
// We don't want to do the takeover track selection if this was a remote selected track as all of our random
|
|
// seed etc. info is being extracted after this process has already been done
|
|
if (!wasNetworkSelectedTrack)
|
|
{
|
|
if (category == RADIO_TRACK_CAT_TAKEOVER_IDENTS)
|
|
{
|
|
m_TakeoverLastTimeMs = m_StationAccumulatedPlayTimeMs;
|
|
|
|
Assign(m_TakeoverMusicTrackCounter, GetRandomNumberInRange(m_TakeoverMinTracks, m_TakeoverMaxTracks));
|
|
RADIODEBUG2("Started Takeover Segment - %d tracks", m_TakeoverMusicTrackCounter);
|
|
}
|
|
if (category == RADIO_TRACK_CAT_TAKEOVER_MUSIC)
|
|
{
|
|
// continue to update the LastTakeoverTimer while we're in the takeover segment to avoid coming
|
|
// back too quickly
|
|
m_TakeoverLastTimeMs = m_StationAccumulatedPlayTimeMs;
|
|
|
|
if (m_TakeoverMusicTrackCounter > 0)
|
|
{
|
|
m_TakeoverMusicTrackCounter--;
|
|
}
|
|
}
|
|
|
|
if(m_HasTakeoverContent)
|
|
{
|
|
if(category == RADIO_TRACK_CAT_MUSIC)
|
|
{
|
|
m_MusicRunningCount++;
|
|
}
|
|
else
|
|
{
|
|
m_MusicRunningCount = 0;
|
|
}
|
|
}
|
|
|
|
m_StationAccumulatedPlayTimeMs += nextTrack.GetDuration();
|
|
}
|
|
|
|
//Log the next time that this track category can be selected.
|
|
//NOTE: We log a track category when it is selected, rather than heard, to ensure that we maintain a reasonable
|
|
//distribution of valid selection times across virtualised stations.
|
|
const RadioTrackCategoryData *categoryData = sm_MinTimeBetweenRepeatedCategories;
|
|
#if RSG_PC
|
|
if(m_IsUserStation && sm_MinTimeBetweenRepeatedCategoriesUser)
|
|
{
|
|
categoryData = sm_MinTimeBetweenRepeatedCategoriesUser;
|
|
}
|
|
#endif
|
|
SetNextValidSelectionTime(category, timeInMs + categoryData->Category[category].Value);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void audRadioStation::SetNextValidSelectionTime(const s32 category, const u32 timeMs)
|
|
{
|
|
m_NextValidSelectionTime[category] = timeMs;
|
|
}
|
|
|
|
void audRadioStation::UnlockMissionNewsStory(const u32 newsStory)
|
|
{
|
|
const u32 storyId = newsStory - 1;
|
|
if(naVerifyf(storyId < kMaxNewsStories, "Story id %d is out of bounds", storyId))
|
|
{
|
|
sm_NewsStoryState[storyId] = (RADIO_NEWS_UNLOCKED | RADIO_NEWS_ONCE_ONLY);
|
|
naDisplayf("Unlocked mission news story %u", newsStory);
|
|
}
|
|
// check that we don't have too many news stories unlocked; lock old stories if we do
|
|
u32 numUnlocked = 0;
|
|
for(u32 i = 0; i < kMaxNewsStories; i++)
|
|
{
|
|
if(sm_NewsStoryState[i] == (RADIO_NEWS_ONCE_ONLY|RADIO_NEWS_UNLOCKED))
|
|
{
|
|
numUnlocked++;
|
|
}
|
|
}
|
|
// only allow two unlocked stories
|
|
if(numUnlocked > 2)
|
|
{
|
|
numUnlocked -= 2;
|
|
for(u32 i = 0; i < kMaxNewsStories && numUnlocked > 0; i++)
|
|
{
|
|
if(sm_NewsStoryState[i] == (RADIO_NEWS_ONCE_ONLY|RADIO_NEWS_UNLOCKED))
|
|
{
|
|
sm_NewsStoryState[i] &= ~(RADIO_NEWS_UNLOCKED);
|
|
naDisplayf("Too many news stories unlocked; locking %u", i+1);
|
|
numUnlocked--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ForceNextTrack(const char* categoryName, const u32 contextHash, const u32 trackNameHash, bool ignoreLocking)
|
|
{
|
|
TrackCats category = TrackCats_Parse(categoryName, TRACKCATS_MAX);
|
|
|
|
if (category != TRACKCATS_MAX)
|
|
{
|
|
const audRadioStationTrackListCollection* trackListCollection = FindTrackListsForCategory(category);
|
|
|
|
if (trackListCollection)
|
|
{
|
|
s32 numTracks = trackListCollection->ComputeNumTracks(kNullContext, ignoreLocking);
|
|
|
|
for (u32 i = 0; i < numTracks; i++)
|
|
{
|
|
if (trackListCollection->GetTrack(i, kNullContext, ignoreLocking)->SoundRef == trackNameHash)
|
|
{
|
|
ForceNextTrack((u8)category, contextHash, (u16)i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::ForceNextTrack(const u8 category, const u32 context, const u16 index)
|
|
{
|
|
m_ForceNextTrackCategory = category;
|
|
m_ForceNextTrackContext = context;
|
|
m_ForceNextTrackIndex = index;
|
|
const u8 nextTrackIndex = (m_ActiveTrackIndex + 1) % 2;
|
|
audDisplayf("%s is forcing next track to category %u context %u track %u", GetName(), category, context, index);
|
|
|
|
if(m_Tracks[nextTrackIndex].IsInitialised())
|
|
{
|
|
m_Tracks[nextTrackIndex].Shutdown();
|
|
m_IsPlayingOverlappedTrack = false;
|
|
m_IsRequestingOverlappedTrackPrepare = false;
|
|
}
|
|
}
|
|
|
|
struct trackEntry
|
|
{
|
|
trackEntry(){}
|
|
trackEntry(u8 i, u8 o) : index(i), order(o) { }
|
|
u8 index;
|
|
u8 order;
|
|
};
|
|
|
|
int TrackEntryCompare(const trackEntry *l, const trackEntry *r)
|
|
{
|
|
return (int)l->order - (int)r->order;
|
|
}
|
|
|
|
void audRadioStation::QueueTrackList(const RadioStationTrackList *trackList, const bool forceNow)
|
|
{
|
|
if(trackList->numTracks == 0)
|
|
{
|
|
NOTFINAL_ONLY(audWarningf("%s - Ignoring empty track list %s", GetName(), audNorthAudioEngine::GetMetadataManager().GetNameFromNTO_Debug(trackList->NameTableOffset));)
|
|
return;
|
|
}
|
|
if(m_QueuedTrackList)
|
|
{
|
|
NOTFINAL_ONLY(audWarningf("%s - Replacing queued list %s (at track index %u) with %s", GetName(), audNorthAudioEngine::GetMetadataManager().GetNameFromNTO_Debug(m_QueuedTrackList->NameTableOffset), m_QueuedTrackListIndex, audNorthAudioEngine::GetMetadataManager().GetNameFromNTO_Debug(trackList->NameTableOffset));)
|
|
}
|
|
m_QueuedTrackListIndex = 0;
|
|
m_QueuedTrackList = trackList;
|
|
|
|
if(AUD_GET_TRISTATE_VALUE(trackList->Flags, FLAG_ID_RADIOSTATIONTRACKLIST_SHUFFLE) == AUD_TRISTATE_TRUE)
|
|
{
|
|
atFixedArray<trackEntry, RadioStationTrackList::MAX_TRACKS> shuffler;
|
|
for(u32 i = 0; i < trackList->numTracks; i++)
|
|
{
|
|
if(m_MusicTrackHistory.IsInHistory(trackList->Track[i].SoundRef, 4))
|
|
{
|
|
// push recently heard tracks to the back of the queue
|
|
shuffler.Push(trackEntry((u8)i, 255));
|
|
}
|
|
else
|
|
{
|
|
shuffler.Push(trackEntry((u8)i, (u8)audEngineUtil::GetRandomInteger()));
|
|
}
|
|
|
|
}
|
|
shuffler.QSort(0, -1, &TrackEntryCompare);
|
|
|
|
atRangeArray<RadioStationTrackList::tTrack, RadioStationTrackList::MAX_TRACKS> tracks;
|
|
sysMemCpy(&tracks, &trackList->Track[0], sizeof(RadioStationTrackList::tTrack) * trackList->numTracks);
|
|
|
|
for(u32 i = 0; i < trackList->numTracks; i++)
|
|
{
|
|
const_cast<RadioStationTrackList*>(trackList)->Track[i] = tracks[shuffler[i].index];
|
|
}
|
|
}
|
|
|
|
audRadioTrack &activeTrack = m_Tracks[m_ActiveTrackIndex];
|
|
const u32 nextTrackIndex = (m_ActiveTrackIndex + 1) &1;
|
|
audRadioTrack &nextTrack = m_Tracks[nextTrackIndex];
|
|
|
|
if(forceNow)
|
|
{
|
|
if(nextTrack.IsInitialised())
|
|
{
|
|
nextTrack.Shutdown();
|
|
}
|
|
if(activeTrack.IsInitialised())
|
|
{
|
|
activeTrack.Shutdown();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// If there's time, cancel the next track and choose again
|
|
if(nextTrack.IsInitialised() && activeTrack.IsInitialised() && activeTrack.GetDuration() - (u32)activeTrack.GetPlayTime() > 45000U)
|
|
{
|
|
nextTrack.Shutdown();
|
|
}
|
|
}
|
|
|
|
NOTFINAL_ONLY(audDisplayf("%s - Queued track list %s", GetName(), audNorthAudioEngine::GetMetadataManager().GetNameFromNTO_Debug(m_QueuedTrackList->NameTableOffset));)
|
|
}
|
|
|
|
void audRadioStation::ClearQueuedTracks()
|
|
{
|
|
if(m_QueuedTrackList)
|
|
{
|
|
NOTFINAL_ONLY(audDisplayf("%s - Cleared queued track list %s", GetName(), audNorthAudioEngine::GetMetadataManager().GetNameFromNTO_Debug(m_QueuedTrackList->NameTableOffset));)
|
|
|
|
m_QueuedTrackList = NULL;
|
|
m_QueuedTrackListIndex = 0;
|
|
|
|
audRadioTrack &activeTrack = m_Tracks[m_ActiveTrackIndex];
|
|
const u32 nextTrackIndex = (m_ActiveTrackIndex + 1) &1;
|
|
audRadioTrack &nextTrack = m_Tracks[nextTrackIndex];
|
|
|
|
// If there's time, cancel the next track and choose again
|
|
if(nextTrack.IsInitialised() && activeTrack.IsInitialised() && activeTrack.GetDuration() - (u32)activeTrack.GetPlayTime() > 45000U)
|
|
{
|
|
nextTrack.Shutdown();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool audRadioStation::ShouldOnlyPlayMusic() const
|
|
{
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
return (sm_UserRadioTrackManager.GetRadioMode() != USERRADIO_PLAY_MODE_RADIO);
|
|
}
|
|
#endif
|
|
if(IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get())
|
|
return false; // don't allow switch to music-only as it will break the determinism that we rely on for network sync
|
|
return (!m_ShouldPlayFullRadio || m_ScriptSetMusicOnly);
|
|
}
|
|
|
|
void audRadioStation::DumpNewsState()
|
|
{
|
|
u32 numNewsStoriesUnlocked = 0;
|
|
u32 genericNewsStories = 0;
|
|
|
|
for(u32 i = 0; i < kMaxNewsStories; i++)
|
|
{
|
|
if(sm_NewsStoryState[i] & RADIO_NEWS_UNLOCKED)
|
|
{
|
|
numNewsStoriesUnlocked++;
|
|
if(sm_NewsStoryState[i] & RADIO_NEWS_ONCE_ONLY)
|
|
{
|
|
naDisplayf("Mission news %u unlocked", i);
|
|
}
|
|
else
|
|
{
|
|
genericNewsStories++;
|
|
}
|
|
}
|
|
}
|
|
|
|
naDisplayf("%u unlocked news stories (%u generic)", numNewsStoriesUnlocked, genericNewsStories);
|
|
}
|
|
|
|
u32 audRadioStation::GetNextValidSelectionTime(const s32 category) const
|
|
{
|
|
bool disableNetworkModeForStation = false;
|
|
WIN32PC_ONLY(disableNetworkModeForStation = m_IsUserStation);
|
|
|
|
if(!disableNetworkModeForStation && (IsNetworkModeHistoryActive() || PARAM_disableradiohistory.Get()))
|
|
return 0U; // always valid
|
|
|
|
return m_NextValidSelectionTime[category];
|
|
}
|
|
|
|
bool audRadioStation::LockTrackList(const char *trackListName)
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return LockTrackList(trackList);
|
|
}
|
|
|
|
bool audRadioStation::LockTrackList(u32 trackListName)
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return LockTrackList(trackList);
|
|
}
|
|
|
|
bool audRadioStation::LockTrackList(const RadioStationTrackList *trackList)
|
|
{
|
|
if (trackList)
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(trackList->Category));
|
|
if (audVerifyf(trackListCollection, "%s - Failed to find track lists for %s", GetName(), TrackCats_ToString((TrackCats)trackList->Category)))
|
|
{
|
|
const bool ret = trackListCollection->LockTrackList(trackList);
|
|
if (ret)
|
|
{
|
|
audDisplayf("Locked track list %s on %s", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset), GetName());
|
|
|
|
if(m_UseRandomizedStrideSelection)
|
|
{
|
|
RandomizeCategoryStride((TrackCats)trackList->Category, false, true);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool audRadioStation::IsTrackListUnlocked(const char *trackListName) const
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return IsTrackListUnlocked(trackList);
|
|
}
|
|
|
|
bool audRadioStation::IsTrackListUnlocked(u32 trackListName) const
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return IsTrackListUnlocked(trackList);
|
|
}
|
|
|
|
bool audRadioStation::IsTrackListUnlocked(const RadioStationTrackList *trackList) const
|
|
{
|
|
if(trackList)
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(trackList->Category));
|
|
if(audVerifyf(trackListCollection, "%s - Failed to find track lists for %s", GetName(), TrackCats_ToString((TrackCats)trackList->Category)))
|
|
{
|
|
return trackListCollection->IsTrackListUnlocked(trackList);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool audRadioStation::UnlockTrackList(const char *trackListName)
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return UnlockTrackList(trackList);
|
|
}
|
|
|
|
bool audRadioStation::UnlockTrackList(u32 trackListName)
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(trackListName);
|
|
return UnlockTrackList(trackList);
|
|
}
|
|
|
|
bool audRadioStation::UnlockTrackList(const RadioStationTrackList *trackList)
|
|
{
|
|
if(trackList)
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(trackList->Category));
|
|
if(audVerifyf(trackListCollection, "%s - Failed to find track lists for %s", GetName(), TrackCats_ToString((TrackCats)trackList->Category)))
|
|
{
|
|
const bool ret = trackListCollection->UnlockTrackList(trackList);
|
|
if(ret)
|
|
{
|
|
audDisplayf("Unlocked track list %s on %s", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset), GetName());
|
|
|
|
if(m_UseRandomizedStrideSelection)
|
|
{
|
|
RandomizeCategoryStride((TrackCats)trackList->Category, false, true);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Force the given music track list to be the only available track list (used for USB station behavior)
|
|
bool audRadioStation::ForceMusicTrackList(const u32 trackListName, u32 timeOffsetMs)
|
|
{
|
|
Freeze();
|
|
RadioStationTrackList* trackList = audNorthAudioEngine::GetMetadataManager().GetObject<RadioStationTrackList>(trackListName);
|
|
|
|
if (trackList)
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
for (u32 i = 0; i < trackListCollection->GetListCount(); i++)
|
|
{
|
|
if (trackListCollection->GetList(i) == trackList)
|
|
{
|
|
trackListCollection->UnlockTrackList(trackListCollection->GetList(i));
|
|
}
|
|
else
|
|
{
|
|
trackListCollection->LockTrackList(trackListCollection->GetList(i));
|
|
}
|
|
}
|
|
|
|
SkipToOffsetInMusicTrackList(timeOffsetMs, true);
|
|
}
|
|
|
|
m_LastForcedMusicTrackList = trackListName;
|
|
}
|
|
|
|
Unfreeze();
|
|
return true;
|
|
}
|
|
|
|
// Skip to the given offset relative to the start of the currently active tracklist (used for USB station behavior)
|
|
void audRadioStation::SkipToOffsetInMusicTrackList(u32 timeOffsetMs, bool allowWrap)
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const RadioStationTrackList::tTrack* selectedTrack = GetMusicTracklistTrackForTimeOffset(timeOffsetMs, allowWrap);
|
|
|
|
if (selectedTrack)
|
|
{
|
|
u32 totalTracksIncludingLocked = trackListCollection->ComputeNumTracks(0u, true);
|
|
|
|
for (u32 i = 0; i < totalTracksIncludingLocked; i++)
|
|
{
|
|
if (trackListCollection->GetTrack(i, 0u, true) == selectedTrack)
|
|
{
|
|
audRadioStationHistory* history = const_cast<audRadioStationHistory*>(FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (history)
|
|
{
|
|
(*history)[0] = i;
|
|
|
|
const s32 trackIndex = GetMusicTrackIndexInTrackList(selectedTrack);
|
|
const s32 trackStartTime = GetMusicTrackListTrackStartTimeMs(trackIndex);
|
|
const s32 trackDuration = GetMusicTrackListTrackDurationMs(trackIndex);
|
|
|
|
m_FirstTrackStartOffset = Clamp((timeOffsetMs - trackStartTime) / (f32)trackDuration, 0.f, 1.f);
|
|
m_IsFirstTrack = true;
|
|
m_ActiveTrackIndex = 0;
|
|
|
|
m_Tracks[0].Shutdown();
|
|
m_Tracks[1].Shutdown();
|
|
PrepareNextTrack();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Query the current time offset into the current music track list (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListCurrentPlayTimeMs() const
|
|
{
|
|
u32 startTime = 0u;
|
|
s32 playingTrackIndex = GetMusicTrackListActiveTrackIndex();
|
|
|
|
if (playingTrackIndex >= 0)
|
|
{
|
|
startTime = GetMusicTrackListTrackStartTimeMs((u32)playingTrackIndex);
|
|
}
|
|
|
|
return startTime + m_Tracks[m_ActiveTrackIndex].GetPlayTime();
|
|
}
|
|
|
|
// Get the track that will be playing at the given time offset
|
|
const RadioStationTrackList::tTrack* audRadioStation::GetMusicTracklistTrackForTimeOffset(u32 timeOffsetMs, bool allowWrap) const
|
|
{
|
|
audRadioStationTrackListCollection* trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
u32 totalDuration = 0u;
|
|
const u32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
if(allowWrap)
|
|
{
|
|
for (u32 i = 0; i < numUnlockedTracks; i++)
|
|
{
|
|
if (const RadioStationTrackList::tTrack* track = trackListCollection->GetTrack(i))
|
|
{
|
|
const StreamingSound *streamingSound = SOUNDFACTORY.DecompressMetadata<StreamingSound>(track->SoundRef);
|
|
totalDuration += streamingSound ? streamingSound->Duration : 0u;
|
|
}
|
|
}
|
|
|
|
timeOffsetMs %= totalDuration;
|
|
}
|
|
|
|
u32 cumulativeDuration = 0;
|
|
|
|
for (u32 i = 0; i < numUnlockedTracks; i++)
|
|
{
|
|
const RadioStationTrackList::tTrack* track = trackListCollection->GetTrack(i);
|
|
|
|
if (track)
|
|
{
|
|
const StreamingSound *streamingSound = SOUNDFACTORY.DecompressMetadata<StreamingSound>(track->SoundRef);
|
|
cumulativeDuration += streamingSound ? streamingSound->Duration : 0u;
|
|
|
|
if (timeOffsetMs < cumulativeDuration)
|
|
{
|
|
return track;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Get the track that will be playing at the given index offset
|
|
const RadioStationTrackList::tTrack* audRadioStation::GetMusicTrackListTrackForIndex(u32 trackIndex) const
|
|
{
|
|
audRadioStationTrackListCollection* trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
if (audVerifyf(trackIndex < trackListCollection->ComputeNumTracks(), "Track %u exceeds total number of tracks (%u)", trackIndex, trackListCollection->ComputeNumTracks()))
|
|
{
|
|
return trackListCollection->GetTrack(trackIndex);
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Get the track ID for the track playing at the givne offset in the currently active music playlist (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListTrackIDForTimeOffset(u32 timeOffsetMs) const
|
|
{
|
|
const RadioStationTrackList::tTrack* track = GetMusicTracklistTrackForTimeOffset(timeOffsetMs);
|
|
return track ? audRadioTrack::FindTextIdForSoundHash(track->SoundRef) : 0u;
|
|
}
|
|
|
|
// Get the track ID for the given track in the currently active music playlist (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListTrackIDForIndex(u32 trackIndex) const
|
|
{
|
|
const RadioStationTrackList::tTrack* track = GetMusicTrackListTrackForIndex(trackIndex);
|
|
return track ? audRadioTrack::FindTextIdForSoundHash(track->SoundRef) : 0u;
|
|
}
|
|
|
|
// Query the total number of tracks in the current track list (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListNumTracks() const
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
return trackListCollection ? trackListCollection->ComputeNumTracks() : 0;
|
|
}
|
|
|
|
// Query the total duration of the current music track list (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListDurationMs() const
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
return trackListCollection ? GetMusicTrackListTrackStartTimeMs(trackListCollection->ComputeNumTracks()) : 0;
|
|
}
|
|
|
|
// Query the duration of the music track at the given index in the active music track list (used for USB station behavior)
|
|
u32 audRadioStation::GetMusicTrackListTrackDurationMs(u32 trackIndex) const
|
|
{
|
|
const RadioStationTrackList::tTrack* track = GetMusicTrackListTrackForIndex(trackIndex);
|
|
const StreamingSound *streamingSound = track ? SOUNDFACTORY.DecompressMetadata<StreamingSound>(track->SoundRef) : nullptr;
|
|
return streamingSound ? streamingSound->Duration : 0u;
|
|
}
|
|
|
|
// Get the start time of the given track in the music track list (used for USB station behavior)
|
|
s32 audRadioStation::GetMusicTrackListTrackStartTimeMs(u32 trackIndex) const
|
|
{
|
|
u32 cumulativeDuration = 0;
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const u32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
for (u32 i = 0; i < trackIndex && i < numUnlockedTracks; i++)
|
|
{
|
|
const StreamingSound *streamingSound = SOUNDFACTORY.DecompressMetadata<StreamingSound>(trackListCollection->GetTrack(i)->SoundRef);
|
|
cumulativeDuration += streamingSound ? streamingSound->Duration : 0u;
|
|
}
|
|
}
|
|
|
|
return cumulativeDuration;
|
|
}
|
|
|
|
// Get the index of the given track in the playing tracklist (used for USB station behavior)
|
|
s32 audRadioStation::GetMusicTrackIndexInTrackList(const RadioStationTrackList::tTrack* track) const
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const u32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
for (u32 i = 0; i < numUnlockedTracks; i++)
|
|
{
|
|
if (trackListCollection->GetTrack(i) == track)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// Get the track index of the currently playing track relative to the music track list (used for USB station behavior)
|
|
s32 audRadioStation::GetMusicTrackListActiveTrackIndex() const
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const s32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
for (s32 i = 0; i < numUnlockedTracks; i++)
|
|
{
|
|
const RadioStationTrackList::tTrack* track = trackListCollection->GetTrack(i);
|
|
|
|
if (track && track->SoundRef == m_Tracks[m_ActiveTrackIndex].GetSoundRef())
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
u32 audRadioStation::GetPlayingTrackListNextTrackTimeOffset()
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const s32 nextTrackIndex = GetMusicTrackListActiveTrackIndex() + 1;
|
|
const u32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
if (nextTrackIndex < numUnlockedTracks)
|
|
{
|
|
return GetMusicTrackListTrackStartTimeMs(nextTrackIndex);
|
|
}
|
|
}
|
|
|
|
// Wrap around (needs confirming if this is desired behavior)
|
|
return 0;
|
|
}
|
|
|
|
|
|
u32 audRadioStation::GetPlayingTrackListPrevTrackTimeOffset()
|
|
{
|
|
audRadioStationTrackListCollection *trackListCollection = const_cast<audRadioStationTrackListCollection *>(FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC));
|
|
|
|
if (trackListCollection)
|
|
{
|
|
const s32 prevTrackIndex = GetMusicTrackListActiveTrackIndex() - 1;
|
|
const u32 numUnlockedTracks = trackListCollection->ComputeNumTracks();
|
|
|
|
if (prevTrackIndex >= 0)
|
|
{
|
|
return GetMusicTrackListTrackStartTimeMs((u32)prevTrackIndex);
|
|
}
|
|
|
|
// Wrap around (needs confirming if this is desired behavior)
|
|
return GetMusicTrackListTrackStartTimeMs(numUnlockedTracks - 1);
|
|
}
|
|
|
|
return 0u;
|
|
}
|
|
|
|
bool audRadioStation::IsCurrentTrackNew() const
|
|
{
|
|
const audRadioTrack &track = GetCurrentTrack();
|
|
const audRadioStationTrackListCollection * trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
|
|
if(trackLists &&
|
|
track.GetCategory() == RADIO_TRACK_CAT_MUSIC &&
|
|
track.GetTrackIndex() >= trackLists->GetList(0)->numTracks)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#if __BANK
|
|
u16 g_ForceNextTrackIndex = 0xffff;
|
|
u8 g_ForceNextTrackCategory = 0;
|
|
char g_ForceStationName[128]={0};
|
|
char g_ForceTrackContextName[128]={0};
|
|
char g_ForceTrackSettings[128]={0};
|
|
char g_TrackListName[128]={0};
|
|
u32 g_DebugNewsStory = 0;
|
|
|
|
void UnlockNewsCB()
|
|
{
|
|
audRadioStation::UnlockMissionNewsStory(g_DebugNewsStory);
|
|
}
|
|
|
|
void Debug_ForceNextTrackCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
station->ForceNextTrack(g_ForceNextTrackCategory, atStringHash(g_ForceTrackContextName), g_ForceNextTrackIndex);
|
|
}
|
|
}
|
|
|
|
void ForceNextTrackCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
station->ForceTrack(g_ForceTrackSettings);
|
|
}
|
|
}
|
|
|
|
void DumpNewsStateCB()
|
|
{
|
|
audRadioStation::DumpNewsState();
|
|
}
|
|
|
|
bool g_ForceQueueTrack= true;
|
|
|
|
void QueueTrackListOnStationCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
const RadioStationTrackList *trackList = audNorthAudioEngine::GetObject<RadioStationTrackList>(g_TrackListName);
|
|
if(trackList)
|
|
{
|
|
station->QueueTrackList(trackList, g_ForceQueueTrack);
|
|
}
|
|
else
|
|
{
|
|
audWarningf("Failed to find track list %s", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ClearQueuedTracksOnStationCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
station->ClearQueuedTracks();
|
|
}
|
|
}
|
|
|
|
void SnapshotStationCB()
|
|
{
|
|
audRadioStation::GetStation(g_TestSyncStationIndex)->PopulateSyncData(g_TestSyncData);
|
|
}
|
|
|
|
void ApplyStationSnapshotCB()
|
|
{
|
|
audRadioStation::GetStation(g_TestSyncStationIndex)->SyncStation(g_TestSyncData);
|
|
}
|
|
|
|
void UnlockTrackListCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
station->UnlockTrackList(g_ForceTrackSettings);
|
|
}
|
|
}
|
|
|
|
void LockTrackListCB()
|
|
{
|
|
audRadioStation *station = audRadioStation::FindStation(g_ForceStationName);
|
|
if(station)
|
|
{
|
|
station->LockTrackList(g_ForceTrackSettings);
|
|
}
|
|
}
|
|
|
|
void SwitchUSBStationMixCB()
|
|
{
|
|
audRadioStation* station = audRadioStation::GetUSBMixStation();
|
|
|
|
if (station)
|
|
{
|
|
const char* trackListName = g_RequestedUSBTrackListComboIndex >= 0 ? g_USBTrackListNames[g_RequestedUSBTrackListComboIndex] : nullptr;
|
|
station->ForceMusicTrackList(atStringHash(trackListName), g_USBStationTrackListOffsetMs);
|
|
station->SetLocked(false);
|
|
}
|
|
}
|
|
|
|
void USBStationSkipToOffsetCB()
|
|
{
|
|
audRadioStation* station = audRadioStation::GetUSBMixStation();
|
|
|
|
if (station)
|
|
{
|
|
station->SkipToOffsetInMusicTrackList(g_USBStationTrackListOffsetMs);
|
|
}
|
|
}
|
|
|
|
void USBStationSkipPrevTrackCB()
|
|
{
|
|
audRadioStation* station = audRadioStation::GetUSBMixStation();
|
|
|
|
if (station)
|
|
{
|
|
s32 activeTrack = station->GetMusicTrackListActiveTrackIndex();
|
|
|
|
if (activeTrack >= 0)
|
|
{
|
|
s32 prevTrackStartTime = station->GetMusicTrackListTrackStartTimeMs(activeTrack - 1);
|
|
station->SkipToOffsetInMusicTrackList(prevTrackStartTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void USBStationSkipNextTrackCB()
|
|
{
|
|
audRadioStation* station = audRadioStation::GetUSBMixStation();
|
|
|
|
if (station)
|
|
{
|
|
s32 activeTrack = station->GetMusicTrackListActiveTrackIndex();
|
|
|
|
if (activeTrack >= 0)
|
|
{
|
|
s32 nextTrackStartTime = station->GetMusicTrackListTrackStartTimeMs(activeTrack + 1);
|
|
station->SkipToOffsetInMusicTrackList(nextTrackStartTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void USBStationScriptLockTrackListCB()
|
|
{
|
|
if (audRadioStation* station = audRadioStation::GetUSBMixStation())
|
|
{
|
|
const char* trackListName = g_RequestedUSBTrackListComboIndex >= 0 ? g_USBTrackListNames[g_RequestedUSBTrackListComboIndex] : nullptr;
|
|
u32 trackListNameHash = atStringHash(trackListName);
|
|
|
|
// This duplicates what the script command does
|
|
if(trackListNameHash != ATSTRINGHASH("TUNER_AP_SILENCE_MUSIC", 0x68865F9) && trackListNameHash == station->GetLastForcedMusicTrackList())
|
|
{
|
|
station->ForceMusicTrackList(ATSTRINGHASH("TUNER_AP_SILENCE_MUSIC", 0x68865F9), 0u);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DumpplayerStationtracksCB()
|
|
{
|
|
if(const audRadioStation *station=g_RadioAudioEntity.GetPlayerRadioStation())
|
|
{
|
|
station->DumpTrackList();
|
|
}
|
|
}
|
|
|
|
void audRadioStation::DumpTrackList() const
|
|
{
|
|
|
|
|
|
|
|
char textIdName[32];
|
|
const audRadioStationTrackListCollection *trackLists = FindTrackListsForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
for(s32 listIdx = 0; listIdx < trackLists->GetListCount(); listIdx++)
|
|
{
|
|
const RadioStationTrackList *trackList = trackLists->GetList(listIdx);
|
|
const char *trackListName = audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(trackList->NameTableOffset);
|
|
|
|
for(s32 i = 0; i < trackList->numTracks; i++)
|
|
{
|
|
const u32 soundNameHash = trackList->Track[i].SoundRef;
|
|
formatf(textIdName, "RTT_%08X", soundNameHash);
|
|
const RadioTrackTextIds *rtt = audNorthAudioEngine::GetMetadataManager().GetObject<RadioTrackTextIds>(textIdName);
|
|
const char *soundName = g_AudioEngine.GetSoundManager().GetFactory().GetMetadataManager().GetObjectName(soundNameHash);
|
|
if(rtt)
|
|
{
|
|
|
|
if(rtt->numTextIds != 1)
|
|
{
|
|
audErrorf("%s - %s - %s - %d - Radio track with %u text Ids", GetName(), trackListName, soundName, i, rtt->numTextIds);
|
|
}
|
|
|
|
const u32 textId = rtt->TextId[0].TextId;
|
|
char artistID[16];
|
|
char trackID[16];
|
|
|
|
formatf(artistID,"%dA", textId);
|
|
formatf(trackID,"%dS", textId);
|
|
const char *artistName = TheText.Get(artistID);
|
|
const char *trackTitle = TheText.Get(trackID);
|
|
|
|
audDisplayf("%s,%s,%d,%u,%s,\"%s\",\"%s\",%u", GetName(), trackListName, i, soundNameHash,soundName, artistName, trackTitle, textId);
|
|
}
|
|
else
|
|
{
|
|
audDisplayf("%s,%s,%d,%u,%s,%s,%s,%u", GetName(), trackListName, i, soundNameHash, soundName, "MISSING", "MISSING", 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void audRadioStation::AddWidgets(bkBank &bank)
|
|
{
|
|
bank.AddButton("DumpPlayerStationTracks", CFA(DumpplayerStationtracksCB));
|
|
bank.AddToggle("DisableOverlappedTracks", &sm_DisableOverlap);
|
|
bank.AddToggle("Disable Play Time Compensation", &g_DisablePlayTimeCompensation);
|
|
bank.AddToggle("DebugHistory", &sm_DebugHistory);
|
|
bank.AddButton("Snapshot", CFA(SnapshotStationCB));
|
|
bank.AddButton("Apply", CFA(ApplyStationSnapshotCB));
|
|
bank.AddSlider("Snapshot/Apply Station Index", &g_TestSyncStationIndex, 0, 30, 1);
|
|
bank.AddToggle("DebugRadioRandom", &g_DebugRadioRandom);
|
|
|
|
bank.PushGroup("Radio Wheel Winding");
|
|
bank.AddSlider("Station Wind Start", &g_RadioWheelWindStart, 0, 100000, 100);
|
|
bank.AddSlider("Station Wind Offset", &g_RadioWheelWindOffset, 0, 100000, 100);
|
|
bank.AddButton("Re-Sort Stations", CFA(SortRadioStationList));
|
|
bank.PopGroup();
|
|
|
|
bank.PushGroup("Transitions");
|
|
bank.AddSlider("Mix Transition Time", &g_RadioTrackMixtransitionTimeMs, 0, 60000, 100);
|
|
bank.AddSlider("Mix Transition Offset Time", &g_RadioTrackMixtransitionOffsetTimeMs, 0, 60000, 100);
|
|
bank.AddSlider("Track Overlap Time", &g_RadioTrackOverlapTimeMs, 0, 60000, 100);
|
|
bank.AddSlider("User Track Overlap Time", &g_UserRadioTrackOverlapTimeMs, 0, 60000, 100);
|
|
bank.AddSlider("Track Prepare Time", &g_RadioTrackPrepareTimeMs, 0, 60000, 100);
|
|
bank.AddSlider("Track Skip End Time", &g_RadioTrackSkipEndTimeMs, 0, 60000, 100);
|
|
bank.AddToggle("Use Precise Crossfades", &g_UsePreciseTrackCrossfades);
|
|
bank.AddSlider("Precise Crossfade Play Time", &g_RadioTrackOverlapPlayTimeMs, 0, 60000, 100);
|
|
bank.PopGroup();
|
|
|
|
bank.PushGroup("ForceNextTrack");
|
|
bank.AddText("Station", &g_ForceStationName[0], sizeof(g_ForceStationName));
|
|
bank.AddText("Track", &g_ForceTrackSettings[0], sizeof(g_ForceTrackSettings));
|
|
bank.AddButton("ForceTrack", CFA(ForceNextTrackCB));
|
|
bank.AddButton("UnlockTrackList", CFA(UnlockTrackListCB));
|
|
bank.AddButton("LockTrackList", CFA(LockTrackListCB));
|
|
bank.AddSlider("Debug_ForceIndex", &g_ForceNextTrackIndex, 0, 0xffff, 1);
|
|
bank.AddSlider("Debug_ForceCategory", &g_ForceNextTrackCategory, 0, 255, 1);
|
|
bank.AddText("Debug_ForceContext", &g_ForceTrackContextName[0], sizeof(g_ForceTrackContextName));
|
|
bank.AddButton("Debug_ForceNextTrack", CFA(Debug_ForceNextTrackCB));
|
|
bank.AddToggle("ForceDjSpeech", &g_ForceDjSpeech);
|
|
bank.AddText("TrackListName", &g_TrackListName[0], sizeof(g_TrackListName));
|
|
bank.AddButton("QueueListOnStation", CFA(QueueTrackListOnStationCB));
|
|
bank.AddToggle("ForceQueuedTrack", &g_ForceQueueTrack);
|
|
bank.AddButton("ClearQueuedTracksOnStation", CFA(ClearQueuedTracksOnStationCB));
|
|
bank.AddSlider("NewsStory", &g_DebugNewsStory, 0, kMaxNewsStories, 1);
|
|
bank.AddButton("UnlockNews", CFA(UnlockNewsCB));
|
|
bank.PopGroup();
|
|
|
|
g_USBStationBank = &bank;
|
|
g_USBStationGroup = bank.PushGroup("USB Station");
|
|
bank.AddButton("Add USB Station Widgets", CFA(AddUSBStationWidgets));
|
|
bank.PopGroup();
|
|
|
|
bank.PushGroup("Radio DJ", false);
|
|
bank.AddSlider("DJ ducking level (dB)", &g_RadioDjDuckingLevelDb, 0.f, 24.f, 0.5f);
|
|
bank.AddSlider("DJ ducking smooth time (ms)", &g_RadioDjDuckTimeMs, 0, 1000, 100);
|
|
bank.AddSlider("DJ Speech Probability", &g_RadioDjSpeechProbability, 0.f, 1.f, 0.1f);
|
|
bank.AddSlider("DJ Speech Probability (Kult)", &g_RadioDjSpeechProbabilityKult, 0.f, 1.f, 0.1f);
|
|
bank.AddSlider("DJ Speech Probability (Motomami Outro)", &g_RadioDjOutroSpeechProbabilityMotomami, 0.f, 1.f, 0.1f);
|
|
bank.AddSlider("DJ Speech Min Retrigger Time Ms (Motomami)", &g_RadioDjSpeechMinDelayMsMotomami, 0u, 100000u, 100u);
|
|
bank.AddSlider("DJ Time Probability", &g_RadioDjTimeProbability, 0.f, 1.f, 0.1f);
|
|
bank.PopGroup();
|
|
|
|
bank.AddButton("DumpNewsState", CFA(DumpNewsStateCB));
|
|
bank.AddToggle("LogRadio", &g_LogRadio);
|
|
}
|
|
|
|
void audRadioStation::AddUSBStationWidgets()
|
|
{
|
|
if (g_USBStationBank && g_USBStationGroup && g_NumUSBStationTrackLists > 0 && !g_HasAddedUSBStationWidgets)
|
|
{
|
|
bkBank& bank = *g_USBStationBank;
|
|
bank.SetCurrentGroup(*g_USBStationGroup);
|
|
bank.AddToggle("Debug Draw USB Station", &g_DebugDrawUSBStation);
|
|
g_USBStationTrackListCombo = bank.AddCombo("Track List", &g_RequestedUSBTrackListComboIndex, g_NumUSBStationTrackLists, g_USBTrackListNames.GetElements());
|
|
bank.AddSlider("Start Offset (ms)", &g_USBStationTrackListOffsetMs, 0, 3600000, 1000);
|
|
bank.AddButton("Set Track List", CFA(SwitchUSBStationMixCB));
|
|
bank.AddButton("Skip To Offset", CFA(USBStationSkipToOffsetCB));
|
|
bank.AddButton("<< Skip Track", CFA(USBStationSkipPrevTrackCB));
|
|
bank.AddButton("Skip Track >>", CFA(USBStationSkipNextTrackCB));
|
|
bank.AddButton("Lock Track List", CFA(USBStationScriptLockTrackListCB));
|
|
g_HasAddedUSBStationWidgets = true;
|
|
}
|
|
}
|
|
|
|
void audRadioStation::FormatTimeString(const u32 milliseconds, char *destBuffer, const u32 destLength)
|
|
{
|
|
float seconds = milliseconds * 0.001f;
|
|
u32 minutes = (u32)(seconds / 60.f);
|
|
f32 remainderSeconds = seconds - (minutes*60.f);
|
|
|
|
formatf(destBuffer, destLength, "%02u:%02.02f", minutes, remainderSeconds);
|
|
}
|
|
|
|
void audRadioStation::DrawUSBStation() const
|
|
{
|
|
const f32 yStepRate = 0.015f;
|
|
f32 yCoord = 0.05f;
|
|
f32 xCoord = 0.05f;
|
|
u32 numTracks = GetMusicTrackListNumTracks();
|
|
s32 playingTrack = Max(0, GetMusicTrackListActiveTrackIndex());
|
|
|
|
char tempString[256];
|
|
formatf(tempString, "Station %s", GetName());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Last Forced Track List: %s", audNorthAudioEngine::GetMetadataManager().GetObjectName(m_LastForcedMusicTrackList));
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Playing Track %u of %u", playingTrack, numTracks);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Tracklist Play Time: %u/%u", GetMusicTrackListCurrentPlayTimeMs(), GetMusicTrackListDurationMs());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
for (u32 i = 0; i < numTracks; i++)
|
|
{
|
|
s32 startTime = GetMusicTrackListTrackStartTimeMs(i);
|
|
|
|
formatf(tempString, "Track %u", i);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), (s32)i == playingTrack ? Color32(100, 255, 100) : Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
xCoord += 0.02f;
|
|
|
|
const RadioStationTrackList::tTrack* track = GetMusicTracklistTrackForTimeOffset(startTime);
|
|
|
|
if (track)
|
|
{
|
|
formatf(tempString, "Sound: %s", SOUNDFACTORY.GetMetadataManager().GetObjectName(track->SoundRef));
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Start Time: %d", startTime);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
|
|
xCoord -= 0.02f;
|
|
}
|
|
|
|
yCoord += yStepRate;
|
|
}
|
|
|
|
void audRadioStation::DrawTakeoverStation() const
|
|
{
|
|
const f32 yStepRate = 0.015f;
|
|
f32 yCoord = 0.05f;
|
|
f32 xCoord = 0.05f;
|
|
|
|
char tempString[256];
|
|
formatf(tempString, "Station %s", GetName());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Random Seed: %u", GetRandomSeed());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Last Takeover Time: %u", m_TakeoverLastTimeMs);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Station Accumulated Playtime: %u", m_StationAccumulatedPlayTimeMs);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Takeover Music Track Count: %u", m_TakeoverMusicTrackCounter);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Music Run Count: %u", m_MusicRunningCount);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
const audRadioTrack& currentTrack = GetCurrentTrack();
|
|
|
|
if (currentTrack.IsInitialised())
|
|
{
|
|
formatf(tempString, "Current Track: %s (%s track %u)", SOUNDFACTORY.GetMetadataManager().GetObjectName(currentTrack.GetSoundRef()), TrackCats_ToString((TrackCats)currentTrack.GetCategory()), currentTrack.GetTrackIndex());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Progress: %u/%u (%.02f%%)", currentTrack.GetPlayTime(), currentTrack.GetDuration(), (currentTrack.GetPlayTime() / (f32)currentTrack.GetDuration()) * 100.f);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
else
|
|
{
|
|
formatf(tempString, "Current Track: Not Initialised");
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
|
|
const audRadioTrack& nextTrack = GetNextTrack();
|
|
|
|
if (nextTrack.IsInitialised())
|
|
{
|
|
formatf(tempString, "Next Track: %s (%s track %u)", SOUNDFACTORY.GetMetadataManager().GetObjectName(nextTrack.GetSoundRef()), TrackCats_ToString((TrackCats)nextTrack.GetCategory()), nextTrack.GetTrackIndex());
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
else
|
|
{
|
|
formatf(tempString, "Next Track: Not Initialised");
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
|
|
yCoord += yStepRate;
|
|
|
|
for (u32 category = 0; category < TRACKCATS_MAX; category++)
|
|
{
|
|
if (category == RADIO_TRACK_CAT_MUSIC ||
|
|
category == RADIO_TRACK_CAT_IDENTS ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_DJSOLO ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_IDENTS ||
|
|
category == RADIO_TRACK_CAT_TAKEOVER_MUSIC ||
|
|
category == RADIO_TRACK_CAT_DJSOLO)
|
|
{
|
|
s32 trackIndex = ~0u;
|
|
|
|
if (const audRadioStationHistory* history = FindHistoryForCategory(category))
|
|
{
|
|
trackIndex = history->GetPreviousEntry();
|
|
}
|
|
|
|
if (trackIndex < 0xff)
|
|
{
|
|
formatf(tempString, "Category %d: %s (%d tracks available)", category, TrackCats_ToString((TrackCats)category), ComputeNumTracksAvailable(category));
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Next Valid Selection Time: %d", GetNextValidSelectionTime(category));
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
formatf(tempString, "Category Stride: %d", m_CategoryStride[category]);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
|
|
const RadioStationTrackList::tTrack* trackMetadata = GetTrack(category, kNullContext, trackIndex);
|
|
formatf(tempString, "Previous Track: %s (Index: %u)", trackMetadata ? SOUNDFACTORY.GetMetadataManager().GetObjectName(trackMetadata->SoundRef) : "NULL", trackIndex);
|
|
grcDebugDraw::Text(Vector2(xCoord, yCoord), Color32(255, 255, 255), tempString);
|
|
yCoord += yStepRate;
|
|
}
|
|
|
|
yCoord += yStepRate;
|
|
}
|
|
}
|
|
}
|
|
|
|
void audRadioStation::DrawDebug(audDebugDrawManager &drawMgr) const
|
|
{
|
|
if(ShouldOnlyPlayMusic())
|
|
{
|
|
drawMgr.DrawLine("MUSIC ONLY");
|
|
}
|
|
|
|
if(GetCurrentTrack().IsInitialised())
|
|
{
|
|
drawMgr.PushSection("ActiveTrack");
|
|
GetCurrentTrack().DrawDebug(drawMgr);
|
|
drawMgr.PopSection();
|
|
}
|
|
else
|
|
{
|
|
drawMgr.DrawLine("ActiveTrack NOT INITIALISED");
|
|
}
|
|
if(GetNextTrack().IsInitialised())
|
|
{
|
|
drawMgr.PushSection("NextTrack");
|
|
GetNextTrack().DrawDebug(drawMgr);
|
|
drawMgr.PopSection();
|
|
}
|
|
else
|
|
{
|
|
drawMgr.DrawLine("NextTrack NOT INITIALISED");
|
|
}
|
|
|
|
if(sm_DebugHistory && this == g_RadioAudioEntity.GetPlayerRadioStation())
|
|
{
|
|
const audRadioStationHistory *musicHistory = FindHistoryForCategory(RADIO_TRACK_CAT_MUSIC);
|
|
const s32 historyLength = Max<s32>(ComputeNumTracksAvailable(RADIO_TRACK_CAT_MUSIC) - kMinRadioTracksOutsideHistory, 0);
|
|
const s32 searchLength = Clamp<s32>(historyLength, 0, audRadioStationHistory::kRadioHistoryLength);
|
|
for(s32 i = 0; i < searchLength; i++)
|
|
{
|
|
s32 historyIndex = (musicHistory->GetWriteIndex() + audRadioStationHistory::kRadioHistoryLength - 1 - i) % audRadioStationHistory::kRadioHistoryLength;
|
|
const u32 trackId = (*musicHistory)[historyIndex];
|
|
|
|
const char *objName = g_AudioEngine.GetSoundManager().GetFactory().GetMetadataManager().GetObjectName(trackId);
|
|
#if RSG_PC
|
|
if(m_IsUserStation)
|
|
{
|
|
if(trackId < sm_UserRadioTrackManager.GetNumTracks())
|
|
objName = sm_UserRadioTrackManager.GetTrackTitle(static_cast<s32>(trackId));
|
|
else
|
|
objName = "(invalid)";
|
|
}
|
|
#endif
|
|
|
|
drawMgr.DrawLinef("%d / %d: %08X - %s", i, historyIndex, trackId, objName ? objName : "unknown");
|
|
}
|
|
}
|
|
|
|
bool isDummy = false;
|
|
if(sm_DjSpeechMonoSound != NULL)
|
|
{
|
|
u32 clientVar = 0;
|
|
sm_DjSpeechMonoSound->GetClientVariable(clientVar);
|
|
if(clientVar == 0xdeadbeef) // using special value in client variable to denote dummy DJ speech
|
|
{
|
|
isDummy = true;
|
|
}
|
|
}
|
|
|
|
const char *djStates[] = {"Idle","Preparing","Prepared","Playing"};
|
|
char djSpeechWaitTimeString[32];
|
|
FormatTimeString(sm_ActiveDjSpeechStartTimeMs > m_Tracks[m_ActiveTrackIndex].GetPlayTime() ? sm_ActiveDjSpeechStartTimeMs - m_Tracks[m_ActiveTrackIndex].GetPlayTime() : 0, djSpeechWaitTimeString);
|
|
drawMgr.DrawLinef("Dj Speech state: %s starting in %s%s", djStates[sm_DjSpeechState], djSpeechWaitTimeString, isDummy ? " DUMMY" : "");
|
|
}
|
|
|
|
const char *audRadioStation::GetTrackCategoryName(const s32 trackCategory)
|
|
{
|
|
const char *ret = TrackCats_ToString((TrackCats)trackCategory);
|
|
if(ret)
|
|
{
|
|
return ret+16;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#if RSG_PC
|
|
void audRadioStation::DebugDrawUserMusic()
|
|
{
|
|
//for(int i=0; i<MAX_TRACK_HISTORY; i++)
|
|
//{
|
|
// s32 trackId = sm_UserRadioTrackManager.GetTrackIdFromHistory(i);
|
|
// if(trackId != -1)
|
|
// {
|
|
// char trackName[256];
|
|
// snprintf(trackName, 128, "%s", sm_UserRadioTrackManager.GetFileName(trackId));
|
|
// //Displayf("%d : %s : %d", i, trackName, trackId);
|
|
// grcDebugDraw::PrintToScreenCoors(trackName, 10, 10+i);
|
|
// }
|
|
//}
|
|
}
|
|
#endif //WIN32PC
|
|
#endif
|
|
#endif // NA_RADIO_ENABLED
|
|
|