Cutlery/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2025-07-09 03:04:24 -04:00
Code Issues Packages Projects Releases Wiki Activity

Better bitrate and resolution normalization (#12644)

Browse Source
This commit is contained in:
gnattu 2024-09-22 10:01:47 +08:00 committed by GitHub
parent c97c2217a5
commit 56cf1a581c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 51 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Jellyfin.Api/Helpers/StreamingHelpers.cs
View File

@ -219,11 +219,17 @@ public static class StreamingHelpers
}
else
{
var h264EquivalentBitrate = EncodingHelper.ScaleBitrate(
state.OutputVideoBitrate.Value,
state.ActualOutputVideoCodec,
"h264");
var resolution = ResolutionNormalizer.Normalize(
state.VideoStream?.BitRate,
state.OutputVideoBitrate.Value,
h264EquivalentBitrate,
state.VideoRequest.MaxWidth,
state.VideoRequest.MaxHeight);
state.VideoRequest.MaxHeight,
state.TargetFramerate);
state.VideoRequest.MaxWidth = resolution.MaxWidth;
state.VideoRequest.MaxHeight = resolution.MaxHeight;

8
MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
View File

@ -2400,7 +2400,7 @@ namespace MediaBrowser.Controller.MediaEncoding
return 1;
}
private static int ScaleBitrate(int bitrate, string inputVideoCodec, string outputVideoCodec)
public static int ScaleBitrate(int bitrate, string inputVideoCodec, string outputVideoCodec)
{
var inputScaleFactor = GetVideoBitrateScaleFactor(inputVideoCodec);
var outputScaleFactor = GetVideoBitrateScaleFactor(outputVideoCodec);
@ -2424,6 +2424,12 @@ namespace MediaBrowser.Controller.MediaEncoding
{
scaleFactor = Math.Max(scaleFactor, 2);
}
else if (bitrate >= 30000000)
{
// Don't scale beyond 30Mbps, it is hardly visually noticeable for most codecs with our prefer speed encoding
// and will cause extremely high bitrate to be used for av1->h264 transcoding that will overload clients and encoders
scaleFactor = 1;
}
return Convert.ToInt32(scaleFactor * bitrate);
}

63
MediaBrowser.Model/Dlna/ResolutionNormalizer.cs
View File

@ -2,28 +2,33 @@
#pragma warning disable CS1591
using System;
using System.Linq;
namespace MediaBrowser.Model.Dlna
{
public static class ResolutionNormalizer
{
private static readonly ResolutionConfiguration[] Configurations =
new[]
{
new ResolutionConfiguration(426, 320000),
new ResolutionConfiguration(640, 400000),
new ResolutionConfiguration(720, 950000),
new ResolutionConfiguration(1280, 2500000),
new ResolutionConfiguration(1920, 4000000),
new ResolutionConfiguration(2560, 20000000),
new ResolutionConfiguration(3840, 35000000)
};
// Please note: all bitrate here are in the scale of SDR h264 bitrate at 30fps
private static readonly ResolutionConfiguration[] _configurations =
[
new ResolutionConfiguration(416, 365000),
new ResolutionConfiguration(640, 730000),
new ResolutionConfiguration(768, 1100000),
new ResolutionConfiguration(960, 3000000),
new ResolutionConfiguration(1280, 6000000),
new ResolutionConfiguration(1920, 13500000),
new ResolutionConfiguration(2560, 28000000),
new ResolutionConfiguration(3840, 50000000)
];
public static ResolutionOptions Normalize(
int? inputBitrate,
int outputBitrate,
int h264EquivalentOutputBitrate,
int? maxWidth,
int? maxHeight)
int? maxHeight,
float? targetFps,
bool isHdr = false) // We are not doing HDR transcoding for now, leave for future use
{
// If the bitrate isn't changing, then don't downscale the resolution
if (inputBitrate.HasValue && outputBitrate >= inputBitrate.Value)
@ -38,17 +43,27 @@ namespace MediaBrowser.Model.Dlna
}
}
var resolutionConfig = GetResolutionConfiguration(outputBitrate);
if (resolutionConfig is not null)
var referenceBitrate = h264EquivalentOutputBitrate * (30.0f / (targetFps ?? 30.0f));
if (isHdr)
{
var originvalValue = maxWidth;
referenceBitrate *= 0.8f;
}
var resolutionConfig = GetResolutionConfiguration(Convert.ToInt32(referenceBitrate));
if (resolutionConfig is null)
{
return new ResolutionOptions { MaxWidth = maxWidth, MaxHeight = maxHeight };
}
var originWidthValue = maxWidth;
maxWidth = Math.Min(resolutionConfig.MaxWidth, maxWidth ?? resolutionConfig.MaxWidth);
if (!originvalValue.HasValue || originvalValue.Value != maxWidth.Value)
if (!originWidthValue.HasValue || originWidthValue.Value != maxWidth.Value)
{
maxHeight = null;
}
}
return new ResolutionOptions
{
@ -59,19 +74,7 @@ namespace MediaBrowser.Model.Dlna
private static ResolutionConfiguration GetResolutionConfiguration(int outputBitrate)
{
ResolutionConfiguration previousOption = null;
foreach (var config in Configurations)
{
if (outputBitrate <= config.MaxBitrate)
{
return previousOption ?? config;
}
previousOption = config;
}
return null;
return _configurations.FirstOrDefault(config => outputBitrate <= config.MaxBitrate);
}
}
}