// --------------------------------------------------------------------------------------------------------------------
//
// This file is part of the HandBrake source code - It may be used under the terms of the GNU General Public License.
//
//
// Defines the HandBrakeUtils type.
//
// --------------------------------------------------------------------------------------------------------------------
namespace HandBrake.Interop
{
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using HandBrake.Interop.EventArgs;
using HandBrake.Interop.HbLib;
using HandBrake.Interop.Model;
using HandBrake.Interop.Model.Encoding;
using HandBrake.Interop.Model.Scan;
///
/// HandBrake Interop Utilities
///
public static class HandBrakeUtils
{
///
/// Estimated overhead in bytes for each frame in output container.
///
internal const int ContainerOverheadPerFrame = 6;
///
/// The callback for log messages from HandBrake.
///
private static LoggingCallback loggingCallback;
///
/// The callback for error messages from HandBrake.
///
private static LoggingCallback errorCallback;
///
/// True if the global initialize function has been called.
///
private static bool globalInitialized;
///
/// Fires when HandBrake has logged a message.
///
public static event EventHandler MessageLogged;
///
/// Fires when HandBrake has logged an error.
///
public static event EventHandler ErrorLogged;
///
/// Initializes static members of the HandBrakeUtils class.
///
static HandBrakeUtils()
{
if (!globalInitialized)
{
if (HBFunctions.hb_global_init() == -1)
{
throw new InvalidOperationException("HB global init failed.");
}
globalInitialized = true;
}
}
///
/// Gets the HandBrake version string.
///
public static string Version
{
get
{
var versionPtr = HBFunctions.hb_get_version(IntPtr.Zero); // Pointer isn't actually used.
return Marshal.PtrToStringAnsi(versionPtr);
}
}
///
/// Gets the HandBrake build number.
///
public static int Build
{
get
{
return HBFunctions.hb_get_build(IntPtr.Zero);
}
}
///
/// Ensures the HB global initialize method has been called.
///
public static void EnsureGlobalInit()
{
// Does nothing, but invokes static ctor.
}
///
/// Enables or disables LibDVDNav. If disabled libdvdread will be used instead.
///
///
/// True to enable LibDVDNav.
///
public static void SetDvdNav(bool enableDvdNav)
{
HBFunctions.hb_dvd_set_dvdnav(enableDvdNav ? 1 : 0);
}
///
/// Call before app shutdown. Performs global cleanup.
///
public static void DisposeGlobal()
{
HBFunctions.hb_global_close();
}
///
/// Register the logger.
///
public static void RegisterLogger()
{
// Register the logger if we have not already
if (loggingCallback == null)
{
// Keep the callback as a member to prevent it from being garbage collected.
loggingCallback = LoggingHandler;
errorCallback = ErrorHandler;
HBFunctions.hb_register_logger(loggingCallback);
HBFunctions.hb_register_error_handler(errorCallback);
}
}
///
/// Handles log messages from HandBrake.
///
///
/// The log message (including newline).
///
public static void LoggingHandler(string message)
{
if (!string.IsNullOrEmpty(message))
{
string[] messageParts = message.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
if (messageParts.Length > 0)
{
message = messageParts[0];
SendMessageEvent(message);
}
}
}
///
/// Handles errors from HandBrake.
///
///
/// The error message.
///
public static void ErrorHandler(string message)
{
if (!string.IsNullOrEmpty(message))
{
// These errors happen in normal operations. Log them as messages.
if (message == "dvd: ifoOpen failed" || message.Contains("avformat_seek_file failed") || message.Contains("nav_get_title_list"))
{
SendMessageEvent(message);
return;
}
SendErrorEvent(message);
}
}
///
/// Gets the standard x264 option name given the starting point.
///
///
/// The name.
///
///
/// The standard x264 option name.
///
public static string SanitizeX264OptName(string name)
{
IntPtr namePtr = Marshal.StringToHGlobalAnsi(name);
string sanitizedName = Marshal.PtrToStringAnsi(HBFunctions.hb_x264_encopt_name(namePtr));
Marshal.FreeHGlobal(namePtr);
return sanitizedName;
}
///
/// Checks to see if the given H.264 level is valid given the inputs.
///
///
/// The level to check.
///
///
/// The output picture width.
///
///
/// The output picture height.
///
///
/// The rate numerator.
///
///
/// The rate denominator.
///
///
/// True if x264 interlaced output is enabled.
///
///
/// True if x264 fake interlacing is enabled.
///
///
/// True if the level is valid.
///
public static bool IsH264LevelValid(string level, int width, int height, int fpsNumerator, int fpsDenominator, bool interlaced, bool fakeInterlaced)
{
return HBFunctions.hb_check_h264_level(
level,
width,
height,
fpsNumerator,
fpsDenominator,
interlaced ? 1 : 0,
fakeInterlaced ? 1 : 0) == 0;
}
///
/// Creates an X264 options string from the given settings.
///
///
/// The x264 preset.
///
///
/// The x264 tunes being used.
///
///
/// The extra options string.
///
///
/// The H.264 profile.
///
///
/// The H.264 level.
///
///
/// The width of the final picture.
///
///
/// The height of the final picture.
///
///
/// The full x264 options string from the given inputs.
///
public static string CreateX264OptionsString(
string preset,
IList tunes,
string extraOptions,
string profile,
string level,
int width,
int height)
{
if (width <= 0)
{
throw new ArgumentException("width must be positive.");
}
if (height <= 0)
{
throw new ArgumentException("height must be positive.");
}
IntPtr ptr = HBFunctions.hb_x264_param_unparse(
preset,
string.Join(",", tunes),
extraOptions,
profile,
level,
width,
height);
string x264Settings = Marshal.PtrToStringAnsi(ptr);
return x264Settings;
}
///
/// Sends the message logged event to any registered listeners.
///
///
/// The message to send.
///
private static void SendMessageEvent(string message)
{
if (MessageLogged != null)
{
MessageLogged(null, new MessageLoggedEventArgs { Message = message });
}
Debug.WriteLine(message);
}
///
/// Sends the error logged event to any registered listeners.
///
///
/// The message to send
///
private static void SendErrorEvent(string message)
{
if (ErrorLogged != null)
{
ErrorLogged(null, new MessageLoggedEventArgs { Message = message });
}
Debug.WriteLine("ERROR: " + message);
}
}
}