Struct rustube::VideoDescrambler

pub struct VideoDescrambler { /* private fields */ }

A descrambler used to decrypt the data fetched by VideoFetcher.

You will probably rarely use this type directly, and use Video instead. There’s no public way of directly constructing a VideoDescrambler. The only way of getting one is by calling VideoFetcher::fetch.

Example

let url = Url::parse("https://youtube.com/watch?iv=5jlI4uzZGjU").unwrap();

let fetcher: VideoFetcher =  VideoFetcher::from_url(&url).unwrap();
let descrambler: VideoDescrambler = fetcher.fetch().await.unwrap();

How it works

(To fully understand descramble, you should first read how VideoFetcher works).

Descrambling, in this case, mainly refers to descrambling the SignatureCipher. After we requested the VideoInfo in fetch, we are left with many RawFormats. A RawFormat is just a bucket full of information about a video. Those formats come in two flavours: pre-signed and encrypted formats. Pre-signed formats are actually a free lunch. Such formats already contain a valid video URL, which can be used to download the video. The encrypted once are a little bit more complicated.

These encrypted RawFormats contain a so called SignatureCipher with a the signature field s in it. This signature is a long string and the YouTube server requires us to include in the URL query or we get a 403 back. Unfortunalty this signature isn’t correct yet! We first need to decrypt it. And that’s where the transform_plan and the transform_map come into play.

The transform_plan is just a list of JavaScript function calls, which take a string (or an array) plus sometimes an integer as input. The called JavaScript functions then transforms the string in a certain way and returns a new string. This new string then represents the new signature. To decrypt the signature we just need to pass it through all of these functions in a row.

But wait! How can we run JavaScript in Rust? And doesn’t that come with a considerable overhead? It actually would come with a vast overhead! That’s why we need the transform_map. The transform_map is a HashMap<String, TransformFn>, which maps JavaScript function names to Rust functions.

To finally decrypt the signature, we just iterate over each function call in the the transform_plan, extract both the function name and the optinal integer argument, and call the corresponding Rust function in transform_map.

The last step descramble performs, is to take all RawFormats, which now contain the correct signature, and convert them to Streams. At the end of the day, Streams are just RawFormats with some extra information.

And that’s it! We can now download a YouTube video like we would download any other video from the internet. The only difference is that the Streams url will eventually expire.

Implementations

impl VideoDescrambler

pub fn descramble(self) -> Result<Video>

Descrambles the data fetched by YouTubeFetcher. For more information have a look at the Video documentation.

Errors

• When the streaming data of the video is incomplete.
• When descrambling the videos signatures fails.

pub fn video_info(&self) -> &VideoInfo

The VideoInfo of the video.

pub fn video_details(&self) -> &VideoDetails

The VideoDetails of the video.

pub fn video_id(&self) -> &IdBuf

The Id of the video.

pub fn video_title(&self) -> &String

The title of the video.

Trait Implementations

impl Clone for VideoDescrambler

fn clone(&self) -> VideoDescrambler

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VideoDescrambler

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for VideoDescrambler

fn fmt(&self, _derive_more_display_formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<VideoDescrambler> for VideoDescrambler

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for VideoDescrambler