forked from Leak_Technologies/VideoTools
Add job queue system with batch processing support
Implements a comprehensive job queue system for batch video processing: - Job queue with priority-based processing - Queue persistence (saves/restores across app restarts) - Pause/resume/cancel individual jobs - Real-time progress tracking - Queue viewer UI with job management controls - Clickable queue tile on main menu showing completed/total - "View Queue" button in convert module Batch processing features: - Drag multiple video files to convert tile → auto-add to queue - Drag folders → recursively scans and adds all videos - Batch add confirmation dialog - Supports 14 common video formats Convert module improvements: - "Add to Queue" button for queuing single conversions - "CONVERT NOW" button (renamed for clarity) - "View Queue" button for quick queue access Technical implementation: - internal/queue package with job management - Job executor with FFmpeg integration - Progress callbacks for live updates - Tappable widget component for clickable UI elements WIP: Queue system functional, tabs feature pending 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
parent
d7ec373470
commit
b09ab8d8b4
382
internal/queue/queue.go
Normal file
382
internal/queue/queue.go
Normal file
|
|
@ -0,0 +1,382 @@
|
|||
package queue
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// JobType represents the type of job to execute
|
||||
type JobType string
|
||||
|
||||
const (
|
||||
JobTypeConvert JobType = "convert"
|
||||
JobTypeMerge JobType = "merge"
|
||||
JobTypeTrim JobType = "trim"
|
||||
JobTypeFilter JobType = "filter"
|
||||
JobTypeUpscale JobType = "upscale"
|
||||
JobTypeAudio JobType = "audio"
|
||||
JobTypeThumb JobType = "thumb"
|
||||
)
|
||||
|
||||
// JobStatus represents the current state of a job
|
||||
type JobStatus string
|
||||
|
||||
const (
|
||||
JobStatusPending JobStatus = "pending"
|
||||
JobStatusRunning JobStatus = "running"
|
||||
JobStatusPaused JobStatus = "paused"
|
||||
JobStatusCompleted JobStatus = "completed"
|
||||
JobStatusFailed JobStatus = "failed"
|
||||
JobStatusCancelled JobStatus = "cancelled"
|
||||
)
|
||||
|
||||
// Job represents a single job in the queue
|
||||
type Job struct {
|
||||
ID string `json:"id"`
|
||||
Type JobType `json:"type"`
|
||||
Status JobStatus `json:"status"`
|
||||
Title string `json:"title"`
|
||||
Description string `json:"description"`
|
||||
InputFile string `json:"input_file"`
|
||||
OutputFile string `json:"output_file"`
|
||||
Config map[string]interface{} `json:"config"`
|
||||
Progress float64 `json:"progress"`
|
||||
Error string `json:"error,omitempty"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
StartedAt *time.Time `json:"started_at,omitempty"`
|
||||
CompletedAt *time.Time `json:"completed_at,omitempty"`
|
||||
Priority int `json:"priority"` // Higher priority = runs first
|
||||
cancel context.CancelFunc `json:"-"`
|
||||
}
|
||||
|
||||
// JobExecutor is a function that executes a job
|
||||
type JobExecutor func(ctx context.Context, job *Job, progressCallback func(float64)) error
|
||||
|
||||
// Queue manages a queue of jobs
|
||||
type Queue struct {
|
||||
jobs []*Job
|
||||
executor JobExecutor
|
||||
running bool
|
||||
mu sync.RWMutex
|
||||
onChange func() // Callback when queue state changes
|
||||
}
|
||||
|
||||
// New creates a new queue with the given executor
|
||||
func New(executor JobExecutor) *Queue {
|
||||
return &Queue{
|
||||
jobs: make([]*Job, 0),
|
||||
executor: executor,
|
||||
running: false,
|
||||
}
|
||||
}
|
||||
|
||||
// SetChangeCallback sets a callback to be called when the queue state changes
|
||||
func (q *Queue) SetChangeCallback(callback func()) {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
q.onChange = callback
|
||||
}
|
||||
|
||||
// notifyChange triggers the onChange callback if set
|
||||
func (q *Queue) notifyChange() {
|
||||
if q.onChange != nil {
|
||||
q.onChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Add adds a job to the queue
|
||||
func (q *Queue) Add(job *Job) {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
if job.ID == "" {
|
||||
job.ID = generateID()
|
||||
}
|
||||
if job.CreatedAt.IsZero() {
|
||||
job.CreatedAt = time.Now()
|
||||
}
|
||||
if job.Status == "" {
|
||||
job.Status = JobStatusPending
|
||||
}
|
||||
|
||||
q.jobs = append(q.jobs, job)
|
||||
q.notifyChange()
|
||||
}
|
||||
|
||||
// Remove removes a job from the queue by ID
|
||||
func (q *Queue) Remove(id string) error {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
for i, job := range q.jobs {
|
||||
if job.ID == id {
|
||||
// Cancel if running
|
||||
if job.Status == JobStatusRunning && job.cancel != nil {
|
||||
job.cancel()
|
||||
}
|
||||
q.jobs = append(q.jobs[:i], q.jobs[i+1:]...)
|
||||
q.notifyChange()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("job not found: %s", id)
|
||||
}
|
||||
|
||||
// Get retrieves a job by ID
|
||||
func (q *Queue) Get(id string) (*Job, error) {
|
||||
q.mu.RLock()
|
||||
defer q.mu.RUnlock()
|
||||
|
||||
for _, job := range q.jobs {
|
||||
if job.ID == id {
|
||||
return job, nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf("job not found: %s", id)
|
||||
}
|
||||
|
||||
// List returns all jobs in the queue
|
||||
func (q *Queue) List() []*Job {
|
||||
q.mu.RLock()
|
||||
defer q.mu.RUnlock()
|
||||
|
||||
result := make([]*Job, len(q.jobs))
|
||||
copy(result, q.jobs)
|
||||
return result
|
||||
}
|
||||
|
||||
// Stats returns queue statistics
|
||||
func (q *Queue) Stats() (pending, running, completed, failed int) {
|
||||
q.mu.RLock()
|
||||
defer q.mu.RUnlock()
|
||||
|
||||
for _, job := range q.jobs {
|
||||
switch job.Status {
|
||||
case JobStatusPending, JobStatusPaused:
|
||||
pending++
|
||||
case JobStatusRunning:
|
||||
running++
|
||||
case JobStatusCompleted:
|
||||
completed++
|
||||
case JobStatusFailed, JobStatusCancelled:
|
||||
failed++
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Pause pauses a running job
|
||||
func (q *Queue) Pause(id string) error {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
for _, job := range q.jobs {
|
||||
if job.ID == id {
|
||||
if job.Status != JobStatusRunning {
|
||||
return fmt.Errorf("job is not running")
|
||||
}
|
||||
if job.cancel != nil {
|
||||
job.cancel()
|
||||
}
|
||||
job.Status = JobStatusPaused
|
||||
q.notifyChange()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("job not found: %s", id)
|
||||
}
|
||||
|
||||
// Resume resumes a paused job
|
||||
func (q *Queue) Resume(id string) error {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
for _, job := range q.jobs {
|
||||
if job.ID == id {
|
||||
if job.Status != JobStatusPaused {
|
||||
return fmt.Errorf("job is not paused")
|
||||
}
|
||||
job.Status = JobStatusPending
|
||||
q.notifyChange()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("job not found: %s", id)
|
||||
}
|
||||
|
||||
// Cancel cancels a job
|
||||
func (q *Queue) Cancel(id string) error {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
for _, job := range q.jobs {
|
||||
if job.ID == id {
|
||||
if job.Status == JobStatusRunning && job.cancel != nil {
|
||||
job.cancel()
|
||||
}
|
||||
job.Status = JobStatusCancelled
|
||||
q.notifyChange()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("job not found: %s", id)
|
||||
}
|
||||
|
||||
// Start starts processing jobs in the queue
|
||||
func (q *Queue) Start() {
|
||||
q.mu.Lock()
|
||||
if q.running {
|
||||
q.mu.Unlock()
|
||||
return
|
||||
}
|
||||
q.running = true
|
||||
q.mu.Unlock()
|
||||
|
||||
go q.processJobs()
|
||||
}
|
||||
|
||||
// Stop stops processing jobs
|
||||
func (q *Queue) Stop() {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
q.running = false
|
||||
}
|
||||
|
||||
// processJobs continuously processes pending jobs
|
||||
func (q *Queue) processJobs() {
|
||||
for {
|
||||
q.mu.Lock()
|
||||
if !q.running {
|
||||
q.mu.Unlock()
|
||||
return
|
||||
}
|
||||
|
||||
// Find highest priority pending job
|
||||
var nextJob *Job
|
||||
highestPriority := -1
|
||||
for _, job := range q.jobs {
|
||||
if job.Status == JobStatusPending && job.Priority > highestPriority {
|
||||
nextJob = job
|
||||
highestPriority = job.Priority
|
||||
}
|
||||
}
|
||||
|
||||
if nextJob == nil {
|
||||
q.mu.Unlock()
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
continue
|
||||
}
|
||||
|
||||
// Mark as running
|
||||
nextJob.Status = JobStatusRunning
|
||||
now := time.Now()
|
||||
nextJob.StartedAt = &now
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
nextJob.cancel = cancel
|
||||
|
||||
q.mu.Unlock()
|
||||
q.notifyChange()
|
||||
|
||||
// Execute job
|
||||
err := q.executor(ctx, nextJob, func(progress float64) {
|
||||
q.mu.Lock()
|
||||
nextJob.Progress = progress
|
||||
q.mu.Unlock()
|
||||
q.notifyChange()
|
||||
})
|
||||
|
||||
// Update job status
|
||||
q.mu.Lock()
|
||||
now = time.Now()
|
||||
nextJob.CompletedAt = &now
|
||||
if err != nil {
|
||||
nextJob.Status = JobStatusFailed
|
||||
nextJob.Error = err.Error()
|
||||
} else {
|
||||
nextJob.Status = JobStatusCompleted
|
||||
nextJob.Progress = 100.0
|
||||
}
|
||||
nextJob.cancel = nil
|
||||
q.mu.Unlock()
|
||||
q.notifyChange()
|
||||
}
|
||||
}
|
||||
|
||||
// Save saves the queue to a JSON file
|
||||
func (q *Queue) Save(path string) error {
|
||||
q.mu.RLock()
|
||||
defer q.mu.RUnlock()
|
||||
|
||||
// Create directory if it doesn't exist
|
||||
dir := filepath.Dir(path)
|
||||
if err := os.MkdirAll(dir, 0755); err != nil {
|
||||
return fmt.Errorf("failed to create directory: %w", err)
|
||||
}
|
||||
|
||||
data, err := json.MarshalIndent(q.jobs, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to marshal queue: %w", err)
|
||||
}
|
||||
|
||||
if err := os.WriteFile(path, data, 0644); err != nil {
|
||||
return fmt.Errorf("failed to write queue file: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Load loads the queue from a JSON file
|
||||
func (q *Queue) Load(path string) error {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return nil // No saved queue, that's OK
|
||||
}
|
||||
return fmt.Errorf("failed to read queue file: %w", err)
|
||||
}
|
||||
|
||||
var jobs []*Job
|
||||
if err := json.Unmarshal(data, &jobs); err != nil {
|
||||
return fmt.Errorf("failed to unmarshal queue: %w", err)
|
||||
}
|
||||
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
// Reset running jobs to pending
|
||||
for _, job := range jobs {
|
||||
if job.Status == JobStatusRunning {
|
||||
job.Status = JobStatusPending
|
||||
job.Progress = 0
|
||||
}
|
||||
}
|
||||
|
||||
q.jobs = jobs
|
||||
q.notifyChange()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Clear removes all completed, failed, and cancelled jobs
|
||||
func (q *Queue) Clear() {
|
||||
q.mu.Lock()
|
||||
defer q.mu.Unlock()
|
||||
|
||||
filtered := make([]*Job, 0)
|
||||
for _, job := range q.jobs {
|
||||
if job.Status == JobStatusPending || job.Status == JobStatusRunning || job.Status == JobStatusPaused {
|
||||
filtered = append(filtered, job)
|
||||
}
|
||||
}
|
||||
q.jobs = filtered
|
||||
q.notifyChange()
|
||||
}
|
||||
|
||||
// generateID generates a unique ID for a job
|
||||
func generateID() string {
|
||||
return fmt.Sprintf("job-%d", time.Now().UnixNano())
|
||||
}
|
||||
|
|
@ -163,6 +163,61 @@ func TintedBar(col color.Color, body fyne.CanvasObject) fyne.CanvasObject {
|
|||
return container.NewMax(rect, padded)
|
||||
}
|
||||
|
||||
// Tappable wraps any canvas object and makes it tappable
|
||||
type Tappable struct {
|
||||
widget.BaseWidget
|
||||
content fyne.CanvasObject
|
||||
onTapped func()
|
||||
}
|
||||
|
||||
// NewTappable creates a new tappable wrapper
|
||||
func NewTappable(content fyne.CanvasObject, onTapped func()) *Tappable {
|
||||
t := &Tappable{
|
||||
content: content,
|
||||
onTapped: onTapped,
|
||||
}
|
||||
t.ExtendBaseWidget(t)
|
||||
return t
|
||||
}
|
||||
|
||||
// CreateRenderer creates the renderer for the tappable
|
||||
func (t *Tappable) CreateRenderer() fyne.WidgetRenderer {
|
||||
return &tappableRenderer{
|
||||
tappable: t,
|
||||
content: t.content,
|
||||
}
|
||||
}
|
||||
|
||||
// Tapped handles tap events
|
||||
func (t *Tappable) Tapped(*fyne.PointEvent) {
|
||||
if t.onTapped != nil {
|
||||
t.onTapped()
|
||||
}
|
||||
}
|
||||
|
||||
type tappableRenderer struct {
|
||||
tappable *Tappable
|
||||
content fyne.CanvasObject
|
||||
}
|
||||
|
||||
func (r *tappableRenderer) Layout(size fyne.Size) {
|
||||
r.content.Resize(size)
|
||||
}
|
||||
|
||||
func (r *tappableRenderer) MinSize() fyne.Size {
|
||||
return r.content.MinSize()
|
||||
}
|
||||
|
||||
func (r *tappableRenderer) Refresh() {
|
||||
r.content.Refresh()
|
||||
}
|
||||
|
||||
func (r *tappableRenderer) Destroy() {}
|
||||
|
||||
func (r *tappableRenderer) Objects() []fyne.CanvasObject {
|
||||
return []fyne.CanvasObject{r.content}
|
||||
}
|
||||
|
||||
// DraggableVScroll creates a vertical scroll container with draggable track
|
||||
type DraggableVScroll struct {
|
||||
widget.BaseWidget
|
||||
|
|
|
|||
|
|
@ -20,12 +20,12 @@ type ModuleInfo struct {
|
|||
}
|
||||
|
||||
// BuildMainMenu creates the main menu view with module tiles
|
||||
func BuildMainMenu(modules []ModuleInfo, onModuleClick func(string), onModuleDrop func(string, []fyne.URI), titleColor, queueColor, textColor color.Color) fyne.CanvasObject {
|
||||
func BuildMainMenu(modules []ModuleInfo, onModuleClick func(string), onModuleDrop func(string, []fyne.URI), onQueueClick func(), titleColor, queueColor, textColor color.Color, queueCompleted, queueTotal int) fyne.CanvasObject {
|
||||
title := canvas.NewText("VIDEOTOOLS", titleColor)
|
||||
title.TextStyle = fyne.TextStyle{Monospace: true, Bold: true}
|
||||
title.TextSize = 28
|
||||
|
||||
queueTile := buildQueueTile(0, 0, queueColor, textColor)
|
||||
queueTile := buildQueueTile(queueCompleted, queueTotal, queueColor, textColor, onQueueClick)
|
||||
|
||||
header := container.New(layout.NewHBoxLayout(),
|
||||
title,
|
||||
|
|
@ -70,7 +70,7 @@ func buildModuleTile(mod ModuleInfo, tapped func(), dropped func([]fyne.URI)) fy
|
|||
}
|
||||
|
||||
// buildQueueTile creates the queue status tile
|
||||
func buildQueueTile(done, total int, queueColor, textColor color.Color) fyne.CanvasObject {
|
||||
func buildQueueTile(done, total int, queueColor, textColor color.Color, onClick func()) fyne.CanvasObject {
|
||||
rect := canvas.NewRectangle(queueColor)
|
||||
rect.CornerRadius = 8
|
||||
rect.SetMinSize(fyne.NewSize(160, 60))
|
||||
|
|
@ -80,5 +80,9 @@ func buildQueueTile(done, total int, queueColor, textColor color.Color) fyne.Can
|
|||
text.TextStyle = fyne.TextStyle{Monospace: true, Bold: true}
|
||||
text.TextSize = 18
|
||||
|
||||
return container.NewMax(rect, container.NewCenter(text))
|
||||
tile := container.NewMax(rect, container.NewCenter(text))
|
||||
|
||||
// Make it tappable
|
||||
tappable := NewTappable(tile, onClick)
|
||||
return tappable
|
||||
}
|
||||
|
|
|
|||
206
internal/ui/queueview.go
Normal file
206
internal/ui/queueview.go
Normal file
|
|
@ -0,0 +1,206 @@
|
|||
package ui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"image/color"
|
||||
"time"
|
||||
|
||||
"fyne.io/fyne/v2"
|
||||
"fyne.io/fyne/v2/canvas"
|
||||
"fyne.io/fyne/v2/container"
|
||||
"fyne.io/fyne/v2/widget"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/queue"
|
||||
)
|
||||
|
||||
// BuildQueueView creates the queue viewer UI
|
||||
func BuildQueueView(
|
||||
jobs []*queue.Job,
|
||||
onBack func(),
|
||||
onPause func(string),
|
||||
onResume func(string),
|
||||
onCancel func(string),
|
||||
onRemove func(string),
|
||||
onClear func(),
|
||||
titleColor, bgColor, textColor color.Color,
|
||||
) fyne.CanvasObject {
|
||||
// Header
|
||||
title := canvas.NewText("JOB QUEUE", titleColor)
|
||||
title.TextStyle = fyne.TextStyle{Monospace: true, Bold: true}
|
||||
title.TextSize = 24
|
||||
|
||||
backBtn := widget.NewButton("← Back", onBack)
|
||||
clearBtn := widget.NewButton("Clear Completed", onClear)
|
||||
|
||||
header := container.NewBorder(
|
||||
nil, nil,
|
||||
backBtn,
|
||||
clearBtn,
|
||||
container.NewCenter(title),
|
||||
)
|
||||
|
||||
// Job list
|
||||
var jobItems []fyne.CanvasObject
|
||||
|
||||
if len(jobs) == 0 {
|
||||
emptyMsg := widget.NewLabel("No jobs in queue")
|
||||
emptyMsg.Alignment = fyne.TextAlignCenter
|
||||
jobItems = append(jobItems, container.NewCenter(emptyMsg))
|
||||
} else {
|
||||
for _, job := range jobs {
|
||||
jobItems = append(jobItems, buildJobItem(job, onPause, onResume, onCancel, onRemove, bgColor, textColor))
|
||||
}
|
||||
}
|
||||
|
||||
jobList := container.NewVBox(jobItems...)
|
||||
scrollable := container.NewVScroll(jobList)
|
||||
|
||||
body := container.NewBorder(
|
||||
header,
|
||||
nil, nil, nil,
|
||||
scrollable,
|
||||
)
|
||||
|
||||
return container.NewPadded(body)
|
||||
}
|
||||
|
||||
// buildJobItem creates a single job item in the queue list
|
||||
func buildJobItem(
|
||||
job *queue.Job,
|
||||
onPause func(string),
|
||||
onResume func(string),
|
||||
onCancel func(string),
|
||||
onRemove func(string),
|
||||
bgColor, textColor color.Color,
|
||||
) fyne.CanvasObject {
|
||||
// Status color
|
||||
statusColor := getStatusColor(job.Status)
|
||||
|
||||
// Status indicator
|
||||
statusRect := canvas.NewRectangle(statusColor)
|
||||
statusRect.SetMinSize(fyne.NewSize(6, 0))
|
||||
|
||||
// Title and description
|
||||
titleLabel := widget.NewLabel(job.Title)
|
||||
titleLabel.TextStyle = fyne.TextStyle{Bold: true}
|
||||
|
||||
descLabel := widget.NewLabel(job.Description)
|
||||
descLabel.TextStyle = fyne.TextStyle{Italic: true}
|
||||
|
||||
// Progress bar (for running jobs)
|
||||
var progressWidget fyne.CanvasObject
|
||||
if job.Status == queue.JobStatusRunning {
|
||||
progress := widget.NewProgressBar()
|
||||
progress.SetValue(job.Progress / 100.0)
|
||||
progressWidget = progress
|
||||
} else if job.Status == queue.JobStatusCompleted {
|
||||
progress := widget.NewProgressBar()
|
||||
progress.SetValue(1.0)
|
||||
progressWidget = progress
|
||||
} else {
|
||||
progressWidget = widget.NewLabel("")
|
||||
}
|
||||
|
||||
// Status text
|
||||
statusText := getStatusText(job)
|
||||
statusLabel := widget.NewLabel(statusText)
|
||||
statusLabel.TextStyle = fyne.TextStyle{Monospace: true}
|
||||
|
||||
// Control buttons
|
||||
var buttons []fyne.CanvasObject
|
||||
switch job.Status {
|
||||
case queue.JobStatusRunning:
|
||||
buttons = append(buttons,
|
||||
widget.NewButton("Pause", func() { onPause(job.ID) }),
|
||||
widget.NewButton("Cancel", func() { onCancel(job.ID) }),
|
||||
)
|
||||
case queue.JobStatusPaused:
|
||||
buttons = append(buttons,
|
||||
widget.NewButton("Resume", func() { onResume(job.ID) }),
|
||||
widget.NewButton("Cancel", func() { onCancel(job.ID) }),
|
||||
)
|
||||
case queue.JobStatusPending:
|
||||
buttons = append(buttons,
|
||||
widget.NewButton("Cancel", func() { onCancel(job.ID) }),
|
||||
)
|
||||
case queue.JobStatusCompleted, queue.JobStatusFailed, queue.JobStatusCancelled:
|
||||
buttons = append(buttons,
|
||||
widget.NewButton("Remove", func() { onRemove(job.ID) }),
|
||||
)
|
||||
}
|
||||
|
||||
buttonBox := container.NewHBox(buttons...)
|
||||
|
||||
// Info section
|
||||
infoBox := container.NewVBox(
|
||||
titleLabel,
|
||||
descLabel,
|
||||
progressWidget,
|
||||
statusLabel,
|
||||
)
|
||||
|
||||
// Main content
|
||||
content := container.NewBorder(
|
||||
nil, nil,
|
||||
statusRect,
|
||||
buttonBox,
|
||||
infoBox,
|
||||
)
|
||||
|
||||
// Card background
|
||||
card := canvas.NewRectangle(bgColor)
|
||||
card.CornerRadius = 4
|
||||
|
||||
item := container.NewPadded(
|
||||
container.NewMax(card, content),
|
||||
)
|
||||
|
||||
return item
|
||||
}
|
||||
|
||||
// getStatusColor returns the color for a job status
|
||||
func getStatusColor(status queue.JobStatus) color.Color {
|
||||
switch status {
|
||||
case queue.JobStatusPending:
|
||||
return color.RGBA{R: 150, G: 150, B: 150, A: 255} // Gray
|
||||
case queue.JobStatusRunning:
|
||||
return color.RGBA{R: 68, G: 136, B: 255, A: 255} // Blue
|
||||
case queue.JobStatusPaused:
|
||||
return color.RGBA{R: 255, G: 193, B: 7, A: 255} // Yellow
|
||||
case queue.JobStatusCompleted:
|
||||
return color.RGBA{R: 76, G: 232, B: 112, A: 255} // Green
|
||||
case queue.JobStatusFailed:
|
||||
return color.RGBA{R: 255, G: 68, B: 68, A: 255} // Red
|
||||
case queue.JobStatusCancelled:
|
||||
return color.RGBA{R: 255, G: 136, B: 68, A: 255} // Orange
|
||||
default:
|
||||
return color.Gray{Y: 128}
|
||||
}
|
||||
}
|
||||
|
||||
// getStatusText returns a human-readable status string
|
||||
func getStatusText(job *queue.Job) string {
|
||||
switch job.Status {
|
||||
case queue.JobStatusPending:
|
||||
return fmt.Sprintf("Status: Pending | Priority: %d", job.Priority)
|
||||
case queue.JobStatusRunning:
|
||||
elapsed := ""
|
||||
if job.StartedAt != nil {
|
||||
elapsed = fmt.Sprintf(" | Elapsed: %s", time.Since(*job.StartedAt).Round(time.Second))
|
||||
}
|
||||
return fmt.Sprintf("Status: Running | Progress: %.1f%%%s", job.Progress, elapsed)
|
||||
case queue.JobStatusPaused:
|
||||
return "Status: Paused"
|
||||
case queue.JobStatusCompleted:
|
||||
duration := ""
|
||||
if job.StartedAt != nil && job.CompletedAt != nil {
|
||||
duration = fmt.Sprintf(" | Duration: %s", job.CompletedAt.Sub(*job.StartedAt).Round(time.Second))
|
||||
}
|
||||
return fmt.Sprintf("Status: Completed%s", duration)
|
||||
case queue.JobStatusFailed:
|
||||
return fmt.Sprintf("Status: Failed | Error: %s", job.Error)
|
||||
case queue.JobStatusCancelled:
|
||||
return "Status: Cancelled"
|
||||
default:
|
||||
return fmt.Sprintf("Status: %s", job.Status)
|
||||
}
|
||||
}
|
||||
576
main.go
576
main.go
|
|
@ -34,6 +34,7 @@ import (
|
|||
"git.leaktechnologies.dev/stu/VideoTools/internal/logging"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/modules"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/player"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/queue"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/ui"
|
||||
"git.leaktechnologies.dev/stu/VideoTools/internal/utils"
|
||||
"github.com/hajimehoshi/oto"
|
||||
|
|
@ -170,6 +171,7 @@ type appState struct {
|
|||
convertBusy bool
|
||||
convertStatus string
|
||||
playSess *playSession
|
||||
jobQueue *queue.Queue
|
||||
}
|
||||
|
||||
func (s *appState) stopPreview() {
|
||||
|
|
@ -303,10 +305,129 @@ func (s *appState) showMainMenu() {
|
|||
}
|
||||
|
||||
titleColor := utils.MustHex("#4CE870")
|
||||
menu := ui.BuildMainMenu(mods, s.showModule, s.handleModuleDrop, titleColor, queueColor, textColor)
|
||||
|
||||
// Get queue stats
|
||||
var queueCompleted, queueTotal int
|
||||
if s.jobQueue != nil {
|
||||
_, _, completed, _ := s.jobQueue.Stats()
|
||||
queueCompleted = completed
|
||||
queueTotal = len(s.jobQueue.List())
|
||||
}
|
||||
|
||||
menu := ui.BuildMainMenu(mods, s.showModule, s.handleModuleDrop, s.showQueue, titleColor, queueColor, textColor, queueCompleted, queueTotal)
|
||||
s.setContent(container.NewPadded(menu))
|
||||
}
|
||||
|
||||
func (s *appState) showQueue() {
|
||||
s.stopPreview()
|
||||
s.stopPlayer()
|
||||
s.active = "queue"
|
||||
|
||||
jobs := s.jobQueue.List()
|
||||
|
||||
view := ui.BuildQueueView(
|
||||
jobs,
|
||||
s.showMainMenu, // onBack
|
||||
func(id string) { // onPause
|
||||
if err := s.jobQueue.Pause(id); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to pause job: %v", err)
|
||||
}
|
||||
s.showQueue() // Refresh
|
||||
},
|
||||
func(id string) { // onResume
|
||||
if err := s.jobQueue.Resume(id); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to resume job: %v", err)
|
||||
}
|
||||
s.showQueue() // Refresh
|
||||
},
|
||||
func(id string) { // onCancel
|
||||
if err := s.jobQueue.Cancel(id); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to cancel job: %v", err)
|
||||
}
|
||||
s.showQueue() // Refresh
|
||||
},
|
||||
func(id string) { // onRemove
|
||||
if err := s.jobQueue.Remove(id); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to remove job: %v", err)
|
||||
}
|
||||
s.showQueue() // Refresh
|
||||
},
|
||||
func() { // onClear
|
||||
s.jobQueue.Clear()
|
||||
s.showQueue() // Refresh
|
||||
},
|
||||
utils.MustHex("#4CE870"), // titleColor
|
||||
gridColor, // bgColor
|
||||
textColor, // textColor
|
||||
)
|
||||
|
||||
s.setContent(container.NewPadded(view))
|
||||
}
|
||||
|
||||
// addConvertToQueue adds a conversion job to the queue
|
||||
func (s *appState) addConvertToQueue() error {
|
||||
if s.source == nil {
|
||||
return fmt.Errorf("no video loaded")
|
||||
}
|
||||
|
||||
src := s.source
|
||||
cfg := s.convert
|
||||
|
||||
outDir := filepath.Dir(src.Path)
|
||||
outName := cfg.OutputFile()
|
||||
if outName == "" {
|
||||
outName = "converted" + cfg.SelectedFormat.Ext
|
||||
}
|
||||
outPath := filepath.Join(outDir, outName)
|
||||
if outPath == src.Path {
|
||||
outPath = filepath.Join(outDir, "converted-"+outName)
|
||||
}
|
||||
|
||||
// Create job config map
|
||||
config := map[string]interface{}{
|
||||
"inputPath": src.Path,
|
||||
"outputPath": outPath,
|
||||
"outputBase": cfg.OutputBase,
|
||||
"selectedFormat": cfg.SelectedFormat,
|
||||
"quality": cfg.Quality,
|
||||
"mode": cfg.Mode,
|
||||
"videoCodec": cfg.VideoCodec,
|
||||
"encoderPreset": cfg.EncoderPreset,
|
||||
"crf": cfg.CRF,
|
||||
"bitrateMode": cfg.BitrateMode,
|
||||
"videoBitrate": cfg.VideoBitrate,
|
||||
"targetResolution": cfg.TargetResolution,
|
||||
"frameRate": cfg.FrameRate,
|
||||
"pixelFormat": cfg.PixelFormat,
|
||||
"hardwareAccel": cfg.HardwareAccel,
|
||||
"twoPass": cfg.TwoPass,
|
||||
"audioCodec": cfg.AudioCodec,
|
||||
"audioBitrate": cfg.AudioBitrate,
|
||||
"audioChannels": cfg.AudioChannels,
|
||||
"inverseTelecine": cfg.InverseTelecine,
|
||||
"coverArtPath": cfg.CoverArtPath,
|
||||
"aspectHandling": cfg.AspectHandling,
|
||||
"outputAspect": cfg.OutputAspect,
|
||||
"sourceWidth": src.Width,
|
||||
"sourceHeight": src.Height,
|
||||
}
|
||||
|
||||
job := &queue.Job{
|
||||
Type: queue.JobTypeConvert,
|
||||
Title: fmt.Sprintf("Convert %s", filepath.Base(src.Path)),
|
||||
Description: fmt.Sprintf("Output: %s → %s", filepath.Base(src.Path), filepath.Base(outPath)),
|
||||
InputFile: src.Path,
|
||||
OutputFile: outPath,
|
||||
Config: config,
|
||||
Priority: 0,
|
||||
}
|
||||
|
||||
s.jobQueue.Add(job)
|
||||
logging.Debug(logging.CatSystem, "added convert job to queue: %s", job.ID)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *appState) showModule(id string) {
|
||||
switch id {
|
||||
case "convert":
|
||||
|
|
@ -322,7 +443,9 @@ func (s *appState) handleModuleDrop(moduleID string, items []fyne.URI) {
|
|||
logging.Debug(logging.CatModule, "handleModuleDrop: no items to process")
|
||||
return
|
||||
}
|
||||
// Load the first video file
|
||||
|
||||
// Collect all video files (including from folders)
|
||||
var videoPaths []string
|
||||
for _, uri := range items {
|
||||
logging.Debug(logging.CatModule, "handleModuleDrop: processing uri scheme=%s path=%s", uri.Scheme(), uri.Path())
|
||||
if uri.Scheme() != "file" {
|
||||
|
|
@ -330,20 +453,149 @@ func (s *appState) handleModuleDrop(moduleID string, items []fyne.URI) {
|
|||
continue
|
||||
}
|
||||
path := uri.Path()
|
||||
logging.Debug(logging.CatModule, "drop on module %s path=%s - starting load", moduleID, path)
|
||||
|
||||
// Load video and switch to the module
|
||||
go func() {
|
||||
logging.Debug(logging.CatModule, "loading video in goroutine")
|
||||
s.loadVideo(path)
|
||||
// After loading, switch to the module
|
||||
fyne.CurrentApp().Driver().DoFromGoroutine(func() {
|
||||
logging.Debug(logging.CatModule, "showing module %s after load", moduleID)
|
||||
s.showModule(moduleID)
|
||||
}, false)
|
||||
}()
|
||||
break
|
||||
// Check if it's a directory
|
||||
if info, err := os.Stat(path); err == nil && info.IsDir() {
|
||||
logging.Debug(logging.CatModule, "processing directory: %s", path)
|
||||
videos := s.findVideoFiles(path)
|
||||
videoPaths = append(videoPaths, videos...)
|
||||
} else if s.isVideoFile(path) {
|
||||
videoPaths = append(videoPaths, path)
|
||||
}
|
||||
}
|
||||
|
||||
logging.Debug(logging.CatModule, "found %d video files to process", len(videoPaths))
|
||||
|
||||
if len(videoPaths) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
// If convert module and multiple files, add all to queue
|
||||
if moduleID == "convert" && len(videoPaths) > 1 {
|
||||
go s.batchAddToQueue(videoPaths)
|
||||
return
|
||||
}
|
||||
|
||||
// Single file or non-convert module: load first video and show module
|
||||
path := videoPaths[0]
|
||||
logging.Debug(logging.CatModule, "drop on module %s path=%s - starting load", moduleID, path)
|
||||
|
||||
go func() {
|
||||
logging.Debug(logging.CatModule, "loading video in goroutine")
|
||||
s.loadVideo(path)
|
||||
// After loading, switch to the module
|
||||
fyne.CurrentApp().Driver().DoFromGoroutine(func() {
|
||||
logging.Debug(logging.CatModule, "showing module %s after load", moduleID)
|
||||
s.showModule(moduleID)
|
||||
}, false)
|
||||
}()
|
||||
}
|
||||
|
||||
// isVideoFile checks if a file has a video extension
|
||||
func (s *appState) isVideoFile(path string) bool {
|
||||
ext := strings.ToLower(filepath.Ext(path))
|
||||
videoExts := []string{".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v", ".mpg", ".mpeg", ".3gp", ".ogv"}
|
||||
for _, videoExt := range videoExts {
|
||||
if ext == videoExt {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// findVideoFiles recursively finds all video files in a directory
|
||||
func (s *appState) findVideoFiles(dir string) []string {
|
||||
var videos []string
|
||||
|
||||
err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return nil // Skip errors
|
||||
}
|
||||
if !info.IsDir() && s.isVideoFile(path) {
|
||||
videos = append(videos, path)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
logging.Debug(logging.CatModule, "error walking directory %s: %v", dir, err)
|
||||
}
|
||||
|
||||
return videos
|
||||
}
|
||||
|
||||
// batchAddToQueue adds multiple videos to the queue
|
||||
func (s *appState) batchAddToQueue(paths []string) {
|
||||
logging.Debug(logging.CatModule, "batch adding %d videos to queue", len(paths))
|
||||
|
||||
addedCount := 0
|
||||
for _, path := range paths {
|
||||
// Load video metadata
|
||||
src, err := probeVideo(path)
|
||||
if err != nil {
|
||||
logging.Debug(logging.CatModule, "failed to parse metadata for %s: %v", path, err)
|
||||
continue
|
||||
}
|
||||
|
||||
// Create job config
|
||||
outDir := filepath.Dir(path)
|
||||
baseName := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
|
||||
outName := baseName + "-converted" + s.convert.SelectedFormat.Ext
|
||||
outPath := filepath.Join(outDir, outName)
|
||||
|
||||
config := map[string]interface{}{
|
||||
"inputPath": path,
|
||||
"outputPath": outPath,
|
||||
"outputBase": baseName + "-converted",
|
||||
"selectedFormat": s.convert.SelectedFormat,
|
||||
"quality": s.convert.Quality,
|
||||
"mode": s.convert.Mode,
|
||||
"videoCodec": s.convert.VideoCodec,
|
||||
"encoderPreset": s.convert.EncoderPreset,
|
||||
"crf": s.convert.CRF,
|
||||
"bitrateMode": s.convert.BitrateMode,
|
||||
"videoBitrate": s.convert.VideoBitrate,
|
||||
"targetResolution": s.convert.TargetResolution,
|
||||
"frameRate": s.convert.FrameRate,
|
||||
"pixelFormat": s.convert.PixelFormat,
|
||||
"hardwareAccel": s.convert.HardwareAccel,
|
||||
"twoPass": s.convert.TwoPass,
|
||||
"audioCodec": s.convert.AudioCodec,
|
||||
"audioBitrate": s.convert.AudioBitrate,
|
||||
"audioChannels": s.convert.AudioChannels,
|
||||
"inverseTelecine": s.convert.InverseTelecine,
|
||||
"coverArtPath": "",
|
||||
"aspectHandling": s.convert.AspectHandling,
|
||||
"outputAspect": s.convert.OutputAspect,
|
||||
"sourceWidth": src.Width,
|
||||
"sourceHeight": src.Height,
|
||||
}
|
||||
|
||||
job := &queue.Job{
|
||||
Type: queue.JobTypeConvert,
|
||||
Title: fmt.Sprintf("Convert %s", filepath.Base(path)),
|
||||
Description: fmt.Sprintf("Output: %s → %s", filepath.Base(path), filepath.Base(outPath)),
|
||||
InputFile: path,
|
||||
OutputFile: outPath,
|
||||
Config: config,
|
||||
Priority: 0,
|
||||
}
|
||||
|
||||
s.jobQueue.Add(job)
|
||||
addedCount++
|
||||
}
|
||||
|
||||
// Show confirmation dialog
|
||||
fyne.CurrentApp().Driver().DoFromGoroutine(func() {
|
||||
msg := fmt.Sprintf("Added %d video(s) to the queue!", addedCount)
|
||||
dialog.ShowInformation("Batch Add", msg, s.window)
|
||||
|
||||
// Load the first video so user can adjust settings if needed
|
||||
if len(paths) > 0 {
|
||||
s.loadVideo(paths[0])
|
||||
s.showModule("convert")
|
||||
}
|
||||
}, false)
|
||||
}
|
||||
|
||||
func (s *appState) showConvertView(file *videoSource) {
|
||||
|
|
@ -360,7 +612,258 @@ func (s *appState) showConvertView(file *videoSource) {
|
|||
s.setContent(buildConvertView(s, s.source))
|
||||
}
|
||||
|
||||
// jobExecutor executes a job from the queue
|
||||
func (s *appState) jobExecutor(ctx context.Context, job *queue.Job, progressCallback func(float64)) error {
|
||||
logging.Debug(logging.CatSystem, "executing job %s: %s", job.ID, job.Title)
|
||||
|
||||
switch job.Type {
|
||||
case queue.JobTypeConvert:
|
||||
return s.executeConvertJob(ctx, job, progressCallback)
|
||||
case queue.JobTypeMerge:
|
||||
return fmt.Errorf("merge jobs not yet implemented")
|
||||
case queue.JobTypeTrim:
|
||||
return fmt.Errorf("trim jobs not yet implemented")
|
||||
case queue.JobTypeFilter:
|
||||
return fmt.Errorf("filter jobs not yet implemented")
|
||||
case queue.JobTypeUpscale:
|
||||
return fmt.Errorf("upscale jobs not yet implemented")
|
||||
case queue.JobTypeAudio:
|
||||
return fmt.Errorf("audio jobs not yet implemented")
|
||||
case queue.JobTypeThumb:
|
||||
return fmt.Errorf("thumb jobs not yet implemented")
|
||||
default:
|
||||
return fmt.Errorf("unknown job type: %s", job.Type)
|
||||
}
|
||||
}
|
||||
|
||||
// executeConvertJob executes a conversion job from the queue
|
||||
func (s *appState) executeConvertJob(ctx context.Context, job *queue.Job, progressCallback func(float64)) error {
|
||||
cfg := job.Config
|
||||
inputPath := cfg["inputPath"].(string)
|
||||
outputPath := cfg["outputPath"].(string)
|
||||
|
||||
// Build FFmpeg arguments
|
||||
args := []string{
|
||||
"-y",
|
||||
"-hide_banner",
|
||||
"-loglevel", "error",
|
||||
"-i", inputPath,
|
||||
}
|
||||
|
||||
// Add cover art if available
|
||||
coverArtPath, _ := cfg["coverArtPath"].(string)
|
||||
hasCoverArt := coverArtPath != ""
|
||||
if hasCoverArt {
|
||||
args = append(args, "-i", coverArtPath)
|
||||
}
|
||||
|
||||
// Hardware acceleration
|
||||
hardwareAccel, _ := cfg["hardwareAccel"].(string)
|
||||
if hardwareAccel != "none" && hardwareAccel != "" {
|
||||
switch hardwareAccel {
|
||||
case "nvenc":
|
||||
args = append(args, "-hwaccel", "cuda")
|
||||
case "vaapi":
|
||||
args = append(args, "-hwaccel", "vaapi")
|
||||
case "qsv":
|
||||
args = append(args, "-hwaccel", "qsv")
|
||||
case "videotoolbox":
|
||||
args = append(args, "-hwaccel", "videotoolbox")
|
||||
}
|
||||
}
|
||||
|
||||
// Video filters
|
||||
var vf []string
|
||||
|
||||
// Deinterlacing
|
||||
if inverseTelecine, _ := cfg["inverseTelecine"].(bool); inverseTelecine {
|
||||
vf = append(vf, "yadif")
|
||||
}
|
||||
|
||||
// Scaling/Resolution
|
||||
targetResolution, _ := cfg["targetResolution"].(string)
|
||||
if targetResolution != "" && targetResolution != "Source" {
|
||||
var scaleFilter string
|
||||
switch targetResolution {
|
||||
case "720p":
|
||||
scaleFilter = "scale=-2:720"
|
||||
case "1080p":
|
||||
scaleFilter = "scale=-2:1080"
|
||||
case "1440p":
|
||||
scaleFilter = "scale=-2:1440"
|
||||
case "4K":
|
||||
scaleFilter = "scale=-2:2160"
|
||||
}
|
||||
if scaleFilter != "" {
|
||||
vf = append(vf, scaleFilter)
|
||||
}
|
||||
}
|
||||
|
||||
// Aspect ratio conversion
|
||||
sourceWidth, _ := cfg["sourceWidth"].(int)
|
||||
sourceHeight, _ := cfg["sourceHeight"].(int)
|
||||
srcAspect := utils.AspectRatioFloat(sourceWidth, sourceHeight)
|
||||
outputAspect, _ := cfg["outputAspect"].(string)
|
||||
aspectHandling, _ := cfg["aspectHandling"].(string)
|
||||
|
||||
// Create temp source for aspect calculation
|
||||
tempSrc := &videoSource{Width: sourceWidth, Height: sourceHeight}
|
||||
targetAspect := resolveTargetAspect(outputAspect, tempSrc)
|
||||
if targetAspect > 0 && srcAspect > 0 && !utils.RatiosApproxEqual(targetAspect, srcAspect, 0.01) {
|
||||
vf = append(vf, aspectFilters(targetAspect, aspectHandling)...)
|
||||
}
|
||||
|
||||
// Frame rate
|
||||
frameRate, _ := cfg["frameRate"].(string)
|
||||
if frameRate != "" && frameRate != "Source" {
|
||||
vf = append(vf, "fps="+frameRate)
|
||||
}
|
||||
|
||||
if len(vf) > 0 {
|
||||
args = append(args, "-vf", strings.Join(vf, ","))
|
||||
}
|
||||
|
||||
// Video codec
|
||||
videoCodec, _ := cfg["videoCodec"].(string)
|
||||
if videoCodec == "Copy" {
|
||||
args = append(args, "-c:v", "copy")
|
||||
} else {
|
||||
// Determine the actual codec to use
|
||||
actualCodec := determineVideoCodec(convertConfig{
|
||||
VideoCodec: videoCodec,
|
||||
HardwareAccel: hardwareAccel,
|
||||
})
|
||||
args = append(args, "-c:v", actualCodec)
|
||||
|
||||
// Bitrate mode and quality
|
||||
bitrateMode, _ := cfg["bitrateMode"].(string)
|
||||
if bitrateMode == "CRF" || bitrateMode == "" {
|
||||
crfStr, _ := cfg["crf"].(string)
|
||||
if crfStr == "" {
|
||||
quality, _ := cfg["quality"].(string)
|
||||
crfStr = crfForQuality(quality)
|
||||
}
|
||||
if actualCodec == "libx264" || actualCodec == "libx265" || actualCodec == "libvpx-vp9" {
|
||||
args = append(args, "-crf", crfStr)
|
||||
}
|
||||
} else if bitrateMode == "CBR" {
|
||||
if videoBitrate, _ := cfg["videoBitrate"].(string); videoBitrate != "" {
|
||||
args = append(args, "-b:v", videoBitrate, "-minrate", videoBitrate, "-maxrate", videoBitrate, "-bufsize", videoBitrate)
|
||||
}
|
||||
} else if bitrateMode == "VBR" {
|
||||
if videoBitrate, _ := cfg["videoBitrate"].(string); videoBitrate != "" {
|
||||
args = append(args, "-b:v", videoBitrate)
|
||||
}
|
||||
}
|
||||
|
||||
// Encoder preset
|
||||
if encoderPreset, _ := cfg["encoderPreset"].(string); encoderPreset != "" && (actualCodec == "libx264" || actualCodec == "libx265") {
|
||||
args = append(args, "-preset", encoderPreset)
|
||||
}
|
||||
|
||||
// Pixel format
|
||||
if pixelFormat, _ := cfg["pixelFormat"].(string); pixelFormat != "" {
|
||||
args = append(args, "-pix_fmt", pixelFormat)
|
||||
}
|
||||
}
|
||||
|
||||
// Audio codec and settings
|
||||
audioCodec, _ := cfg["audioCodec"].(string)
|
||||
if audioCodec == "Copy" {
|
||||
args = append(args, "-c:a", "copy")
|
||||
} else {
|
||||
actualAudioCodec := determineAudioCodec(convertConfig{AudioCodec: audioCodec})
|
||||
args = append(args, "-c:a", actualAudioCodec)
|
||||
|
||||
if audioBitrate, _ := cfg["audioBitrate"].(string); audioBitrate != "" && actualAudioCodec != "flac" {
|
||||
args = append(args, "-b:a", audioBitrate)
|
||||
}
|
||||
|
||||
if audioChannels, _ := cfg["audioChannels"].(string); audioChannels != "" && audioChannels != "Source" {
|
||||
switch audioChannels {
|
||||
case "Mono":
|
||||
args = append(args, "-ac", "1")
|
||||
case "Stereo":
|
||||
args = append(args, "-ac", "2")
|
||||
case "5.1":
|
||||
args = append(args, "-ac", "6")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Map cover art
|
||||
if hasCoverArt {
|
||||
args = append(args, "-map", "0:v", "-map", "0:a?", "-map", "1:v")
|
||||
args = append(args, "-c:v:1", "png")
|
||||
args = append(args, "-disposition:v:1", "attached_pic")
|
||||
}
|
||||
|
||||
// Format-specific settings
|
||||
selectedFormat := cfg["selectedFormat"].(formatOption)
|
||||
if strings.EqualFold(selectedFormat.Ext, ".mp4") || strings.EqualFold(selectedFormat.Ext, ".mov") {
|
||||
args = append(args, "-movflags", "+faststart")
|
||||
}
|
||||
|
||||
// Progress feed
|
||||
args = append(args, "-progress", "pipe:1", "-nostats")
|
||||
args = append(args, outputPath)
|
||||
|
||||
logging.Debug(logging.CatFFMPEG, "queue convert command: ffmpeg %s", strings.Join(args, " "))
|
||||
|
||||
// Execute FFmpeg
|
||||
cmd := exec.CommandContext(ctx, "ffmpeg", args...)
|
||||
stdout, err := cmd.StdoutPipe()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to create stdout pipe: %w", err)
|
||||
}
|
||||
|
||||
if err := cmd.Start(); err != nil {
|
||||
return fmt.Errorf("failed to start ffmpeg: %w", err)
|
||||
}
|
||||
|
||||
// Parse progress
|
||||
scanner := bufio.NewScanner(stdout)
|
||||
var duration float64
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
if strings.HasPrefix(line, "out_time_ms=") {
|
||||
val := strings.TrimPrefix(line, "out_time_ms=")
|
||||
if ms, err := strconv.ParseInt(val, 10, 64); err == nil && ms > 0 {
|
||||
currentSec := float64(ms) / 1000000.0
|
||||
if duration > 0 {
|
||||
progress := (currentSec / duration) * 100.0
|
||||
if progress > 100 {
|
||||
progress = 100
|
||||
}
|
||||
progressCallback(progress)
|
||||
}
|
||||
}
|
||||
} else if strings.HasPrefix(line, "duration_ms=") {
|
||||
val := strings.TrimPrefix(line, "duration_ms=")
|
||||
if ms, err := strconv.ParseInt(val, 10, 64); err == nil && ms > 0 {
|
||||
duration = float64(ms) / 1000000.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if err := cmd.Wait(); err != nil {
|
||||
return fmt.Errorf("ffmpeg failed: %w", err)
|
||||
}
|
||||
|
||||
logging.Debug(logging.CatFFMPEG, "queue conversion completed: %s", outputPath)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *appState) shutdown() {
|
||||
// Save queue before shutting down
|
||||
if s.jobQueue != nil {
|
||||
s.jobQueue.Stop()
|
||||
queuePath := filepath.Join(os.TempDir(), "videotools-queue.json")
|
||||
if err := s.jobQueue.Save(queuePath); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to save queue: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
s.stopPlayer()
|
||||
if s.player != nil {
|
||||
s.player.Close()
|
||||
|
|
@ -462,6 +965,25 @@ func runGUI() {
|
|||
playerMuted: false,
|
||||
playerPaused: true,
|
||||
}
|
||||
|
||||
// Initialize job queue
|
||||
state.jobQueue = queue.New(state.jobExecutor)
|
||||
state.jobQueue.SetChangeCallback(func() {
|
||||
// Refresh UI when queue changes
|
||||
if state.active == "" {
|
||||
state.showMainMenu()
|
||||
}
|
||||
})
|
||||
|
||||
// Load saved queue
|
||||
queuePath := filepath.Join(os.TempDir(), "videotools-queue.json")
|
||||
if err := state.jobQueue.Load(queuePath); err != nil {
|
||||
logging.Debug(logging.CatSystem, "failed to load queue: %v", err)
|
||||
}
|
||||
|
||||
// Start queue processing
|
||||
state.jobQueue.Start()
|
||||
|
||||
defer state.shutdown()
|
||||
w.SetOnDropped(func(pos fyne.Position, items []fyne.URI) {
|
||||
state.handleDrop(pos, items)
|
||||
|
|
@ -603,7 +1125,13 @@ func buildConvertView(state *appState, src *videoSource) fyne.CanvasObject {
|
|||
state.showMainMenu()
|
||||
})
|
||||
back.Importance = widget.LowImportance
|
||||
backBar := ui.TintedBar(convertColor, container.NewHBox(back, layout.NewSpacer()))
|
||||
|
||||
// Queue button to view queue
|
||||
queueBtn := widget.NewButton("View Queue", func() {
|
||||
state.showQueue()
|
||||
})
|
||||
|
||||
backBar := ui.TintedBar(convertColor, container.NewHBox(back, layout.NewSpacer(), queueBtn))
|
||||
|
||||
var updateCover func(string)
|
||||
var coverDisplay *widget.Label
|
||||
|
|
@ -975,7 +1503,20 @@ func buildConvertView(state *appState, src *videoSource) fyne.CanvasObject {
|
|||
})
|
||||
cancelBtn.Importance = widget.DangerImportance
|
||||
cancelBtn.Disable()
|
||||
convertBtn = widget.NewButton("CONVERT", func() {
|
||||
|
||||
// Add to Queue button
|
||||
addQueueBtn := widget.NewButton("Add to Queue", func() {
|
||||
if err := state.addConvertToQueue(); err != nil {
|
||||
dialog.ShowError(err, state.window)
|
||||
} else {
|
||||
dialog.ShowInformation("Queue", "Job added to queue!", state.window)
|
||||
}
|
||||
})
|
||||
if src == nil {
|
||||
addQueueBtn.Disable()
|
||||
}
|
||||
|
||||
convertBtn = widget.NewButton("CONVERT NOW", func() {
|
||||
state.startConvert(statusLabel, convertBtn, cancelBtn, activity)
|
||||
})
|
||||
convertBtn.Importance = widget.HighImportance
|
||||
|
|
@ -985,9 +1526,10 @@ func buildConvertView(state *appState, src *videoSource) fyne.CanvasObject {
|
|||
if state.convertBusy {
|
||||
convertBtn.Disable()
|
||||
cancelBtn.Enable()
|
||||
addQueueBtn.Disable()
|
||||
}
|
||||
|
||||
actionInner := container.NewHBox(resetBtn, activity, statusLabel, layout.NewSpacer(), cancelBtn, convertBtn)
|
||||
actionInner := container.NewHBox(resetBtn, activity, statusLabel, layout.NewSpacer(), cancelBtn, addQueueBtn, convertBtn)
|
||||
actionBar := ui.TintedBar(convertColor, actionInner)
|
||||
|
||||
// Wrap mainArea in a scroll container to prevent content from forcing window resize
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user