# Song-Cover-Anfrage

# Request-Typen

{"type": "cover_request"}: Startet die Erstellung eines Song-Covers.

# Song-Cover-Request-Struktur

# Funktion zum Senden der Song-Cover-Anfrage nach erfolgreicher Authentifizierung

async def send_cover_request(websocket):
    cover_request = {
        "type": "cover_request",
        "song": "Rihanna - Diamonds",
        "model": "henningmay",
        "pitch": 0,
        "user_id": 241579763498614784
    }
    await websocket.send(json.dumps(cover_request))

# Funktion zum Senden der Song-Cover-Anfrage nach erfolgreicher Authentifizierung
function sendCoverRequest(ws) {
    const coverRequest = {
        type: "cover_request",
        song: "Rihanna - Diamonds",
        model: "henningmay",
        pitch: 0,
        user_id: 241579763498614784
    };
    ws.send(JSON.stringify(coverRequest));
}

Name	Value
type	cover_request = Erstelle ein KI Cover Song
song	Eindeutiger Song Titel oder Youtube URL
model	KI-Stimme aus der Auswahl von TitAInium Website https://voiceshiftde.site/
pitch	Die Tonhöhe von -2 bis + 2 wobei 1 Schritt eine Oktave wiederspiegelt
user_id	Discord User ID

# Antworten

# Queue-Position

{
  "type": "job_queued",
  "message": "Job wurde in die Warteschlange eingereiht."
}

# Audio-Segment

{
  "type": "audio_segment",
  "song_title": "SONGTITEL",
  "audio_data": "BASE64_AUDIO_SEGMENT",
  "is_final": false
}

Name	Value
type	audio_segment = Audio-Daten des KI Covers
song_title	Song Titel mit Zusatzinfo (Model, Pitch)
audio_data	BASE64 Audio Segment des fertigen KI Covers
is_final	true = Letzte Nachricht vom Websocket nach fertigstellung

# Empfangen der Audio-Segmente

Nach dem Senden der Cover-Anfrage empfängt der Client mehrere Audio-Segmente vom Server. Dieser Prozess läuft wie folgt ab:

Der Client empfängt Nachrichten vom WebSocket in einer Schleife.
Jede Nachricht wird als JSON-Objekt interpretiert.
Wenn die Nachricht vom Typ "job_queued" ist, wird der Job-Status angezeigt.
Wenn die Nachricht vom Typ "audio_segment" ist:
- Das Audio-Segment wird zu einer Liste hinzugefügt.
- Der Client prüft, ob es sich um das letzte Segment handelt (is_final = true).
Der Prozess wird fortgesetzt, bis das letzte Segment empfangen wurde oder ein Fehler auftritt.

Hier ein Beispielcode für diesen Prozess:

async def receive_audio_segments(websocket):
    encoded_audio_segments = []
    while True:
        try:
            message = await websocket.recv()
            response = json.loads(message)

            if response.get("type") == "job_queued":
                print(f"Job in Warteschlange: {response}")
                continue

            if response.get("type") == "audio_segment":
                encoded_audio_segments.append(response["audio_data"])
                print(f"Empfangenes Segment: {len(response['audio_data'])} Zeichen")
                if response.get("is_final"):
                    break

        except websockets.exceptions.ConnectionClosedError as e:
            print(f"WebSocket-Verbindung wurde geschlossen: {e}")
            break
        except Exception as e:
            print(f"Ein unerwarteter Fehler ist aufgetreten: {e}")
            break

    return ''.join(encoded_audio_segments)

function receiveAudioSegments(ws) {
    return new Promise((resolve, reject) => {
        const encodedAudioSegments = [];

        ws.onmessage = function(event) {
            try {
                const response = JSON.parse(event.data);

                if (response.type === "job_queued") {
                    console.log(`Job in Warteschlange: ${JSON.stringify(response)}`);
                    return;
                }

                if (response.type === "audio_segment") {
                    encodedAudioSegments.push(response.audio_data);
                    console.log(`Empfangenes Segment: ${response.audio_data.length} Zeichen`);
                    if (response.is_final) {
                        resolve(encodedAudioSegments.join(''));
                    }
                }
            } catch (error) {
                console.error("Fehler beim Verarbeiten der Nachricht:", error);
                reject(error);
            }
        };

        ws.onerror = function(error) {
            console.error("WebSocket-Fehler:", error);
            reject(error);
        };

        ws.onclose = function(event) {
            if (!event.wasClean) {
                console.error(`WebSocket-Verbindung unerwartet geschlossen. Code: ${event.code}`);
                reject(new Error("WebSocket-Verbindung unerwartet geschlossen"));
            }
        };
    });
}

Dieser Code empfängt die Audio-Segmente, bis das letzte Segment (gekennzeichnet durch is_final = true) empfangen wurde oder ein Fehler auftritt. Die empfangenen Segmente werden in einer Liste gespeichert und am Ende zu einem einzigen String zusammengefügt. Wichtige Punkte:

Die Segmente werden in der Reihenfolge empfangen, in der sie gesendet wurden.
Das letzte Segment wird durch is_final = true gekennzeichnet.
Nach Empfang aller Segmente müssen diese zu einer vollständigen Audio-Datei zusammengefügt werden.
Es ist wichtig, auf mögliche Verbindungsfehler oder unerwartete Nachrichten zu achten und diese entsprechend zu behandeln.