Spaces:

svabald
/

video_translator

Sleeping

App Files Files Community

sergey.agapov commited on Jul 3

Commit

12b350f

•

1 Parent(s): ee6428d

initial commit

Browse files

Files changed (6) hide show

Dockerfile +16 -0
requirements.txt +8 -0
static/images/logo.png +0 -0
templates/tiktok_player.html +366 -0
translator.py +346 -0
validator.py +102 -0

Dockerfile ADDED Viewed

	@@ -0,0 +1,16 @@

+FROM python:3.9
+# Install FFmpeg
+RUN apt-get update && apt-get install -y ffmpeg
+WORKDIR /code
+# Create the directory and set permissions
+RUN mkdir -p /tmp/dash/test_stream && chmod 777 /tmp/dash/test_stream
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+COPY . /code
+CMD ["python", "validator.py"]

requirements.txt ADDED Viewed

	@@ -0,0 +1,8 @@

+flask
+flask-cors
+psutil
+numpy
+transformers
+sentencepiece
+webrtcvad
+openai-whisper

static/images/logo.png ADDED Viewed

templates/tiktok_player.html ADDED Viewed

	@@ -0,0 +1,366 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Multilanguage Player</title>
+    <script src="https://cdn.dashjs.org/latest/dash.all.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/webvtt-parser@2.1.2/dist/parser.min.js"></script>
+    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            margin: 0;
+            background-color: #ffffff;
+        }
+        .top-div {
+            width: 100%;
+            height: 100px;
+            background-color: #3C8DF9;
+            margin-bottom: 20px;
+        }
+        .container {
+            display: flex;
+            justify-content: space-between;
+            width: 90%;
+            max-width: 1200px;
+        }
+        .left-panel {
+            width: 30%;
+            padding: 20px;
+            box-sizing: border-box;
+        }
+        .right-panel {
+            width: 65%;
+            padding: 20px;
+            box-sizing: border-box;
+        }
+        .frame {
+            width: 402px;
+            height: 720px;
+            border: 2px solid #ccc;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+        video {
+            max-width: 100%;
+            max-height: 100%;
+            box-shadow: 0 0 10px rgba(0,0,0,0.1);
+        }
+        select, input, button {
+            margin: 10px 0;
+            padding: 5px;
+            width: 100%;
+        }
+        #result {
+            margin-top: 10px;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+<div class="top-div"><img src="{{ url_for('static', filename='images/logo.png') }}" alt="Bytedance" height="100px"></div>
+<div class="container">
+    <div class="left-panel">
+        <h2>FLV Stream Url</h2>
+        <form id="flvForm">
+            <input type="text" id="flvInput" placeholder="http://example.com/stream.flv" required>
+            <button type="submit">Play Stream</button>
+        </form>
+        <div id="result"></div>
+        <form id="terminateStreamForm">
+            <button type="submit">Stop Stream</button>
+        </form>
+        <h3>Language Selection</h3>
+        <select id="captionSelect">
+            <option value="original">Original</option>
+            <option value="es">Spanish</option>
+            <option value="ru">Russian</option>
+            <option value="en">English</option>
+            <option value="zh">Chinese</option>
+        </select>
+        <h3>Model Selection</h3>
+        <select id="models">
+            <option value="base">Base</option>
+            <option value="small">Small</option>
+            <option value="medium">Medium</option>
+            <option value="large">Large</option>
+            <option value="large-v2">Large-V2</option>
+        </select>
+    </div>
+    <div class="right-panel">
+        <div class="frame">
+            <div id="waitingMessage">Waiting for the stream...</div>
+            <video id="videoPlayer" controls style="display: none;"></video>
+        </div>
+    </div>
+</div>
+<script>
+    (function () {
+        var url = "{{ url_for('serve_file', filename='manifest.mpd') }}";
+        var player = dashjs.MediaPlayer().create();
+        var video = document.querySelector("#videoPlayer");
+        var waitingMessage = document.querySelector("#waitingMessage");
+        var captionSelect = document.querySelector("#captionSelect");
+        var currentLanguage = "original";
+        var refreshInterval = 10000;
+        var desiredDelay = 45;
+        var checkInterval = 5000; // Check every 5 seconds
+        function initializePlayer() {
+            // Reset the player if it's already initialized
+            if (player.isReady()) {
+                player.reset();
+            }
+            console.log("Initializing the player with %s", url)
+            player.updateSettings({
+                streaming: {
+                    delay: {
+                        liveDelay: 50,
+                    },
+                    buffer: {
+                        bufferToKeep: 40,
+                        bufferTimeAtTopQuality: 50,
+                        bufferTimeAtTopQualityLongForm: 50,
+                        initialBufferLevel: 50,
+                    },
+                }
+            });
+            fetch(url, {method: 'GET', cache: "no-store"})
+                .then(response => {
+                    if (response.ok) {
+                        console.log("Response: ", response.text())
+                    } else {
+                        console.log("Response not ok: ", response.body)
+                    }
+                })
+                .catch(() => {
+                    console.log("Error")
+                });
+            player.initialize(video, url, false);
+           // player.attachView(video);
+            player.setMute(true)
+            player.enableForcedTextStreaming(true);
+            player.on(dashjs.MediaPlayer.events.STREAM_INITIALIZED, onStreamInitialized);
+            player.on(dashjs.MediaPlayer.events.ERROR, onPlayerError);
+        }
+        function checkStreamAvailability() {
+            fetch(url, {method: 'GET', cache: "no-store"})
+                .then(response => {
+                    if (response.ok) {
+                        console.log("Stream is ready")
+                        //manifest is there, wait a sec for init segments
+                        setTimeout(initializePlayer, 15000)
+                    } else {
+                        setTimeout(checkStreamAvailability, checkInterval);
+                    }
+                })
+                .catch(() => {
+                    setTimeout(checkStreamAvailability, checkInterval);
+                });
+        }
+        function onStreamInitialized() {
+            console.log("Stream initialized, setting up captions");
+            setupCaptions();
+            setInterval(refreshCaptions, refreshInterval);
+            waitForInitialData();
+            player.play()
+        }
+        function onPlayerError(e) {
+            console.log("Player error:", e);
+            let errorCode = e.code || e.error?.code || e.error?.error?.code;
+            console.log("Extracted error code:", errorCode);
+            if (errorCode === 25) {
+                console.log("Rescheduling...")
+                waitingMessage.style.display = "block";
+                video.style.display = "none";
+                checkStreamAvailability();
+            }
+            console.log("None...")
+            //waitingMessage.style.display = "block";
+            //video.style.display = "none";
+            //checkStreamAvailability();
+        }
+        function waitForInitialData() {
+            console.log("Waiting for initial data");
+            if (player.getBufferLength() > 0 && video.readyState >= 2) {
+                console.log("Initial data buffered, starting playback");
+                waitingMessage.style.display = "none";
+                video.style.display = "block";
+                //player.play();
+            } else {
+                setTimeout(waitForInitialData, 100);
+            }
+        }
+        function parseVTT(vttContent) {
+            const lines = vttContent.trim().split('\n');
+            let cues = [];
+            let cue = {};
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes('-->')) {
+                    const [start, end] = lines[i].split('-->').map(timeString => {
+                        const [hours, minutes, seconds] = timeString.trim().split(':');
+                        return parseFloat(hours) * 3600 + parseFloat(minutes) * 60 + parseFloat(seconds);
+                    });
+                    cue = {start, end, text: ''};
+                } else if (lines[i].trim() !== '' && cue.start !== undefined) {
+                    cue.text += lines[i] + '\n';
+                } else if (lines[i].trim() === '' && cue.text) {
+                    cues.push(cue);
+                    cue = {};
+                }
+            }
+            if (cue.text) {
+                cues.push(cue);
+            }
+            return cues;
+        }
+        function loadCaptions(lang) {
+            console.log("Loading captions for language: " + lang);
+            var baseUrl = "{{ url_for('serve_file', filename='') }}";  // This will give the base URL for the 'serve_file' endpoint.
+            var fileName = "captions_" + lang + ".vtt";
+            var captionUrl = baseUrl + fileName;
+            for (var i = 0; i < video.textTracks.length; i++) {
+                video.textTracks[i].mode = 'disabled';
+            }
+            var track = Array.from(video.textTracks).find(t => t.language === lang);
+            if (!track) {
+                track = video.addTextTrack("captions", lang, lang);
+            }
+            track.mode = 'showing';
+            updateTrackCues(track, captionUrl);
+            currentLanguage = lang;
+            console.log("Captions loaded for language: " + lang);
+        }
+        function updateTrackCues(track, url) {
+            fetch(url)
+                .then(response => response.text())
+                .then(vttContent => {
+                    const cues = parseVTT(vttContent);
+                    while (track.cues.length > 0) {
+                        track.removeCue(track.cues[0]);
+                    }
+                    cues.forEach(cue => {
+                        const vttCue = new VTTCue(cue.start, cue.end, cue.text.trim());
+                        track.addCue(vttCue);
+                    });
+                })
+                .catch(error => console.error('Error updating captions:', error));
+        }
+        function refreshCaptions() {
+            if (currentLanguage) {
+                var track = Array.from(video.textTracks).find(t => t.language === currentLanguage);
+                if (track) {
+                    var baseUrl = "{{ url_for('serve_file', filename='') }}";  // This will give the base URL for the 'serve_file' endpoint.
+                    var fileName = "captions_" + currentLanguage + ".vtt";
+                    var captionUrl = baseUrl + fileName;
+                    updateTrackCues(track, captionUrl);
+                }
+            }
+        }
+        function setupCaptions() {
+            var tracks = player.getTracksFor('text');
+            console.log("Available text tracks:", tracks);
+            if (tracks.length > 0) {
+                captionSelect.innerHTML = '';
+                tracks.forEach(function (track) {
+                    var option = document.createElement('option');
+                    option.value = track.lang;
+                    option.text = track.lang;
+                    captionSelect.appendChild(option);
+                });
+                loadCaptions(tracks[0].lang);
+            } else {
+                loadCaptions(currentLanguage);
+            }
+        }
+        captionSelect.addEventListener("change", function () {
+            loadCaptions(this.value);
+        });
+        // FLV Stream Checker
+        $('#flvForm').submit(function(e) {
+            $('#waitingMessage').text("Checking the url...");
+            e.preventDefault();
+            $.ajax({
+                url: '/terminate',
+                method: 'POST',
+                data: null,
+            });
+            if (player.isReady()) {
+                player.pause()
+            }
+            $.ajax({
+                url: '/check_flv',
+                method: 'POST',
+                data: { url: $('#flvInput').val(), model: $('#models').val() },
+                success: function(response) {
+                    $('#waitingMessage').text(response.message);
+                    if (response.status === 'success') {
+                        waitingMessage.style.display = "block";
+                        video.style.display = "none";
+                        //initializePlayer();
+                        //checkStreamAvailability();
+                    }
+                },
+                error: function() {
+                    $('#result').text('An error occurred');
+                }
+            });
+        });
+        // FLV Stream Checker
+        $('#terminateStreamForm').submit(function(e) {
+            e.preventDefault();
+            $.ajax({
+                url: '/terminate',
+                method: 'POST',
+                data: null,
+            });
+            if (player.isReady()) {
+                player.pause()
+            }
+        });
+        // Start checking for stream availability
+        //initializePlayer();
+        checkStreamAvailability();
+        // Log current live delay every 5 seconds
+       // setInterval(() => {
+       //     var currentLiveDelay = player.duration() - player.time();
+       //     console.log("Current live delay:", currentLiveDelay);
+        //}, 5000);
+    })();
+</script>
+</body>
+</html>

