mirrors/invidious
1
0
Fork 0
mirror of https://github.com/iv-org/invidious.git synced 2025-07-14 09:28:32 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Merge a85f579b19 into 9892604758

Browse Source
This commit is contained in:
Samantaz Fox 2024-11-10 22:16:26 +01:00 committed by GitHub
commit 4ccd7c8dd3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 623 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
spec/invidious/hashtag_spec.cr
View File

@ -3,7 +3,7 @@ require "../parsers_helper.cr"
Spectator.describe Invidious::Hashtag do
it "parses richItemRenderer containers (test 1)" do
# Enable mock
test_content = load_mock("hashtag/martingarrix_page1")
test_content = load_mock("hashtag/martingarrix_page1").as_h
videos, _ = extract_items(test_content)
expect(typeof(videos)).to eq(Array(SearchItem))
@ -56,7 +56,7 @@ Spectator.describe Invidious::Hashtag do
it "parses richItemRenderer containers (test 2)" do
# Enable mock
test_content = load_mock("hashtag/martingarrix_page2")
test_content = load_mock("hashtag/martingarrix_page2").as_h
videos, _ = extract_items(test_content)
expect(typeof(videos)).to eq(Array(SearchItem))

143
spec/invidious/videos/adaptative_audio_stream_spec.cr Normal file
View File

@ -0,0 +1,143 @@
require "../../parsers_helper.cr"
Spectator.describe Invidious::Videos do
subject(streams) {
described_class.parse_adaptative_formats(load_mock(mock_name))
}
describe ".parse_adaptative_formats" do
provided mock_name: "streams/audio_stereo" do
expect(streams.size).to eq(2)
sample_one = streams[0]
sample_two = streams[1]
#
# Test 1 / itag 139
#
expect(sample_one).to be_a(Invidious::Videos::AdaptativeAudioStream)
sample_one = sample_one.as(Invidious::Videos::AdaptativeAudioStream)
expect(sample_one.itag).to eq(139)
expect(sample_one.label).to eq("low")
expect(sample_one.url).to eq("https://rr5---sn-4g5edndl.googlevideo.com/videoplayback")
expect(sample_one.last_modified).to eq(Time.utc(seconds: 1_677_975_303_i64, nanoseconds: 572_731_000))
expect(sample_one.projection_type).to eq(Invidious::Videos::ProjType::Rectangular)
expect(sample_one).to have_attributes(
raw_mime_type: "audio/mp4; codecs=\"mp4a.40.5\"",
mime_type: "audio/mp4",
codecs: "mp4a.40.5",
# Adaptative properties
init_range: Invidious::Videos::ByteRange.new(0_u32, 640_u32),
index_range: Invidious::Videos::ByteRange.new(641_u32, 2148_u32),
# Common properties
bitrate: 50_854,
bitrate_avg: 48_788,
content_length: 7_454_256,
# Audio properties
audio_quality: Invidious::Videos::AudioQuality::Low,
audio_sample_rate: 22_050,
audio_channels: 2,
audio_loudness_db: -5.01,
audio_spatial_type: Invidious::Videos::SpatialType::None
)
#
# Test 2 / itag 251 (Note: most properties aren't checked)
#
expect(sample_two).to be_a(Invidious::Videos::AdaptativeAudioStream)
sample_two = sample_two.as(Invidious::Videos::AdaptativeAudioStream)
expect(sample_two.itag).to eq(251)
expect(sample_two.label).to eq("medium")
expect(sample_two).to have_attributes(
raw_mime_type: "audio/webm; codecs=\"opus\"",
mime_type: "audio/webm",
codecs: "opus",
# Audio properties
audio_quality: Invidious::Videos::AudioQuality::Medium,
audio_sample_rate: 48_000,
audio_channels: 2,
audio_loudness_db: -5.01,
audio_spatial_type: Invidious::Videos::SpatialType::None
)
end
provided mock_name: "streams/audio_spatial" do
expect(streams.size).to eq(2)
sample_one = streams[0] # Quad
sample_two = streams[1] # 5.1
# Test 1
expect(sample_one).to be_a(Invidious::Videos::AdaptativeAudioStream)
sample_one = sample_one.as(Invidious::Videos::AdaptativeAudioStream)
expect(sample_one.itag).to eq(327)
expect(sample_one).to have_attributes(
audio_quality: Invidious::Videos::AudioQuality::Medium,
audio_sample_rate: 44_100,
audio_channels: 6,
audio_loudness_db: 0.0,
audio_spatial_type: Invidious::Videos::SpatialType::Ambisonics_5_1
)
# Test 2
expect(sample_two).to be_a(Invidious::Videos::AdaptativeAudioStream)
sample_two = sample_two.as(Invidious::Videos::AdaptativeAudioStream)
expect(sample_two.itag).to eq(338)
expect(sample_two).to have_attributes(
audio_quality: Invidious::Videos::AudioQuality::Medium,
audio_sample_rate: 48_000,
audio_channels: 4,
audio_loudness_db: 0.0,
audio_spatial_type: Invidious::Videos::SpatialType::AmbisonicsQuad
)
end
provided mock_name: "streams/audio_multi_lang" do
expect(streams.size).to eq(8)
sample_one = streams[1] # English
sample_two = streams[4] # hindi
# Test 1
expect(sample_one).to be_a(Invidious::Videos::AdaptativeAudioTrackStream)
sample_one = sample_one.as(Invidious::Videos::AdaptativeAudioTrackStream)
expect(sample_one.itag).to eq(249)
expect(sample_one).to have_attributes(
track_id: "en.0",
track_name: "English",
iso_code: "en",
default: true
)
# Test 2
expect(sample_two).to be_a(Invidious::Videos::AdaptativeAudioTrackStream)
sample_two = sample_two.as(Invidious::Videos::AdaptativeAudioTrackStream)
expect(sample_two.itag).to eq(249)
expect(sample_two).to have_attributes(
track_id: "hi.0",
track_name: "Hindi",
iso_code: "hi",
default: false
)
end
end
end

