2307 lines
58 KiB
Go
2307 lines
58 KiB
Go
package main
|
||
|
||
import (
|
||
"bufio"
|
||
"bytes"
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"net/url"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"regexp"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/PuerkitoBio/goquery"
|
||
"github.com/google/uuid"
|
||
"github.com/grafov/m3u8"
|
||
"github.com/sqweek/dialog"
|
||
)
|
||
|
||
var roomDossierRegexp = regexp.MustCompile(`window\.initialRoomDossier = "(.*?)"`)
|
||
|
||
type JobStatus string
|
||
|
||
const (
|
||
JobRunning JobStatus = "running"
|
||
JobFinished JobStatus = "finished"
|
||
JobFailed JobStatus = "failed"
|
||
JobStopped JobStatus = "stopped"
|
||
)
|
||
|
||
type RecordJob struct {
|
||
ID string `json:"id"`
|
||
model string `json:"model"`
|
||
SourceURL string `json:"sourceUrl"`
|
||
Output string `json:"output"`
|
||
Status JobStatus `json:"status"`
|
||
StartedAt time.Time `json:"startedAt"`
|
||
EndedAt *time.Time `json:"endedAt,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
|
||
PreviewDir string `json:"-"`
|
||
PreviewImage string `json:"-"`
|
||
previewCmd *exec.Cmd `json:"-"`
|
||
|
||
// Thumbnail cache (verhindert, dass pro HTTP-Request ffmpeg läuft)
|
||
previewMu sync.Mutex `json:"-"`
|
||
previewJpeg []byte `json:"-"`
|
||
previewJpegAt time.Time `json:"-"`
|
||
previewGen bool `json:"-"`
|
||
|
||
cancel context.CancelFunc `json:"-"`
|
||
}
|
||
|
||
var (
|
||
jobs = map[string]*RecordJob{}
|
||
jobsMu = sync.Mutex{}
|
||
)
|
||
|
||
// ffmpeg-Binary suchen (env, neben EXE, oder PATH)
|
||
var ffmpegPath = detectFFmpegPath()
|
||
|
||
// main.go
|
||
|
||
type RecorderSettings struct {
|
||
RecordDir string `json:"recordDir"`
|
||
DoneDir string `json:"doneDir"`
|
||
FFmpegPath string `json:"ffmpegPath,omitempty"`
|
||
|
||
AutoAddToDownloadList bool `json:"autoAddToDownloadList,omitempty"`
|
||
AutoStartAddedDownloads bool `json:"autoStartAddedDownloads,omitempty"`
|
||
|
||
UseChaturbateAPI bool `json:"useChaturbateApi,omitempty"`
|
||
|
||
// EncryptedCookies contains base64(nonce+ciphertext) of a JSON cookie map.
|
||
EncryptedCookies string `json:"encryptedCookies,omitempty"`
|
||
}
|
||
|
||
var (
|
||
settingsMu sync.Mutex
|
||
settings = RecorderSettings{
|
||
RecordDir: "/records",
|
||
DoneDir: "/records/done",
|
||
FFmpegPath: "",
|
||
|
||
AutoAddToDownloadList: false,
|
||
AutoStartAddedDownloads: false,
|
||
|
||
UseChaturbateAPI: false,
|
||
EncryptedCookies: "",
|
||
}
|
||
settingsFile = "recorder_settings.json"
|
||
)
|
||
|
||
func getSettings() RecorderSettings {
|
||
settingsMu.Lock()
|
||
defer settingsMu.Unlock()
|
||
return settings
|
||
}
|
||
|
||
func detectFFmpegPath() string {
|
||
// 0. Settings-Override (ffmpegPath in recorder_settings.json / UI)
|
||
s := getSettings()
|
||
if p := strings.TrimSpace(s.FFmpegPath); p != "" {
|
||
// Relativ zur EXE auflösen, falls nötig
|
||
if !filepath.IsAbs(p) {
|
||
if abs, err := resolvePathRelativeToApp(p); err == nil {
|
||
p = abs
|
||
}
|
||
}
|
||
return p
|
||
}
|
||
|
||
// 1. Umgebungsvariable FFMPEG_PATH erlaubt Override
|
||
if p := strings.TrimSpace(os.Getenv("FFMPEG_PATH")); p != "" {
|
||
if abs, err := filepath.Abs(p); err == nil {
|
||
return abs
|
||
}
|
||
return p
|
||
}
|
||
|
||
// 2. ffmpeg / ffmpeg.exe im selben Ordner wie dein Go-Programm
|
||
if exe, err := os.Executable(); err == nil {
|
||
exeDir := filepath.Dir(exe)
|
||
candidates := []string{
|
||
filepath.Join(exeDir, "ffmpeg"),
|
||
filepath.Join(exeDir, "ffmpeg.exe"),
|
||
}
|
||
for _, c := range candidates {
|
||
if fi, err := os.Stat(c); err == nil && !fi.IsDir() {
|
||
return c
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. ffmpeg über PATH suchen und absolut machen
|
||
if lp, err := exec.LookPath("ffmpeg"); err == nil {
|
||
if abs, err2 := filepath.Abs(lp); err2 == nil {
|
||
return abs
|
||
}
|
||
return lp
|
||
}
|
||
|
||
// 4. Fallback: plain "ffmpeg" – kann dann immer noch fehlschlagen
|
||
return "ffmpeg"
|
||
}
|
||
|
||
func loadSettings() {
|
||
b, err := os.ReadFile(settingsFile)
|
||
if err == nil {
|
||
var s RecorderSettings
|
||
if json.Unmarshal(b, &s) == nil {
|
||
if strings.TrimSpace(s.RecordDir) != "" {
|
||
s.RecordDir = filepath.Clean(strings.TrimSpace(s.RecordDir))
|
||
}
|
||
if strings.TrimSpace(s.DoneDir) != "" {
|
||
s.DoneDir = filepath.Clean(strings.TrimSpace(s.DoneDir))
|
||
}
|
||
if strings.TrimSpace(s.FFmpegPath) != "" {
|
||
s.FFmpegPath = strings.TrimSpace(s.FFmpegPath)
|
||
}
|
||
|
||
settingsMu.Lock()
|
||
settings = s
|
||
settingsMu.Unlock()
|
||
}
|
||
}
|
||
|
||
// Ordner sicherstellen
|
||
s := getSettings()
|
||
_ = os.MkdirAll(s.RecordDir, 0o755)
|
||
_ = os.MkdirAll(s.DoneDir, 0o755)
|
||
|
||
// ffmpeg-Pfad anhand Settings/Env/PATH bestimmen
|
||
ffmpegPath = detectFFmpegPath()
|
||
fmt.Println("🔍 ffmpegPath:", ffmpegPath)
|
||
}
|
||
|
||
func saveSettingsToDisk() {
|
||
s := getSettings()
|
||
b, _ := json.MarshalIndent(s, "", " ")
|
||
_ = os.WriteFile(settingsFile, b, 0o644)
|
||
}
|
||
|
||
func recordSettingsHandler(w http.ResponseWriter, r *http.Request) {
|
||
switch r.Method {
|
||
case http.MethodGet:
|
||
w.Header().Set("Content-Type", "application/json")
|
||
_ = json.NewEncoder(w).Encode(getSettings())
|
||
return
|
||
|
||
case http.MethodPost:
|
||
var in RecorderSettings
|
||
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
|
||
http.Error(w, "invalid json: "+err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
in.RecordDir = filepath.Clean(strings.TrimSpace(in.RecordDir))
|
||
in.DoneDir = filepath.Clean(strings.TrimSpace(in.DoneDir))
|
||
in.FFmpegPath = strings.TrimSpace(in.FFmpegPath)
|
||
|
||
if in.RecordDir == "" || in.DoneDir == "" {
|
||
http.Error(w, "recordDir und doneDir dürfen nicht leer sein", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// Ordner erstellen (Fehler zurückgeben, falls z.B. keine Rechte)
|
||
if err := os.MkdirAll(in.RecordDir, 0o755); err != nil {
|
||
http.Error(w, "konnte recordDir nicht erstellen: "+err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
if err := os.MkdirAll(in.DoneDir, 0o755); err != nil {
|
||
http.Error(w, "konnte doneDir nicht erstellen: "+err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
current := getSettings()
|
||
in.EncryptedCookies = current.EncryptedCookies
|
||
|
||
settingsMu.Lock()
|
||
settings = in
|
||
settingsMu.Unlock()
|
||
saveSettingsToDisk()
|
||
|
||
// ffmpeg-Pfad nach Änderungen neu bestimmen
|
||
ffmpegPath = detectFFmpegPath()
|
||
fmt.Println("🔍 ffmpegPath (nach Save):", ffmpegPath)
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
_ = json.NewEncoder(w).Encode(getSettings())
|
||
return
|
||
|
||
default:
|
||
http.Error(w, "Nur GET/POST erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
}
|
||
|
||
func settingsBrowse(w http.ResponseWriter, r *http.Request) {
|
||
target := r.URL.Query().Get("target")
|
||
if target != "record" && target != "done" && target != "ffmpeg" {
|
||
http.Error(w, "target muss record, done oder ffmpeg sein", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
var (
|
||
p string
|
||
err error
|
||
)
|
||
|
||
if target == "ffmpeg" {
|
||
// Dateiauswahl für ffmpeg.exe
|
||
p, err = dialog.File().
|
||
Title("ffmpeg.exe auswählen").
|
||
Load()
|
||
} else {
|
||
// Ordnerauswahl für record/done
|
||
p, err = dialog.Directory().
|
||
Title("Ordner auswählen").
|
||
Browse()
|
||
}
|
||
|
||
if err != nil {
|
||
// User cancelled → 204 No Content ist praktisch fürs Frontend
|
||
if strings.Contains(strings.ToLower(err.Error()), "cancel") {
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
http.Error(w, "auswahl fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// optional: wenn innerhalb exe-dir, als RELATIV zurückgeben
|
||
p = maybeMakeRelativeToExe(p)
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
_ = json.NewEncoder(w).Encode(map[string]string{"path": p})
|
||
}
|
||
|
||
func maybeMakeRelativeToExe(abs string) string {
|
||
exe, err := os.Executable()
|
||
if err != nil {
|
||
return abs
|
||
}
|
||
base := filepath.Dir(exe)
|
||
|
||
rel, err := filepath.Rel(base, abs)
|
||
if err != nil {
|
||
return abs
|
||
}
|
||
// wenn rel mit ".." beginnt -> nicht innerhalb base -> absoluten Pfad behalten
|
||
if rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
|
||
return abs
|
||
}
|
||
return filepath.ToSlash(rel) // frontend-freundlich
|
||
}
|
||
|
||
// --- Gemeinsame Status-Werte für MFC ---
|
||
type Status int
|
||
|
||
const (
|
||
StatusUnknown Status = iota
|
||
StatusPublic
|
||
StatusPrivate
|
||
StatusOffline
|
||
StatusNotExist
|
||
)
|
||
|
||
func (s Status) String() string {
|
||
switch s {
|
||
case StatusPublic:
|
||
return "PUBLIC"
|
||
case StatusPrivate:
|
||
return "PRIVATE"
|
||
case StatusOffline:
|
||
return "OFFLINE"
|
||
case StatusNotExist:
|
||
return "NOTEXIST"
|
||
default:
|
||
return "UNKNOWN"
|
||
}
|
||
}
|
||
|
||
// HTTPClient kapselt http.Client + Header/Cookies (wie internal.Req im DVR)
|
||
type HTTPClient struct {
|
||
client *http.Client
|
||
userAgent string
|
||
}
|
||
|
||
// gemeinsamen HTTP-Client erzeugen
|
||
func NewHTTPClient(userAgent string) *HTTPClient {
|
||
if userAgent == "" {
|
||
// Default, falls kein UA übergeben wird
|
||
userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
|
||
}
|
||
|
||
return &HTTPClient{
|
||
client: &http.Client{
|
||
Timeout: 10 * time.Second,
|
||
},
|
||
userAgent: userAgent,
|
||
}
|
||
}
|
||
|
||
// Request-Erstellung mit User-Agent + Cookies
|
||
func (h *HTTPClient) NewRequest(ctx context.Context, method, url, cookieStr string) (*http.Request, error) {
|
||
req, err := http.NewRequestWithContext(ctx, method, url, nil)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// Basis-Header, die immer gesetzt werden
|
||
if h.userAgent != "" {
|
||
req.Header.Set("User-Agent", h.userAgent)
|
||
} else {
|
||
req.Header.Set("User-Agent", "Mozilla/5.0")
|
||
}
|
||
req.Header.Set("Accept", "*/*")
|
||
|
||
// Cookie-String wie "name=value; foo=bar"
|
||
addCookiesFromString(req, cookieStr)
|
||
|
||
return req, nil
|
||
}
|
||
|
||
// Seite laden + einfache Erkennung von Schutzseiten (Cloudflare / Age-Gate)
|
||
func (h *HTTPClient) FetchPage(ctx context.Context, url, cookieStr string) (string, error) {
|
||
req, err := h.NewRequest(ctx, http.MethodGet, url, cookieStr)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
resp, err := h.client.Do(req)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
data, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
body := string(data)
|
||
|
||
// Etwas aussagekräftigere Fehler als nur "room dossier nicht gefunden"
|
||
if strings.Contains(body, "<title>Just a moment...</title>") {
|
||
return "", errors.New("Schutzseite von Cloudflare erhalten (\"Just a moment...\") – kein Room-HTML")
|
||
}
|
||
if strings.Contains(body, "Verify your age") {
|
||
return "", errors.New("Altersverifikationsseite erhalten – kein Room-HTML")
|
||
}
|
||
|
||
if resp.StatusCode != http.StatusOK {
|
||
return "", fmt.Errorf("HTTP %d beim Laden von %s", resp.StatusCode, url)
|
||
}
|
||
|
||
return body, nil
|
||
}
|
||
|
||
func remuxTSToMP4(tsPath, mp4Path string) error {
|
||
// ffmpeg -y -i in.ts -c copy -movflags +faststart out.mp4
|
||
cmd := exec.Command(ffmpegPath,
|
||
"-y",
|
||
"-i", tsPath,
|
||
"-c", "copy",
|
||
"-movflags", "+faststart",
|
||
mp4Path,
|
||
)
|
||
var stderr bytes.Buffer
|
||
cmd.Stderr = &stderr
|
||
if err := cmd.Run(); err != nil {
|
||
return fmt.Errorf("ffmpeg remux failed: %v (%s)", err, stderr.String())
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func extractLastFrameJPEG(path string) ([]byte, error) {
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner",
|
||
"-loglevel", "error",
|
||
"-sseof", "-0.1",
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-q:v", "4",
|
||
"-f", "image2pipe",
|
||
"-vcodec", "mjpeg",
|
||
"pipe:1",
|
||
)
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, fmt.Errorf("ffmpeg last-frame: %w (%s)", err, strings.TrimSpace(stderr.String()))
|
||
}
|
||
return out.Bytes(), nil
|
||
}
|
||
|
||
func extractFrameAtTimeJPEG(path string, seconds float64) ([]byte, error) {
|
||
if seconds < 0 {
|
||
seconds = 0
|
||
}
|
||
seek := fmt.Sprintf("%.3f", seconds)
|
||
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner",
|
||
"-loglevel", "error",
|
||
"-ss", seek,
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-q:v", "4",
|
||
"-f", "image2pipe",
|
||
"-vcodec", "mjpeg",
|
||
"pipe:1",
|
||
)
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, fmt.Errorf("ffmpeg frame-at-time: %w (%s)", err, strings.TrimSpace(stderr.String()))
|
||
}
|
||
return out.Bytes(), nil
|
||
}
|
||
|
||
// sucht das "neueste" Preview-Segment (seg_low_XXXXX.ts / seg_hq_XXXXX.ts)
|
||
func latestPreviewSegment(previewDir string) (string, error) {
|
||
entries, err := os.ReadDir(previewDir)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
var best string
|
||
for _, e := range entries {
|
||
if e.IsDir() {
|
||
continue
|
||
}
|
||
name := e.Name()
|
||
if !strings.HasPrefix(name, "seg_low_") && !strings.HasPrefix(name, "seg_hq_") {
|
||
continue
|
||
}
|
||
if best == "" || name > best {
|
||
best = name
|
||
}
|
||
}
|
||
|
||
if best == "" {
|
||
return "", fmt.Errorf("kein Preview-Segment in %s", previewDir)
|
||
}
|
||
return filepath.Join(previewDir, best), nil
|
||
}
|
||
|
||
// erzeugt ein JPEG aus dem letzten Preview-Segment
|
||
func extractLastFrameFromPreviewDir(previewDir string) ([]byte, error) {
|
||
seg, err := latestPreviewSegment(previewDir)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// Segment ist klein und "fertig" – hier reicht ein Last-Frame-Versuch,
|
||
// mit Fallback auf First-Frame.
|
||
img, err := extractLastFrameJPEG(seg)
|
||
if err != nil {
|
||
return extractFirstFrameJPEG(seg)
|
||
}
|
||
return img, nil
|
||
}
|
||
|
||
func recordPreview(w http.ResponseWriter, r *http.Request) {
|
||
id := r.URL.Query().Get("id")
|
||
if id == "" {
|
||
http.Error(w, "id fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// HLS-Dateien (index.m3u8, seg_*.ts) wie bisher
|
||
if file := r.URL.Query().Get("file"); file != "" {
|
||
servePreviewHLSFile(w, r, id, file)
|
||
return
|
||
}
|
||
|
||
// Schauen, ob wir einen Job mit dieser ID kennen (laufend oder gerade fertig)
|
||
jobsMu.Lock()
|
||
job, ok := jobs[id]
|
||
jobsMu.Unlock()
|
||
|
||
if ok {
|
||
// ✅ Thumbnail-Caching: nicht pro HTTP-Request ffmpeg starten.
|
||
job.previewMu.Lock()
|
||
cached := job.previewJpeg
|
||
cachedAt := job.previewJpegAt
|
||
fresh := len(cached) > 0 && !cachedAt.IsZero() && time.Since(cachedAt) < 10*time.Second
|
||
|
||
// Wenn nicht frisch, ggf. im Hintergrund aktualisieren (einmal gleichzeitig)
|
||
if !fresh && !job.previewGen {
|
||
job.previewGen = true
|
||
go func(j *RecordJob, jobID string) {
|
||
defer func() {
|
||
j.previewMu.Lock()
|
||
j.previewGen = false
|
||
j.previewMu.Unlock()
|
||
}()
|
||
|
||
var img []byte
|
||
var genErr error
|
||
|
||
// 1) aus Preview-Segmenten
|
||
previewDir := strings.TrimSpace(j.PreviewDir)
|
||
if previewDir != "" {
|
||
img, genErr = extractLastFrameFromPreviewDir(previewDir)
|
||
}
|
||
|
||
// 2) Fallback: aus der Ausgabedatei
|
||
if genErr != nil || len(img) == 0 {
|
||
outPath := strings.TrimSpace(j.Output)
|
||
if outPath != "" {
|
||
outPath = filepath.Clean(outPath)
|
||
if !filepath.IsAbs(outPath) {
|
||
if abs, err := resolvePathRelativeToApp(outPath); err == nil {
|
||
outPath = abs
|
||
}
|
||
}
|
||
if fi, err := os.Stat(outPath); err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
img, genErr = extractLastFrameJPEG(outPath)
|
||
if genErr != nil {
|
||
img, _ = extractFirstFrameJPEG(outPath)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if len(img) > 0 {
|
||
j.previewMu.Lock()
|
||
j.previewJpeg = img
|
||
j.previewJpegAt = time.Now()
|
||
j.previewMu.Unlock()
|
||
}
|
||
}(job, id)
|
||
}
|
||
|
||
// Wir liefern entweder ein frisches Bild, oder das zuletzt gecachte.
|
||
out := cached
|
||
job.previewMu.Unlock()
|
||
if len(out) > 0 {
|
||
servePreviewJPEGBytes(w, out)
|
||
return
|
||
}
|
||
// noch kein Bild verfügbar -> 204 (Frontend zeigt Placeholder und retry)
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
|
||
// 3️⃣ Kein Job im RAM → id als Dateistamm für fertige Downloads behandeln
|
||
servePreviewForFinishedFile(w, r, id)
|
||
}
|
||
|
||
// Fallback: Preview für fertige Dateien nur anhand des Dateistamms (id)
|
||
func servePreviewForFinishedFile(w http.ResponseWriter, r *http.Request, id string) {
|
||
id = strings.TrimSpace(id)
|
||
if id == "" {
|
||
http.Error(w, "id fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
if strings.ContainsAny(id, `/\`) {
|
||
http.Error(w, "ungültige id", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
s := getSettings()
|
||
recordAbs, _ := resolvePathRelativeToApp(s.RecordDir)
|
||
doneAbs, _ := resolvePathRelativeToApp(s.DoneDir)
|
||
|
||
candidates := []string{
|
||
filepath.Join(doneAbs, id+".mp4"),
|
||
filepath.Join(doneAbs, id+".ts"),
|
||
filepath.Join(recordAbs, id+".mp4"),
|
||
filepath.Join(recordAbs, id+".ts"),
|
||
}
|
||
|
||
var outPath string
|
||
for _, p := range candidates {
|
||
fi, err := os.Stat(p)
|
||
if err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
outPath = p
|
||
break
|
||
}
|
||
}
|
||
|
||
if outPath == "" {
|
||
http.Error(w, "preview nicht verfügbar", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// 🔹 NEU: dynamischer Frame an Zeitposition t (z.B. für animierte Thumbnails)
|
||
if tStr := strings.TrimSpace(r.URL.Query().Get("t")); tStr != "" {
|
||
if sec, err := strconv.ParseFloat(tStr, 64); err == nil && sec >= 0 {
|
||
if img, err := extractFrameAtTimeJPEG(outPath, sec); err == nil {
|
||
servePreviewJPEGBytes(w, img)
|
||
return
|
||
}
|
||
// wenn ffmpeg hier scheitert, geht's unten mit statischem Preview weiter
|
||
}
|
||
}
|
||
|
||
// 🔸 ALT: einmaliges Preview cachen (preview.jpg) – Fallback
|
||
previewDir := filepath.Join(os.TempDir(), "rec_preview", id)
|
||
if err := os.MkdirAll(previewDir, 0o755); err != nil {
|
||
http.Error(w, "preview-dir nicht verfügbar", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
jpegPath := filepath.Join(previewDir, "preview.jpg")
|
||
|
||
if fi, err := os.Stat(jpegPath); err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
servePreviewJPEGFile(w, r, jpegPath)
|
||
return
|
||
}
|
||
|
||
img, err := extractLastFrameJPEG(outPath)
|
||
if err != nil {
|
||
img2, err2 := extractFirstFrameJPEG(outPath)
|
||
if err2 != nil {
|
||
http.Error(w, "konnte preview nicht erzeugen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
img = img2
|
||
}
|
||
|
||
_ = os.WriteFile(jpegPath, img, 0o644)
|
||
servePreviewJPEGBytes(w, img)
|
||
}
|
||
|
||
func servePreviewJPEGBytes(w http.ResponseWriter, img []byte) {
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "public, max-age=31536000")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
w.WriteHeader(http.StatusOK)
|
||
_, _ = w.Write(img)
|
||
}
|
||
|
||
func servePreviewJPEGFile(w http.ResponseWriter, r *http.Request, path string) {
|
||
w.Header().Set("Content-Type", "image/jpeg")
|
||
w.Header().Set("Cache-Control", "public, max-age=31536000")
|
||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||
http.ServeFile(w, r, path)
|
||
}
|
||
|
||
func recordList(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodGet {
|
||
http.Error(w, "Nur GET erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
jobsMu.Lock()
|
||
list := make([]*RecordJob, 0, len(jobs))
|
||
for _, j := range jobs {
|
||
list = append(list, j)
|
||
}
|
||
jobsMu.Unlock()
|
||
|
||
// optional: neueste zuerst
|
||
sort.Slice(list, func(i, j int) bool {
|
||
return list[i].StartedAt.After(list[j].StartedAt)
|
||
})
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode(list)
|
||
}
|
||
|
||
var previewFileRe = regexp.MustCompile(`^(index(_hq)?\.m3u8|seg_(low|hq)_\d+\.ts|seg_\d+\.ts)$`)
|
||
|
||
func servePreviewHLSFile(w http.ResponseWriter, r *http.Request, id, file string) {
|
||
file = strings.TrimSpace(file)
|
||
if file == "" || filepath.Base(file) != file || !previewFileRe.MatchString(file) {
|
||
http.Error(w, "ungültige file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
isIndex := file == "index.m3u8" || file == "index_hq.m3u8"
|
||
|
||
jobsMu.Lock()
|
||
job, ok := jobs[id]
|
||
jobsMu.Unlock()
|
||
if !ok {
|
||
// Job wirklich unbekannt => 404 ist ok
|
||
http.Error(w, "job nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// Preview noch nicht initialisiert? Für index => 204 (kein roter Fehler im Browser)
|
||
if strings.TrimSpace(job.PreviewDir) == "" {
|
||
if isIndex {
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
http.Error(w, "preview nicht verfügbar", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
p := filepath.Join(job.PreviewDir, file)
|
||
if _, err := os.Stat(p); err != nil {
|
||
if isIndex {
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.WriteHeader(http.StatusNoContent)
|
||
return
|
||
}
|
||
http.Error(w, "datei nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
switch strings.ToLower(filepath.Ext(p)) {
|
||
case ".m3u8":
|
||
w.Header().Set("Content-Type", "application/vnd.apple.mpegurl; charset=utf-8")
|
||
case ".ts":
|
||
w.Header().Set("Content-Type", "video/mp2t")
|
||
default:
|
||
w.Header().Set("Content-Type", "application/octet-stream")
|
||
}
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
http.ServeFile(w, r, p)
|
||
}
|
||
|
||
func rewriteM3U8ToPreviewEndpoint(m3u8 string, id string) string {
|
||
lines := strings.Split(m3u8, "\n")
|
||
escapedID := url.QueryEscape(id)
|
||
|
||
for i, line := range lines {
|
||
l := strings.TrimSpace(line)
|
||
if l == "" || strings.HasPrefix(l, "#") {
|
||
continue
|
||
}
|
||
// Segment/URI-Zeilen umschreiben
|
||
lines[i] = "/api/record/preview?id=" + escapedID + "&file=" + url.QueryEscape(l)
|
||
}
|
||
|
||
return strings.Join(lines, "\n")
|
||
}
|
||
|
||
func startPreviewHLS(ctx context.Context, jobID, m3u8URL, previewDir, httpCookie, userAgent string) error {
|
||
if strings.TrimSpace(ffmpegPath) == "" {
|
||
return fmt.Errorf("kein ffmpeg gefunden – setze FFMPEG_PATH oder lege ffmpeg(.exe) neben das Backend")
|
||
}
|
||
|
||
if err := os.MkdirAll(previewDir, 0755); err != nil {
|
||
return err
|
||
}
|
||
|
||
commonIn := []string{"-y"}
|
||
if strings.TrimSpace(userAgent) != "" {
|
||
commonIn = append(commonIn, "-user_agent", userAgent)
|
||
}
|
||
if strings.TrimSpace(httpCookie) != "" {
|
||
commonIn = append(commonIn, "-headers", fmt.Sprintf("Cookie: %s\r\n", httpCookie))
|
||
}
|
||
commonIn = append(commonIn, "-i", m3u8URL)
|
||
|
||
baseURL := fmt.Sprintf("/api/record/preview?id=%s&file=", url.QueryEscape(jobID))
|
||
|
||
// ✅ Nur EIN Preview-Transcode pro Job (sonst wird es bei vielen Downloads sehr teuer).
|
||
// Wir nutzen das HQ-Playlist-Format (index_hq.m3u8), aber skalieren etwas kleiner.
|
||
hqArgs := append(commonIn,
|
||
"-vf", "scale=480:-2",
|
||
"-c:v", "libx264", "-preset", "veryfast", "-tune", "zerolatency",
|
||
"-g", "48", "-keyint_min", "48", "-sc_threshold", "0",
|
||
"-c:a", "aac", "-b:a", "128k", "-ac", "2",
|
||
"-f", "hls",
|
||
"-hls_time", "2",
|
||
"-hls_list_size", "4",
|
||
"-hls_flags", "delete_segments+append_list+independent_segments",
|
||
"-hls_segment_filename", filepath.Join(previewDir, "seg_hq_%05d.ts"),
|
||
"-hls_base_url", baseURL,
|
||
filepath.Join(previewDir, "index_hq.m3u8"),
|
||
)
|
||
|
||
// Preview-Prozess starten (einfach & robust)
|
||
go func(kind string, args []string) {
|
||
cmd := exec.CommandContext(ctx, ffmpegPath, args...)
|
||
var stderr bytes.Buffer
|
||
cmd.Stderr = &stderr
|
||
if err := cmd.Run(); err != nil && ctx.Err() == nil {
|
||
fmt.Printf("⚠️ preview %s ffmpeg failed: %v (%s)\n", kind, err, strings.TrimSpace(stderr.String()))
|
||
}
|
||
}("hq", hqArgs)
|
||
|
||
return nil
|
||
}
|
||
|
||
func extractFirstFrameJPEG(path string) ([]byte, error) {
|
||
cmd := exec.Command(
|
||
ffmpegPath,
|
||
"-hide_banner",
|
||
"-loglevel", "error",
|
||
"-i", path,
|
||
"-frames:v", "1",
|
||
"-q:v", "4",
|
||
"-f", "image2pipe",
|
||
"-vcodec", "mjpeg",
|
||
"pipe:1",
|
||
)
|
||
|
||
var out bytes.Buffer
|
||
var stderr bytes.Buffer
|
||
cmd.Stdout = &out
|
||
cmd.Stderr = &stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
return nil, fmt.Errorf("ffmpeg first-frame: %w (%s)", err, strings.TrimSpace(stderr.String()))
|
||
}
|
||
return out.Bytes(), nil
|
||
}
|
||
|
||
func resolvePathRelativeToApp(p string) (string, error) {
|
||
p = strings.TrimSpace(p)
|
||
if p == "" {
|
||
return "", nil
|
||
}
|
||
|
||
p = filepath.Clean(filepath.FromSlash(p))
|
||
if filepath.IsAbs(p) {
|
||
return p, nil
|
||
}
|
||
|
||
exe, err := os.Executable()
|
||
if err == nil {
|
||
exeDir := filepath.Dir(exe)
|
||
low := strings.ToLower(exeDir)
|
||
|
||
// Heuristik: go run / tests -> exe liegt in Temp/go-build
|
||
isTemp := strings.Contains(low, `\appdata\local\temp`) ||
|
||
strings.Contains(low, `\temp\`) ||
|
||
strings.Contains(low, `\tmp\`) ||
|
||
strings.Contains(low, `\go-build`) ||
|
||
strings.Contains(low, `/tmp/`) ||
|
||
strings.Contains(low, `/go-build`)
|
||
|
||
if !isTemp {
|
||
return filepath.Join(exeDir, p), nil
|
||
}
|
||
}
|
||
|
||
// Fallback: Working Directory (Dev)
|
||
wd, err := os.Getwd()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return filepath.Join(wd, p), nil
|
||
}
|
||
|
||
// routes.go (package main)
|
||
func registerRoutes(mux *http.ServeMux) {
|
||
mux.HandleFunc("/api/settings", recordSettingsHandler)
|
||
mux.HandleFunc("/api/settings/browse", settingsBrowse)
|
||
|
||
mux.HandleFunc("/api/record", startRecordingFromRequest)
|
||
mux.HandleFunc("/api/record/status", recordStatus)
|
||
mux.HandleFunc("/api/record/stop", recordStop)
|
||
mux.HandleFunc("/api/record/preview", recordPreview)
|
||
mux.HandleFunc("/api/record/list", recordList)
|
||
mux.HandleFunc("/api/record/video", recordVideo)
|
||
mux.HandleFunc("/api/record/done", recordDoneList)
|
||
mux.HandleFunc("/api/record/delete", recordDeleteVideo)
|
||
mux.HandleFunc("/api/record/toggle-hot", recordToggleHot)
|
||
|
||
mux.HandleFunc("/api/chaturbate/online", chaturbateOnlineHandler)
|
||
|
||
modelsPath, _ := resolvePathRelativeToApp("data/models_store.db")
|
||
fmt.Println("📦 Models DB:", modelsPath)
|
||
|
||
store := NewModelStore(modelsPath)
|
||
if err := store.Load(); err != nil {
|
||
fmt.Println("⚠️ models load:", err)
|
||
}
|
||
|
||
// ✅ registriert /api/models/list, /parse, /upsert, /flags, /delete
|
||
RegisterModelAPI(mux, store)
|
||
}
|
||
|
||
// --- main ---
|
||
func main() {
|
||
loadSettings()
|
||
|
||
mux := http.NewServeMux()
|
||
registerRoutes(mux)
|
||
|
||
fmt.Println("🌐 HTTP-API aktiv: http://localhost:9999")
|
||
if err := http.ListenAndServe(":9999", mux); err != nil {
|
||
fmt.Println("❌ HTTP-Server Fehler:", err)
|
||
os.Exit(1)
|
||
}
|
||
}
|
||
|
||
type RecordRequest struct {
|
||
URL string `json:"url"`
|
||
Cookie string `json:"cookie,omitempty"`
|
||
UserAgent string `json:"userAgent,omitempty"`
|
||
}
|
||
|
||
func startRecordingFromRequest(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodPost {
|
||
http.Error(w, "Nur POST erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
var req RecordRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
if req.URL == "" {
|
||
http.Error(w, "url fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
jobID := uuid.NewString()
|
||
ctx, cancel := context.WithCancel(context.Background())
|
||
|
||
job := &RecordJob{
|
||
ID: jobID,
|
||
SourceURL: req.URL,
|
||
Status: JobRunning,
|
||
StartedAt: time.Now(),
|
||
cancel: cancel,
|
||
}
|
||
|
||
jobsMu.Lock()
|
||
jobs[jobID] = job
|
||
jobsMu.Unlock()
|
||
|
||
go runJob(ctx, job, req)
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
json.NewEncoder(w).Encode(job)
|
||
}
|
||
|
||
func parseCookieString(cookieStr string) map[string]string {
|
||
out := map[string]string{}
|
||
for _, pair := range strings.Split(cookieStr, ";") {
|
||
parts := strings.SplitN(strings.TrimSpace(pair), "=", 2)
|
||
if len(parts) != 2 {
|
||
continue
|
||
}
|
||
name := strings.TrimSpace(parts[0])
|
||
value := strings.TrimSpace(parts[1])
|
||
if name == "" {
|
||
continue
|
||
}
|
||
out[strings.ToLower(name)] = value
|
||
}
|
||
return out
|
||
}
|
||
|
||
func hasChaturbateCookies(cookieStr string) bool {
|
||
m := parseCookieString(cookieStr)
|
||
_, hasCF := m["cf_clearance"]
|
||
// akzeptiere session_id ODER sessionid ODER sessionid/sessionId Varianten (case-insensitive durch ToLower)
|
||
_, hasSessID := m["session_id"]
|
||
_, hasSessIdAlt := m["sessionid"] // falls es ohne underscore kommt
|
||
return hasCF && (hasSessID || hasSessIdAlt)
|
||
}
|
||
|
||
func runJob(ctx context.Context, job *RecordJob, req RecordRequest) {
|
||
defer func() {
|
||
now := time.Now()
|
||
job.EndedAt = &now
|
||
}()
|
||
|
||
hc := NewHTTPClient(req.UserAgent)
|
||
provider := detectProvider(req.URL)
|
||
|
||
var err error
|
||
now := time.Now()
|
||
|
||
switch provider {
|
||
case "chaturbate":
|
||
if !hasChaturbateCookies(req.Cookie) {
|
||
err = errors.New("cf_clearance und session_id (oder sessionid) Cookies sind für Chaturbate erforderlich")
|
||
break
|
||
}
|
||
|
||
s := getSettings()
|
||
|
||
username := extractUsername(req.URL)
|
||
filename := fmt.Sprintf("%s_%s.ts", username, now.Format("01_02_2006__15-04-05"))
|
||
outPath := filepath.Join(s.RecordDir, filename)
|
||
|
||
job.Output = outPath
|
||
err = RecordStream(ctx, hc, "https://chaturbate.com/", username, outPath, req.Cookie, job)
|
||
|
||
case "mfc":
|
||
s := getSettings()
|
||
|
||
username := extractMFCUsername(req.URL)
|
||
filename := fmt.Sprintf("%s_%s.ts", username, now.Format("01_02_2006__15-04-05"))
|
||
outPath := filepath.Join(s.RecordDir, filename)
|
||
|
||
job.Output = outPath
|
||
err = RecordStreamMFC(ctx, hc, username, outPath, job)
|
||
|
||
default:
|
||
err = errors.New("unsupported provider")
|
||
}
|
||
|
||
jobsMu.Lock()
|
||
defer jobsMu.Unlock()
|
||
|
||
if err != nil {
|
||
if errors.Is(err, context.Canceled) {
|
||
job.Status = JobStopped
|
||
|
||
// ✅ Auch bei STOP: .ts -> .mp4 remuxen (falls möglich)
|
||
if newOut, err2 := maybeRemuxTS(job.Output); err2 == nil && newOut != "" {
|
||
job.Output = newOut
|
||
}
|
||
|
||
// ✅ und danach nach "done" verschieben
|
||
if moved, err2 := moveToDoneDir(job.Output); err2 == nil && moved != "" {
|
||
job.Output = moved
|
||
}
|
||
} else {
|
||
job.Status = JobFailed
|
||
job.Error = err.Error()
|
||
|
||
// ✅ best effort: trotzdem remuxen und nach done verschieben (falls Datei existiert)
|
||
if newOut, err2 := maybeRemuxTS(job.Output); err2 == nil && newOut != "" {
|
||
job.Output = newOut
|
||
}
|
||
if moved, err2 := moveToDoneDir(job.Output); err2 == nil && moved != "" {
|
||
job.Output = moved
|
||
}
|
||
}
|
||
} else {
|
||
job.Status = JobFinished
|
||
|
||
// ✅ Erst remuxen (damit in /done direkt die .mp4 landet)
|
||
if newOut, err2 := maybeRemuxTS(job.Output); err2 == nil && newOut != "" {
|
||
job.Output = newOut
|
||
}
|
||
|
||
// ✅ nach "done" verschieben (robust)
|
||
if moved, err2 := moveToDoneDir(job.Output); err2 == nil && moved != "" {
|
||
job.Output = moved
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
func recordVideo(w http.ResponseWriter, r *http.Request) {
|
||
// ✅ Wiedergabe über Dateiname (für doneDir / recordDir)
|
||
if raw := strings.TrimSpace(r.URL.Query().Get("file")); raw != "" {
|
||
// explizit decoden (zur Sicherheit)
|
||
file, err := url.QueryUnescape(raw)
|
||
if err != nil {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
file = strings.TrimSpace(file)
|
||
|
||
// kein Pfad, keine Backslashes, kein Traversal
|
||
if file == "" ||
|
||
strings.Contains(file, "/") ||
|
||
strings.Contains(file, "\\") ||
|
||
filepath.Base(file) != file {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(file))
|
||
if ext != ".mp4" && ext != ".ts" {
|
||
http.Error(w, "nicht erlaubt", http.StatusForbidden)
|
||
return
|
||
}
|
||
|
||
s := getSettings()
|
||
recordAbs, err := resolvePathRelativeToApp(s.RecordDir)
|
||
if err != nil {
|
||
http.Error(w, "recordDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
|
||
if err != nil {
|
||
http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// Kandidaten: erst doneDir, dann recordDir
|
||
candidates := []string{
|
||
filepath.Join(doneAbs, file),
|
||
filepath.Join(recordAbs, file),
|
||
}
|
||
|
||
// Falls UI noch ".ts" kennt, die Datei aber schon als ".mp4" existiert:
|
||
if ext == ".ts" {
|
||
mp4File := strings.TrimSuffix(file, ext) + ".mp4"
|
||
candidates = append(candidates,
|
||
filepath.Join(doneAbs, mp4File),
|
||
filepath.Join(recordAbs, mp4File),
|
||
)
|
||
}
|
||
|
||
var outPath string
|
||
for _, p := range candidates {
|
||
fi, err := os.Stat(p)
|
||
if err == nil && !fi.IsDir() && fi.Size() > 0 {
|
||
outPath = p
|
||
break
|
||
}
|
||
}
|
||
if outPath == "" {
|
||
http.Error(w, "datei nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// TS kann der Browser nicht zuverlässig direkt -> on-demand remux nach MP4
|
||
if strings.ToLower(filepath.Ext(outPath)) == ".ts" {
|
||
newOut, err := maybeRemuxTS(outPath)
|
||
if err != nil {
|
||
http.Error(w, "TS kann im Browser nicht abgespielt werden; Remux fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if strings.TrimSpace(newOut) == "" {
|
||
http.Error(w, "TS kann im Browser nicht abgespielt werden; Remux hat keine MP4 erzeugt", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
outPath = newOut
|
||
|
||
// sicherstellen, dass wirklich eine MP4 existiert
|
||
fi, err := os.Stat(outPath)
|
||
if err != nil || fi.IsDir() || fi.Size() == 0 || strings.ToLower(filepath.Ext(outPath)) != ".mp4" {
|
||
http.Error(w, "Remux-Ergebnis ungültig", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
}
|
||
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.Header().Set("Content-Type", "video/mp4")
|
||
http.ServeFile(w, r, outPath)
|
||
return
|
||
}
|
||
|
||
// ✅ ALT: Wiedergabe über Job-ID (funktioniert nur solange Job im RAM existiert)
|
||
id := strings.TrimSpace(r.URL.Query().Get("id"))
|
||
if id == "" {
|
||
http.Error(w, "id fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
jobsMu.Lock()
|
||
job, ok := jobs[id]
|
||
jobsMu.Unlock()
|
||
if !ok {
|
||
http.Error(w, "job nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
outPath := filepath.Clean(strings.TrimSpace(job.Output))
|
||
if outPath == "" {
|
||
http.Error(w, "output fehlt", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
if !filepath.IsAbs(outPath) {
|
||
abs, err := resolvePathRelativeToApp(outPath)
|
||
if err != nil {
|
||
http.Error(w, "pfad auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
outPath = abs
|
||
}
|
||
|
||
fi, err := os.Stat(outPath)
|
||
if err != nil || fi.IsDir() || fi.Size() == 0 {
|
||
http.Error(w, "datei nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// TS kann der Browser nicht zuverlässig direkt -> on-demand remux nach MP4
|
||
if strings.ToLower(filepath.Ext(outPath)) == ".ts" {
|
||
newOut, err := maybeRemuxTS(outPath)
|
||
if err != nil {
|
||
http.Error(w, "TS Remux fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if strings.TrimSpace(newOut) == "" {
|
||
http.Error(w, "TS kann im Browser nicht abgespielt werden; Remux hat keine MP4 erzeugt", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
outPath = newOut
|
||
|
||
fi, err := os.Stat(outPath)
|
||
if err != nil || fi.IsDir() || fi.Size() == 0 || strings.ToLower(filepath.Ext(outPath)) != ".mp4" {
|
||
http.Error(w, "Remux-Ergebnis ungültig", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
}
|
||
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
w.Header().Set("Content-Type", "video/mp4")
|
||
http.ServeFile(w, r, outPath)
|
||
}
|
||
|
||
func recordDoneList(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodGet {
|
||
http.Error(w, "Nur GET erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
s := getSettings()
|
||
doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
|
||
if err != nil {
|
||
http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// Wenn kein DoneDir gesetzt ist → einfach leere Liste zurückgeben
|
||
if strings.TrimSpace(doneAbs) == "" {
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode([]*RecordJob{})
|
||
return
|
||
}
|
||
|
||
entries, err := os.ReadDir(doneAbs)
|
||
if err != nil {
|
||
// Wenn Verzeichnis nicht existiert → leere Liste statt 500
|
||
if os.IsNotExist(err) {
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode([]*RecordJob{})
|
||
return
|
||
}
|
||
|
||
http.Error(w, "doneDir lesen fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
list := make([]*RecordJob, 0, len(entries))
|
||
for _, e := range entries {
|
||
if e.IsDir() {
|
||
continue
|
||
}
|
||
name := e.Name()
|
||
ext := strings.ToLower(filepath.Ext(name))
|
||
if ext != ".mp4" && ext != ".ts" {
|
||
continue
|
||
}
|
||
|
||
full := filepath.Join(doneAbs, name)
|
||
fi, err := os.Stat(full)
|
||
if err != nil || fi.IsDir() {
|
||
continue
|
||
}
|
||
|
||
base := strings.TrimSuffix(name, filepath.Ext(name))
|
||
t := fi.ModTime()
|
||
|
||
list = append(list, &RecordJob{
|
||
ID: base,
|
||
SourceURL: "",
|
||
Output: full,
|
||
Status: JobFinished,
|
||
StartedAt: t,
|
||
EndedAt: &t,
|
||
})
|
||
}
|
||
|
||
sort.Slice(list, func(i, j int) bool {
|
||
return list[i].EndedAt.After(*list[j].EndedAt)
|
||
})
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode(list)
|
||
}
|
||
|
||
func recordDeleteVideo(w http.ResponseWriter, r *http.Request) {
|
||
// Frontend nutzt aktuell POST (siehe FinishedDownloads), daher erlauben wir POST + DELETE
|
||
if r.Method != http.MethodPost && r.Method != http.MethodDelete {
|
||
http.Error(w, "Nur POST oder DELETE erlaubt", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
raw := strings.TrimSpace(r.URL.Query().Get("file"))
|
||
if raw == "" {
|
||
http.Error(w, "file fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// sicher decoden
|
||
file, err := url.QueryUnescape(raw)
|
||
if err != nil {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
file = strings.TrimSpace(file)
|
||
|
||
// kein Pfad, keine Backslashes, kein Traversal
|
||
if file == "" ||
|
||
strings.Contains(file, "/") ||
|
||
strings.Contains(file, "\\") ||
|
||
filepath.Base(file) != file {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(file))
|
||
if ext != ".mp4" && ext != ".ts" {
|
||
http.Error(w, "nicht erlaubt", http.StatusForbidden)
|
||
return
|
||
}
|
||
|
||
s := getSettings()
|
||
doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
|
||
if err != nil {
|
||
http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if strings.TrimSpace(doneAbs) == "" {
|
||
http.Error(w, "doneDir ist leer", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
target := filepath.Join(doneAbs, file)
|
||
|
||
fi, err := os.Stat(target)
|
||
if err != nil {
|
||
if os.IsNotExist(err) {
|
||
http.Error(w, "datei nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
http.Error(w, "stat fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if fi.IsDir() {
|
||
http.Error(w, "ist ein verzeichnis", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
if err := os.Remove(target); err != nil {
|
||
http.Error(w, "löschen fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||
"ok": true,
|
||
"file": file,
|
||
})
|
||
}
|
||
|
||
func recordToggleHot(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodPost {
|
||
http.Error(w, "Nur POST", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
raw := strings.TrimSpace(r.URL.Query().Get("file"))
|
||
if raw == "" {
|
||
http.Error(w, "file fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
file, err := url.QueryUnescape(raw)
|
||
if err != nil {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
file = strings.TrimSpace(file)
|
||
|
||
// kein Pfad, keine Backslashes, kein Traversal
|
||
if file == "" ||
|
||
strings.Contains(file, "/") ||
|
||
strings.Contains(file, "\\") ||
|
||
filepath.Base(file) != file {
|
||
http.Error(w, "ungültiger file", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(file))
|
||
if ext != ".mp4" && ext != ".ts" {
|
||
http.Error(w, "nicht erlaubt", http.StatusForbidden)
|
||
return
|
||
}
|
||
|
||
s := getSettings()
|
||
doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
|
||
if err != nil {
|
||
http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if strings.TrimSpace(doneAbs) == "" {
|
||
http.Error(w, "doneDir ist leer", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
src := filepath.Join(doneAbs, file)
|
||
fi, err := os.Stat(src)
|
||
if err != nil {
|
||
if os.IsNotExist(err) {
|
||
http.Error(w, "datei nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
http.Error(w, "stat fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
if fi.IsDir() {
|
||
http.Error(w, "ist ein verzeichnis", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
newFile := file
|
||
if strings.HasPrefix(file, "HOT ") {
|
||
newFile = strings.TrimPrefix(file, "HOT ")
|
||
} else {
|
||
newFile = "HOT " + file
|
||
}
|
||
|
||
dst := filepath.Join(doneAbs, newFile)
|
||
if _, err := os.Stat(dst); err == nil {
|
||
http.Error(w, "ziel existiert bereits", http.StatusConflict)
|
||
return
|
||
} else if !os.IsNotExist(err) {
|
||
http.Error(w, "stat ziel fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
if err := os.Rename(src, dst); err != nil {
|
||
http.Error(w, "rename fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||
"ok": true,
|
||
"oldFile": file,
|
||
"newFile": newFile,
|
||
})
|
||
}
|
||
|
||
func maybeRemuxTS(path string) (string, error) {
|
||
path = strings.TrimSpace(path)
|
||
if path == "" {
|
||
return "", nil
|
||
}
|
||
|
||
if !strings.EqualFold(filepath.Ext(path), ".ts") {
|
||
return "", nil
|
||
}
|
||
|
||
mp4 := strings.TrimSuffix(path, filepath.Ext(path)) + ".mp4"
|
||
|
||
// remux (ohne neu encoden)
|
||
if err := remuxTSToMP4(path, mp4); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
_ = os.Remove(path) // TS entfernen, wenn MP4 ok
|
||
return mp4, nil
|
||
}
|
||
|
||
func moveFile(src, dst string) error {
|
||
// zuerst Rename (schnell)
|
||
if err := os.Rename(src, dst); err == nil {
|
||
return nil
|
||
} else {
|
||
// Fallback: Copy+Remove (z.B. bei EXDEV)
|
||
in, err2 := os.Open(src)
|
||
if err2 != nil {
|
||
return err
|
||
}
|
||
defer in.Close()
|
||
|
||
out, err2 := os.Create(dst)
|
||
if err2 != nil {
|
||
return err
|
||
}
|
||
if _, err2 := io.Copy(out, in); err2 != nil {
|
||
out.Close()
|
||
return err2
|
||
}
|
||
if err2 := out.Close(); err2 != nil {
|
||
return err2
|
||
}
|
||
return os.Remove(src)
|
||
}
|
||
}
|
||
|
||
func moveToDoneDir(outputPath string) (string, error) {
|
||
outputPath = strings.TrimSpace(outputPath)
|
||
if outputPath == "" {
|
||
return "", nil
|
||
}
|
||
|
||
s := getSettings()
|
||
|
||
// ✅ doneDir relativ zur exe auflösen (funktion hast du schon)
|
||
doneDirAbs, err := resolvePathRelativeToApp(s.DoneDir)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if err := os.MkdirAll(doneDirAbs, 0o755); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
dst := filepath.Join(doneDirAbs, filepath.Base(outputPath))
|
||
if err := moveFile(outputPath, dst); err != nil {
|
||
return "", err
|
||
}
|
||
return dst, nil
|
||
}
|
||
|
||
func recordStatus(w http.ResponseWriter, r *http.Request) {
|
||
id := r.URL.Query().Get("id")
|
||
if id == "" {
|
||
http.Error(w, "id fehlt", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
jobsMu.Lock()
|
||
job, ok := jobs[id]
|
||
jobsMu.Unlock()
|
||
|
||
if !ok {
|
||
http.Error(w, "job nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
json.NewEncoder(w).Encode(job)
|
||
}
|
||
|
||
func recordStop(w http.ResponseWriter, r *http.Request) {
|
||
if r.Method != http.MethodPost {
|
||
http.Error(w, "Nur POST", http.StatusMethodNotAllowed)
|
||
return
|
||
}
|
||
|
||
id := r.URL.Query().Get("id")
|
||
jobsMu.Lock()
|
||
job, ok := jobs[id]
|
||
jobsMu.Unlock()
|
||
|
||
if !ok {
|
||
http.Error(w, "job nicht gefunden", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
if job.previewCmd != nil && job.previewCmd.Process != nil {
|
||
_ = job.previewCmd.Process.Kill()
|
||
job.previewCmd = nil
|
||
}
|
||
|
||
if job.cancel != nil {
|
||
job.cancel()
|
||
}
|
||
|
||
out := job.Output
|
||
if strings.EqualFold(filepath.Ext(out), ".ts") {
|
||
mp4 := strings.TrimSuffix(out, filepath.Ext(out)) + ".mp4"
|
||
|
||
if err := remuxTSToMP4(out, mp4); err == nil {
|
||
_ = os.Remove(out) // optional: TS löschen
|
||
job.Output = mp4 // wichtig: Output umstellen
|
||
} else {
|
||
// optional: loggen, TS behalten
|
||
}
|
||
}
|
||
|
||
fmt.Println("📡 Aufnahme gestoppt:", job.ID)
|
||
|
||
w.Write([]byte(`{"ok":"stopped"}`))
|
||
}
|
||
|
||
// --- DVR-ähnlicher Recorder-Ablauf ---
|
||
// Entspricht grob dem RecordStream aus dem Channel-Snippet:
|
||
func RecordStream(
|
||
ctx context.Context,
|
||
hc *HTTPClient,
|
||
domain string,
|
||
username string,
|
||
outputPath string,
|
||
httpCookie string,
|
||
job *RecordJob,
|
||
) error {
|
||
// 1) Seite laden
|
||
// Domain sauber zusammenbauen (mit/ohne Slash)
|
||
base := strings.TrimRight(domain, "/")
|
||
pageURL := base + "/" + username
|
||
|
||
body, err := hc.FetchPage(ctx, pageURL, httpCookie)
|
||
|
||
// 2) HLS-URL aus roomDossier extrahieren (wie DVR.ParseStream)
|
||
hlsURL, err := ParseStream(body)
|
||
if err != nil {
|
||
return fmt.Errorf("stream-parsing: %w", err)
|
||
}
|
||
|
||
// 3) Playlist holen (wie stream.GetPlaylist im DVR)
|
||
playlist, err := FetchPlaylist(ctx, hc, hlsURL, httpCookie)
|
||
if err != nil {
|
||
return fmt.Errorf("playlist abrufen: %w", err)
|
||
}
|
||
|
||
if job != nil && strings.TrimSpace(job.PreviewDir) == "" {
|
||
previewDir := filepath.Join(os.TempDir(), "rec_preview", job.ID)
|
||
|
||
jobsMu.Lock()
|
||
job.PreviewDir = previewDir
|
||
jobsMu.Unlock()
|
||
|
||
if err := startPreviewHLS(ctx, job.ID, playlist.PlaylistURL, previewDir, httpCookie, hc.userAgent); err != nil {
|
||
fmt.Println("⚠️ preview start fehlgeschlagen:", err)
|
||
}
|
||
}
|
||
|
||
fmt.Printf("Stream-Qualität: %dp @ %dfps\n", playlist.Resolution, playlist.Framerate)
|
||
|
||
// 4) Datei öffnen
|
||
file, err := os.Create(outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("datei erstellen: %w", err)
|
||
}
|
||
defer func() {
|
||
_ = file.Close()
|
||
}()
|
||
|
||
fmt.Println("📡 Aufnahme gestartet:", outputPath)
|
||
|
||
// 5) Segmente „watchen“ – analog zu WatchSegments + HandleSegment im DVR
|
||
err = playlist.WatchSegments(ctx, hc, httpCookie, func(b []byte, duration float64) error {
|
||
// Hier wäre im DVR ch.HandleSegment – bei dir einfach in eine Datei schreiben
|
||
if _, err := file.Write(b); err != nil {
|
||
return fmt.Errorf("schreibe segment: %w", err)
|
||
}
|
||
// Könntest hier z.B. auch Dauer/Größe loggen, wenn du möchtest
|
||
_ = duration // aktuell unbenutzt
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return fmt.Errorf("watch segments: %w", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// RecordStreamMFC nimmt vorerst die URL 1:1 und ruft ffmpeg direkt darauf auf.
|
||
// In der Praxis musst du hier meist erst eine HLS-URL aus dem HTML extrahieren.
|
||
// RecordStreamMFC ist jetzt nur noch ein Wrapper um den bewährten MFC-Flow (runMFC).
|
||
func RecordStreamMFC(
|
||
ctx context.Context,
|
||
hc *HTTPClient,
|
||
username string,
|
||
outputPath string,
|
||
job *RecordJob,
|
||
) error {
|
||
mfc := NewMyFreeCams(username)
|
||
|
||
// optional, aber sinnvoll: nur aufnehmen wenn Public
|
||
st, err := mfc.GetStatus()
|
||
if err != nil {
|
||
return fmt.Errorf("mfc status: %w", err)
|
||
}
|
||
if st != StatusPublic {
|
||
return fmt.Errorf("Stream ist nicht öffentlich (Status: %s)", st)
|
||
}
|
||
|
||
m3u8URL, err := mfc.GetVideoURL(false)
|
||
if err != nil {
|
||
return fmt.Errorf("mfc get video url: %w", err)
|
||
}
|
||
if strings.TrimSpace(m3u8URL) == "" {
|
||
return fmt.Errorf("mfc: keine m3u8 URL gefunden")
|
||
}
|
||
|
||
// ✅ Preview starten
|
||
if job != nil && job.PreviewDir == "" {
|
||
previewDir := filepath.Join(os.TempDir(), "preview_"+job.ID)
|
||
job.PreviewDir = previewDir
|
||
|
||
if err := startPreviewHLS(ctx, job.ID, m3u8URL, previewDir, "", hc.userAgent); err != nil {
|
||
fmt.Println("⚠️ preview start fehlgeschlagen:", err)
|
||
job.PreviewDir = "" // rollback
|
||
}
|
||
}
|
||
|
||
// Aufnahme starten
|
||
return handleM3U8Mode(ctx, m3u8URL, outputPath)
|
||
}
|
||
|
||
func detectProvider(raw string) string {
|
||
s := strings.ToLower(raw)
|
||
|
||
if strings.Contains(s, "chaturbate.com") {
|
||
return "chaturbate"
|
||
}
|
||
if strings.Contains(s, "myfreecams.com") {
|
||
return "mfc"
|
||
}
|
||
return "unknown"
|
||
}
|
||
|
||
// --- helper ---
|
||
func extractUsername(input string) string {
|
||
input = strings.TrimSpace(input)
|
||
input = strings.TrimPrefix(input, "https://")
|
||
input = strings.TrimPrefix(input, "http://")
|
||
input = strings.TrimPrefix(input, "www.")
|
||
if strings.HasPrefix(input, "chaturbate.com/") {
|
||
input = strings.TrimPrefix(input, "chaturbate.com/")
|
||
}
|
||
|
||
// alles nach dem ersten Slash abschneiden (Pfadteile, /, etc.)
|
||
if idx := strings.IndexAny(input, "/?#"); idx != -1 {
|
||
input = input[:idx]
|
||
}
|
||
|
||
// zur Sicherheit evtl. übrig gebliebene Slash/Backslash trimmen
|
||
return strings.Trim(input, "/\\")
|
||
}
|
||
|
||
// Cookie-Hilfsfunktion (wie ParseCookies + AddCookie im DVR)
|
||
func addCookiesFromString(req *http.Request, cookieStr string) {
|
||
if cookieStr == "" {
|
||
return
|
||
}
|
||
pairs := strings.Split(cookieStr, ";")
|
||
for _, pair := range pairs {
|
||
parts := strings.SplitN(strings.TrimSpace(pair), "=", 2)
|
||
if len(parts) != 2 {
|
||
continue
|
||
}
|
||
name := strings.TrimSpace(parts[0])
|
||
value := strings.TrimSpace(parts[1])
|
||
if name == "" {
|
||
continue
|
||
}
|
||
req.AddCookie(&http.Cookie{
|
||
Name: name,
|
||
Value: value,
|
||
})
|
||
}
|
||
}
|
||
|
||
// ParseStream entspricht der DVR-Variante (roomDossier → hls_source)
|
||
func ParseStream(html string) (string, error) {
|
||
matches := roomDossierRegexp.FindStringSubmatch(html)
|
||
if len(matches) == 0 {
|
||
return "", errors.New("room dossier nicht gefunden")
|
||
}
|
||
|
||
// DVR-Style Unicode-Decode
|
||
decoded, err := strconv.Unquote(
|
||
strings.Replace(strconv.Quote(matches[1]), `\\u`, `\u`, -1),
|
||
)
|
||
if err != nil {
|
||
return "", fmt.Errorf("Unicode-decode failed: %w", err)
|
||
}
|
||
|
||
var rd struct {
|
||
HLSSource string `json:"hls_source"`
|
||
}
|
||
if err := json.Unmarshal([]byte(decoded), &rd); err != nil {
|
||
return "", fmt.Errorf("JSON-parse failed: %w", err)
|
||
}
|
||
if rd.HLSSource == "" {
|
||
return "", errors.New("kein HLS-Quell-URL im JSON")
|
||
}
|
||
return rd.HLSSource, nil
|
||
}
|
||
|
||
// --- Playlist/WatchSegments wie gehabt ---
|
||
type Playlist struct {
|
||
PlaylistURL string
|
||
RootURL string
|
||
Resolution int
|
||
Framerate int
|
||
}
|
||
|
||
type Resolution struct {
|
||
Framerate map[int]string
|
||
Width int
|
||
}
|
||
|
||
// nimmt jetzt *HTTPClient entgegen
|
||
func FetchPlaylist(ctx context.Context, hc *HTTPClient, hlsSource, httpCookie string) (*Playlist, error) {
|
||
if hlsSource == "" {
|
||
return nil, errors.New("HLS-URL leer")
|
||
}
|
||
|
||
req, err := hc.NewRequest(ctx, http.MethodGet, hlsSource, httpCookie)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("Fehler beim Erstellen der Playlist-Request: %w", err)
|
||
}
|
||
|
||
resp, err := hc.client.Do(req)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("Fehler beim Laden der Playlist: %w", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
playlist, listType, err := m3u8.DecodeFrom(resp.Body, true)
|
||
if err != nil || listType != m3u8.MASTER {
|
||
return nil, errors.New("keine gültige Master-Playlist")
|
||
}
|
||
|
||
master := playlist.(*m3u8.MasterPlaylist)
|
||
var bestURI string
|
||
var bestWidth int
|
||
var bestFramerate int
|
||
|
||
for _, variant := range master.Variants {
|
||
if variant == nil || variant.Resolution == "" {
|
||
continue
|
||
}
|
||
|
||
parts := strings.Split(variant.Resolution, "x")
|
||
if len(parts) != 2 {
|
||
continue
|
||
}
|
||
|
||
width, err := strconv.Atoi(parts[1])
|
||
if err != nil {
|
||
continue
|
||
}
|
||
|
||
fr := 30
|
||
if strings.Contains(variant.Name, "FPS:60.0") {
|
||
fr = 60
|
||
}
|
||
|
||
if width > bestWidth || (width == bestWidth && fr > bestFramerate) {
|
||
bestWidth = width
|
||
bestFramerate = fr
|
||
bestURI = variant.URI
|
||
}
|
||
}
|
||
|
||
if bestURI == "" {
|
||
return nil, errors.New("keine gültige Auflösung gefunden")
|
||
}
|
||
|
||
root := hlsSource[:strings.LastIndex(hlsSource, "/")+1]
|
||
return &Playlist{
|
||
PlaylistURL: root + bestURI,
|
||
RootURL: root,
|
||
Resolution: bestWidth,
|
||
Framerate: bestFramerate,
|
||
}, nil
|
||
}
|
||
|
||
// nutzt ebenfalls *HTTPClient
|
||
func (p *Playlist) WatchSegments(
|
||
ctx context.Context,
|
||
hc *HTTPClient,
|
||
httpCookie string,
|
||
handler func([]byte, float64) error,
|
||
) error {
|
||
var lastSeq int64 = -1
|
||
emptyRounds := 0
|
||
const maxEmptyRounds = 60 // statt 5
|
||
|
||
for {
|
||
select {
|
||
case <-ctx.Done():
|
||
return ctx.Err()
|
||
default:
|
||
}
|
||
|
||
// Playlist holen
|
||
req, err := hc.NewRequest(ctx, http.MethodGet, p.PlaylistURL, httpCookie)
|
||
if err != nil {
|
||
return fmt.Errorf("Fehler beim Erstellen der Playlist-Request: %w", err)
|
||
}
|
||
|
||
resp, err := hc.client.Do(req)
|
||
if err != nil {
|
||
emptyRounds++
|
||
if emptyRounds >= maxEmptyRounds {
|
||
return errors.New("❌ Playlist nicht mehr erreichbar – Stream vermutlich offline")
|
||
}
|
||
time.Sleep(2 * time.Second)
|
||
continue
|
||
}
|
||
|
||
playlist, listType, err := m3u8.DecodeFrom(resp.Body, true)
|
||
resp.Body.Close()
|
||
|
||
if err != nil || listType != m3u8.MEDIA {
|
||
emptyRounds++
|
||
if emptyRounds >= maxEmptyRounds {
|
||
return errors.New("❌ Fehlerhafte Playlist – möglicherweise offline")
|
||
}
|
||
time.Sleep(2 * time.Second)
|
||
continue
|
||
}
|
||
|
||
media := playlist.(*m3u8.MediaPlaylist)
|
||
newSegment := false
|
||
|
||
for _, segment := range media.Segments {
|
||
if segment == nil {
|
||
continue
|
||
}
|
||
if int64(segment.SeqId) <= lastSeq {
|
||
continue
|
||
}
|
||
|
||
lastSeq = int64(segment.SeqId)
|
||
newSegment = true
|
||
|
||
segmentURL := p.RootURL + segment.URI
|
||
|
||
segReq, err := hc.NewRequest(ctx, http.MethodGet, segmentURL, httpCookie)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
|
||
segResp, err := hc.client.Do(segReq)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
|
||
data, err := io.ReadAll(segResp.Body)
|
||
segResp.Body.Close()
|
||
if err != nil || len(data) == 0 {
|
||
continue
|
||
}
|
||
|
||
if err := handler(data, segment.Duration); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
if newSegment {
|
||
emptyRounds = 0
|
||
} else {
|
||
emptyRounds++
|
||
if emptyRounds >= maxEmptyRounds {
|
||
return errors.New("🛑 Keine neuen HLS-Segmente empfangen – Stream vermutlich beendet oder offline.")
|
||
}
|
||
}
|
||
|
||
time.Sleep(1 * time.Second)
|
||
}
|
||
}
|
||
|
||
/* ───────────────────────────────
|
||
MyFreeCams (übernommener Flow)
|
||
─────────────────────────────── */
|
||
|
||
type MyFreeCams struct {
|
||
Username string
|
||
Attrs map[string]string
|
||
VideoURL string
|
||
}
|
||
|
||
func NewMyFreeCams(username string) *MyFreeCams {
|
||
return &MyFreeCams{
|
||
Username: username,
|
||
Attrs: map[string]string{},
|
||
}
|
||
}
|
||
|
||
func (m *MyFreeCams) GetWebsiteURL() string {
|
||
return "https://www.myfreecams.com/#" + m.Username
|
||
}
|
||
|
||
func (m *MyFreeCams) GetVideoURL(refresh bool) (string, error) {
|
||
if !refresh && m.VideoURL != "" {
|
||
return m.VideoURL, nil
|
||
}
|
||
|
||
// Prüfen, ob alle benötigten Attribute vorhanden sind
|
||
if _, ok := m.Attrs["data-cam-preview-model-id-value"]; !ok {
|
||
return "", nil
|
||
}
|
||
sid := m.Attrs["data-cam-preview-server-id-value"]
|
||
midBase := m.Attrs["data-cam-preview-model-id-value"]
|
||
isWzobs := strings.ToLower(m.Attrs["data-cam-preview-is-wzobs-value"]) == "true"
|
||
|
||
midInt, err := strconv.Atoi(midBase)
|
||
if err != nil {
|
||
return "", fmt.Errorf("model-id parse error: %w", err)
|
||
}
|
||
mid := 100000000 + midInt
|
||
a := ""
|
||
if isWzobs {
|
||
a = "a_"
|
||
}
|
||
|
||
playlistURL := fmt.Sprintf(
|
||
"https://previews.myfreecams.com/hls/NxServer/%s/ngrp:mfc_%s%d.f4v_mobile_mhp1080_previewurl/playlist.m3u8",
|
||
sid, a, mid,
|
||
)
|
||
|
||
// Validieren (HTTP 200) & ggf. auf gewünschte Auflösung verlinken
|
||
u, err := getWantedResolutionPlaylist(playlistURL)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
m.VideoURL = u
|
||
return m.VideoURL, nil
|
||
}
|
||
|
||
func (m *MyFreeCams) GetStatus() (Status, error) {
|
||
// 1) share-Seite prüfen (existiert/nicht existiert)
|
||
shareURL := "https://share.myfreecams.com/" + m.Username
|
||
resp, err := http.Get(shareURL)
|
||
if err != nil {
|
||
return StatusUnknown, err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode == 404 {
|
||
return StatusNotExist, nil
|
||
}
|
||
if resp.StatusCode != 200 {
|
||
return StatusUnknown, fmt.Errorf("HTTP %d", resp.StatusCode)
|
||
}
|
||
|
||
// wir brauchen sowohl Bytes (für Suche) als auch Reader (für HTML)
|
||
bodyBytes, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return StatusUnknown, err
|
||
}
|
||
|
||
// 2) „tracking.php?“ suchen und prüfen, ob model_id vorhanden ist
|
||
start := bytes.Index(bodyBytes, []byte("https://www.myfreecams.com/php/tracking.php?"))
|
||
if start == -1 {
|
||
// ohne tracking Parameter -> behandeln wie nicht existent
|
||
return StatusNotExist, nil
|
||
}
|
||
end := bytes.IndexByte(bodyBytes[start:], '"')
|
||
if end == -1 {
|
||
return StatusUnknown, errors.New("tracking url parse failed")
|
||
}
|
||
raw := string(bodyBytes[start : start+end])
|
||
u, err := url.Parse(raw)
|
||
if err != nil {
|
||
return StatusUnknown, fmt.Errorf("tracking url invalid: %w", err)
|
||
}
|
||
qs := u.Query()
|
||
if qs.Get("model_id") == "" {
|
||
return StatusNotExist, nil
|
||
}
|
||
|
||
// 3) HTML parsen und <div class="campreview" ...> Attribute auslesen
|
||
doc, err := goquery.NewDocumentFromReader(bytes.NewReader(bodyBytes))
|
||
if err != nil {
|
||
return StatusUnknown, err
|
||
}
|
||
|
||
params := doc.Find(".campreview").First()
|
||
if params.Length() == 0 {
|
||
// keine campreview -> offline
|
||
return StatusOffline, nil
|
||
}
|
||
|
||
attrs := map[string]string{}
|
||
params.Each(func(_ int, s *goquery.Selection) {
|
||
for _, a := range []string{
|
||
"data-cam-preview-server-id-value",
|
||
"data-cam-preview-model-id-value",
|
||
"data-cam-preview-is-wzobs-value",
|
||
} {
|
||
if v, ok := s.Attr(a); ok {
|
||
attrs[a] = v
|
||
}
|
||
}
|
||
})
|
||
m.Attrs = attrs
|
||
|
||
// 4) Versuchen, VideoURL (Preview-HLS) zu ermitteln
|
||
uStr, err := m.GetVideoURL(true)
|
||
if err != nil {
|
||
return StatusUnknown, err
|
||
}
|
||
if uStr != "" {
|
||
return StatusPublic, nil
|
||
}
|
||
// campreview vorhanden, aber keine playable url -> „PRIVATE“
|
||
return StatusPrivate, nil
|
||
}
|
||
|
||
func runMFC(ctx context.Context, username string, outArg string) error {
|
||
mfc := NewMyFreeCams(username)
|
||
|
||
st, err := mfc.GetStatus()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if st != StatusPublic {
|
||
return fmt.Errorf("Stream ist nicht öffentlich (Status: %s)", st)
|
||
}
|
||
|
||
m3u8URL, err := mfc.GetVideoURL(false)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if m3u8URL == "" {
|
||
return errors.New("keine m3u8 URL gefunden")
|
||
}
|
||
|
||
return handleM3U8Mode(ctx, m3u8URL, outArg)
|
||
}
|
||
|
||
/* ───────────────────────────────
|
||
Gemeinsame HLS/M3U8-Helper (MFC)
|
||
─────────────────────────────── */
|
||
|
||
func getWantedResolutionPlaylist(playlistURL string) (string, error) {
|
||
// Holt eine URL; wenn MASTER, wähle beste Variante; wenn MEDIA, gib die URL zurück.
|
||
resp, err := http.Get(playlistURL)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
defer resp.Body.Close()
|
||
if resp.StatusCode != 200 {
|
||
return "", fmt.Errorf("HTTP %d beim Abruf der m3u8", resp.StatusCode)
|
||
}
|
||
|
||
playlist, listType, err := m3u8.DecodeFrom(resp.Body, true)
|
||
if err != nil {
|
||
return "", fmt.Errorf("m3u8 parse: %w", err)
|
||
}
|
||
if listType == m3u8.MEDIA {
|
||
return playlistURL, nil
|
||
}
|
||
|
||
master := playlist.(*m3u8.MasterPlaylist)
|
||
var bestURI string
|
||
var bestWidth int
|
||
var bestFramerate float64
|
||
|
||
for _, v := range master.Variants {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
// Resolution kommt als "WxH" – wir nutzen die Höhe als Vergleichswert.
|
||
w := 0
|
||
if v.Resolution != "" {
|
||
parts := strings.Split(v.Resolution, "x")
|
||
if len(parts) == 2 {
|
||
if ww, err := strconv.Atoi(parts[1]); err == nil {
|
||
w = ww
|
||
}
|
||
}
|
||
}
|
||
fr := 30.0
|
||
if v.FrameRate > 0 {
|
||
fr = v.FrameRate
|
||
} else if strings.Contains(v.Name, "FPS:60") {
|
||
fr = 60
|
||
}
|
||
if w > bestWidth || (w == bestWidth && fr > bestFramerate) {
|
||
bestWidth = w
|
||
bestFramerate = fr
|
||
bestURI = v.URI
|
||
}
|
||
}
|
||
if bestURI == "" {
|
||
return "", errors.New("Master-Playlist ohne gültige Varianten")
|
||
}
|
||
|
||
// Absolutieren
|
||
root := playlistURL[:strings.LastIndex(playlistURL, "/")+1]
|
||
if strings.HasPrefix(bestURI, "http://") || strings.HasPrefix(bestURI, "https://") {
|
||
return bestURI, nil
|
||
}
|
||
return root + bestURI, nil
|
||
}
|
||
|
||
func handleM3U8Mode(ctx context.Context, m3u8URL, outFile string) error {
|
||
// Validierung
|
||
u, err := url.Parse(m3u8URL)
|
||
if err != nil || (u.Scheme != "http" && u.Scheme != "https") {
|
||
return fmt.Errorf("ungültige URL: %q", m3u8URL)
|
||
}
|
||
|
||
// HTTP-Check MIT Context
|
||
req, err := http.NewRequestWithContext(ctx, "GET", m3u8URL, nil)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
resp, err := http.DefaultClient.Do(req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
io.Copy(io.Discard, resp.Body)
|
||
resp.Body.Close()
|
||
|
||
if resp.StatusCode != 200 {
|
||
return fmt.Errorf("HTTP %d beim Abruf der m3u8", resp.StatusCode)
|
||
}
|
||
|
||
if strings.TrimSpace(outFile) == "" {
|
||
return errors.New("output file path leer")
|
||
}
|
||
|
||
// ffmpeg mit Context (STOP FUNKTIONIERT HIER!)
|
||
cmd := exec.CommandContext(
|
||
ctx,
|
||
ffmpegPath,
|
||
"-y",
|
||
"-i", m3u8URL,
|
||
"-c", "copy",
|
||
outFile,
|
||
)
|
||
cmd.Stdout = os.Stdout
|
||
cmd.Stderr = os.Stderr
|
||
|
||
if err := cmd.Run(); err != nil {
|
||
if errors.Is(ctx.Err(), context.Canceled) {
|
||
return ctx.Err()
|
||
}
|
||
return fmt.Errorf("ffmpeg fehlgeschlagen: %w", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
/* ───────────────────────────────
|
||
Kleine Helper für MFC
|
||
─────────────────────────────── */
|
||
|
||
func extractMFCUsername(input string) string {
|
||
if strings.Contains(input, "myfreecams.com/#") {
|
||
i := strings.Index(input, "#")
|
||
if i >= 0 && i < len(input)-1 {
|
||
return strings.TrimSpace(input[i+1:])
|
||
}
|
||
return ""
|
||
}
|
||
return strings.TrimSpace(input)
|
||
}
|
||
|
||
func readLine() string {
|
||
r := bufio.NewReader(os.Stdin)
|
||
s, _ := r.ReadString('\n')
|
||
return strings.TrimRight(s, "\r\n")
|
||
}
|
||
|
||
func fileExists(path string) bool {
|
||
_, err := os.Stat(path)
|
||
return err == nil
|
||
}
|