[PYTHON] Ich habe eine Untertiteldatei (SRT) aus JSON-Daten von AmiVoice erstellt

Einführung

Ich werde zum ersten Mal posten. Mein Name ist Denki Sheep von der Golden Bridge. Mein Hauptgeschäft ist die chinesische Übersetzung, aber ich programmiere auch gerne als Hobby.

Ich habe mit Sprachen experimentiert, bin aber immer noch ein Sonntagsprogrammierer. Ich möchte, dass Profis mich immer mehr schlagen!

Hintergrund

In letzter Zeit sind Dolmetscher aufgrund des Einflusses von Corona online besonders gefragt. In vielen Fällen wird das Videoaufzeichnungsformat im Voraus verwendet, so dass die Kommunikation instabil werden kann. Infolgedessen wurden nicht nur Übersetzungen, sondern auch ** Untertitel ** immer mehr behandelt.

Bis jetzt war es eine kleine Menge, also musste ich es manuell machen, aber da es eine große Sache war, entschied ich mich, eine SRT-Datei zu erstellen, um Arbeit zu sparen.

Informationen zu SRT-Dateien

Ein Format, das als De-facto-Standard zum Einfügen von Untertiteln in Videos bezeichnet werden kann. Der Inhalt ist sehr einfach.

1
00:00:01,050 --> 00:00:05,778
Erster Untertitel

2
00:00:07,850 --> 00:00:11,123
Nächster Untertitel

3
00:01:02,566 --> 00:01:12,456
Dritter Untertitel

mögen, Index

• Startzeit-> Endzeit * Text (Neue Zeile) Die vier Elemente von werden nebeneinander hergestellt.

Mit dieser Datei können Sie Untertitel sofort in eine Videodatei importieren.

Transkription

Wir verwenden AmiVoice Cloud Platform für japanische Transkriptionsentwürfe.

Da es in Japan hergestellt wurde, ist es auf Japanisch genauer als Google usw.