8
spec/invidious/videos/regular_videos_extract_spec.cr
View File

@ -3,8 +3,8 @@ require "../../parsers_helper.cr"
Spectator.describe "parse_video_info" do
it "parses a regular video" do
# Enable mock
_player = load_mock("video/regular_mrbeast.player")
_next = load_mock("video/regular_mrbeast.next")
_player = load_mock("video/regular_mrbeast.player").as_h
_next = load_mock("video/regular_mrbeast.next").as_h
raw_data = _player.merge!(_next)
info = parse_video_info("2isYuQZMbdU", raw_data)
@ -85,8 +85,8 @@ Spectator.describe "parse_video_info" do
it "parses a regular video with no descrition/comments" do
# Enable mock
_player = load_mock("video/regular_no-description.player")
_next = load_mock("video/regular_no-description.next")
_player = load_mock("video/regular_no-description.player").as_h
_next = load_mock("video/regular_no-description.next").as_h
raw_data = _player.merge!(_next)
info = parse_video_info("iuevw6218F0", raw_data)

4
spec/invidious/videos/scheduled_live_extract_spec.cr
View File

@ -3,8 +3,8 @@ require "../../parsers_helper.cr"
Spectator.describe "parse_video_info" do
it "parses scheduled livestreams data" do
# Enable mock
_player = load_mock("video/scheduled_live_PBD-Podcast.player")
_next = load_mock("video/scheduled_live_PBD-Podcast.next")
_player = load_mock("video/scheduled_live_PBD-Podcast.player").as_h
_next = load_mock("video/scheduled_live_PBD-Podcast.next").as_h
raw_data = _player.merge!(_next)
info = parse_video_info("N-yVic7BbY0", raw_data)

4
spec/parsers_helper.cr
View File

@ -22,11 +22,11 @@ require "../src/invidious/yt_backend/extractors_utils"
OUTPUT = File.open(File::NULL, "w")
LOGGER = Invidious::LogHandler.new(OUTPUT, LogLevel::Off)
def load_mock(file) : Hash(String, JSON::Any)
def load_mock(file) : JSON::Any
file = File.join(__DIR__, "..", "mocks", file + ".json")
content = File.read(file)
return JSON.parse(content).as_h
return JSON.parse(content)
end
Spectator.configure do |config|

27
src/invidious/frontend/watch_page.cr
View File

