#include "vlc_filter.h"
#include "filter_picture.h"
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int Create ( vlc_object_t * );
static void Destroy ( vlc_object_t * );
static picture_t *Filter( filter_t *, picture_t * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
vlc_module_begin ()
set_description( N_("Wave video filter") )
set_shortname( N_( "Wave" ))
set_capability( "video filter2", 0 )
set_category( CAT_VIDEO )
set_subcategory( SUBCAT_VIDEO_VFILTER )
add_shortcut( "wave" )
set_callbacks( Create, Destroy )
vlc_module_end ()
/*****************************************************************************
* filter_sys_t: Distort video output method descriptor
*****************************************************************************
* This structure is part of the video output thread descriptor.
* It describes the Distort specific properties of an output thread.
*****************************************************************************/
E2K_PERMISSIONS_ROLE_EDITOR,
EXCHANGE_DELEGATES_USER_CUSTOM,
-1
};
const gchar *exchange_delegates_user_folder_names[] = {
"calendar", "tasks", "inbox", "contacts"
};
/* To translators: The folder names to be displayed in the message being
* sent to the delegatee.
*/
static const gchar *folder_names_for_display[] = {
N_("Calendar"), N_("Tasks"), N_("Inbox"), N_("Contacts")
};
enum {
EDITED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (
ExchangeDelegatesUser,
exchange_delegates_user,
G_TYPE_OBJECT)
static void
#include <gtk/gtk.h>
#include <canberra.h>
#include <glib/gi18n.h>
#include <glib/gprintf.h>
#include <libnotify/notify.h>
#include <stdlib.h>
enum {
STARTED,
PAUSED,
STOPPED
};
static ca_context *sound;
static gboolean start_on_run = FALSE;
static const gchar *entry_text = N_("Notification text");
static gint state = STOPPED;
struct gui {
GtkWidget *timer_display;
GtkWidget *entry;
GtkWidget *button_timer;
GtkWidget *button_reset;
} gui_elem;
struct gui_timer {
GtkWidget *spin_seconds;
GtkWidget *spin_minutes;
GtkWidget *spin_hours;
} gui_time_elem;
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/extcmd.h>
#include <grub/term.h>
#include <grub/i18n.h>
static const struct grub_arg_option options[] =
{
{"shift", 's', 0, N_("Check Shift key."), 0, 0},
{"ctrl", 'c', 0, N_("Check Control key."), 0, 0},
{"alt", 'a', 0, N_("Check Alt key."), 0, 0},
{0, 0, 0, 0, 0, 0}
};
#define grub_cur_term_input grub_term_get_current_input ()
static grub_err_t
grub_cmd_keystatus (grub_extcmd_t cmd,
int argc __attribute__ ((unused)),
char **args __attribute__ ((unused)))
{
struct grub_arg_list *state = cmd->state;
int expect_mods = 0;
int mods;
/**
* Mutex to protect auth. token
*/
static GMutex *login_mutex = NULL;
/**
* Different type of trace visibility.
*/
typedef struct _OsmTraceVis_t {
const gchar *combostr;
const gchar *apistr;
} OsmTraceVis_t;
static const OsmTraceVis_t OsmTraceVis[] = {
{ N_("Identifiable (public w/ timestamps)"), "identifiable" },
{ N_("Trackable (private w/ timestamps)"), "trackable" },
{ N_("Public"), "public" },
{ N_("Private"), "private" },
{ NULL, NULL },
};
/**
* Struct hosting needed info.
*/
typedef struct _OsmTracesInfo {
gchar *name;
gchar *description;
gchar *tags;
const OsmTraceVis_t *vistype;
VikTrwLayer *vtl;
CP_C_API cp_plugin_info_t * cp_load_plugin_descriptor(cp_context_t *context, const char *path, cp_status_t *error) {
char *file = NULL;
cp_status_t status = CP_OK;
FILE *fh = NULL;
XML_Parser parser = NULL;
ploader_context_t *plcontext = NULL;
cp_plugin_info_t *plugin = NULL;
CHECK_NOT_NULL(context);
CHECK_NOT_NULL(path);
cpi_lock_context(context);
cpi_check_invocation(context, CPI_CF_ANY, __func__);
do {
int path_len;
// Construct the file name for the plug-in descriptor
path_len = strlen(path);
if (path_len == 0) {
status = CP_ERR_IO;
break;
}
if (path[path_len - 1] == CP_FNAMESEP_CHAR) {
path_len--;
}
file = malloc((path_len + strlen(CP_PLUGIN_DESCRIPTOR) + 2) * sizeof(char));
if (file == NULL) {
status = CP_ERR_RESOURCE;
break;
}
strcpy(file, path);
file[path_len] = CP_FNAMESEP_CHAR;
strcpy(file + path_len + 1, CP_PLUGIN_DESCRIPTOR);
// Open the file
if ((fh = fopen(file, "rb")) == NULL) {
status = CP_ERR_IO;
break;
}
// Initialize the XML parsing
parser = XML_ParserCreate(NULL);
if (parser == NULL) {
status = CP_ERR_RESOURCE;
break;
}
XML_SetElementHandler(parser,
start_element_handler,
end_element_handler);
// Initialize the parsing context
if ((plcontext = malloc(sizeof(ploader_context_t))) == NULL) {
status = CP_ERR_RESOURCE;
break;
}
memset(plcontext, 0, sizeof(ploader_context_t));
if ((plcontext->plugin = malloc(sizeof(cp_plugin_info_t))) == NULL) {
status = CP_ERR_RESOURCE;
break;
}
plcontext->context = context;
plcontext->configuration = NULL;
plcontext->value = NULL;
plcontext->parser = parser;
plcontext->file = file;
plcontext->state = PARSER_BEGIN;
memset(plcontext->plugin, 0, sizeof(cp_plugin_info_t));
plcontext->plugin->name = NULL;
plcontext->plugin->identifier = NULL;
plcontext->plugin->version = NULL;
plcontext->plugin->provider_name = NULL;
plcontext->plugin->abi_bw_compatibility = NULL;
plcontext->plugin->api_bw_compatibility = NULL;
plcontext->plugin->plugin_path = NULL;
plcontext->plugin->req_cpluff_version = NULL;
plcontext->plugin->imports = NULL;
plcontext->plugin->runtime_lib_name = NULL;
plcontext->plugin->runtime_funcs_symbol = NULL;
plcontext->plugin->ext_points = NULL;
plcontext->plugin->extensions = NULL;
plcontext->plugin->url = NULL;
plcontext->plugin->resourcetype = NULL;
XML_SetUserData(parser, plcontext);
// Parse the plug-in descriptor
while (1) {
int bytes_read;
void *xml_buffer;
int i;
// Get buffer from Expat
if ((xml_buffer = XML_GetBuffer(parser, CP_XML_PARSER_BUFFER_SIZE))
== NULL) {
status = CP_ERR_RESOURCE;
break;
}
// Read data into buffer
bytes_read = fread(xml_buffer, 1, CP_XML_PARSER_BUFFER_SIZE, fh);
if (ferror(fh)) {
status = CP_ERR_IO;
break;
}
// Parse the data
if (!(i = XML_ParseBuffer(parser, bytes_read, bytes_read == 0))
&& context != NULL) {
cpi_lock_context(context);
cpi_errorf(context,
N_("XML parsing error in %s, line %d, column %d (%s)."),
file,
XML_GetErrorLineNumber(parser),
XML_GetErrorColumnNumber(parser) + 1,
XML_ErrorString(XML_GetErrorCode(parser)));
cpi_unlock_context(context);
}
if (!i || plcontext->state == PARSER_ERROR) {
status = CP_ERR_MALFORMED;
break;
}
if (bytes_read == 0) {
break;
}
}
if (status == CP_OK) {
if (plcontext->state != PARSER_END || plcontext->error_count > 0) {
status = CP_ERR_MALFORMED;
}
if (plcontext->resource_error_count > 0) {
status = CP_ERR_RESOURCE;
}
}
if (status != CP_OK) {
break;
}
// Initialize the plug-in path
*(file + path_len) = '\0';
plcontext->plugin->plugin_path = file;
file = NULL;
// Increase plug-in usage count
if ((status = cpi_register_info(context, plcontext->plugin, (void (*)(cp_context_t *, void *)) dealloc_plugin_info)) != CP_OK) {
break;
}
} while (0);
// Report possible errors
if (status != CP_OK) {
switch (status) {
case CP_ERR_MALFORMED:
cpi_errorf(context,
N_("Plug-in descriptor in %s is invalid."), path);
break;
case CP_ERR_IO:
cpi_errorf(context,
N_("An I/O error occurred while loading a plug-in descriptor from %s."), path);
break;
case CP_ERR_RESOURCE:
cpi_errorf(context,
N_("Insufficient system resources to load a plug-in descriptor from %s."), path);
break;
default:
cpi_errorf(context,
N_("Failed to load a plug-in descriptor from %s."), path);
break;
}
}
cpi_unlock_context(context);
// Release persistently allocated data on failure
if (status != CP_OK) {
if (file != NULL) {
free(file);
file = NULL;
}
if (plcontext != NULL && plcontext->plugin != NULL) {
cpi_free_plugin(plcontext->plugin);
plcontext->plugin = NULL;
}
}
// Otherwise copy the plug-in pointer
else {
plugin = plcontext->plugin;
}
// Release data allocated for parsing
if (parser != NULL) {
XML_ParserFree(parser);
}
if (fh != NULL) {
fclose(fh);
}
if (plcontext != NULL) {
if (plcontext->value != NULL) {
free(plcontext->value);
}
free(plcontext);
plcontext = NULL;
}
// Return error code
if (error != NULL) {
*error = status;
}
return plugin;
}
void
UnitsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UnitSetting &config = CommonInterface::GetUISettings().format.units;
const CoordinateFormat coordinate_format =
CommonInterface::GetUISettings().format.coordinate_format;
RowFormWidget::Prepare(parent, rc);
WndProperty *wp = AddEnum(_("Preset"), _("Load a set of units."));
DataFieldEnum &df = *(DataFieldEnum *)wp->GetDataField();
df.addEnumText(_("Custom"), (unsigned)0, _("My individual set of units."));
unsigned len = Units::Store::Count();
for (unsigned i = 0; i < len; i++)
df.addEnumText(Units::Store::GetName(i), i+1);
LoadValueEnum(UnitsPreset, Units::Store::EqualsPresetUnits(config));
wp->GetDataField()->SetListener(this);
AddSpacer();
SetExpertRow(spacer_1);
static constexpr StaticEnumChoice units_speed_list[] = {
{ (unsigned)Unit::STATUTE_MILES_PER_HOUR, _T("mph") },
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::KILOMETER_PER_HOUR, _T("km/h") },
{ (unsigned)Unit::METER_PER_SECOND, _T("m/s") },
{ 0 }
};
AddEnum(_("Aircraft/Wind speed"),
_("Units used for airspeed and ground speed. "
"A separate unit is available for task speeds."),
units_speed_list,
(unsigned int)config.speed_unit, this);
SetExpertRow(UnitsSpeed);
static constexpr StaticEnumChoice units_distance_list[] = {
{ (unsigned)Unit::STATUTE_MILES, _T("sm") },
{ (unsigned)Unit::NAUTICAL_MILES, _T("nm") },
{ (unsigned)Unit::KILOMETER, _T("km") },
{ 0 }
};
AddEnum(_("Distance"),
_("Units used for horizontal distances e.g. "
"range to waypoint, distance to go."),
units_distance_list,
(unsigned)config.distance_unit, this);
SetExpertRow(UnitsDistance);
static constexpr StaticEnumChoice units_lift_list[] = {
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::METER_PER_SECOND, _T("m/s") },
{ (unsigned)Unit::FEET_PER_MINUTE, _T("ft/min") },
{ 0 }
};
AddEnum(_("Lift"), _("Units used for vertical speeds (variometer)."),
units_lift_list,
(unsigned)config.vertical_speed_unit, this);
SetExpertRow(UnitsLift);
static constexpr StaticEnumChoice units_altitude_list[] = {
{ (unsigned)Unit::FEET, N_("foot") },
{ (unsigned)Unit::METER, N_("meter") },
{ 0 }
};
AddEnum(_("Altitude"), _("Units used for altitude and heights."),
units_altitude_list,
(unsigned)config.altitude_unit, this);
SetExpertRow(UnitsAltitude);
static constexpr StaticEnumChoice units_temperature_list[] = {
{ (unsigned)Unit::DEGREES_CELCIUS, _T(DEG "C") },
{ (unsigned)Unit::DEGREES_FAHRENHEIT, _T(DEG "F") },
{ 0 }
};
AddEnum(_("Temperature"), _("Units used for temperature."),
units_temperature_list,
(unsigned)config.temperature_unit, this);
SetExpertRow(UnitsTemperature);
static constexpr StaticEnumChoice units_taskspeed_list[] = {
{ (unsigned)Unit::STATUTE_MILES_PER_HOUR, _T("mph") },
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::KILOMETER_PER_HOUR, _T("km/h") },
{ (unsigned)Unit::METER_PER_SECOND, _T("m/s") },
{ 0 }
};
AddEnum(_("Task speed"), _("Units used for task speeds."),
units_taskspeed_list,
(unsigned)config.task_speed_unit, this);
SetExpertRow(UnitsTaskSpeed);
static constexpr StaticEnumChoice pressure_labels_list[] = {
{ (unsigned)Unit::HECTOPASCAL, _T("hPa") },
{ (unsigned)Unit::MILLIBAR, _T("mb") },
{ (unsigned)Unit::INCH_MERCURY, _T("inHg") },
{ 0 }
};
AddEnum(_("Pressure"), _("Units used for pressures."),
pressure_labels_list,
(unsigned)config.pressure_unit, this);
SetExpertRow(UnitsPressure);
static constexpr StaticEnumChoice mass_labels_list[] = {
{ (unsigned)Unit::KG, _T("kg") },
{ (unsigned)Unit::LB, _T("lb") },
{ 0 }
};
AddEnum(_("Mass"), _("Units used mass."),
mass_labels_list,
(unsigned)config.mass_unit, this);
SetExpertRow(UnitsMass);
static constexpr StaticEnumChoice wing_loading_labels_list[] = {
{ (unsigned)Unit::KG_PER_M2, _T("kg/m²") },
{ (unsigned)Unit::LB_PER_FT2, _T("lb/ft²") },
{ 0 }
};
AddEnum(_("Wing loading"), _("Units used for wing loading."),
wing_loading_labels_list,
(unsigned)config.wing_loading_unit, this);
SetExpertRow(UnitsWingLoading);
AddSpacer();
SetExpertRow(spacer_2);
static constexpr StaticEnumChoice units_lat_lon_list[] = {
{ (unsigned)CoordinateFormat::DDMMSS, _T("DDMMSS") },
{ (unsigned)CoordinateFormat::DDMMSS_S, _T("DDMMSS.s") },
{ (unsigned)CoordinateFormat::DDMM_MMM, _T("DDMM.mmm") },
{ (unsigned)CoordinateFormat::DD_DDDDD, _T("DD.ddddd") },
{ (unsigned)CoordinateFormat::UTM, _T("UTM") },
{ 0 }
};
AddEnum(_("Lat./Lon."), _("Units used for latitude and longitude."),
units_lat_lon_list,
(unsigned)coordinate_format);
SetExpertRow(UnitsLatLon);
}
#include "field.h"
#include "bmap.h"
#include "io.h"
#include "inode.h"
#include "output.h"
#include "init.h"
static int bmap_f(int argc, char **argv);
static int bmap_one_extent(xfs_bmbt_rec_t *ep,
xfs_fileoff_t *offp, xfs_fileoff_t eoff,
int *idxp, bmap_ext_t *bep);
static xfs_fsblock_t select_child(xfs_fileoff_t off, xfs_bmbt_key_t *kp,
xfs_bmbt_ptr_t *pp, int nrecs);
static const cmdinfo_t bmap_cmd =
{ "bmap", NULL, bmap_f, 0, 3, 0, N_("[-ad] [block [len]]"),
N_("show block map for current file"), NULL };
void
bmap(
xfs_fileoff_t offset,
xfs_filblks_t len,
int whichfork,
int *nexp,
bmap_ext_t *bep)
{
struct xfs_btree_block *block;
xfs_fsblock_t bno;
xfs_fileoff_t curoffset;
xfs_dinode_t *dip;
xfs_fileoff_t eoffset;
static gboolean
print_version (const gchar *option_name,
const gchar *value,
gpointer data,
GError **error)
{
g_print ("Cinnamon %s\n", VERSION);
exit (0);
}
GOptionEntry gnome_cinnamon_options[] = {
{
"version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
print_version,
N_("Print version"),
NULL
},
{ NULL }
};
static void
center_pointer_on_screen ()
{
Display *dpy;
Window root_window;
Screen *screen;
dpy = XOpenDisplay(0);
root_window = XRootWindow(dpy, 0);
XSelectInput(dpy, root_window, KeyReleaseMask);
/**
* @interface_method_impl{Construct a NAT network transport driver instance,
* PDMDRVREG,pfnDestruct}
*/
static DECLCALLBACK(int) drvR3NetShaperConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
{
PDRVNETSHAPER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSHAPER);
LogFlow(("drvNetShaperConstruct:\n"));
PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
/*
* Init the static parts.
*/
pThis->pDrvInsR3 = pDrvIns;
pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
/* IBase */
pDrvIns->IBase.pfnQueryInterface = drvR3NetShaperIBase_QueryInterface;
pThis->IBaseR0.pfnQueryInterface = drvR3NetShaperIBaseR0_QueryInterface;
pThis->IBaseRC.pfnQueryInterface = drvR3NetShaperIBaseRC_QueryInterface;
/* INetworkUp */
pThis->INetworkUpR3.pfnBeginXmit = drvNetShaperUp_BeginXmit;
pThis->INetworkUpR3.pfnAllocBuf = drvNetShaperUp_AllocBuf;
pThis->INetworkUpR3.pfnFreeBuf = drvNetShaperUp_FreeBuf;
pThis->INetworkUpR3.pfnSendBuf = drvNetShaperUp_SendBuf;
pThis->INetworkUpR3.pfnEndXmit = drvNetShaperUp_EndXmit;
pThis->INetworkUpR3.pfnSetPromiscuousMode = drvNetShaperUp_SetPromiscuousMode;
pThis->INetworkUpR3.pfnNotifyLinkChanged = drvR3NetShaperUp_NotifyLinkChanged;
/* Resolve the ring-0 context interface addresses. */
int rc = pDrvIns->pHlpR3->pfnLdrGetR0InterfaceSymbols(pDrvIns, &pThis->INetworkUpR0,
sizeof(pThis->INetworkUpR0),
"drvNetShaperUp_", PDMINETWORKUP_SYM_LIST);
AssertLogRelRCReturn(rc, rc);
/* INetworkDown */
pThis->INetworkDown.pfnWaitReceiveAvail = drvR3NetShaperDown_WaitReceiveAvail;
pThis->INetworkDown.pfnReceive = drvR3NetShaperDown_Receive;
pThis->INetworkDown.pfnReceiveGso = drvR3NetShaperDown_ReceiveGso;
pThis->INetworkDown.pfnXmitPending = drvR3NetShaperDown_XmitPending;
/* INetworkConfig */
pThis->INetworkConfig.pfnGetMac = drvR3NetShaperDownCfg_GetMac;
pThis->INetworkConfig.pfnGetLinkState = drvR3NetShaperDownCfg_GetLinkState;
pThis->INetworkConfig.pfnSetLinkState = drvR3NetShaperDownCfg_SetLinkState;
/*
* Create the locks.
*/
rc = PDMDrvHlpCritSectInit(pDrvIns, &pThis->XmitLock, RT_SRC_POS, "NetShaper");
AssertRCReturn(rc, rc);
/*
* Validate the config.
*/
if (!CFGMR3AreValuesValid(pCfg, "BwGroup\0"))
return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
/*
* Find the bandwidth group we have to attach to.
*/
rc = CFGMR3QueryStringAlloc(pCfg, "BwGroup", &pThis->pszBwGroup);
if (RT_FAILURE(rc) && rc != VERR_CFGM_VALUE_NOT_FOUND)
{
rc = PDMDRV_SET_ERROR(pDrvIns, rc,
N_("DrvNetShaper: Configuration error: Querying \"BwGroup\" as string failed"));
return rc;
}
else
rc = VINF_SUCCESS;
pThis->Filter.pIDrvNetR3 = &pThis->INetworkDown;
rc = PDMDrvHlpNetShaperAttach(pDrvIns, pThis->pszBwGroup, &pThis->Filter);
if (RT_FAILURE(rc))
{
rc = PDMDRV_SET_ERROR(pDrvIns, rc,
N_("DrvNetShaper: Configuration error: Failed to attach to bandwidth group"));
return rc;
}
/*
* Query the network port interface.
*/
pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
if (!pThis->pIAboveNet)
{
AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
return VERR_PDM_MISSING_INTERFACE_ABOVE;
}
/*
* Query the network config interface.
*/
pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
if (!pThis->pIAboveConfig)
{
AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
return VERR_PDM_MISSING_INTERFACE_ABOVE;
}
/*
* Query the network connector interface.
*/
PPDMIBASE pBaseDown;
rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
|| rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
{
pThis->pIBelowNetR3 = NULL;
pThis->pIBelowNetR0 = NIL_RTR0PTR;
}
else if (RT_SUCCESS(rc))
{
pThis->pIBelowNetR3 = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
if (!pThis->pIBelowNetR3)
{
AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
return VERR_PDM_MISSING_INTERFACE_BELOW;
}
PPDMIBASER0 pBaseR0 = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMIBASER0);
pThis->pIBelowNetR0 = pBaseR0 ? pBaseR0->pfnQueryInterface(pBaseR0, PDMINETWORKUP_IID) : NIL_RTR0PTR;
}
else
{
AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
return rc;
}
/*
* Register statistics.
*/
PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesRequested, "Bytes/Tx/Requested", STAMUNIT_BYTES, "Number of requested TX bytes.");
PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesDenied, "Bytes/Tx/Denied", STAMUNIT_BYTES, "Number of denied TX bytes.");
PDMDrvHlpSTAMRegCounterEx(pDrvIns, &pThis->StatXmitBytesGranted, "Bytes/Tx/Granted", STAMUNIT_BYTES, "Number of granted TX bytes.");
PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsRequested, "Packets/Tx/Requested", "Number of requested TX packets.");
PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsDenied, "Packets/Tx/Denied", "Number of denied TX packets.");
PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPktsGranted, "Packets/Tx/Granted", "Number of granted TX packets.");
PDMDrvHlpSTAMRegCounter(pDrvIns, &pThis->StatXmitPendingCalled, "Tx/WakeUp", "Number of wakeup TX calls.");
return VINF_SUCCESS;
}
static void WarnMenuClear(GWindow gw,struct gmenuitem *mi,GEvent *e) {
int i;
for ( i=0; i<errdata.cnt; ++i ) {
free(errdata.errlines[i]);
errdata.errlines[i] = NULL;
}
errdata.cnt = 0;
GDrawRequestExpose(gw,NULL,false);
}
#define MID_Copy 1
#define MID_Clear 2
GMenuItem warnpopupmenu[] = {
{ { (unichar_t *) N_("Cu_t"), NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 1, 0, 0, 0, 0, 0, 1, 1, 0, 't' }, '\0', ksm_control, NULL, NULL, NULL, 0 },
{ { (unichar_t *) N_("_Copy"), NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 0, 0, 0, 0, 0, 1, 1, 0, 'C' }, '\0', ksm_control, NULL, NULL, WarnMenuCopy, MID_Copy },
{ { (unichar_t *) N_("_Paste"), NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 1, 0, 0, 0, 0, 0, 1, 1, 0, 'P' }, '\0', ksm_control, NULL, NULL, NULL, 0 },
{ { (unichar_t *) N_("C_lear"), NULL, COLOR_DEFAULT, COLOR_DEFAULT, NULL, NULL, 0, 0, 0, 0, 0, 0, 1, 1, 0, 'l' }, 0, 0, NULL, NULL, WarnMenuClear, MID_Clear },
GMENUITEM_EMPTY
};
static int warningsv_e_h(GWindow gw, GEvent *event) {
int i;
extern GBox _ggadget_Default_Box;
if (( event->type==et_mouseup || event->type==et_mousedown ) &&
(event->u.mouse.button>=4 && event->u.mouse.button<=7) ) {
return( GGadgetDispatchEvent(errdata.vsb,event));
}
#include "print.h"
#include "bit.h"
#include "flist.h"
#include "strvec.h"
#include "output.h"
#include "sig.h"
#include "write.h"
static void print_allfields(const struct field *fields);
static int print_f(int argc, char **argv);
static void print_flist_1(struct flist *flist, char **pfx, int parentoff);
static void print_somefields(const struct field *fields, int argc,
char **argv);
static const cmdinfo_t print_cmd =
{ "print", "p", print_f, 0, -1, 0, N_("[value]..."),
N_("print field values"), NULL };
static void
print_allfields(
const field_t *fields)
{
flist_t *flist;
#ifdef DEBUG
int i;
#endif
flist = flist_make("");
flist->fld = fields;
#ifndef DEBUG
(void)flist_parse(fields, flist, iocur_top->data, 0);
#include <vlc_meta.h> /* vlc_meta_* */
#include <vlc_input.h> /* vlc_input_attachment, vlc_seekpoint */
#include <vlc_codec.h> /* decoder_t */
#include <vlc_charset.h> /* EnsureUTF8 */
#include <assert.h>
#include "xiph_metadata.h" /* vorbis comments */
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
vlc_module_begin ()
set_description( N_("FLAC demuxer") )
set_capability( "demux", 155 )
set_category( CAT_INPUT )
set_subcategory( SUBCAT_INPUT_DEMUX )
set_callbacks( Open, Close )
add_shortcut( "flac" )
vlc_module_end ()
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int Demux ( demux_t * );
static int Control( demux_t *, int, va_list );
static int ReadMeta( demux_t *, uint8_t **pp_streaminfo, int *pi_streaminfo );
// columns: thing-name, instance-state, variable-value, instance-visible, variable-visible, instance_state_sensitivity
// at depth=0: <sx>, N/A, N/A, N/A N/A, N/A
// at depth=1: <instance>, <state>, N/A, <valid>, N/A, <valid>
// at depth=2: <variable>, N/A, <value>, N/A, <valid>, N/A
adapter->real = gtk_tree_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
g_signal_connect(adapter->real, "row-changed", G_CALLBACK(gsslrtma_proxy_row_changed), adapter);
g_signal_connect(adapter->real, "row-deleted", G_CALLBACK(gsslrtma_proxy_row_deleted), adapter);
g_signal_connect(adapter->real, "row-has-child-toggled", G_CALLBACK(gsslrtma_proxy_row_has_child_toggled), adapter);
g_signal_connect(adapter->real, "row-inserted", G_CALLBACK(gsslrtma_proxy_row_inserted), adapter);
g_signal_connect(adapter->real, "rows-reordered", G_CALLBACK(gsslrtma_proxy_rows_reordered), adapter);
}
static char* gnc_sx_instance_state_names[] =
{
N_("Ignored"),
N_("Postponed"),
N_("To-Create"),
N_("Reminder"),
N_("Created"),
NULL
};
static GtkTreeModel* _singleton_slr_state_model = NULL;
GtkTreeModel*
gnc_sx_get_slr_state_model(void)
{
if (_singleton_slr_state_model == NULL)
{
int i;
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <assert.h>
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_aout.h>
#include <vlc_filter.h>
static int Create( vlc_object_t * );
static void Destroy( vlc_object_t * );
vlc_module_begin ()
set_description( N_("Audio filter for trivial channel mixing") )
set_capability( "audio converter", 1 )
set_category( CAT_AUDIO )
set_subcategory( SUBCAT_AUDIO_MISC )
set_callbacks( Create, Destroy )
vlc_module_end ()
struct filter_sys_t
{
int channel_map[AOUT_CHAN_MAX];
};
/**
* Trivially upmixes
*/
static block_t *Upmix( filter_t *p_filter, block_t *p_in_buf )
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
}
*/
#ifndef XCSOAR_VEGA_DISPLAY_PARAMETERS_HPP
#define XCSOAR_VEGA_DISPLAY_PARAMETERS_HPP
#include "VegaParametersWidget.hpp"
#include "Form/DataField/Enum.hpp"
#include "Language/Language.hpp"
static constexpr StaticEnumChoice needle_gauge_types[] = {
{ 0, _T("None") },
{ 1, _T("LX") },
{ 2, _T("Analog") },
{ 0 },
};
static constexpr
VegaParametersWidget::StaticParameter display_parameters[] = {
{ DataField::Type::ENUM, "NeedleGaugeType", N_("Needle gauge type"),
NULL, needle_gauge_types },
{ DataField::Type::INTEGER, "LedBrightness", N_("LED bright"), NULL,
NULL, 1, 15, 1, _T("%d/15") },
/* sentinel */
{ DataField::Type::BOOLEAN }
};
#endif
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_demux.h>
#include <vlc_charset.h>
#include <limits.h>
#include <assert.h>
#define TEMPO_MIN 20
#define TEMPO_MAX 250 /* Beats per minute */
static int Open (vlc_object_t *);
static void Close (vlc_object_t *);
vlc_module_begin ()
set_description (N_("SMF demuxer"))
set_category (CAT_INPUT)
set_subcategory (SUBCAT_INPUT_DEMUX)
set_capability ("demux", 20)
set_callbacks (Open, Close)
vlc_module_end ()
static int Demux (demux_t *);
static int Control (demux_t *, int i_query, va_list args);
typedef struct smf_track_t
{
int64_t offset; /* Read offset in the file (stream_Tell) */
int64_t end; /* End offset in the file */
uint64_t next; /* Time of next message (in term of pulses) */
uint8_t running_event; /* Running (previous) event */
#include "mxpeg_helper.h"
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close( vlc_object_t * );
#define FPS_TEXT N_("Frames per Second")
#define FPS_LONGTEXT N_("This is the desired frame rate when " \
"playing MJPEG from a file. Use 0 (this is the default value) for a " \
"live stream (from a camera).")
vlc_module_begin ()
set_shortname( "MJPEG")
set_description( N_("M-JPEG camera demuxer") )
set_capability( "demux", 5 )
set_callbacks( Open, Close )
set_category( CAT_INPUT )
set_subcategory( SUBCAT_INPUT_DEMUX )
add_float( "mjpeg-fps", 0.0, FPS_TEXT, FPS_LONGTEXT, false )
vlc_module_end ()
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int MimeDemux( demux_t * );
static int MjpgDemux( demux_t * );
static int Control( demux_t *, int i_query, va_list args );
struct demux_sys_t
#include <libxml/xpath.h>
#include <libxml/xmlsave.h>
#include "internal.h"
#include "buf.h"
#include "memory.h"
#include "util.h"
#include "virsh-domain.h"
#include "xml.h"
#include "virtypedparam.h"
/*
* "capabilities" command
*/
static const vshCmdInfo info_capabilities[] = {
{"help", N_("capabilities")},
{"desc", N_("Returns capabilities of hypervisor/driver.")},
{NULL, NULL}
};
static bool
cmdCapabilities(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
char *caps;
if ((caps = virConnectGetCapabilities(ctl->conn)) == NULL) {
vshError(ctl, "%s", _("failed to get capabilities"));
return false;
}
vshPrint(ctl, "%s\n", caps);
VIR_FREE(caps);
static void FilterPlanar( vout_thread_t *, const picture_t *, picture_t * );
static void FilterI422( vout_thread_t *, const picture_t *, picture_t * );
static void FilterYUYV( vout_thread_t *, const picture_t *, picture_t * );
static int MouseEvent( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define TYPE_TEXT N_("Transform type")
#define TYPE_LONGTEXT N_("One of '90', '180', '270', 'hflip' and 'vflip'")
static const char *const type_list[] = { "90", "180", "270", "hflip", "vflip" };
static const char *const type_list_text[] = { N_("Rotate by 90 degrees"),
N_("Rotate by 180 degrees"), N_("Rotate by 270 degrees"),
N_("Flip horizontally"), N_("Flip vertically") };
#define TRANSFORM_HELP N_("Rotate or flip the video")
#define CFG_PREFIX "transform-"
vlc_module_begin ()
set_description( N_("Video transformation filter") )
set_shortname( N_("Transformation"))
set_help(TRANSFORM_HELP)
set_capability( "video filter", 0 )
set_category( CAT_VIDEO )
set_subcategory( SUBCAT_VIDEO_VFILTER )
add_string( CFG_PREFIX "type", "90", NULL,
GError **error);
static gboolean sdfile_read_header_text(gchar **buffer,
gsize *len,
SDFile *sdfile,
GError **error);
static gchar* sdfile_next_line (gchar **buffer,
const gchar *key,
GError **error);
static GwyDataField* sdfile_read_data_bin (SDFile *sdfile);
static GwyDataField* sdfile_read_data_text (SDFile *sdfile,
GError **error);
static GwyModuleInfo module_info = {
GWY_MODULE_ABI_VERSION,
&module_register,
N_("Imports Surfstand group SDF (Surface Data File) files."),
"Yeti <*****@*****.**>",
"0.10",
"David Nečas (Yeti) & Petr Klapetek",
"2005",
};
static const guint type_sizes[] = { 1, 2, 4, 4, 1, 2, 4, 8 };
GWY_MODULE_QUERY(module_info)
static gboolean
module_register(void)
{
gwy_file_func_register("sdfile-bin",
N_("Surfstand SDF files, binary (.sdf)"),
static void hotkey_key_callback( void *data, uint32_t value, uint32_t pressure, gboolean isKeyDown );
static gboolean hotkey_config_changed( void *data, lxdream_config_group_t group, unsigned key,
const gchar *oldval, const gchar *newval );
#define TAG_RESUME 0
#define TAG_STOP 1
#define TAG_RESET 2
#define TAG_EXIT 3
#define TAG_SAVE 4
#define TAG_LOAD 5
#define TAG_SELECT(i) (6+(i))
struct lxdream_config_group hotkeys_group = {
"hotkeys", input_keygroup_changed, hotkey_key_callback, NULL, {
{"resume", N_("Resume emulation"), CONFIG_TYPE_KEY, NULL, TAG_RESUME },
{"stop", N_("Stop emulation"), CONFIG_TYPE_KEY, NULL, TAG_STOP },
{"reset", N_("Reset emulator"), CONFIG_TYPE_KEY, NULL, TAG_RESET },
{"exit", N_("Exit emulator"), CONFIG_TYPE_KEY, NULL, TAG_EXIT },
{"save", N_("Save current quick save"), CONFIG_TYPE_KEY, NULL, TAG_SAVE },
{"load", N_("Load current quick save"), CONFIG_TYPE_KEY, NULL, TAG_LOAD },
{"state0", N_("Select quick save state 0"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(0) },
{"state1", N_("Select quick save state 1"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(1) },
{"state2", N_("Select quick save state 2"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(2) },
{"state3", N_("Select quick save state 3"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(3) },
{"state4", N_("Select quick save state 4"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(4) },
{"state5", N_("Select quick save state 5"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(5) },
{"state6", N_("Select quick save state 6"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(6) },
{"state7", N_("Select quick save state 7"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(7) },
{"state8", N_("Select quick save state 8"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(8) },
{"state9", N_("Select quick save state 9"), CONFIG_TYPE_KEY, NULL, TAG_SELECT(9) },
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Robin Allen
*
* ***** END GPL LICENSE BLOCK *****
*/
#include "../../../../source/blender/nodes/shader/node_shader_util.h"
static bNodeSocketTemplate sh_node_in[] = {
{SOCK_RGBA, 1, N_("Color"), 0.7f, 0.7f, 0.7f, 1.0f, 0.0f, 1.0f, PROP_NONE, SOCK_NO_INTERNAL_LINK},
{-1, 0, ""}
};
static bNodeSocketTemplate sh_node_out[] = {
{SOCK_SHADER, 0, N_("OutTex")},
{-1, 0, ""}
};
void register_node_type_tex_oct_rgb_spectrum(void) {
static bNodeType ntype;
if(ntype.type != SH_NODE_OCT_RGB_SPECTRUM_TEX) node_type_base(&ntype, SH_NODE_OCT_RGB_SPECTRUM_TEX, "Octane RGBSpectrum Tex", NODE_CLASS_OCT_TEXTURE, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_NEW_SHADING);
node_type_socket_templates(&ntype, sh_node_in, sh_node_out);
node_type_size(&ntype, 160, 160, 200);
static krb5_error_code
kcm_get_cache_first(krb5_context context, krb5_cc_cursor *cursor)
{
krb5_error_code ret;
krb5_kcm_cursor c;
krb5_storage *request, *response;
krb5_data response_data;
*cursor = NULL;
c = calloc(1, sizeof(*c));
if (c == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret,
N_("malloc: out of memory", ""));
goto out;
}
ret = krb5_kcm_storage_request(context, KCM_OP_GET_CACHE_UUID_LIST, &request);
if (ret)
goto out;
ret = krb5_kcm_call(context, request, &response, &response_data);
krb5_storage_free(request);
if (ret)
goto out;
while (1) {
ssize_t sret;
kcmuuid_t uuid;
void *ptr;
sret = krb5_storage_read(response, &uuid, sizeof(uuid));
if (sret == 0) {
ret = 0;
break;
} else if (sret != sizeof(uuid)) {
ret = EINVAL;
goto out;
}
ptr = realloc(c->uuids, sizeof(c->uuids[0]) * (c->length + 1));
if (ptr == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret,
N_("malloc: out of memory", ""));
goto out;
}
c->uuids = ptr;
memcpy(&c->uuids[c->length], &uuid, sizeof(uuid));
c->length += 1;
}
krb5_storage_free(response);
krb5_data_free(&response_data);
out:
if (ret && c) {
free(c->uuids);
free(c);
} else
*cursor = c;
return ret;
}
OPTION_EMERGENCY= 'e' ,
};
static struct option long_options[] =
{
{ "quiet" ,no_argument, NULL, OPTION_QUIET },
{ "help" ,no_argument, NULL, OPTION_HELP },
{ "verbose" ,no_argument, NULL, OPTION_VERBOSE },
{ "version" ,no_argument, NULL, OPTION_VERSION },
{ "device" ,required_argument, NULL, OPTION_DEVICE },
{ "emergency" ,no_argument, NULL, OPTION_EMERGENCY },
{ NULL }
};
static char *option_help[] = {
N_("be quiet"),
N_("print this text"),
N_("be verbose"),
N_("print binary version"),
N_("use this device (default: /dev/pccl)"),
N_("emergency mode (you have to boot with a special CD-ROM)"),
};
static char *version_text =
"1.0.0"
;
static char *copyright_text = N_(
"%s - flash a PAR rom image\n"
"Copyright (C) 1999 by Andrew Kieschnick <*****@*****.**>\n"
"Copyright (C) 1997, 1998, 1999, 2000 by Daniel Balster <*****@*****.**>\n"
static void
query (void)
{
static const GimpParamDef info_return_vals[] =
{
{ GIMP_PDB_STRING, "profile-name", "Name" },
{ GIMP_PDB_STRING, "profile-desc", "Description" },
{ GIMP_PDB_STRING, "profile-info", "Info" }
};
gimp_install_procedure (PLUG_IN_PROC_SET,
N_("Set a color profile on the image"),
"This procedure sets an ICC color profile on an "
"image using the 'icc-profile' parasite. It does "
"not do any color conversion.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("_Assign Color Profile..."),
"RGB*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (set_args), 0,
set_args, NULL);
gimp_install_procedure (PLUG_IN_PROC_SET_RGB,
"Set the default RGB color profile on the image",
"This procedure sets the user-configured RGB "
"profile on an image using the 'icc-profile' "
"parasite. If no RGB profile is configured, sRGB "
"is assumed and the parasite is unset. This "
"procedure does not do any color conversion.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("Assign default RGB Profile"),
"RGB*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (set_rgb_args), 0,
set_rgb_args, NULL);
gimp_install_procedure (PLUG_IN_PROC_APPLY,
_("Apply a color profile on the image"),
"This procedure transform from the image's color "
"profile (or the default RGB profile if none is "
"set) to the given ICC color profile. Only RGB "
"color profiles are accepted. The profile "
"is then set on the image using the 'icc-profile' "
"parasite.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("_Convert to Color Profile..."),
"RGB*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (apply_args), 0,
apply_args, NULL);
gimp_install_procedure (PLUG_IN_PROC_APPLY_RGB,
"Apply default RGB color profile on the image",
"This procedure transform from the image's color "
"profile (or the default RGB profile if none is "
"set) to the configured default RGB color profile. "
"The profile is then set on the image using the "
"'icc-profile' parasite. If no RGB color profile "
"is configured, sRGB is assumed and the parasite "
"is unset.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("Convert to default RGB Profile"),
"RGB*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (apply_rgb_args), 0,
apply_rgb_args, NULL);
gimp_install_procedure (PLUG_IN_PROC_INFO,
"Retrieve information about an image's color profile",
"This procedure returns information about the RGB "
"color profile attached to an image. If no RGB "
"color profile is attached, sRGB is assumed.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("Image Color Profile Information"),
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (info_args),
G_N_ELEMENTS (info_return_vals),
info_args, info_return_vals);
gimp_install_procedure (PLUG_IN_PROC_FILE_INFO,
"Retrieve information about a color profile",
"This procedure returns information about an ICC "
"color profile on disk.",
"Sven Neumann",
"Sven Neumann",
"2006, 2007",
N_("Color Profile Information"),
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (file_info_args),
G_N_ELEMENTS (info_return_vals),
file_info_args, info_return_vals);
gimp_plugin_menu_register (PLUG_IN_PROC_SET,
"<Image>/Image/Mode/Color Profile");
gimp_plugin_menu_register (PLUG_IN_PROC_APPLY,
"<Image>/Image/Mode/Color Profile");
}
#include <locale.h>
#include <errno.h>
#include <string.h>
#include <glib.h>
#include <glib/gi18n.h>
#include <gio/gio.h>
static gboolean progress = FALSE;
static gboolean interactive = FALSE;
static gboolean backup = FALSE;
static gboolean no_target_directory = FALSE;
static GOptionEntry entries[] =
{
{ "no-target-directory", 'T', 0, G_OPTION_ARG_NONE, &no_target_directory, N_("No target directory"), NULL },
{ "progress", 'p', 0, G_OPTION_ARG_NONE, &progress, N_("Show progress"), NULL },
{ "interactive", 'i', 0, G_OPTION_ARG_NONE, &interactive, N_("Prompt before overwrite"), NULL },
{ "backup", 'b', 0, G_OPTION_ARG_NONE, &backup, N_("Backup existing destination files"), NULL },
{ NULL }
};
static gboolean
is_dir (GFile *file)
{
GFileInfo *info;
gboolean res;
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, NULL);
res = info && g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY;
if (info)
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define DEVICE_TEXT N_("Output device")
#define DEVICE_LONGTEXT N_("Select your audio output device")
#define SPEAKER_TEXT N_("Speaker configuration")
#define SPEAKER_LONGTEXT N_("Select speaker configuration you want to use. " \
"This option doesn't upmix! So NO e.g. Stereo -> 5.1 conversion." )
#define VOLUME_TEXT N_("Audio volume")
#define VOLUME_LONGTEXT N_("Audio volume in hundredths of decibels (dB).")
vlc_module_begin ()
set_description( N_("DirectX audio output") )
set_shortname( "DirectX" )
set_capability( "audio output", 100 )
set_category( CAT_AUDIO )
set_subcategory( SUBCAT_AUDIO_AOUT )
add_shortcut( "directx", "aout_directx" )
add_string( "directx-audio-device", NULL,
DEVICE_TEXT, DEVICE_LONGTEXT, false )
change_string_cb( ReloadDirectXDevices )
add_obsolete_string( "directx-audio-device-name")
add_bool( "directx-audio-float32", true, FLOAT_TEXT,
FLOAT_LONGTEXT, true )
add_string( "directx-audio-speaker", "Windows default",
SPEAKER_TEXT, SPEAKER_LONGTEXT, true )
change_string_list( speaker_list, speaker_list )
#define DEFAULT_NAME "Default"
#define MAX_LINE 8192
/*****************************************************************************
* Module descriptor.
*****************************************************************************/
#define FORMAT_TEXT N_("Formatted Subtitles")
#define FORMAT_LONGTEXT N_("Kate streams allow for text formatting. " \
"VLC partly implements this, but you can choose to disable all formatting." \
"Note that this has no effect is rendering via Tiger is enabled.")
#ifdef HAVE_TIGER
static const tiger_font_effect pi_font_effects[] = { tiger_font_plain, tiger_font_shadow, tiger_font_outline };
static const char * const ppsz_font_effect_names[] = { N_("None"), N_("Shadow"), N_("Outline") };
/* nicked off freetype.c */
static const int pi_color_values[] = {
0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
static const char *const ppsz_color_descriptions[] = {
N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
#define TIGER_TEXT N_("Use Tiger for rendering")
#define TIGER_LONGTEXT N_("Kate streams can be rendered using the Tiger library. " \
"Disabling this will only render static text and bitmap based streams.")
* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
#include "../node_shader_util.h"
/* **************** MUSGRAVE ******************** */
static bNodeSocketTemplate sh_node_tex_musgrave_in[] = {
{ SOCK_VECTOR, 1, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
{ SOCK_FLOAT, 1, N_("Scale"), 5.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
{ SOCK_FLOAT, 1, N_("Detail"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 16.0f},
{ SOCK_FLOAT, 1, N_("Dimension"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{ SOCK_FLOAT, 1, N_("Lacunarity"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{ SOCK_FLOAT, 1, N_("Offset"), 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
{ SOCK_FLOAT, 1, N_("Gain"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{ -1, 0, "" }
};
static bNodeSocketTemplate sh_node_tex_musgrave_out[] = {
{ SOCK_RGBA, 0, N_("Color"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_NO_INTERNAL_LINK},
{ SOCK_FLOAT, 0, N_("Fac"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR, SOCK_NO_INTERNAL_LINK},
{ -1, 0, "" }
};