softworkz
commented
8 months ago Explanations
"Unknown Fields
The two fields you get from FFmpeg and where you had questionmarks are ReadOrder and Layer.
Layer is the original value from the ASS content.
ReadOrder is a counter which increases strict monotonically and indicates the original order of dialogue lines. libass takes this as an input when the subtitle events are provided subsequently. While the ASS spec doc says that the order of dialog lines doesn't matter, this isn't quite true. One example is that when two lines have the start time, then it surely matters which of the lines came first in the order. This can affect the stacking order of multiple unpositioned elements or the z-order of positioned and overlapping elements. There's at least one more case which I don't remember right now, probably more.
For a correct implementation, it would be required to put incoming events into an ordered map or something and then process them in the right order, this would also allow to prevent processing duplicated events. But maybe this isn't needed here. It seems that you are getting and processing all ASS lines from all subtitle streams even before playback start, right? Is that in all cases? If yes, then there's probably no need to care about the ReadOrder field.
Layer
The Layer field is in fact important for two reasons:
- Stacking/Collision handling must not happen when elements are on separate layers
- The Layer number also specifies the Z-Order for rendering the content of a layer
This PR addresses both
- It sets the ZIndex of a TimedTextRegion to the Layer number (as simple as that 😉 )
- It doesn't re-use regions for content on different layers
Stacking of Text Blocks
I recently asked why elements are overlapping and I could not find any documentation how this is handled and can be controlled. Eventually I figured it out myself: It depends on the TimedTextRegion. Only text elements in the same region are stacked, otherwise they are rendered on top of each other and can overlap. The reason why stacking has been somewhat working before, is that the style parsing was often failing (shadow width is not an integer) and that caused the default style's region to be used in many cases: Same region => Stacking After this was fixed, the styles were applied correctly and that means that elements having different styles were no longer stacked (because each style has its own region).
The problem here for us is this: ASS performs collision detection among all elements which are not absolutely positioned and which are on the same layer, while it allows the elements to have different alignments and different margins.
=> We cannot replicate this. We can set margins (in form of TimedTextPadding) only per region when we use separate regions, we don't get stacking
The only solution for this would be to implement a manual collision handling and I'm not ready for this. It costs a large amount of time to get this right which I don't have. Hence, I could only come up with an approximate approach, which is fine in most cases:
The TimedTextRegions are being put into a cache now. If a region is required with the exact same parameters as a cached region, then the cached region is used. Otherwise A new region is added to the cache and used.
This also reduces resource usage and flickering (in those cases where subs are animated and changes happen at a high frequency).
The subRegion variable in this PR is always copied from the style now. All manipulations are still applied to it, but it only serves as a prototype for the region parameters, while the actual region is retrieved from the region cache at the end.
lukasf
SubtitleProviderSsaAss: Parse layer SubtitleProviderSsaAss: Cache regions