@ -4,9 +4,9 @@ module Invidious::Frontend::WatchPage
# A handy structure to pass many elements at
# once to the download widget function
struct VideoAssets
getter full_videos : Array(Hash(String, JSON::Any))
getter video_streams : Array(Hash(String, JSON::Any))
getter audio_streams : Array(Hash(String, JSON::Any))
getter full_videos : Array(Videos::ProgressiveHttpStream)
getter video_streams : Array(Videos::AdaptativeVideoStream)
getter audio_streams : Array(Videos::AdaptativeAudioStream)
getter captions : Array(Invidious::Videos::Captions::Metadata)
def initialize(
@ -47,38 +47,33 @@ module Invidious::Frontend::WatchPage
# Non-DASH videos (audio+video)
video_assets.full_videos.each do |option|
mimetype = option["mimeType"].as_s.split(";")[0]
height = Invidious::Videos::Formats.itag_to_metadata?(option.itag).try &.["height"]?
height = Invidious::Videos::Formats.itag_to_metadata?(option["itag"]).try &.["height"]?
value = {"itag": option["itag"], "ext": mimetype.split("/")[1]}.to_json
value = {"itag": option.itag, "ext": option.mime_type.split("/")[1]}.to_json
str << "\t\t\t<option value='" << value << "'>"
str << (height || "~240") << "p - " << mimetype
str << (height || option.video_height) << "p - " << option.mime_type
str << "</option>\n"
end
# DASH video streams
video_assets.video_streams.each do |option|
mimetype = option["mimeType"].as_s.split(";")[0]
value = {"itag": option["itag"], "ext": mimetype.split("/")[1]}.to_json
value = {"itag": option.itag, "ext": option.mime_type.split("/")[1]}.to_json
str << "\t\t\t<option value='" << value << "'>"
str << option["qualityLabel"] << " - " << mimetype << " @ " << option["fps"] << "fps - video only"
str << option.label << " - " << option.mime_type
str << " @ " << option.video_fps << "fps - video only"
str << "</option>\n"
end
# DASH audio streams
video_assets.audio_streams.each do |option|
mimetype = option["mimeType"].as_s.split(";")[0]
value = {"itag": option["itag"], "ext": mimetype.split("/")[1]}.to_json
value = {"itag": option.itag, "ext": option.mime_type.split("/")[1]}.to_json
str << "\t\t\t<option value='" << value << "'>"
str << mimetype << " @ " << (option["bitrate"]?.try &.as_i./ 1000) << "k - audio only"
str << option.mime_type << " @ " << (option.bitrate // 1000) << "kbps - audio only"
str << "</option>\n"
end

121
src/invidious/jsonify/api_v1/video_json.cr
View File

@ -81,78 +81,62 @@ module Invidious::JSONify::APIv1
video.adaptive_fmts.each do |fmt|
json.object do
# Only available on regular videos, not livestreams/OTF streams
if init_range = fmt["initRange"]?
json.field "init", "#{init_range["start"]}-#{init_range["end"]}"
end
if index_range = fmt["indexRange"]?
json.field "index", "#{index_range["start"]}-#{index_range["end"]}"
end
json.field "init", fmt.init_range.to_s if fmt.init_range
json.field "index", fmt.index_range.to_s if fmt.index_range
# Not available on MPEG-4 Timed Text (`text/mp4`) streams (livestreams only)
json.field "bitrate", fmt["bitrate"].as_i.to_s if fmt["bitrate"]?
json.field "bitrate", fmt.bitrate.to_s if fmt.responds_to?(:bitrate)
if proxy
json.field "url", Invidious::HttpServer::Utils.proxy_video_url(
fmt["url"].to_s, absolute: true
)
json.field "url", HttpServer::Utils.proxy_video_url(fmt.url, absolute: true)
else
json.field "url", fmt["url"]
json.field "url", fmt.url
end
json.field "itag", fmt["itag"].as_i.to_s
json.field "type", fmt["mimeType"]
json.field "clen", fmt["contentLength"]? || "-1"
json.field "itag", fmt.itag.to_s
json.field "type", fmt.raw_mime_type
json.field "clen", fmt.content_length if fmt.responds_to?(:content_length)
# Last modified is a unix timestamp with µS, with the dot omitted.
# E.g: 1638056732(.)141582
#
# On livestreams, it's not present, so always fall back to the
# current unix timestamp (up to mS precision) for compatibility.
last_modified = fmt["lastModified"]?
last_modified ||= "#{Time.utc.to_unix_ms}000"
json.field "lmt", last_modified
last_modified = fmt.last_modified || Time.utc
json.field "lmt", "#{last_modified.to_unix_ms}000"
json.field "projectionType", fmt["projectionType"]
json.field "projectionType", fmt.projection_type.to_s.upcase
height = fmt["height"]?.try &.as_i
width = fmt["width"]?.try &.as_i
fps = fmt["fps"]?.try &.as_i
if fps
json.field "fps", fps
# Video-related data
if fmt.is_a?(Videos::AdaptativeVideoStream)
json.field "size", "#{fmt.video_width}x#{fmt.video_height}"
json.field "resolution", "#{fmt.video_height}p"
json.field "fps", fmt.video_fps
end
if height && width
json.field "size", "#{width}x#{height}"
json.field "resolution", "#{height}p"
json.field "qualityLabel", fmt.label
quality_label = "#{width > height ? height : width}p"
if fps && fps > 30
quality_label += fps.to_s
end
json.field "qualityLabel", quality_label
end
if fmt_info = Invidious::Videos::Formats.itag_to_metadata?(fmt["itag"])
if fmt_info = Invidious::Videos::Formats.itag_to_metadata?(fmt.itag)
json.field "container", fmt_info["ext"]
json.field "encoding", fmt_info["vcodec"]? || fmt_info["acodec"]
end
# Livestream chunk infos
json.field "targetDurationSec", fmt["targetDurationSec"].as_i if fmt.has_key?("targetDurationSec")
json.field "maxDvrDurationSec", fmt["maxDvrDurationSec"].as_i if fmt.has_key?("maxDvrDurationSec")
json.field "encoding", fmt.codecs
# Livestream chunk infos. Should be present when `init` and `index` aren't
json.field "targetDurationSec", fmt.target_duration if fmt.target_duration
json.field "maxDvrDurationSec", fmt.max_dvr_duration if fmt.max_dvr_duration
# Audio-related data
json.field "audioQuality", fmt["audioQuality"] if fmt.has_key?("audioQuality")
json.field "audioSampleRate", fmt["audioSampleRate"].as_s.to_i if fmt.has_key?("audioSampleRate")
json.field "audioChannels", fmt["audioChannels"] if fmt.has_key?("audioChannels")
if fmt.is_a?(Videos::AdaptativeAudioStream)
json.field "audioQuality", fmt.audio_quality
json.field "audioSampleRate", fmt.audio_sample_rate
json.field "audioChannels", fmt.audio_channels
end
# Extra misc stuff
json.field "colorInfo", fmt["colorInfo"] if fmt.has_key?("colorInfo")
json.field "captionTrack", fmt["captionTrack"] if fmt.has_key?("captionTrack")
# json.field "colorInfo", fmt["colorInfo"] if fmt.has_key?("colorInfo")
# json.field "captionTrack", fmt["captionTrack"] if fmt.has_key?("captionTrack")
end
end
end
@ -163,44 +147,27 @@ module Invidious::JSONify::APIv1
video.fmt_stream.each do |fmt|
json.object do
if proxy
json.field "url", Invidious::HttpServer::Utils.proxy_video_url(
fmt["url"].to_s, absolute: true
)
json.field "url", HttpServer::Utils.proxy_video_url(fmt.url, absolute: true)
else
json.field "url", fmt["url"]
end
json.field "itag", fmt["itag"].as_i.to_s
json.field "type", fmt["mimeType"]
json.field "quality", fmt["quality"]
json.field "bitrate", fmt["bitrate"].as_i.to_s if fmt["bitrate"]?
height = fmt["height"]?.try &.as_i
width = fmt["width"]?.try &.as_i
fps = fmt["fps"]?.try &.as_i
if fps
json.field "fps", fps
json.field "url", fmt.url
end
if height && width
json.field "size", "#{width}x#{height}"
json.field "resolution", "#{height}p"
json.field "itag", fmt.itag.to_s
json.field "type", fmt.raw_mime_type
json.field "quality", fmt.label
quality_label = "#{width > height ? height : width}p"
json.field "bitrate", fmt.bitrate
if fps && fps > 30
quality_label += fps.to_s
end
json.field "size", "#{fmt.video_width}x#{fmt.video_height}"
json.field "resolution", "#{fmt.video_height}p"
json.field "fps", fmt.video_fps
json.field "qualityLabel", quality_label
end
if fmt_info = Invidious::Videos::Formats.itag_to_metadata?(fmt["itag"])
if fmt_info = Videos::Formats.itag_to_metadata?(fmt.itag)
json.field "container", fmt_info["ext"]
json.field "encoding", fmt_info["vcodec"]? || fmt_info["acodec"]
end
json.field "qualityLabel", fmt.label
json.field "encoding", fmt.codecs
end
end
end

71
src/invidious/routes/api/manifest.cr
View File

@ -4,7 +4,7 @@ module Invidious::Routes::API::Manifest
env.response.headers.add("Access-Control-Allow-Origin", "*")
env.response.content_type = "application/dash+xml"
local = env.params.query["local"]?.try &.== "true"
local = (env.params.query["local"]? == "true")
id = env.params.url["id"]
region = env.params.query["region"]?
@ -44,18 +44,18 @@ module Invidious::Routes::API::Manifest
return manifest
end
adaptive_fmts = video.adaptive_fmts
# Transform URLs for proxying
if local
adaptive_fmts.each do |fmt|
fmt["url"] = JSON::Any.new("#{HOST_URL}#{URI.parse(fmt["url"].as_s).request_target}")
video.adaptive_fmts.each do |fmt|
fmt.url = "#{HOST_URL}#{URI.parse(fmt.url).request_target}"
end
end
audio_streams = video.audio_streams.sort_by { |stream| {stream["bitrate"].as_i} }.reverse!
video_streams = video.video_streams.sort_by { |stream| {stream["width"].as_i, stream["fps"].as_i} }.reverse!
audio_streams = video.audio_streams.sort_by(&.bitrate).reverse!
video_streams = video.video_streams.sort_by { |fmt| {fmt.video_width, fmt.video_fps} }.reverse!
manifest = XML.build(indent: " ", encoding: "UTF-8") do |xml|
# Build the manifest
return XML.build(indent: " ", encoding: "UTF-8") do |xml|
xml.element("MPD", "xmlns": "urn:mpeg:dash:schema:mpd:2011",
"profiles": "urn:mpeg:dash:profile:full:2011", minBufferTime: "PT1.5S", type: "static",
mediaPresentationDuration: "PT#{video.length_seconds}S") do
@ -63,34 +63,28 @@ module Invidious::Routes::API::Manifest
i = 0
{"audio/mp4"}.each do |mime_type|
mime_streams = audio_streams.select { |stream| stream["mimeType"].as_s.starts_with? mime_type }
next if mime_streams.empty?
formats = audio_streams.select(&.mime_type.== mime_type)
next if formats.empty?
mime_streams.each do |fmt|
formats.each do |fmt|
# OTF streams aren't supported yet (See https://github.com/TeamNewPipe/NewPipe/issues/2415)
next if !(fmt.has_key?("indexRange") && fmt.has_key?("initRange"))
next if (fmt.index_range.nil? || fmt.init_range.nil?)
# Different representations of the same audio should be groupped into one AdaptationSet.
# However, most players don't support auto quality switching, so we have to trick them
# into providing a quality selector.
# See https://github.com/iv-org/invidious/issues/3074 for more details.
xml.element("AdaptationSet", id: i, mimeType: mime_type, startWithSAP: 1, subsegmentAlignment: true, label: fmt["bitrate"].to_s + "k") do
codecs = fmt["mimeType"].as_s.split("codecs=")[1].strip('"')
bandwidth = fmt["bitrate"].as_i
itag = fmt["itag"].as_i
url = fmt["url"].as_s
xml.element("AdaptationSet", id: i, mimeType: mime_type, startWithSAP: 1, subsegmentAlignment: true, label: "#{(fmt.bitrate // 1000)} kbps") do
xml.element("Role", schemeIdUri: "urn:mpeg:dash:role:2011", value: i == 0 ? "main" : "alternate")
xml.element("Representation", id: fmt["itag"], codecs: codecs, bandwidth: bandwidth) do
xml.element("AudioChannelConfiguration", schemeIdUri: "urn:mpeg:dash:23003:3:audio_channel_configuration:2011",
value: "2")
xml.element("BaseURL") { xml.text url }
xml.element("SegmentBase", indexRange: "#{fmt["indexRange"]["start"]}-#{fmt["indexRange"]["end"]}") do
xml.element("Initialization", range: "#{fmt["initRange"]["start"]}-#{fmt["initRange"]["end"]}")
xml.element("Representation", id: fmt.itag, codecs: fmt.codecs, bandwidth: fmt.bitrate) do
xml.element("AudioChannelConfiguration", schemeIdUri: "urn:mpeg:dash:23003:3:audio_channel_configuration:2011", value: fmt.audio_channels)
xml.element("BaseURL") { xml.text fmt.url }
xml.element("SegmentBase", indexRange: fmt.index_range.to_s) do
xml.element("Initialization", range: fmt.init_range.to_s)
end
end
end
i += 1
end
end
@ -98,33 +92,26 @@ module Invidious::Routes::API::Manifest
potential_heights = {4320, 2160, 1440, 1080, 720, 480, 360, 240, 144}
{"video/mp4"}.each do |mime_type|
mime_streams = video_streams.select { |stream| stream["mimeType"].as_s.starts_with? mime_type }
mime_streams = video_streams.select(&.mime_type.== mime_type)
next if mime_streams.empty?
heights = [] of Int32
xml.element("AdaptationSet", id: i, mimeType: mime_type, startWithSAP: 1, subsegmentAlignment: true, scanType: "progressive") do
mime_streams.each do |fmt|
# OTF streams aren't supported yet (See https://github.com/TeamNewPipe/NewPipe/issues/2415)
next if !(fmt.has_key?("indexRange") && fmt.has_key?("initRange"))
codecs = fmt["mimeType"].as_s.split("codecs=")[1].strip('"')
bandwidth = fmt["bitrate"].as_i
itag = fmt["itag"].as_i
url = fmt["url"].as_s
width = fmt["width"].as_i
height = fmt["height"].as_i
next if (fmt.index_range.nil? || fmt.init_range.nil?)
# Resolutions reported by YouTube player (may not accurately reflect source)
height = potential_heights.min_by { |x| (height - x).abs }
height = potential_heights.min_by { |x| (fmt.video_height.to_i32 - x).abs }
next if unique_res && heights.includes? height
heights << height
xml.element("Representation", id: itag, codecs: codecs, width: width, height: height,
startWithSAP: "1", maxPlayoutRate: "1",
bandwidth: bandwidth, frameRate: fmt["fps"]) do
xml.element("BaseURL") { xml.text url }
xml.element("SegmentBase", indexRange: "#{fmt["indexRange"]["start"]}-#{fmt["indexRange"]["end"]}") do
xml.element("Initialization", range: "#{fmt["initRange"]["start"]}-#{fmt["initRange"]["end"]}")
xml.element("Representation", id: fmt.itag, codecs: fmt.codecs, width: fmt.video_width, height: height,
startWithSAP: "1", maxPlayoutRate: "1", bandwidth: fmt.bitrate, frameRate: fmt.video_fps) do
xml.element("BaseURL") { xml.text fmt.url }
xml.element("SegmentBase", indexRange: fmt.index_range.to_s) do
xml.element("Initialization", range: fmt.init_range.to_s)
end
end
end
@ -135,8 +122,6 @@ module Invidious::Routes::API::Manifest
end
end
end
return manifest
end
# /api/manifest/dash/id/videoplayback

8
src/invidious/routes/embed.cr
View File

@ -157,8 +157,8 @@ module Invidious::Routes::Embed
adaptive_fmts = video.adaptive_fmts
if params.local
fmt_stream.each { |fmt| fmt["url"] = JSON::Any.new(URI.parse(fmt["url"].as_s).request_target) }
adaptive_fmts.each { |fmt| fmt["url"] = JSON::Any.new(URI.parse(fmt["url"].as_s).request_target) }
fmt_stream.each { |fmt| fmt.url = HttpServer::Utils.proxy_video_url(fmt.url) }
adaptive_fmts.each { |fmt| fmt.url = HttpServer::Utils.proxy_video_url(fmt.url) }
end
video_streams = video.video_streams
@ -192,10 +192,10 @@ module Invidious::Routes::Embed
thumbnail = "/vi/#{video.id}/maxres.jpg"
if params.raw
url = fmt_stream[0]["url"].as_s
url = fmt_stream[0].url
fmt_stream.each do |fmt|
url = fmt["url"].as_s if fmt["quality"].as_s == params.quality
url = fmt.url if fmt.label == params.quality
end
return env.redirect url

7
src/invidious/routes/video_playback.cr
View File

@ -285,14 +285,15 @@ module Invidious::Routes::VideoPlayback
if itag.nil?
fmt = video.fmt_stream[-1]?
else
fmt = video.fmt_stream.find(nil) { |f| f["itag"].as_i == itag } || video.adaptive_fmts.find(nil) { |f| f["itag"].as_i == itag }
fmt = video.fmt_stream.find(nil, &.itag.== itag) || video.adaptive_fmts.find(nil, &.itag.== itag)
end
url = fmt.try &.["url"]?.try &.as_s
if !url
if !fmt
haltf env, status_code: 404
end
url = fmt.url
if local
url = URI.parse(url).request_target.not_nil!
url += "&title=#{URI.encode_www_form(title, space_to_plus: false)}" if title

16
src/invidious/routes/watch.cr
View File

@ -121,8 +121,8 @@ module Invidious::Routes::Watch
adaptive_fmts = video.adaptive_fmts
if params.local
fmt_stream.each { |fmt| fmt["url"] = JSON::Any.new(URI.parse(fmt["url"].as_s).request_target) }
adaptive_fmts.each { |fmt| fmt["url"] = JSON::Any.new(URI.parse(fmt["url"].as_s).request_target) }
fmt_stream.each { |fmt| fmt.url = HttpServer::Utils.proxy_video_url(fmt.url) }
adaptive_fmts.each { |fmt| fmt.url = HttpServer::Utils.proxy_video_url(fmt.url) }
end
video_streams = video.video_streams
@ -160,21 +160,21 @@ module Invidious::Routes::Watch
if params.raw
if params.listen
url = audio_streams[0]["url"].as_s
url = audio_streams[0].url
if params.quality.ends_with? "k"
audio_streams.each do |fmt|
if fmt["bitrate"].as_i == params.quality.rchop("k").to_i
url = fmt["url"].as_s
if fmt.bitrate == params.quality.rchop("k").to_i
url = fmt.url
end
end
end
else
url = fmt_stream[0]["url"].as_s
url = fmt_stream[0].url
fmt_stream.each do |fmt|
if fmt["quality"].as_s == params.quality
url = fmt["url"].as_s
if fmt.label == params.quality
url = fmt.url
end
end
end

42
src/invidious/videos.cr
View File

@ -26,6 +26,12 @@ struct Video
@[DB::Field(ignore: true)]
@captions = [] of Invidious::Videos::Captions::Metadata
@[DB::Field(ignore: true)]
@adaptive_fmts = [] of Invidious::Videos::AdaptativeStream
@[DB::Field(ignore: true)]
@fmt_stream = [] of Invidious::Videos::ProgressiveHttpStream
@[DB::Field(ignore: true)]
property description : String?
@ -92,32 +98,32 @@ struct Video
# Methods for parsing streaming data
def fmt_stream : Array(Hash(String, JSON::Any))
if formats = info.dig?("streamingData", "formats")
return formats
.as_a.map(&.as_h)
.sort_by! { |f| f["width"]?.try &.as_i || 0 }
else
return [] of Hash(String, JSON::Any)
def fmt_stream : Array(Invidious::Videos::ProgressiveHttpStream)
if @fmt_stream.empty?
if formats = info.dig?("streamingData", "formats")
@fmt_stream = Invidious::Videos.parse_progressive_formats(formats)
end
end
return @fmt_stream
end
def adaptive_fmts : Array(Hash(String, JSON::Any))
if formats = info.dig?("streamingData", "adaptiveFormats")
return formats
.as_a.map(&.as_h)
.sort_by! { |f| f["width"]?.try &.as_i || 0 }
else
return [] of Hash(String, JSON::Any)
def adaptive_fmts : Array(Invidious::Videos::AdaptativeStream)
if @adaptive_fmts.empty?
if formats = info.dig?("streamingData", "adaptiveFormats")
@adaptive_fmts = Invidious::Videos.parse_adaptative_formats(formats)
end
end
return @adaptive_fmts
end
def video_streams
adaptive_fmts.select &.["mimeType"]?.try &.as_s.starts_with?("video")
def video_streams : Array(Invidious::Videos::AdaptativeVideoStream)
self.adaptive_fmts.select(Invidious::Videos::AdaptativeVideoStream)
end
def audio_streams
adaptive_fmts.select &.["mimeType"]?.try &.as_s.starts_with?("audio")
def audio_streams : Array(Invidious::Videos::AdaptativeAudioStream)
self.adaptive_fmts.select(Invidious::Videos::AdaptativeAudioStream)
end
# Misc. methods

2
src/invidious/videos/formats.cr
View File

@ -1,5 +1,5 @@
module Invidious::Videos::Formats
def self.itag_to_metadata?(itag : JSON::Any)
def self.itag_to_metadata?(itag : Int)
return FORMATS[itag.to_s]?
end

336
src/invidious/videos/streams.cr Normal file
View File

@ -0,0 +1,336 @@
module Invidious::Videos
# ------------------
# Structs & Enums
# ------------------
# "AUDIO_QUALITY_"
enum AudioQuality
UltraLow
Low
Medium
end
# "SPATIAL_AUDIO_TYPE_"
enum SpatialType
None
AmbisonicsQuad
Ambisonics_5_1
FoaWithNonDiegetic
end
enum ProjType
Unknown
Rectangular
Equirectangular
EquirectangularThreedTopBottom
Mesh
end
struct ByteRange
getter start : UInt32
getter end : UInt32
def initialize(@start, @end)
end
def to_s
return "#{@start}-#{@end}"
end
end
# ------------------
# Traits
# ------------------
# Properties common to all streams containing audio
module AudioProperties
macro included
property audio_quality : AudioQuality
property audio_sample_rate : UInt32
property audio_channels : UInt8
property audio_loudness_db : Float64 = 0.0
property audio_spatial_type : SpatialType
private macro init_audio_properties(format)
@audio_quality = AudioQuality.parse(format["audioQuality"].as_s.lchop("AUDIO_QUALITY_"))
@audio_sample_rate = format["audioSampleRate"].as_s.to_u32
@audio_channels = format["audioChannels"].as_i.to_u8
if _loudness = format["loudnessDb"]?
@audio_loudness_db = _loudness.as_f? || _loudness.as_i64?.try &.to_f || 0.0
end
_spatial_type = format["spatialAudioType"]?.try &.as_s || "SPATIAL_AUDIO_TYPE_NONE"
@audio_spatial_type = SpatialType.parse(_spatial_type.lchop("SPATIAL_AUDIO_TYPE_"))
end
end
end
# Properties common to all streams containing video
module VideoProperties
macro included
property video_width : UInt32
property video_height : UInt32
property video_fps : UInt16
private macro init_video_properties(format)
@video_width = format["width"].as_i.to_u32
@video_height = format["height"].as_i.to_u32
@video_fps = format["fps"].as_i.to_u16
end
end
end
# Properties common to all audio & video streams
module AVCommonProperties
macro included
property bitrate : UInt64
property bitrate_avg : UInt64?
# Itag 22 sometimes doesn't have a contentLength ?!
# Not present on livestreams
property content_length : UInt64?
private macro init_av_common_properties(format)
@bitrate = format["bitrate"].as_i.to_u64
@bitrate_avg = format["averageBitrate"]?.try &.as_i.to_u64
@content_length = format["contentLength"]?.try &.as_s.to_u64
end
end
end
# Properties that only applies to multi-lingual adaptative streams.
# They apply to audio and text streams (notably text/mp4).
#
# Sample JSON for an audio track:
# "audioTrack": {
# "displayName": "Arabic",
# "id": "ar.0",
# "audioIsDefault": false
# },
#
# Sample JSON for a caption track:
# "captionTrack": {
# "displayName": "English",
# "vssId": ".en.eEY6OEpapPo",
# "languageCode": "en"
# }
module TrackProperties
macro included
property track_id : String?
property track_name : String = "default"
property iso_code : String?
property default : Bool = false
private macro init_track_properties(format)
if audio_track = format["audioTrack"]?
id = audio_track["id"].as_s
@track_id = id
@track_name = audio_track["displayName"].as_s
@default = audio_track["audioIsDefault"].as_bool
_xtags = format["xtags"]?
.try { |i| Base64.decode(URI.decode_www_form(i.as_s)) }
.try { |i| Protodec::Any.parse(IO::Memory.new(i)) }
@iso_code = _xtags
.try &.dig?("1:1:embedded", "2:2:string")
.try &.as_s || id.rchop(".0")
#
elsif caption_track = format["captionTrack"]?
@track_name = caption_track["displayName"].as_s
@track_id = caption_track["vssId"].as_s
@iso_code = caption_track["languageCode"].as_s
end
end
end
end
# Properties that only apply to adaptative streams of regular videos
module AdaptativeProperties
macro included
property init_range : ByteRange?
property index_range : ByteRange?
private macro init_adaptative_properties(format)
if init_range = format["initRange"]?
@init_range = ByteRange.new(
init_range["start"].as_s.to_u32,
init_range["end"].as_s.to_u32
)
end
if index_range = format["indexRange"]?
@index_range = ByteRange.new(
index_range["start"].as_s.to_u32,
index_range["end"].as_s.to_u32
)
end
end
end
end
# Properties that only apply to adaptative streams from livestrams
# (either in progress, or recenlty ended)
module LiveProperties
macro included
property target_duration : UInt32?
property max_dvr_duration : UInt32?
private macro init_live_properties(format)
@target_duration = format["targetDurationSec"]?.try(&.as_i.to_u32)
@max_dvr_duration = format["maxDvrDurationSec"]?.try(&.as_i.to_u32)
end
end
end
# ------------------
# Base class
# ------------------
# Base stream class defining all the common properties for all streams
abstract class Stream
getter itag : UInt16
getter label : String
property url : String
getter raw_mime_type : String
getter mime_type : String
getter codecs : String
getter last_modified : Time?
getter projection_type : ProjType
def initialize(format : JSON::Any, @label)
@itag = format["itag"].as_i.to_u16
@url = format["url"].as_s
@raw_mime_type = format["mimeType"].as_s
# Extract MIME type and codecs from the raw mimeType string
@mime_type, raw_codecs = @raw_mime_type.split(';')
@codecs = raw_codecs.lchop(" codecs=\"").rchop('"')
# Last modified is not present on livestreams
if last_modified = format["lastModified"]?.try &.as_s
# E.g "1670664306(.)849305"
# Note: (.) is not present in the input data, it's used here to show
# the demarcation between seconds and microseconds.
timestamp = last_modified[0...10]
microseconds = last_modified[10..]
@last_modified = Time.utc(
seconds: timestamp.to_i64,
nanoseconds: microseconds.to_i * 1000
)
end
@projection_type = ProjType.parse(format["projectionType"].as_s)
# Initialize extra properties as required
{% begin %}
{%
properties_types = [
AudioProperties,
VideoProperties,
TrackProperties,
AVCommonProperties,
AdaptativeProperties,
LiveProperties,
]
%}
{% for type in properties_types %}
# Call the appropriate initialization macro if self
# inherits from the given type
{% if @type < type %}
init_{{type.id.split("::").last.id.underscore}}(format)
{% end %}
{% end %}
{% end %}
end
end
# ------------------
# Children classes
# ------------------
# An HTTP progressive stream (audio + video)
class ProgressiveHttpStream < Stream
include AudioProperties
include VideoProperties
include AVCommonProperties
end
# Base class for adaptative (DASH) streams
abstract class AdaptativeStream < Stream
include AdaptativeProperties
include LiveProperties
end
# An audio-only adaptative (DASH) stream
class AdaptativeAudioStream < AdaptativeStream
include AudioProperties
include AVCommonProperties
end
# An audio-only adaptative (DASH) stream with track informations
class AdaptativeAudioTrackStream < AdaptativeAudioStream
include TrackProperties
end
# A video-only adaptative (DASH) stream
class AdaptativeVideoStream < AdaptativeStream
include VideoProperties
include AVCommonProperties
end
# A text-only adaptative (DASH) stream
class AdaptativeTextStream < AdaptativeStream
include TrackProperties
end
# ------------------------
# High-level functions
# ------------------------
def self.parse_progressive_formats(formats : JSON::Any) : Array(ProgressiveHttpStream)
return formats.as_a.map do |format|
label = format["quality"].to_s
ProgressiveHttpStream.new(format, label)
end
end
def self.parse_adaptative_formats(formats : JSON::Any) : Array(AdaptativeStream)
return formats.as_a.compact_map do |format|
# "Encrypted" video URLs are not supported. They require some logic
# to extract the JS and run it in a dedicated JS engine like ducktape.
# See: https://github.com/iv-org/invidious/issues/3245
next if (format["cipher"]? || format["signatureCipher"]?)
# OTF streams are not supported either.
# See https://github.com/TeamNewPipe/NewPipe/issues/2415
next if format["type"]? == "FORMAT_STREAM_TYPE_OTF"
# Handle the various types of adaptative formats
case format["mimeType"].as_s
when .starts_with?("audio/")
label = format["audioQuality"].as_s.lchop("AUDIO_QUALITY_").downcase
if format["audioTrack"]?
AdaptativeAudioTrackStream.new(format, label)
else
AdaptativeAudioStream.new(format, label)
end
when .starts_with?("video/")
label = format["qualityLabel"].to_s
AdaptativeVideoStream.new(format, label)
when .starts_with?("text/")
label = format.dig("captionTrack", "displayName").as_s
AdaptativeTextStream.new(format, label)
end
end
end
end

20
src/invidious/views/components/player.ecr
View File

@ -12,19 +12,19 @@
best_m4a_stream_index = 0
best_m4a_stream_bitrate = 0
audio_streams.each_with_index do |fmt, i|
bandwidth = fmt["bitrate"].as_i
if (fmt["mimeType"].as_s.starts_with?("audio/mp4") && bandwidth > best_m4a_stream_bitrate)
bandwidth = fmt.bitrate
if (fmt.mime_type == "audio/mp4" && bandwidth > best_m4a_stream_bitrate)
best_m4a_stream_bitrate = bandwidth
best_m4a_stream_index = i
end
end
audio_streams.each_with_index do |fmt, i|
src_url = "/latest_version?id=#{video.id}&itag=#{fmt["itag"]}"
src_url = "/latest_version?id=#{video.id}&itag=#{fmt.itag}"
src_url += "&local=true" if params.local
bitrate = fmt["bitrate"]
mimetype = HTML.escape(fmt["mimeType"].as_s)
bitrate = fmt.bitrate // 1000
mimetype = HTML.escape(fmt.raw_mime_type)
selected = (i == best_m4a_stream_index)
%>
@ -39,14 +39,14 @@
<% end %>
<%
fmt_stream.reject! { |f| f["itag"] == 17 }
fmt_stream.sort_by! {|f| params.quality == f["quality"] ? 0 : 1 }
fmt_stream.reject!(&.itag.== 17)
fmt_stream.sort_by! { |f| params.quality == f.label ? 0 : 1 }
fmt_stream.each_with_index do |fmt, i|
src_url = "/latest_version?id=#{video.id}&itag=#{fmt["itag"]}"
src_url = "/latest_version?id=#{video.id}&itag=#{fmt.itag}"
src_url += "&local=true" if params.local
quality = fmt["quality"]
mimetype = HTML.escape(fmt["mimeType"].as_s)
quality = fmt.label
mimetype = HTML.escape(fmt.raw_mime_type)
selected = params.quality ? (params.quality == quality) : (i == 0)
%>