Das Schreiben von Grund auf ist schwierig, daher [Beispielprogramm](https://acp.amivoice.com/main/manual/%e3%82%b5%e3%83%b3%e3%83%97%e3%83%ab Nur% e3% 83% 97% e3% 83% ad% e3% 82% b0% e3% 83% a9% e3% 83% a0 /) optimieren.

Durch Ausführen dieses Beispielprogramms können Sie die spracherkannten JSON-Daten abrufen. Für mehr Informationen

[Zurückgegebenes JSON (AmiVoice)](https://acp.amivoice.com/main/manual/if%E4%BB%95%E6%A7%98-http%E9%9F%B3%E5%A3 % B0% E8% AA% 8D% E8% AD% 98api% E8% A9% B3% E7% B4% B0 / # Antwort)

Verwenden Sie aus diesen JSON-Daten Startzeit, Endzeit und in Token geschrieben, um sie im SRT-Format anzuordnen.

Lesen Sie JSON

Sobald Sie den JSON erhalten haben, werden wir sofort mit der Konvertierung beginnen. Als Bedingung zum Trennen von Untertitelblöcken

• Interpunktion (,?)
• Zeit (Millisekunden)
• Wortzahl

Ich werde herum verwenden. Außerdem füge ich den Untertiteln keine Satzzeichen hinzu, daher überspringe ich sie.

Diese Elemente sind Befehlszeilenargumente, die flexibel geändert werden können.

import argparse
import json

parser = argparse.ArgumentParser()
parser.add_argument("file", help="Designate JSON file name to read")
parser.add_argument("-d", "--delimiters", help="Designate delimiters to separate subtitles. Default value is ['。','、']", default="。,、")
parser.add_argument("-s", "--skip", help="Designate skip words which do not inculud in subtitles. Default value is ['。','、']", default="。,、")
parser.add_argument("-t", "--time", help="Designate allowed time for single subtile by millisecongds. Default value is 5000", default=5000, type=int)
parser.add_argument("-c", "--charas", help="Designate allowed charas for single subtile. Default value is 25", default=25, type=int)

class SRTFomart():
	def __init__(self, args): 
		self.text = ""
		self.blocks = []
		self.delimiters = args.delimiters.split(",")
		self.skipWords = args.skip.split(",")
		self.time = args.time
		self.charas = args.charas

	def readFile(self, file):
		f = open(file, "r", encoding="utf-8")
		contents = f.read()
		f.close()
		data = json.loads(contents)["results"][0]
		self.text = data["text"]
		self.readTokens(data["tokens"])

	def readTokens(self, tokens):
		sub = ""
		startTime = 0
		index = 1
		# subTitles = []
		
		for token in tokens:
			written = token["written"]
			#Stellen Sie startTime ein, wenn der Untertitel leer ist
			if sub == "":
				#Auch wenn die Untertitel leer sind, überspringen Sie, wenn der Inhalt des Tokens Satzzeichen usw. sind.
				if written in self.delimiters or written in self.skipWords:
					continue

				else:
					startTime = token["starttime"]

			#Erstellen Sie Untertitelumbrüche
			#Speichern Sie Untertitel unter jeder Bedingung in Blöcken und setzen Sie sie einmal zurück
			#Wenn Sie ein Interpunktionszeichen treffen
			if written in self.delimiters or len(sub) > self.charas or token["endtime"] - startTime > self.time:
				self.blocks.append(self.createSRTBlock(index, startTime, token["endtime"], sub))
				sub = ""
				startTime = 0
				index += 1

			#Verbinden Sie Untertitel mit Ausnahme der Bedingungen
			else:
				if written not in self.skipWords:
					sub += token["written"]
		
		#Für Schleife bisher
		#Speichern Sie den letzten Block
		self.blocks.append(self.createSRTBlock(index, startTime, tokens[-1]["endtime"], sub))


	def createSRTBlock(self, index, startTime, endTime, sub):
		stime = self.timeFormat(startTime)
		etime = self.timeFormat(endTime)
		return f"{index}\n{stime} --> {etime}\n{sub}\n"

	def timeFormat(self, time):
		time_ = time
		ms_ = int(time_ % 1000)
		time_ = int((time_ - ms_) / 1000)
		sec_ = int(time_ % 60)
		time_ = int((time_ - sec_) / 60)
		mn_ = int(time_ % 60)
		time_ = int((time_ - mn_) /60)
		hr_ = int(time_ % 60)
		if ms_ < 10:
			ms = f"00{ms_}"
		elif ms_ < 100:
			ms = f"0{ms_}"
		else:
			ms = str(ms_)
				
		if sec_ < 10:
			sec = f"0{sec_}"
		else:
			sec = str(sec_)
				
		if mn_ < 10:
			mn = f"0{mn_}"
		else:
			mn = str(mn_)
				
		if hr_ < 10:
			hr = f"0{hr_}"
		else:
			hr = str(hr_)
	
		return f"{hr}:{mn}:{sec},{ms}"

	def exportSRTText(self):
		return "\n".join(self.blocks)


if __name__ == "__main__":
	args = parser.parse_args()
	if not args.file.endswith(".json"):
		print("Please set json file")
	
	else:
		srt = SRTFomart(args)
		srt.readFile(args.file)
		text = srt.exportSRTText()
		srtName = args.file.replace(".json", ".srt")
		f = open(srtName, "w", encoding="utf-8")
		f.write(text)
		f.close()
		print("done")

Sie haben erfolgreich in das SRT-Format konvertiert.

importieren

Schließlich müssen Sie nur die generierte SRT-Datei anpassen oder übersetzen und in Ihre Videobearbeitungssoftware importieren. Mit Davinci Resolve habe ich es einfach aus dem Medienpool auf die Videospur gelegt.

Von der bisherigen manuellen Arbeit scheinen wir eine erhebliche Effizienzverbesserung erwarten zu können!

von jetzt an

――Ich möchte mich mit maschineller Übersetzung verbinden!

• Japanische Kalibrierung mit Word usw. → Suche nach einer Möglichkeit zum erneuten Importieren.

Viel Glück beim Erstellen von Untertiteln für die neue normale Ära!