367 lines
15 KiB
Python
367 lines
15 KiB
Python
import requests
|
|
import os
|
|
import pandas as pd
|
|
from tqdm import tqdm
|
|
import hashlib
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
import re
|
|
from tts_cli.env_vars import ELEVENLABS_API_KEY
|
|
from tts_cli.consts import RACE_DICT, GENDER_DICT
|
|
from tts_cli.length_table import write_sound_length_table_lua
|
|
from tts_cli.utils import get_first_n_words, get_last_n_words, replace_dollar_bs_with_space
|
|
from slpp import slpp as lua
|
|
|
|
# TODO: make module name a cli arg when we do other expansions
|
|
MODULE_NAME = 'AI_VoiceOverData_Vanilla'
|
|
OUTPUT_FOLDER = MODULE_NAME + '/generated'
|
|
SOUND_OUTPUT_FOLDER = OUTPUT_FOLDER + '/sounds'
|
|
DATAMODULE_TABLE_GUARD_CLAUSE = 'if not VoiceOver or not VoiceOver.DataModules then return end'
|
|
REPLACE_DICT = {'$b': '\n', '$B': '\n', '$n': 'adventurer', '$N': 'Adventurer',
|
|
'$C': 'Adventurer', '$c': 'adventurer', '$R': 'Traveler', '$r': 'traveler'}
|
|
|
|
def get_hash(text):
|
|
hash_object = hashlib.md5(text.encode())
|
|
return hash_object.hexdigest()
|
|
|
|
def create_output_subdirs(subdir: str):
|
|
output_subdir = os.path.join(SOUND_OUTPUT_FOLDER, subdir)
|
|
if not os.path.exists(output_subdir):
|
|
os.makedirs(output_subdir)
|
|
|
|
def prune_quest_id_table(quest_id_table):
|
|
def is_single_quest_id(nested_dict):
|
|
if isinstance(nested_dict, dict):
|
|
if len(nested_dict) == 1:
|
|
return is_single_quest_id(next(iter(nested_dict.values())))
|
|
else:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def single_quest_id(nested_dict):
|
|
if isinstance(nested_dict, dict):
|
|
return single_quest_id(next(iter(nested_dict.values())))
|
|
else:
|
|
return nested_dict
|
|
|
|
pruned_table = {}
|
|
for source_key, source_value in quest_id_table.items():
|
|
pruned_table[source_key] = {}
|
|
for title_key, title_value in source_value.items():
|
|
if is_single_quest_id(title_value):
|
|
pruned_table[source_key][title_key] = single_quest_id(title_value)
|
|
else:
|
|
pruned_table[source_key][title_key] = {}
|
|
for npc_key, npc_value in title_value.items():
|
|
if is_single_quest_id(npc_value):
|
|
pruned_table[source_key][title_key][npc_key] = single_quest_id(npc_value)
|
|
else:
|
|
pruned_table[source_key][title_key][npc_key] = npc_value
|
|
|
|
return pruned_table
|
|
|
|
class TTSProcessor:
|
|
def __init__(self):
|
|
self.voice_map = self.fetch_voice_map()
|
|
|
|
def get_voice_map(self):
|
|
return self.voice_map
|
|
|
|
def fetch_voice_map(self):
|
|
url = "https://api.elevenlabs.io/v1/voices"
|
|
headers = {
|
|
"xi-api-key": ELEVENLABS_API_KEY
|
|
}
|
|
|
|
response = requests.get(url, headers=headers)
|
|
if response.status_code != 200:
|
|
print("Error: unable to fetch data.")
|
|
return {}
|
|
|
|
response = response.json()
|
|
voice_map = {}
|
|
|
|
for voice in response["voices"]:
|
|
name_parts = voice["name"].split('-')
|
|
if len(name_parts) == 2:
|
|
race, gender = name_parts
|
|
if race in RACE_DICT.values() and (gender == 'male' or gender == 'female'):
|
|
voice_map[voice["name"]] = voice["voice_id"]
|
|
|
|
return voice_map
|
|
|
|
def tts(self, text: str, voice: str, outputName: str, output_subfolder: str, forceGen: bool = False):
|
|
result = ""
|
|
outpath = os.path.join(SOUND_OUTPUT_FOLDER, output_subfolder, outputName)
|
|
if os.path.isfile(outpath) and forceGen is not True:
|
|
result = "duplicate generation, skipping"
|
|
return
|
|
|
|
voice_id = self.voice_map[voice]
|
|
url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
|
|
payload = {
|
|
"text": text,
|
|
"voice_settings": {
|
|
"stability": 0.28,
|
|
"similarity_boost": .992
|
|
}
|
|
}
|
|
headers = {
|
|
"xi-api-key": ELEVENLABS_API_KEY
|
|
}
|
|
|
|
response = requests.post(url, json=payload, headers=headers)
|
|
|
|
if response.status_code == 200 and response.headers["Content-Type"] == "audio/mpeg":
|
|
with open(outpath, "wb") as f:
|
|
f.write(response.content)
|
|
result = f"Audio file saved successfully!: {outpath}"
|
|
print(result)
|
|
else:
|
|
result = f"Error: unable to save audio file {response}"
|
|
print(result)
|
|
return result
|
|
|
|
|
|
|
|
def handle_gender_options(self, text):
|
|
pattern = re.compile(r'\$[Gg]\s*([^:;]+?)\s*:\s*([^:;]+?)\s*;')
|
|
|
|
male_text = pattern.sub(r'\1', text)
|
|
female_text = pattern.sub(r'\2', text)
|
|
|
|
return male_text, female_text
|
|
|
|
def preprocess_dataframe(self, df):
|
|
df = df.copy() # prevent mutation on original df for safety
|
|
df['race'] = df['DisplayRaceID'].map(RACE_DICT)
|
|
df['gender'] = df['DisplaySexID'].map(GENDER_DICT)
|
|
df['voice_name'] = df['race'] + '-' + df['gender']
|
|
|
|
df['templateText_race_gender'] = df['original_text'] + df['race'] + df['gender']
|
|
df['templateText_race_gender_hash'] = df['templateText_race_gender'].apply(get_hash)
|
|
|
|
df['cleanedText'] = df['text'].copy()
|
|
|
|
for k, v in REPLACE_DICT.items():
|
|
df['cleanedText'] = df['cleanedText'].str.replace(k, v, regex=False)
|
|
|
|
df['cleanedText'] = df['cleanedText'].str.replace(r'<.*?>\s', '', regex=True)
|
|
|
|
df['player_gender'] = None
|
|
rows = []
|
|
for _, row in df.iterrows():
|
|
if re.search(r'\$[Gg]', row['cleanedText']):
|
|
male_text, female_text = self.handle_gender_options(row['cleanedText'])
|
|
|
|
row_male = row.copy()
|
|
row_male['cleanedText'] = male_text
|
|
row_male['player_gender'] = 'm'
|
|
|
|
row_female = row.copy()
|
|
row_female['cleanedText'] = female_text
|
|
row_female['player_gender'] = 'f'
|
|
|
|
rows.extend([row_male, row_female])
|
|
else:
|
|
rows.append(row)
|
|
|
|
new_df = pd.DataFrame(rows)
|
|
new_df.reset_index(drop=True, inplace=True)
|
|
|
|
return new_df
|
|
|
|
|
|
def process_row(self, row_tuple):
|
|
row = pd.Series(row_tuple[1:], index=row_tuple._fields[1:])
|
|
voice_name = f'{row["race"]}-{row["gender"]}'
|
|
custom_message = ""
|
|
if "$" in row["cleanedText"] or "<" in row["cleanedText"] or ">" in row["cleanedText"]:
|
|
custom_message = f'skipping due to invalid chars: {row["cleanedText"]}'
|
|
elif voice_name not in self.selected_voice_names:
|
|
custom_message = f'skipping due to voice being unselected or unavailable: {voice_name}'
|
|
elif row['source'] == "progress": # skip progress text (progress text is usually better left unread since its always played before quest completion)
|
|
custom_message = f'skipping progress text: {row["quest"]}-{row["source"]}'
|
|
else:
|
|
self.tts_row(row, voice_name)
|
|
return custom_message
|
|
|
|
def tts_row(self, row, voice_name):
|
|
tts_text = row['cleanedText']
|
|
file_name = f'{row["quest"]}-{row["source"]}' if row['quest'] else f'{row["templateText_race_gender_hash"]}'
|
|
if row['player_gender'] is not None:
|
|
file_name = row['player_gender'] + '-'+ file_name
|
|
file_name = file_name + '.mp3'
|
|
subfolder = 'quests' if row['quest'] else 'gossip'
|
|
self.tts(tts_text, voice_name, file_name, subfolder)
|
|
|
|
def create_output_dirs(self):
|
|
create_output_subdirs('')
|
|
create_output_subdirs('quests')
|
|
create_output_subdirs('gossip')
|
|
|
|
def process_rows_in_parallel(self, df, row_proccesing_fn, selected_voice_names: list[str], max_workers=5):
|
|
|
|
total_rows = len(df)
|
|
bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}] {postfix}'
|
|
self.selected_voice_names = set(selected_voice_names)
|
|
|
|
with tqdm(total=total_rows, unit='rows', ncols=100, desc='Generating Audio', ascii=False, bar_format=bar_format, dynamic_ncols=True) as pbar:
|
|
with ThreadPoolExecutor(max_workers=max_workers) as executor:
|
|
for row, custom_message in zip(df.iterrows(), executor.map(row_proccesing_fn, df.itertuples())):
|
|
pbar.set_postfix_str(custom_message)
|
|
pbar.update(1)
|
|
|
|
|
|
def write_gossip_file_lookups_table(self, df, module_name, type, table, filename):
|
|
output_file = OUTPUT_FOLDER + f"/{filename}.lua"
|
|
gossip_table = {}
|
|
|
|
accept_df = df[(df['quest'] == '') & (df['type'] == type)]
|
|
|
|
for i, row in tqdm(accept_df.iterrows()):
|
|
if row['id'] not in gossip_table:
|
|
gossip_table[row['id']] = {}
|
|
|
|
escapedText = row['text'].replace('"', '\'').replace('\r',' ').replace('\n',' ')
|
|
|
|
gossip_table[row['id']][escapedText] = row['templateText_race_gender_hash']
|
|
|
|
with open(output_file, "w", encoding="UTF-8") as f:
|
|
f.write(DATAMODULE_TABLE_GUARD_CLAUSE + "\n")
|
|
f.write(f"{module_name}.{table} = ")
|
|
f.write(lua.encode(gossip_table))
|
|
f.write("\n")
|
|
|
|
print(f"Finished writing {filename}.lua")
|
|
|
|
|
|
def write_questlog_npc_lookups_table(self, df, module_name, type, table, filename):
|
|
output_file = OUTPUT_FOLDER + f"/{filename}.lua"
|
|
questlog_table = {}
|
|
|
|
accept_df = df[(df['source'] == 'accept') & (df['type'] == type)]
|
|
|
|
for i, row in tqdm(accept_df.iterrows()):
|
|
questlog_table[int(row['quest'])] = row['id']
|
|
|
|
with open(output_file, "w", encoding="UTF-8") as f:
|
|
f.write(DATAMODULE_TABLE_GUARD_CLAUSE + "\n")
|
|
f.write(f"{module_name}.{table} = ")
|
|
f.write(lua.encode(questlog_table))
|
|
f.write("\n")
|
|
|
|
print(f"Finished writing {filename}.lua")
|
|
|
|
def write_npc_name_lookup_table(self, df, module_name, type, table, filename):
|
|
output_file = OUTPUT_FOLDER + f"/{filename}.lua"
|
|
npc_name_table = {}
|
|
|
|
accept_df = df[df['type'] == type]
|
|
|
|
for i, row in tqdm(accept_df.iterrows()):
|
|
npc_name_table[row['id']] = row['name']
|
|
|
|
with open(output_file, "w", encoding="UTF-8") as f:
|
|
f.write(DATAMODULE_TABLE_GUARD_CLAUSE + "\n")
|
|
f.write(f"{module_name}.{table} = ")
|
|
f.write(lua.encode(npc_name_table))
|
|
f.write("\n")
|
|
|
|
print(f"Finished writing {filename}.lua")
|
|
|
|
def write_quest_id_lookup(self, df, module_name):
|
|
output_file = OUTPUT_FOLDER + "/quest_id_lookups.lua"
|
|
quest_id_table = {}
|
|
|
|
quest_df = df[df['quest'] != '']
|
|
|
|
for i, row in tqdm(quest_df.iterrows()):
|
|
quest_source = row['source']
|
|
if quest_source == 'progress': # skipping progress text for now
|
|
continue
|
|
|
|
quest_id = int(row['quest'])
|
|
quest_title = row['quest_title']
|
|
quest_text = get_first_n_words(row['text'], 15) + ' ' + get_last_n_words(row['text'], 15)
|
|
escaped_quest_text = replace_dollar_bs_with_space(quest_text.replace('"', '\'').replace('\r',' ').replace('\n',' '))
|
|
escaped_quest_title = quest_title.replace('"', '\'').replace('\r',' ').replace('\n',' ')
|
|
npc_name = row['name']
|
|
escaped_npc_name = npc_name.replace('"', '\'').replace('\r',' ').replace('\n',' ')
|
|
|
|
# table[source][title][npcName][text]
|
|
if quest_source not in quest_id_table:
|
|
quest_id_table[quest_source] = {}
|
|
|
|
if escaped_quest_title not in quest_id_table[quest_source]:
|
|
quest_id_table[quest_source][escaped_quest_title] = {}
|
|
|
|
if escaped_npc_name not in quest_id_table[quest_source][escaped_quest_title]:
|
|
quest_id_table[quest_source][escaped_quest_title][escaped_npc_name] = {}
|
|
|
|
if quest_text not in quest_id_table[quest_source][escaped_quest_title][escaped_npc_name]:
|
|
quest_id_table[quest_source][escaped_quest_title][escaped_npc_name][escaped_quest_text] = quest_id
|
|
|
|
pruned_quest_id_table = prune_quest_id_table(quest_id_table)
|
|
|
|
# UTF-8 Encoding is important for other languages!
|
|
with open(output_file, "w", encoding="utf-8") as f:
|
|
f.write(DATAMODULE_TABLE_GUARD_CLAUSE + "\n")
|
|
f.write(f"{module_name}.QuestIDLookup = ")
|
|
f.write(lua.encode(pruned_quest_id_table))
|
|
f.write("\n")
|
|
|
|
def write_npc_name_gossip_file_lookups_table(self, df, module_name, type, table, filename):
|
|
output_file = OUTPUT_FOLDER + f"/{filename}.lua"
|
|
gossip_table = {}
|
|
|
|
accept_df = df[(df['quest'] == '') & (df['type'] == type)]
|
|
|
|
for i, row in tqdm(accept_df.iterrows()):
|
|
npc_name = row['name']
|
|
escaped_npc_name = npc_name.replace('"', '\'').replace('\r',' ').replace('\n',' ')
|
|
|
|
if escaped_npc_name not in gossip_table:
|
|
gossip_table[escaped_npc_name] = {}
|
|
|
|
escapedText = row['text'].replace('"', '\'').replace('\r',' ').replace('\n',' ')
|
|
|
|
gossip_table[escaped_npc_name][escapedText] = row['templateText_race_gender_hash']
|
|
|
|
with open(output_file, "w", encoding="UTF-8") as f:
|
|
f.write(DATAMODULE_TABLE_GUARD_CLAUSE + "\n")
|
|
f.write(f"{module_name}.{table} = ")
|
|
f.write(lua.encode(gossip_table))
|
|
f.write("\n")
|
|
|
|
print(f"Finished writing {filename}.lua")
|
|
|
|
|
|
|
|
def tts_dataframe(self, df, selected_voices):
|
|
self.create_output_dirs()
|
|
self.process_rows_in_parallel(df, self.process_row, selected_voices, max_workers=5)
|
|
print("Audio finished generating.")
|
|
|
|
def generate_lookup_tables(self, df):
|
|
self.create_output_dirs()
|
|
self.write_gossip_file_lookups_table(df, MODULE_NAME, 'creature', 'GossipLookupByNPCID', 'npc_gossip_file_lookups')
|
|
self.write_gossip_file_lookups_table(df, MODULE_NAME, 'gameobject', 'GossipLookupByObjectID', 'object_gossip_file_lookups')
|
|
|
|
self.write_quest_id_lookup(df, MODULE_NAME)
|
|
print("Finished writing quest_id_lookups.lua")
|
|
|
|
self.write_npc_name_gossip_file_lookups_table(df, MODULE_NAME, 'creature', 'GossipLookupByNPCName', 'npc_name_gossip_file_lookups')
|
|
self.write_npc_name_gossip_file_lookups_table(df, MODULE_NAME, 'gameobject', 'GossipLookupByObjectName', 'object_name_gossip_file_lookups')
|
|
|
|
self.write_questlog_npc_lookups_table(df, MODULE_NAME, 'creature', 'NPCIDLookupByQuestID', 'questlog_npc_lookups')
|
|
self.write_questlog_npc_lookups_table(df, MODULE_NAME, 'gameobject', 'ObjectIDLookupByQuestID', 'questlog_object_lookups')
|
|
self.write_questlog_npc_lookups_table(df, MODULE_NAME, 'item', 'ItemIDLookupByQuestID', 'questlog_item_lookups')
|
|
|
|
self.write_npc_name_lookup_table(df, MODULE_NAME, 'creature', 'NPCNameLookupByNPCID', 'npc_name_lookups')
|
|
self.write_npc_name_lookup_table(df, MODULE_NAME, 'gameobject', 'ObjectNameLookupByObjectID', 'object_name_lookups')
|
|
self.write_npc_name_lookup_table(df, MODULE_NAME, 'item', 'ItemNameLookupByItemID', 'item_name_lookups')
|
|
|
|
write_sound_length_table_lua(MODULE_NAME, SOUND_OUTPUT_FOLDER, OUTPUT_FOLDER)
|
|
print("Updated sound_length_table.lua")
|