📝

jiangyangcreate · jiangyangcreate · commit 48612fba092d · 2024-10-11T20:13:07.000+08:00
diff --git a/blog/2024-5-31.md b/blog/2024-5-31.md
@@ -13,24 +13,126 @@ description: 记录使用flask搭建个人共享屏幕工具
 
 这个时候，你就需要一个工具来捕获和分享你的屏幕和音频（包括设备音频和麦克风输入），并通过网页形式与他人共享。这样，观众无需下载任何会议软件，仅需打开浏览器即可观看。
 
+当然有时候你需要提供必要的文件，比如代码，文档等。所以这个程序还允许你上传与下载文件。上传的文件会保存在当前目录下的`upload`文件夹中，你也可以从`upload`文件夹中下载文件。
+
 ## 安装依赖
 
 ```bash
-pip install opencv-python Pillow greenlet pyaudio Flask
+pip install flask opencv-python Pillow greenlet pyaudio Flask
 ```
 
+## 项目目录结构
+
+项目下有两个文件夹： templates 和 uploads。
+
+templates 文件夹中包含一个 upload.html 文件，用于页面展示。
+
+uploads 文件夹用于保存上传的文件。
+
+```bash showLineNumbers
+your_project/
+├── templates/
+│   └── upload.html
+│   └── stream.html
+├── uploads/
+└── app.py
+``` 
+
+## 路由说明
+
+`/` 路由。它处理文件上传、下载功能。
+
+`/d` 路由。它提供桌面视频流+音频流。
+
+`/c` 路由。它提供摄像头视频流+音频流。
+
+
 ## 代码
 
-```python showLineNumbers title="share.py"
-from flask import Flask, Response, render_template_string, stream_with_context
+```html showLineNumbers title="upload.html"
+<!doctype html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <title>上传文件</title>
+</head>
+<body>
+    <h1>上传文件</h1>
+    <form method="post" enctype="multipart/form-data">
+        <input type="file" name="file">
+        <input type="submit" value="上传">
+    </form>
+    {% if filename %}
+        <p>文件上传成功！</p>
+        <a href="{{ url_for('download_file', filename=filename) }}">下载 {{ filename }}</a>
+    {% endif %}
+</body>
+</html>
+```
+
+```html showLineNumbers title="stream.html"
+<!DOCTYPE html>
+<head>
+    <title>Intranet Broadcast</title>
+</head>
+
+<body>
+    <img id="video" src="{{ video_url }}" alt="视频流">
+    <audio autoplay style="display:none;">
+        <source src="{{ audio_url }}" type="audio/x-wav; codec=pcm">Your browser does not support the audio
+        element.
+    </audio>
+</body>
+</html>
+```
+
+```python showLineNumbers title="app.py"
+from flask import Flask, render_template, request, send_from_directory, abort, Response,stream_with_context
+import os
 import time
 import cv2
-from PIL import ImageGrab, Image
+import numpy as np
+from PIL import ImageGrab
 import threading
-from io import BytesIO
 from greenlet import getcurrent as get_ident
 import pyaudio
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+app = Flask(__name__)
+
+# 设置上传文件夹
+UPLOAD_FOLDER = "uploads"
+app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
 
+# 添加下载文件的路由
+@app.route("/download/<filename>")
+def download_file(filename):
+    try:
+        return send_from_directory(
+            app.config["UPLOAD_FOLDER"], filename, as_attachment=True
+        )
+    except FileNotFoundError:
+        abort(404)
+
+@app.route("/", methods=["GET", "POST"])
+def upload_file():
+    if request.method == "POST":
+        if "file" not in request.files:
+            return "没有文件部分"
+        file = request.files["file"]
+        if file.filename == "":
+            return "没有选择文件"
+        if file:
+            filename = file.filename
+            file.save(os.path.join(app.config["UPLOAD_FOLDER"], filename))
+            return "文件上传成功"
+    return render_template("upload.html")
+
+@app.route("/uploads/<filename>")
+def uploaded_file(filename):
+    return send_from_directory(app.config["UPLOAD_FOLDER"], filename)
 
 class Audio:
     def __init__(self):
@@ -75,34 +177,60 @@ class Audio:
         return self.wav_header + data
 
     def _get_audio_subsequent_times(self):
