314 lines
9.4 KiB
Go
314 lines
9.4 KiB
Go
package ass
|
|
|
|
import (
|
|
"fmt"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/ass/line"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/ass/tag"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/settings"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/types"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/types/math"
|
|
"git.gammaspectra.live/WeebDataHoarder/swf2ass-go/types/shapes"
|
|
"github.com/ctessum/polyclip-go"
|
|
"runtime"
|
|
"slices"
|
|
"strconv"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
type Renderer struct {
|
|
Header []string
|
|
RunningBuffer []*line.EventLine
|
|
Display shapes.Rectangle[float64]
|
|
|
|
Statistics map[uint16]rendererStatsEntry
|
|
}
|
|
|
|
func NewRenderer(title string, frameRate float64, display shapes.Rectangle[float64]) *Renderer {
|
|
width := int64(display.Width() * settings.GlobalSettings.VideoScaleMultiplier)
|
|
height := int64(display.Height() * settings.GlobalSettings.VideoScaleMultiplier)
|
|
|
|
ar := float64(width) / float64(height)
|
|
|
|
frameRate *= settings.GlobalSettings.VideoRateMultiplier
|
|
|
|
return &Renderer{
|
|
Statistics: make(map[uint16]rendererStatsEntry),
|
|
Display: display,
|
|
Header: []string{
|
|
"[Script Info]",
|
|
"; Script generated by swf2ass Renderer",
|
|
"; https://git.gammaspectra.live/WeebDataHoarder/swf2ass-go",
|
|
fmt.Sprintf("Title: %s", title),
|
|
"ScriptType: v4.00+",
|
|
//TODO: WrapStyle: 0 or 2?
|
|
"WrapStyle: 2",
|
|
"ScaledBorderAndShadow: yes",
|
|
"YCbCr Matrix: PC.709",
|
|
fmt.Sprintf("PlayResX: %d", width),
|
|
fmt.Sprintf("PlayResY: %d", height),
|
|
fmt.Sprintf("LayoutResX: %d", width),
|
|
fmt.Sprintf("LayoutResY: %d", height),
|
|
"",
|
|
"",
|
|
"[Aegisub Project Garbage]",
|
|
"Last Style Storage: f",
|
|
fmt.Sprintf("Video File: ?dummy:%s:10000:%d:%d:160:160:160:c", strconv.FormatFloat(frameRate, 'f', -1, 64), width, height),
|
|
fmt.Sprintf("Video AR Value: %s", strconv.FormatFloat(ar, 'f', -1, 64)),
|
|
"Active Line: 0",
|
|
"Video Zoom Percent: 2.000000",
|
|
"",
|
|
"[V4+ Styles]",
|
|
"Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
|
|
fmt.Sprintf("Style: %s,Arial,20,&H00000000,&H00000000,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1", line.StyleFill),
|
|
fmt.Sprintf("Style: %s,Arial,20,&H00000000,&H00000000,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,0,0,7,0,0,0,1", line.StyleLine),
|
|
"",
|
|
"[Events]",
|
|
"Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
|
|
},
|
|
}
|
|
}
|
|
func (r *Renderer) RenderFrame(frameInfo types.FrameInformation, frame types.RenderedFrame, keyframeInterval, flushInterval, flushCountLimit int) (result []string) {
|
|
if len(r.Header) != 0 {
|
|
result = append(result, r.Header...)
|
|
r.Header = nil
|
|
}
|
|
|
|
slices.SortStableFunc(frame, RenderedObjectDepthSort)
|
|
|
|
var linesKeptOrTransitioned []*line.EventLine
|
|
var linesNotTransitioned []*line.EventLine
|
|
|
|
scale := math.ScaleTransform(math.NewVector2(settings.GlobalSettings.VideoScaleMultiplier, settings.GlobalSettings.VideoScaleMultiplier))
|
|
|
|
animated := 0
|
|
|
|
viewPortClip := shapes.NewClipPath(r.Display.Draw()).ApplyMatrixTransform(scale, true)
|
|
|
|
for _, object := range frame {
|
|
obEntry := *BakeRenderedObjectsFillables(object)
|
|
object = &obEntry
|
|
|
|
if _, ok := r.Statistics[object.ObjectId]; !ok {
|
|
r.Statistics[object.ObjectId] = rendererStatsEntry{
|
|
Frames: &atomic.Uint64{},
|
|
Lines: &atomic.Uint64{},
|
|
Size: &atomic.Uint64{},
|
|
}
|
|
}
|
|
|
|
object.MatrixTransform = scale.Multiply(object.MatrixTransform) //TODO: order?
|
|
if object.Clip != nil {
|
|
//apply scale, then clip to viewPort
|
|
newClip := object.Clip.ApplyMatrixTransform(scale, true)
|
|
newClipIntersected := newClip.Intersect(viewPortClip)
|
|
if len(newClipIntersected.Clip.Pol) == 0 {
|
|
//shape clip does not intersect with viewport! we can safely drop this
|
|
continue
|
|
}
|
|
diffPol := viewPortClip.Clip.Pol.Construct(polyclip.DIFFERENCE, newClipIntersected.Clip.Pol)
|
|
if len(diffPol) == 0 {
|
|
//omit viewport that is exactly the display area
|
|
object.Clip = nil
|
|
} else {
|
|
object.Clip = newClipIntersected
|
|
}
|
|
}
|
|
|
|
depth := object.GetDepth()
|
|
|
|
var tagsToTransition []*line.EventLine
|
|
|
|
for i := len(r.RunningBuffer) - 1; i >= 0; i-- {
|
|
tag := r.RunningBuffer[i]
|
|
if depth.Equals(tag.Layer) && object.ObjectId == tag.ObjectId && (keyframeInterval == 0 || tag.GetDuration() < int64(keyframeInterval)) {
|
|
tagsToTransition = append(tagsToTransition, tag)
|
|
r.RunningBuffer = slices.Delete(r.RunningBuffer, i, i+1)
|
|
}
|
|
}
|
|
slices.Reverse(tagsToTransition)
|
|
|
|
canTransition := true
|
|
var transitionedTags []*line.EventLine
|
|
|
|
for _, tag := range tagsToTransition {
|
|
tag = tag.Transition(frameInfo, object)
|
|
if tag != nil {
|
|
transitionedTags = append(transitionedTags, tag)
|
|
tag.DropCache()
|
|
} else {
|
|
canTransition = false
|
|
break
|
|
}
|
|
}
|
|
|
|
r.Statistics[object.ObjectId].Frames.Add(1)
|
|
|
|
if canTransition && len(transitionedTags) > 0 {
|
|
animated += len(transitionedTags)
|
|
linesKeptOrTransitioned = append(linesKeptOrTransitioned, transitionedTags...)
|
|
} else {
|
|
linesNotTransitioned = append(linesNotTransitioned, tagsToTransition...)
|
|
|
|
for _, l := range line.EventLinesFromRenderObject(frameInfo, object, settings.GlobalSettings.ASSBakeMatrixTransforms) {
|
|
l.DropCache()
|
|
linesKeptOrTransitioned = append(linesKeptOrTransitioned, l)
|
|
}
|
|
}
|
|
}
|
|
|
|
//Flush tags that explicitly could not transition
|
|
result = append(result, r.flush(frameInfo, linesNotTransitioned)...)
|
|
|
|
var tagsToKeep []*line.EventLine
|
|
if flushInterval > 0 {
|
|
//loop things kept in buffer that could not transition, and see which must be flushed
|
|
|
|
for i := len(r.RunningBuffer) - 1; i >= 0; i-- {
|
|
eventLine := r.RunningBuffer[i]
|
|
// keep tag for further transitions, BUT try to hide it
|
|
if flushInterval == 0 || eventLine.GetSinceLastTransition() < int64(flushInterval) {
|
|
eventLine := eventLine.TransitionVisible(frameInfo, false)
|
|
if eventLine != nil {
|
|
//we can transition!
|
|
tagsToKeep = append(tagsToKeep, eventLine)
|
|
r.RunningBuffer = slices.Delete(r.RunningBuffer, i, i+1)
|
|
}
|
|
}
|
|
}
|
|
slices.Reverse(tagsToKeep)
|
|
|
|
if len(tagsToKeep) > flushCountLimit {
|
|
slices.SortFunc(tagsToKeep, func(a, b *line.EventLine) int {
|
|
return int(a.GetSinceLastTransition() - b.GetSinceLastTransition())
|
|
})
|
|
//append back tail of buffer
|
|
r.RunningBuffer = append(r.RunningBuffer, tagsToKeep[flushCountLimit:]...)
|
|
tagsToKeep = tagsToKeep[:flushCountLimit]
|
|
}
|
|
}
|
|
|
|
fmt.Printf("[ASS] Total %d objects, %d flush, %d buffer, %d kept, %d animated tags.\n", len(frame), len(r.RunningBuffer)+len(linesNotTransitioned), len(linesKeptOrTransitioned), len(tagsToKeep), animated)
|
|
|
|
linesKeptOrTransitioned = append(linesKeptOrTransitioned, tagsToKeep...)
|
|
|
|
//Flush non dupes on Running buffer
|
|
result = append(result, r.Flush(frameInfo)...)
|
|
r.RunningBuffer = linesKeptOrTransitioned
|
|
|
|
return result
|
|
}
|
|
|
|
func threadedRenderer(stats map[uint16]rendererStatsEntry, buf []*line.EventLine, duration time.Duration) []string {
|
|
if len(buf) == 0 {
|
|
return nil
|
|
}
|
|
results := make([]string, len(buf))
|
|
var cnt atomic.Uint64
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < min(len(buf), runtime.NumCPU()); i++ {
|
|
wg.Add(1)
|
|
go func(n int) {
|
|
defer wg.Done()
|
|
|
|
for {
|
|
i := cnt.Add(1) - 1
|
|
if i >= uint64(len(buf)) {
|
|
break
|
|
}
|
|
l := buf[i]
|
|
var hasColor bool
|
|
for _, t := range l.Tags {
|
|
if ct, ok := t.(tag.ColorTag); ok && ct.HasColor() {
|
|
hasColor = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !hasColor {
|
|
//skip lines without any color at all
|
|
continue
|
|
}
|
|
|
|
stats[l.ObjectId].Lines.Add(1)
|
|
|
|
l.Name += fmt.Sprintf(" f:%d>%d~%d", l.Start, l.LastTransition, l.LastTransition-l.Start+1)
|
|
l.DropCache()
|
|
encode := l.Encode(duration)
|
|
results[i] = encode
|
|
stats[l.ObjectId].Size.Add(uint64(len(encode)))
|
|
}
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
return results
|
|
}
|
|
|
|
func (r *Renderer) Flush(frameInfo types.FrameInformation) (result []string) {
|
|
result = r.flush(frameInfo, r.RunningBuffer)
|
|
r.RunningBuffer = r.RunningBuffer[:0]
|
|
return
|
|
}
|
|
|
|
func (r *Renderer) flush(frameInfo types.FrameInformation, buf []*line.EventLine) (result []string) {
|
|
return threadedRenderer(r.Statistics, buf, frameInfo.GetFrameDuration())
|
|
}
|
|
|
|
func BakeRenderedObjectsFillables(o *types.RenderedObject) *types.RenderedObject {
|
|
var baked bool
|
|
|
|
drawPathList := make(shapes.DrawPathList, 0, len(o.DrawPathList))
|
|
|
|
for _, command := range o.DrawPathList {
|
|
if fillStyleRecord, ok := command.Style.(*shapes.FillStyleRecord); ok && !fillStyleRecord.IsFlat() {
|
|
baked = true
|
|
flattened := fillStyleRecord.Flatten(command.Shape)
|
|
drawPathList = append(drawPathList, flattened...)
|
|
} else {
|
|
drawPathList = append(drawPathList, command)
|
|
}
|
|
}
|
|
|
|
if baked {
|
|
return &types.RenderedObject{
|
|
Depth: o.Depth,
|
|
ObjectId: o.ObjectId,
|
|
DrawPathList: drawPathList,
|
|
Clip: o.Clip,
|
|
ColorTransform: o.ColorTransform,
|
|
MatrixTransform: o.MatrixTransform,
|
|
}
|
|
} else {
|
|
return o
|
|
}
|
|
}
|
|
|
|
func RenderedObjectDepthSort(a, b *types.RenderedObject) int {
|
|
if len(b.Depth) > len(a.Depth) {
|
|
for i, depth := range b.Depth {
|
|
var otherDepth uint16
|
|
if i < len(a.Depth) {
|
|
otherDepth = a.Depth[i]
|
|
}
|
|
|
|
if depth != otherDepth {
|
|
return int(otherDepth) - int(depth)
|
|
}
|
|
}
|
|
} else {
|
|
for i, depth := range a.Depth {
|
|
var otherDepth uint16
|
|
if i < len(b.Depth) {
|
|
otherDepth = b.Depth[i]
|
|
}
|
|
|
|
if depth != otherDepth {
|
|
return int(depth) - int(otherDepth)
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|