translator.py ADDED Viewed

	@@ -0,0 +1,346 @@

+import subprocess
+import threading
+import argparse
+import fcntl
+import select
+import whisper
+import ffmpeg
+import signal
+import numpy as np
+import queue
+import time
+import webrtcvad
+import collections
+import os
+from transformers import MarianMTModel, MarianTokenizer
+# Global variables
+rtmp_url = ""
+dash_output_path = ""
+segment_duration = 2
+last_activity_time = 0.0
+cleanup_threshold = 10  # seconds of inactivity before cleanup
+start_time = 0.0
+# Languages for translation (ISO 639-1 codes)
+target_languages = ["es", "zh", "ru"]  # Example: Spanish, Chinese, Russian
+# Initialize Whisper model
+whisper_model = {}
+# Define Frame class
+class Frame:
+    def __init__(self, data, timestamp, duration):
+        self.data = data
+        self.timestamp = timestamp
+        self.duration = duration
+# Audio buffer and caption queues
+audio_buffer = queue.Queue()
+caption_queues = {lang: queue.Queue() for lang in target_languages + ["original", "en"]}
+language_model_names = {
+    "es": "Helsinki-NLP/opus-mt-en-es",
+    "zh": "Helsinki-NLP/opus-mt-en-zh",
+    "ru": "Helsinki-NLP/opus-mt-en-ru",
+}
+translation_models = {}
+tokenizers = {}
+# Initialize VAD
+vad = webrtcvad.Vad(3)  # Aggressiveness mode 3 (most aggressive)
+# Event to signal threads to stop
+stop_event = threading.Event()
+def transcode_rtmp_to_dash():
+    ffmpeg_command = [
+        "/opt/homebrew/bin/ffmpeg",
+        "-i", rtmp_url,
+        "-map", "0:v:0", "-map", "0:a:0",
+        "-c:v", "libx264", "-preset", "slow",
+        "-c:a", "aac", "-b:a", "128k",
+        "-f", "dash",
+        "-seg_duration", str(segment_duration),
+        "-use_timeline", "1",
+        "-use_template", "1",
+        "-init_seg_name", "init_$RepresentationID$.m4s",
+        "-media_seg_name", "chunk_$RepresentationID$_$Number%05d$.m4s",
+        "-adaptation_sets", "id=0,streams=v id=1,streams=a",
+        f"{dash_output_path}/manifest.mpd"
+    ]
+    process = subprocess.Popen(ffmpeg_command)
+    while not stop_event.is_set():
+        time.sleep(1)
+    process.kill()
+def capture_audio():
+    global last_activity_time
+    command = [
+        '/opt/homebrew/bin/ffmpeg',
+        '-i', rtmp_url,
+        '-acodec', 'pcm_s16le',
+        '-ar', '16000',
+        '-ac', '1',
+        '-f', 's16le',
+        '-'
+    ]
+    sample_rate = 16000
+    frame_duration_ms = 30
+    sample_width = 2  # Only 16-bit audio supported
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    # Set stdout to non-blocking mode
+    fd = process.stdout.fileno()
+    fl = fcntl.fcntl(fd, fcntl.F_GETFL)
+    fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+    frame_size = int(sample_rate * frame_duration_ms / 1000) * sample_width
+    frame_count = 0
+    while not stop_event.is_set():
+        ready, _, _ = select.select([process.stdout], [], [], 0.1)
+        if ready:
+            try:
+                in_bytes = os.read(fd, frame_size)
+                if not in_bytes:
+                    break
+                if len(in_bytes) < frame_size:
+                    in_bytes += b'\x00' * (frame_size - len(in_bytes))
+                last_activity_time = time.time()
+                timestamp = frame_count * frame_duration_ms * 0.85
+                frame = Frame(np.frombuffer(in_bytes, np.int16), timestamp, frame_duration_ms)
+                audio_buffer.put(frame)
+                frame_count += 1
+            except BlockingIOError:
+                continue
+        else:
+            time.sleep(0.01)
+    process.kill()
+def frames_to_numpy(frames):
+    all_frames = np.concatenate([f.data for f in frames])
+    float_samples = all_frames.astype(np.float32) / np.iinfo(np.int16).max
+    return float_samples
+def vad_collector(sample_rate, frame_duration_ms, padding_duration_ms, vad, frames):
+    num_padding_frames = int(padding_duration_ms / frame_duration_ms)
+    ring_buffer = collections.deque(maxlen=num_padding_frames)
+    triggered = False
+    for frame in frames:
+        if len(frame.data) != int(sample_rate * (frame_duration_ms / 1000.0)):
+            print(f"Skipping frame with incorrect size: {len(frame.data)} samples", flush=True)
+            continue
+        is_speech = vad.is_speech(frame.data.tobytes(), sample_rate)
+        if not triggered:
+            ring_buffer.append((frame, is_speech))
+            num_voiced = len([f for f, speech in ring_buffer if speech])
+            if num_voiced > 0.8 * ring_buffer.maxlen:
+                triggered = True
+                for f, s in ring_buffer:
+                    yield f
+                ring_buffer.clear()
+        else:
+            yield frame
+            ring_buffer.append((frame, is_speech))
+            num_unvoiced = len([f for f, speech in ring_buffer if not speech])
+            if num_unvoiced > 0.8 * ring_buffer.maxlen:
+                triggered = False
+                yield None
+                ring_buffer.clear()
+    for f, s in ring_buffer:
+        yield f
+    ring_buffer.clear()
+def process_audio():
+    global last_activity_time
+    frames = []
+    buffer_duration_ms = 1500  # About 1.5 seconds of audio
+    while not stop_event.is_set():
+        while not audio_buffer.empty():
+            frame = audio_buffer.get(timeout=5.0)
+            frames.append(frame)
+        if frames and sum(f.duration for f in frames) >= buffer_duration_ms:
+            vad_frames = list(vad_collector(16000, 30, 300, vad, frames))
+            if vad_frames:
+                audio_segment = [f for f in vad_frames if f is not None]
+                if audio_segment:
+                    # Transcribe the original audio
+                    result = whisper_model.transcribe(frames_to_numpy(audio_segment))
+                    if result["text"]:
+                        timestamp = audio_segment[0].timestamp
+                        caption_queues["original"].put((timestamp, result["text"]))
+                        english_translation = whisper_model.transcribe(frames_to_numpy(audio_segment), task="translate")
+                        caption_queues["en"].put((timestamp, english_translation["text"]))
+                        # Translate to target languages
+                        for lang in target_languages:
+                            tokenizer = tokenizers[lang]
+                            translation_model = translation_models[lang]
+                            inputs = tokenizer.encode(english_translation["text"], return_tensors="pt", padding=True, truncation=True)
+                            translated_tokens = translation_model.generate(inputs)
+                            translated_text = tokenizer.decode(translated_tokens[0], skip_special_tokens=True)
+                            caption_queues[lang].put((timestamp, translated_text))
+            frames = []
+        time.sleep(0.01)
+def write_captions(lang):
+    os.makedirs(dash_output_path, exist_ok=True)
+    filename = f"{dash_output_path}/captions_{lang}.vtt"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("WEBVTT\n\n")
+    last_end_time = None
+    while not stop_event.is_set():
+        if not caption_queues[lang].empty():
+            timestamp, text = caption_queues[lang].get()
+            start_time = format_time(timestamp / 1000)  # Convert ms to seconds
+            end_time = format_time((timestamp + 5000) / 1000)  # Assume 5-second duration for each caption
+            # Adjust the previous caption's end time if necessary
+            if last_end_time and start_time != last_end_time:
+                adjust_previous_caption(filename, last_end_time, start_time)
+            # Write the new caption
+            with open(filename, "a", encoding="utf-8") as f:
+                f.write(f"{start_time} --> {end_time}\n")
+                f.write(f"{text}\n\n")
+                f.flush()
+            last_end_time = end_time
+        time.sleep(0.1)
+def adjust_previous_caption(filename, old_end_time, new_end_time):
+    with open(filename, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+    for i in range(len(lines) - 1, -1, -1):
+        if "-->" in lines[i]:
+            parts = lines[i].split("-->")
+            if parts[1].strip() == old_end_time:
+                lines[i] = f"{parts[0].strip()} --> {new_end_time}\n"
+                break
+    with open(filename, "w", encoding="utf-8") as f:
+        f.writelines(lines)
+def format_time(seconds):
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{int(hours):02d}:{int(minutes):02d}:{seconds:06.3f}"
+def signal_handler(signum, frame):
+    print(f"Received signal {signum}. Cleaning up and exiting...")
+    # Signal all threads to stop
+    stop_event.set()
+def cleanup():
+    global last_activity_time
+    while not stop_event.is_set():
+        current_time = time.time()
+        if last_activity_time != 0.0 and current_time - last_activity_time > cleanup_threshold:
+            print("No activity detected for 10 seconds. Cleaning up...", flush=True)
+            # Signal all threads to stop
+            stop_event.set()
+            break
+        time.sleep(1)  # Check for inactivity every second
+    # Clear caption queues
+    for lang in target_languages + ["original", "en"]:
+        while not caption_queues[lang].empty():
+            caption_queues[lang].get()
+    # Delete DASH output files
+    for root, dirs, files in os.walk(dash_output_path, topdown=False):
+        for name in files:
+            os.remove(os.path.join(root, name))
+        for name in dirs:
+            os.rmdir(os.path.join(root, name))
+    print("Cleanup completed.", flush=True)
+if __name__ == "__main__":
+    # Get RTMP URL and DASH output path from user input
+    signal.signal(signal.SIGTERM, signal_handler)
+    parser = argparse.ArgumentParser(description="Process audio for translation.")
+    parser.add_argument('--rtmp_url', help='rtmp url')
+    parser.add_argument('--output_directory', help='Dash directory')
+    parser.add_argument('--model', help='Whisper model size: base|small|medium|large|large-v2')
+    start_time = time.time()
+    args = parser.parse_args()
+    rtmp_url = args.rtmp_url
+    dash_output_path = args.output_directory
+    model_size = args.model
+    print(f"RTMP URL: {rtmp_url}")
+    print(f"DASH output path: {dash_output_path}")
+    print(f"Model: {dash_output_path}")
+    print("Downloading models\n")
+    print("Whisper\n")
+    whisper_model = whisper.load_model(model_size, download_root="/tmp/model/")  # Adjust model size as necessary
+    for lang, model_name in language_model_names.items():
+        print(f"Lang: {lang}, model: {model_name}\n")
+        tokenizers[lang] = MarianTokenizer.from_pretrained(model_name)
+        translation_models[lang] = MarianMTModel.from_pretrained(model_name)
+    # Start RTMP to DASH transcoding in a separate thread
+    transcode_thread = threading.Thread(target=transcode_rtmp_to_dash)
+    transcode_thread.start()
+    # Start audio capture in a separate thread
+    audio_capture_thread = threading.Thread(target=capture_audio)
+    audio_capture_thread.start()
+    # Start audio processing in a separate thread
+    audio_processing_thread = threading.Thread(target=process_audio)
+    audio_processing_thread.start()
+    # Start caption writing threads for original and all target languages
+    caption_threads = []
+    for lang in target_languages + ["original", "en"]:
+        caption_thread = threading.Thread(target=write_captions, args=(lang,))
+        caption_threads.append(caption_thread)
+        caption_thread.start()
+    # Start the cleanup thread
+    cleanup_thread = threading.Thread(target=cleanup)
+    cleanup_thread.start()
+    # Wait for all threads to complete
+    print("Join transcode", flush=True)
+    if transcode_thread.is_alive():
+        transcode_thread.join()
+    print("Join sudio capture", flush=True)
+    if audio_capture_thread.is_alive():
+        audio_capture_thread.join()
+    print("Join audio processing", flush=True)
+    if audio_processing_thread.is_alive():
+        audio_processing_thread.join()
+    for thread in caption_threads:
+        if thread.is_alive():
+            thread.join()
+    print("Join clenaup", flush=True)
+    if cleanup_thread.is_alive():
+        cleanup_thread.join()
+    print("All threads have been stopped and cleaned up.")
+    exit(0)

validator.py ADDED Viewed

	@@ -0,0 +1,102 @@

+from flask import Flask, render_template, request, jsonify, send_from_directory
+import subprocess
+import json
+import psutil
+import time
+import signal
+import os
+from flask_cors import CORS
+app = Flask(__name__)
+CORS(app)  # This will allow all domains to make requests to your server
+script_process = None
+SCRIPT_NAME = 'translator.py'
+def find_process_by_name(name):
+    for process in psutil.process_iter(['pid', 'name', 'cmdline']):
+        cmdline = process.info['cmdline']
+        if cmdline and any(name in arg for arg in cmdline):
+            return process
+    return None
+def terminate_script():
+    global script_process
+    process = find_process_by_name(SCRIPT_NAME)
+    if process:
+        print(f"Terminating existing script process (PID: {process.pid})")
+        process.send_signal(signal.SIGTERM)
+        try:
+            process.wait(timeout=20)  # Wait up to 10 seconds for the process to terminate
+        except psutil.TimeoutExpired:
+            print(f"Process {process.pid} did not terminate in time, forcing...")
+            process.kill()  # Force kill if it doesn't terminate
+        # Double-check if the process is really terminated
+        if not find_process_by_name(SCRIPT_NAME):
+            print(f"Process {SCRIPT_NAME} successfully terminated")
+        else:
+            print(f"Warning: Process {SCRIPT_NAME} could not be terminated")
+    else:
+        print(f"No running process found with name: {SCRIPT_NAME}")
+    script_process = None
+@app.route('/', methods=['GET'])
+def index():
+    return render_template('tiktok_player.html')
+@app.route('/terminate', methods=['POST'])
+def terminate():
+    terminate_script()
+    return jsonify({'status': 'success', 'message': 'Stream stopped'})
+@app.route('/stream/<path:filename>')
+def serve_file(filename):
+    return send_from_directory('/tmp/dash/test_stream', filename)
+@app.route('/check_flv', methods=['POST'])
+def check_flv():
+    global script_process
+    flv_url = request.form['url']
+    model = request.form['model']
+    try:
+        # Use ffprobe to check the FLV stream
+        result = subprocess.run([
+            'ffprobe',
+            '-v', 'quiet',
+            '-print_format', 'json',
+            '-show_streams',
+            flv_url
+        ], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            # Parse the JSON output
+            probe_data = json.loads(result.stdout)
+            # Check if there are any streams in the output
+            if 'streams' in probe_data and len(probe_data['streams']) > 0:
+                # Stream is valid
+                # Terminate existing script if running
+                terminate_script()
+                # Start new script
+                new_process = subprocess.Popen(['python', '/Users/bytedance/source/video_translator/src/flask_app'
+                                                          '/translator.py', '--rtmp_url', flv_url,
+                                                '--output_directory', '/tmp/dash/test_stream/', '--model', model])
+                script_process = psutil.Process(new_process.pid)
+                return jsonify({'status': 'success', 'message': 'Buffering...'})
+            else:
+                return jsonify({'status': 'error', 'message': 'No valid streams found in the FLV'})
+        else:
+            # Stream is invalid
+            return jsonify({'status': 'error', 'message': 'Invalid FLV stream'})
+    except subprocess.TimeoutExpired:
+        return jsonify({'status': 'error', 'message': 'Timeout while checking FLV stream'})
+    except Exception as e:
+        return jsonify({'status': 'error', 'message': f'Error: {str(e)}'})
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)