-        return self.stream.read(self.CHUNK)
+        if self.stream:
+            data = self.stream.read(self.CHUNK)
+            shared_timestamp.update()  # 更新时间戳
+            return data
+        else:
+            return b'\x00' * self.CHUNK * 2  # 返回静音数据
+
+class SharedTimestamp:
+    def __init__(self):
+        self.timestamp = 0
+        self.lock = threading.Lock()
+
+    def update(self):
+        with self.lock:
+            self.timestamp = time.time()
+
+    def get(self):
+        with self.lock:
+            return self.timestamp
+
+shared_timestamp = SharedTimestamp()
 
 class CameraEvent(object):
     def __init__(self):
         self.events = {}
+        self.lock = threading.Lock()
 
     def wait(self):
         ident = get_ident()
-        if ident not in self.events:
-            self.events[ident] = [threading.Event(), time.time()]
-        return self.events[ident][0].wait()
+        with self.lock:
+            if ident not in self.events:
+                self.events[ident] = [threading.Event(), time.time()]
+            event = self.events[ident][0]
+        event.wait()
 
     def set(self):
         now = time.time()
-        remove = None
-        for ident, event in self.events.items():
-            if not event[0].is_set():
-                event[0].set()
-                event[1] = now
-            else:
-                if now - event[1] > 5:
-                    remove = ident
-        if remove:
-            del self.events[remove]
+        with self.lock:
+            remove = []
+            for ident, event in self.events.items():
+                if not event[0].is_set():
+                    event[0].set()
+                    event[1] = now
+                else:
+                    if now - event[1] > 5:
+                        remove.append(ident)
+            for ident in remove:
+                del self.events[ident]
 
     def clear(self):
-        self.events[get_ident()][0].clear()
-
+        ident = get_ident()
+        with self.lock:
+            if ident in self.events:
+                self.events[ident][0].clear()
 
 class BaseCamera(object):
     thread = None
@@ -131,100 +259,115 @@ class BaseCamera(object):
     @classmethod
     def _thread(cls):
         print("Starting camera thread.")
-        frames_iterator = cls.frames()
-        for frame in frames_iterator:
-            BaseCamera.frame = frame
-            BaseCamera.event.set()
-            time.sleep(0)
-            if time.time() - BaseCamera.last_access > 10:
-                frames_iterator.close()
-                print("Stopping camera thread due to inactivity.")
-                break
-        BaseCamera.thread = None
+        try:
+            frames_iterator = cls.frames()
+            for frame in frames_iterator:
+                BaseCamera.frame = frame
+                shared_timestamp.update()  # 更新时间戳
+                BaseCamera.event.set()
+                time.sleep(0)
+                if time.time() - BaseCamera.last_access > 10:
+                    frames_iterator.close()
+                    print("Stopping camera thread due to inactivity.")
+                    break
+        except Exception as e:
+            print(f"Camera thread encountered an error: {e}")
+        finally:
+            BaseCamera.thread = None
+            cls.release_resources()
 
+    @classmethod
+    def release_resources(cls):
+        if hasattr(cls, 'cap') and cls.cap.isOpened():
+            cls.cap.release()
+            print("Camera resources released.")
 
 class Camera(BaseCamera):
-    video_source = 0
+    cap = None
 
-    @staticmethod
-    def set_video_source(source):
-        Camera.video_source = source
+    def __init__(self):
+        if Camera.cap is None:
+            Camera.cap = cv2.VideoCapture(0)
+        if not Camera.cap.isOpened():
+            logging.error("无法打开摄像头")
+            raise RuntimeError("无法打开摄像头")
+        super().__init__()
 
     @staticmethod
     def frames():
-        camera = cv2.VideoCapture(Camera.video_source)
-        if not camera.isOpened():
-            raise RuntimeError("Error")
         while True:
-            image = ImageGrab.grab()
-            image = image.resize((1366, 750), Image.LANCZOS)
-            output_buffer = BytesIO()
-            image.save(output_buffer, format="JPEG", quality=100)
-            frame = output_buffer.getvalue()
-            yield frame
-app = Flask(__name__)
+            if Camera.cap is None:
+                Camera.cap = cv2.VideoCapture(0)
+            success, frame = Camera.cap.read()
+            if not success:
+                logging.error("无法从摄像头读取帧")
+                break
+            else:
+                ret, jpeg = cv2.imencode('.jpg', frame)
+                if not ret:
+                    logging.error("无法编码图像")
+                    continue
+                yield jpeg.tobytes()
 
