protected virtual void Grab(GrabResult result, JObject vars, GrabOptions options)
{
if (options.Flags.HasFlag(GrabOptionFlag.GrabImages))
{
var image_url = new Uri(result.OriginalUri, vars.SelectToken("$.image_url").Value <string>());
result.Resources.Add(new GrabbedImage(GrabbedImageType.Primary, null, image_url));
}
result.Title = vars.SelectToken("$.video_title").Value <string>();
result.Statistics = new GrabStatisticInfo();
result.Statistics.Length = TimeSpan.FromSeconds(vars.SelectToken("$.video_duration").Value <int>());
var qualities = vars.SelectTokens("$.defaultQuality[*]").Select(t => t.Value <int>()).ToArray();
foreach (var quality in qualities)
{
var key = $"quality_{quality}p";
var url = vars.SelectToken($"$.{key}")?.Value <string>();
if (string.IsNullOrEmpty(url))
{
continue;
}
var vid = new GrabbedMedia(new Uri(result.OriginalUri, url), null, new MediaFormat("video/mp4", "mp4"), MediaChannels.Both);
vid.Resolution = $"{quality}p";
vid.FormatTitle = $"MP4 {vid.Resolution}";
result.Resources.Add(vid);
}
}
public static void Convert(GrabbedMedia videoStream, GrabbedMedia audioStream, string videoPath, string audioPath, string outputPath)
{
var builder = new MediaMerger(outputPath);
builder.AddStreamSource(videoPath, MediaStreamType.Video);
builder.AddStreamSource(audioPath, MediaStreamType.Audio);
builder.OutputMimeType = videoStream.Format.Mime;
builder.OutputShortName = videoStream.Format.Extension;
builder.Build();
}
public GrabbedMediaViewModel(GrabbedMedia media, GrabbedMedia attachTo = null)
{
Media = media;
AttachTo = attachTo;
Name = $"{media.Container?.ToUpperInvariant()} {media.Resolution}".Trim();
if (IsComposition)
{
Consideration = "Full media after conversion";
}
else if (media.Channels == MediaChannels.Both)
{
Consideration = "Full Media";
}
else
{
Consideration = (media.Channels.HasAudio() ? "Audio" : "Video") + " Only";
}
}
/// <summary>
/// Given the specified <paramref name="metaData"/>, generates proper <see cref="GrabResult"/>.
/// </summary>
protected virtual GrabResult GrabUsingConfiguration(Configuration configuration, Uri originalUri)
{
var grabList = new List <IGrabbed>();
// Ensure we have at least one video format available
if (string.IsNullOrWhiteSpace(configuration?.Request?.Files?.Progressive?.FirstOrDefault().Url))
{
return(null);
}
if (configuration.Video?.Thumbs != null)
{
foreach (var keyValuePair in configuration.Video.Thumbs)
{
var imageType = GrabbedImageType.Thumbnail;
if (keyValuePair.Key == "base")
{
imageType = GrabbedImageType.Primary;
}
grabList.Add(new GrabbedImage(imageType, null, new Uri(keyValuePair.Value)));
}
}
foreach (var progressive in configuration.Request.Files.Progressive)
{
var format = new MediaFormat(progressive.Mime, MimeHelper.ExtractMimeExtension(progressive.Mime));
var vid = new GrabbedMedia(new Uri(progressive.Url), null, format, MediaChannels.Both)
{
Resolution = progressive.Quality
};
grabList.Add(vid);
}
var result = new GrabResult(originalUri, grabList)
{
Title = configuration.Video?.Title
};
return(result);
}
/// <summary>
/// Given the specified <paramref name="metaData"/>, generates proper <see cref="GrabResult"/>.
/// </summary>
protected virtual GrabResult GrabUsingMetadata(IDictionary <string, string> metaData)
{
var grabList = new List <IGrabbed>();
// extract metadata
var title = metaData.GetOrDefault("og:title");
var image = metaData.GetOrDefault("og:image");
var description = metaData.GetOrDefault("og:description");
var originalUri = new Uri(metaData.GetOrDefault("og:url"));
var type = metaData.GetOrDefault("og:type");
var video = metaData.GetOrDefault("og:video");
var video_secure_url = metaData.GetOrDefault("og:video:secure_url");
var video_type = metaData.GetOrDefault("og:video:type");
var video_width = int.Parse(metaData.GetOrDefault("og:video:width", "0"));
var video_height = int.Parse(metaData.GetOrDefault("og:video:height", "0"));
// grab image
if (!string.IsNullOrEmpty(image))
{
grabList.Add(new GrabbedImage(GrabbedImageType.Primary, null, new Uri(image)));
}
// grab video
if (!string.IsNullOrEmpty(video))
{
var format = new MediaFormat(video_type, MimeHelper.ExtractMimeExtension(video_type));
var vid = new GrabbedMedia(new Uri(video), null, format, MediaChannels.Both);
grabList.Add(vid);
}
// make result
var result = new GrabResult(originalUri, grabList)
{
Title = title,
Description = description,
};
return(result);
}
/// <summary>
/// Updates information about the grabbed media according to the given YouTube iTag info.
/// </summary>
protected virtual void UpdateStreamITagInfo(GrabbedMedia grabbed, YouTubeTagInfo itag)
{
grabbed.BitRateString = itag.BitRateString;
grabbed.Container = itag.Container;
grabbed.Resolution = itag.VideoResolution;
grabbed.FormatId = itag.iTag;
if (!string.IsNullOrEmpty(grabbed.Container))
{
grabbed.Format.Extension = grabbed.Container.ToLowerInvariant();
}
var attributes = new List <string>
{
grabbed.Container?.ToUpperInvariant(),
grabbed.Resolution
};
if (grabbed.Channels != MediaChannels.Both)
{
attributes.Add($"({grabbed.Channels} only)");
}
grabbed.FormatTitle = string.Join(" ", attributes.Where(attr => !string.IsNullOrWhiteSpace(attr)));
}
/// <summary>
/// Appends the specified <paramref name="stream"/> to the specified <paramref name="result"/>.
/// </summary>
protected virtual void AppendStreamToResult(GrabResult result, YouTubeStreamInfo stream)
{
MediaChannels channels;
// get iTag info
var itagInfo = stream.iTag == null ? null : YouTubeTags.For(stream.iTag.Value);
// extract extension from mime
var extension = stream.Extension ?? stream.Mime?.Split('/')?.Last();
// decide according to stream type - adaptive, or muxed
if (stream is YouTubeMuxedStream muxedStream)
{
// Muxed stream
channels = MediaChannels.Both;
}
else if (stream is YouTubeAdaptiveStream adaptiveStream)
{
// Adaptive stream
var hasVideo = itagInfo?.HasVideo ?? stream.Mime.StartsWith("video");
channels = hasVideo ? MediaChannels.Video : MediaChannels.Audio;
}
else
{
throw new NotSupportedException($"YouTube stream of type {stream.GetType()} is not implemented in {nameof(YouTubeGrabber)}.{nameof(AppendStreamToResult)}.");
}
var format = new MediaFormat(stream.Mime, extension);
var grabbed = new GrabbedMedia(new Uri(stream.Url), null, format, channels);
result.Resources.Add(grabbed);
// update grabbed media iTag info
if (itagInfo != null)
{
UpdateStreamITagInfo(grabbed, itagInfo.Value);
}
}
protected virtual void Grab(GrabResult result, JObject flashVars, JArray qualityItemVars, GrabOptions options)
{
var grabbed = new Dictionary <int, GrabbedMedia>();
if (options.Flags.HasFlag(GrabOptionFlag.GrabImages))
{
var image_url = new Uri(result.OriginalUri, flashVars.SelectToken("$.image_url").Value <string>());
result.Resources.Add(new GrabbedImage(GrabbedImageType.Primary, null, image_url));
}
result.Title = flashVars.SelectToken("$.video_title").Value <string>();
result.Statistics = new GrabStatisticInfo
{
Length = TimeSpan.FromSeconds(flashVars.SelectToken("$.video_duration").Value <int>())
};
if (qualityItemVars != null && qualityItemVars.Count > 0)
{
foreach (var quality in qualityItemVars)
{
var url = quality.Value <string>("url");
if (string.IsNullOrEmpty(url))
{
continue;
}
var vid = new GrabbedMedia(new Uri(result.OriginalUri, url), result.OriginalUri, DefaultMediaFormat, MediaChannels.Both);
vid.Resolution = quality.Value <string>("text");
var qint = StringHelper.ForceParseInt(vid.Resolution);
grabbed.Add(qint, vid);
}
}
var mediaDefinitions = flashVars.SelectToken("$.mediaDefinitions");
foreach (var def in mediaDefinitions)
{
var format = def.Value <string>("format");
var url = def.Value <string>("videoUrl");
var isQualityArr = def["quality"] is JArray;
var qualityArr = isQualityArr ? def["quality"].Values <int>().ToArray() : null;
var quality = isQualityArr ? 0 : StringHelper.ForceParseInt(def.Value <string>("quality"));
if (grabbed.ContainsKey(quality) || string.IsNullOrEmpty(url))
{
continue;
}
if (isQualityArr && qualityArr.Length == 0)
{
continue;
}
var uri = new Uri(result.OriginalUri, url);
var resol = isQualityArr ? null : $"{quality}p";
var playlistType = isQualityArr ? HlsPlaylistType.Master : HlsPlaylistType.Stream;
switch (format.ToLowerInvariant())
{
case "mp4":
var m = new GrabbedMedia(uri, result.OriginalUri, DefaultMediaFormat, MediaChannels.Both)
{
Resolution = resol,
FormatTitle = $"MP4 {resol}",
};
grabbed.Add(quality, m);
break;
case "hls":
var sr = new GrabbedStreamReference(uri, result.OriginalUri)
{
Resolution = resol,
PlaylistType = playlistType,
};
result.Resources.Add(sr);
break;
default:
continue;
}
}
foreach (var g in grabbed.OrderByDescending(m => m.Key))
{
result.Resources.Add(g.Value);
}
}
