-
Notifications
You must be signed in to change notification settings - Fork 0
/
videoGenerator.go
113 lines (100 loc) · 2.73 KB
/
videoGenerator.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package main
import (
"errors"
"fmt"
fluentffmpeg "github.com/modfy/fluent-ffmpeg"
"io"
"os"
"os/exec"
"path/filepath"
"strconv"
)
type Clip struct {
videosPath []string
concatListCache string
}
func editVideo(videoList []map[string]interface{}) {
fmt.Println("generating")
var videos []string
var videoPath string
var convetedVideoPath string
for _, element := range videoList {
var name = element["filename"].(string)
videoLength := 15 * 30
videoPath = folderName + "/" + name + ".mp4"
convetedVideoPath = folderName + "/" + name + " converted " + strconv.Itoa(videoLength) + ".mp4"
if _, err := os.Stat(convetedVideoPath); os.IsNotExist(err) {
fmt.Println("converting:" + name)
_ = fluentffmpeg.NewCommand("").
InputPath(videoPath).
OutputFormat("mp4").
OutputPath(convetedVideoPath).VideoCodec("libx264").Preset("ultrafast").FrameRate(30).Resolution("1920x1080").VFrames(videoLength).
Overwrite(true).Run()
fmt.Println("converted:" + name)
} else {
fmt.Println("already converted")
}
videos = append(videos, convetedVideoPath)
}
fmt.Println(videos)
clip, _ := NewClip(videos)
clip.Concatenate(resVideoName)
}
func NewClip(videoPath []string) (*Clip, error) {
var clip Clip
for _, path := range videoPath {
if _, err := os.Stat(path); err != nil {
return nil, errors.New("unable to load file: " + err.Error())
}
}
dir := filepath.Dir(videoPath[0])
clip = Clip{videosPath: videoPath, concatListCache: filepath.Join(dir, "concat.txt")}
return &clip, nil
}
func (c *Clip) saveConcatenateList() error {
var maxLengthPerVideo = "outpoint 15"
f, err := os.Create(c.concatListCache)
if err != nil {
return err
}
defer f.Close()
for _, video := range c.videosPath {
fmt.Fprintf(f, "file '%s'\n%s\n", filepath.Base(video), maxLengthPerVideo)
}
return nil
}
func (c *Clip) Concatenate(output string) error {
return c.ConcatenateWithStreams(output, nil, nil)
}
func (c *Clip) ConcatenateWithStreams(output string, os io.Writer, es io.Writer) error {
c.saveConcatenateList()
//defer c.deleteConcatenateList()
line := c.CommandLine(output)
fmt.Println(line)
cmd := exec.Command(line[0], line[1:]...)
cmd.Stderr = es
cmd.Stdout = os
err := cmd.Run()
if err != nil {
return errors.New("cinema.Video.Concatenate: ffmpeg failed: " + err.Error())
}
return nil
}
func (c *Clip) deleteConcatenateList() error {
if err := os.Remove(c.concatListCache); err != nil {
return err
}
return nil
}
func (c *Clip) CommandLine(output string) []string {
cmdline := []string{
"ffmpeg",
"-y",
"-f", "concat",
"-safe", "0",
"-i", c.concatListCache,
"-c", "copy",
}
cmdline = append(cmdline, "-fflags", "+genpts", filepath.Join(filepath.Dir(c.videosPath[0]), output))
return cmdline
}