-def gen(camera):
+    @classmethod
+    def release_resources(cls):
+        if cls.cap is not None:
+            cls.cap.release()
+            cls.cap = None
+            logging.info("摄像头资源已释放")
+
+class DesktopCapture(BaseCamera):
+    @staticmethod
+    def frames():
+        while True:
+            screen = np.array(ImageGrab.grab())
+            frame = cv2.cvtColor(screen, cv2.COLOR_RGB2BGR)
+            ret, jpeg = cv2.imencode('.jpg', frame)
+            if not ret:
+                logging.error("无法编码桌面图像")
+                continue
+            yield jpeg.tobytes()
+
+def gen_video(camera):
     while True:
         frame = camera.get_frame()
-        yield (b"--frame\r\n" b"Content-Type: image/jpeg\r\n\r\n" + frame + b"\r\n")
+        timestamp = shared_timestamp.get()
+        yield frame
 
 def gen_audio(audio):
     while True:
         data = audio.get_audio()
+        timestamp = shared_timestamp.get()
         yield data
 
-@app.route("/video_feed")
-def video_feed():
-    return Response(gen(Camera()), mimetype="multipart/x-mixed-replace; boundary=frame")
+@app.route("/c_video")
+def camera_video_feed():
+    return Response(gen_video(Camera()))
+
+@app.route("/d_video")
+def desktop_video_feed():
+    return Response(gen_video(DesktopCapture()))
 
 @app.route("/audio_feed")
 def audio_feed():
-    return Response(stream_with_context(gen_audio(Audio())))
-
-@app.route("/")
-def index():
-    global mode
-    video_tag = """<img src="{{ url_for('video_feed') }}">"""
-    audio_tag = """<audio autoplay style="display:none;"><source src="{{ url_for('audio_feed') }}" type="audio/x-wav; codec=pcm">Your browser does not support the audio element.</audio>"""
-
-    tags = {0: video_tag + audio_tag, 1: audio_tag, 2: video_tag}
-
-    content = tags[mode]
-
-    return render_template_string(
-        """<html>
-    <head>
-        <title>{title}</title>
-        <link rel="icon" href="data:image/svg+xml;base64,CjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB2aWV3Qm94PSIwIDAgNTAgNTAiPgogICAgPGNpcmNsZSBjeD0iMjUiIGN5PSIyNSIgcj0iMjAiIGZpbGw9InJlZCIgLz4KPC9zdmc+Cg==">
-    </head>
-    <body>{content}</body>
-    </html>""".format(
-            title=["Intranet Broadcast", "Audio Sharing", "Screen Sharing"][mode],
-            content=content,
-        )
-    )
-
-if __name__ == "__main__":
-    local_host = "127.0.0.1"
-    ip_host = "0.0.0.0"
-    port = 8001
-    mode = int(input("Please select the mode: 0 for Intranet Broadcast, 1 for Audio Sharing, 2 for Screen Sharing: "))
-    app.run(threaded=True, host=ip_host, port=port)
+    return Response(gen_audio(Audio()))
 
-```
-运行程序后，程序会提示你输入一个数字：
-
-0表示同时分享屏幕和音频  
-1表示仅分享音频  
-2表示仅分享屏幕  
-
-输入相应数字后按回车键即可。程序运行后，会在控制台输出一个URL。你只需在浏览器中输入这个URL，就可以看到你的屏幕和音频了。
+@app.route("/c")
+def camera_page():
+    return render_template("stream.html", video_url="/c_video", audio_url="/audio_feed")
 
-## 后话
+@app.route("/d")
+def desktop_page():
+    return render_template("stream.html", video_url="/d_video", audio_url="/audio_feed")
 
-你可以在此项目的基础上进行扩展，增加更多功能，如：
-
-- [x] 识别当前音频并将其转化为文本，与屏幕共享一起传输，这样观众就可以在屏幕上看到你的讲话内容。
-- [x] 结合翻译API，实现实时翻译功能。
-- [x] 压缩屏幕画面质量，获得更流畅的传输效果等等。
+if __name__ == "__main__":
+    try:
+        os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+        local_host = "127.0.0.1"
+        ip_host = "0.0.0.0"
+        port = 8001
+        app.run(threaded=True, host=ip_host, port=port, debug=True)
+    except Exception as e:
+        logging.error(f"发生错误: {e}")
+        # 可以选择在这里保持程序运行
+```
