void D3DVideo::init(const video_info_t &info)
{
if (!g_pD3D)
init_base(info);
else if (needs_restore)
{
D3DPRESENT_PARAMETERS d3dpp;
make_d3dpp(info, d3dpp);
if (dev->Reset(&d3dpp) != D3D_OK)
{
HRESULT res = dev->TestCooperativeLevel();
const char *err;
switch (res)
{
case D3DERR_DEVICELOST:
err = "DEVICELOST";
break;
case D3DERR_DEVICENOTRESET:
err = "DEVICENOTRESET";
break;
case D3DERR_DRIVERINTERNALERROR:
err = "DRIVERINTERNALERROR";
break;
default:
err = "Unknown";
}
// Try to recreate the device completely ...
RARCH_WARN("[D3D9]: Attempting to recover from dead state (%s).\n", err);
deinit();
g_pD3D->Release();
g_pD3D = nullptr;
init_base(info);
RARCH_LOG("[D3D9]: Recovered from dead state.\n");
}
}
calculate_rect(screen_width, screen_height, info.force_aspect, g_settings.video.aspect_ratio);
#ifdef HAVE_CG
if (!init_cg())
throw std::runtime_error("Failed to init Cg");
#endif
if (!init_chain(info))
throw std::runtime_error("Failed to init render chain");
if (!init_font())
throw std::runtime_error("Failed to init Font");
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
int res = init_base(uart, baudrate);
if (res < 0) {
return res;
}
/* save callbacks */
config[uart].rx_cb = rx_cb;
config[uart].arg = arg;
switch (uart) {
#if UART_0_EN
case UART_0:
/* configure and enable global device interrupts */
NVIC_SetPriority(UART_0_IRQ, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART_0_IRQ);
/* enable RX interrupt */
UART_0_DEV->IER |= (1 << 0);
break;
#endif
#if UART_1_EN
case UART_1:
/* configure and enable global device interrupts */
NVIC_SetPriority(UART_1_IRQ, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART_1_IRQ);
/* enable RX interrupt */
UART_1_DEV->IER |= (1 << 0);
break;
#endif
}
return 0;
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
int res;
/* initialize UART in blocking mode first */
res = init_base(uart, baudrate);
if (res < 0) {
return res;
}
/* enable global interrupt and configure the interrupts priority */
switch (uart) {
#if UART_0_EN
case UART_0:
NVIC_EnableIRQ(UART_0_IRQ);
UART_0_DEV->CR1 |= USART_CR1_RXNEIE;
break;
#endif
#if UART_1_EN
case UART_1:
NVIC_EnableIRQ(UART_1_IRQ);
UART_1_DEV->CR1 |= USART_CR1_RXNEIE;
break;
#endif
}
/* register callbacks */
uart_config[uart].rx_cb = rx_cb;
uart_config[uart].arg = arg;
return 0;
}
struct _cef_life_span_handler_t *init_life_span_handler()
{
struct _cef_life_span_handler_t *ret = NULL;
struct refcount *r = NULL;
char *cp = NULL;
DEBUG_ONCE("");
if (!(r = calloc(sizeof(struct refcount) + sizeof(struct _cef_life_span_handler_t), 1))) {
DEBUG_PRINT("#### out of memory! #####");;
return NULL;
}
cp = (char*)r;
cp += sizeof(struct refcount);
ret = (struct _cef_life_span_handler_t*)cp;
if(!init_base((cef_base_t*)ret, sizeof(struct _cef_life_span_handler_t))) {
free(r);
return NULL;
}
ret->base.add_ref((cef_base_t*)ret);
// callbacks
ret->on_before_close = &life_span_handler_on_before_close;
ret->do_close = &life_span_handler_do_close;
ret->on_before_popup = &life_span_handler_on_before_popup;
ret->run_modal = &life_span_handler_run_modal;
ret->on_after_created = &life_span_handler_on_after_created;
return ret;
}
struct _cef_focus_handler_t *init_focus_handler()
{
struct _cef_focus_handler_t *ret = NULL;
struct refcount *r = NULL;
char *cp = NULL;
DEBUG_ONCE("");
if (!(r = calloc(sizeof(struct refcount) + sizeof(struct _cef_focus_handler_t), 1))) {
DEBUG_PRINT("#### out of memory! #####");;
return NULL;
}
cp = (char*)r;
cp += sizeof(struct refcount);
ret = (struct _cef_focus_handler_t*)cp;
if(!init_base((cef_base_t*)ret, sizeof(struct _cef_focus_handler_t))) {
free(r);
return NULL;
}
ret->base.add_ref((cef_base_t*)ret);
// callbacks
ret->on_set_focus = &focus_handler_on_set_focus;
ret->on_got_focus = &focus_handler_on_got_focus;
ret->on_take_focus = &focus_handler_on_take_focus;
return ret;
}
struct _cef_keyboard_handler_t *init_keyboard_handler()
{
struct _cef_keyboard_handler_t *ret = NULL;
struct refcount *r = NULL;
char *cp = NULL;
DEBUG_ONCE("called");
if (!(r = calloc(sizeof(struct refcount) + sizeof(struct _cef_keyboard_handler_t), 1))) {
DEBUG_PRINT("#### out of memory! #####");
return NULL;
}
cp = (char*)r;
cp += sizeof(struct refcount);
ret = (struct _cef_keyboard_handler_t*)cp;
if(!init_base((cef_base_t*)ret, sizeof(struct _cef_keyboard_handler_t))) {
free(r);
return NULL;
}
ret->base.add_ref((cef_base_t*)ret);
// callbacks
ret->on_pre_key_event = &keyboard_handler_on_pre_key_event;
ret->on_key_event = &keyboard_handler_on_key_event;
return ret;
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
/* initialize basic functionality */
int res = init_base(uart, baudrate);
if (res != UART_OK) {
return res;
}
/* register callbacks */
uart_config[uart].rx_cb = rx_cb;
uart_config[uart].arg = arg;
/* configure interrupts and enable RX interrupt */
switch (uart) {
#if UART_0_EN
case UART_0:
NVIC_SetPriority(UART0_IRQn, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART0_IRQn);
break;
#endif
#if UART_1_EN
case UART_1:
NVIC_SetPriority(UART1_IRQn, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART1_IRQn);
break;
#endif
default:
return UART_NODEV;
}
return UART_OK;
}
void gt_gui_stat_update(void) {
session_status *status;
if (base == NULL)
init_base();
status = lt_session_get_status(gt_core_get_session());
(*p)->val = status->payload_download_rate;
p = &(*p)->next;
}
int main(int ac, char **av)
{
t_prog_base base;
if (!test_arg(ac, av))
{
my_putstr("First argument is not a number.\n", 1);
return (0);
}
init_base(&base, ac, av);
print_screen(&base);
(base.difficulty != 200) ? aff_game(&base) : ia_vs_ia(&base);
free_base(&base);
return (0);
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
/* initialize basic functionality */
int res = init_base(uart, baudrate);
if (res != 0) {
return res;
}
/* register callbacks */
uart_ctx[uart].rx_cb = rx_cb;
uart_ctx[uart].arg = arg;
/* configure interrupts and enable RX interrupt */
_uart(uart)->INTENSET.reg = SERCOM_USART_INTENSET_RXC;
NVIC_EnableIRQ(SERCOM0_IRQn + _sercom_id(_uart(uart)));
return 0;
}
int init_game(t_game *game, int nb_map, char **maps)
{
game->map = NULL;
game->maps_list = NULL;
game->screen = NULL;
game->images[0] = NULL;
game->background = NULL;
game->enemies = NULL;
if (load_maps(game, nb_map, maps) == -1)
return (-1);
if (init_base(game) == -1)
return (-1);
if (load_images(game) < 0)
return (-1);
return (0);
}
/**
* Configuring the UART console
*/
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
/* Check the arguments */
assert((uart == 0) || (uart == 1));
/* Check to make sure the UART peripheral is present */
if(!ROM_SysCtlPeripheralPresent(g_ulUARTPeriph[uart])){
return -1;
}
int res = init_base(uart, baudrate);
if(res < 0){
return res;
}
/* save callbacks */
config[uart].rx_cb = rx_cb;
config[uart].arg = arg;
switch (uart){
#if UART_0_EN
case UART_0:
ROM_UARTTxIntModeSet(g_ulUARTBase[uart], UART_TXINT_MODE_EOT);
ROM_UARTFIFOLevelSet(g_ulUARTBase[uart], UART_FIFO_TX4_8, UART_FIFO_RX4_8);
ROM_UARTFIFOEnable(g_ulUARTBase[uart]);
/* Enable the UART interrupt */
NVIC_EnableIRQ(UART_0_IRQ_CHAN);
/* Enable RX interrupt */
UART_0_IM = UART_IM_RXIM | UART_IM_RTIM;
break;
#endif
#if UART_1_EN
case UART_1:
ROM_UARTTxIntModeSet(g_ulUARTBase[uart], UART_TXINT_MODE_EOT);
ROM_UARTFIFOLevelSet(g_ulUARTBase[uart], UART_FIFO_TX4_8, UART_FIFO_RX4_8);
ROM_UARTFIFOEnable(g_ulUARTBase[uart]);
/* Enable the UART interrupt */
NVIC_EnableIRQ(UART_1_IRQ_CHAN);
/* Enable RX interrupt */
UART_1_IM = UART_IM_RXIM | UART_IM_RTIM;
break;
#endif
}
return 0;
}
int main(int argc, char * argv[])
{
if (argc != 2)
print_help();
init_base();
CML_Node * result = NULL;
result_fill(&result, argv[1]);
node_expn( result);
print_result(result, 0);
CML_CHECK(CML_Free(&result));
CML_CHECK(CML_Free(&base));
return 0;
}
void D3DVideo::init(const video_info_t &info)
{
if (!g_pD3D)
init_base(info);
else if (needs_restore)
{
D3DPRESENT_PARAMETERS d3dpp;
make_d3dpp(info, d3dpp);
if (dev->Reset(&d3dpp) != D3D_OK)
throw std::runtime_error("Failed to reset device ...");
}
calculate_rect(screen_width, screen_height, info.force_aspect, g_settings.video.aspect_ratio);
if (!init_cg())
throw std::runtime_error("Failed to init Cg");
if (!init_chain(info))
throw std::runtime_error("Failed to init render chain");
if (!init_font())
throw std::runtime_error("Failed to init Font");
}
struct _cef_client_t *init_client()
{
struct _cef_client_t *ret = NULL;
struct refcount *r = NULL;
char *cp = NULL;
DEBUG_ONCE("init_client()");
if (!(r = calloc(sizeof(struct refcount) + sizeof(struct _cef_client_t), 1))) {
DEBUG_PRINT("#### out of memory! #####");;
return NULL;
}
cp = (char*)r;
cp += sizeof(struct refcount);
ret = (struct _cef_client_t*)cp;
if(!init_base((cef_base_t*)ret, sizeof(struct _cef_client_t))) {
free(r);
return NULL;
}
ret->base.add_ref((cef_base_t*)ret);
// callbacks
ret->get_life_span_handler = &client_get_life_span_handler;
ret->get_keyboard_handler = &client_get_keyboard_handler;
ret->get_dialog_handler = &client_get_dialog_handler;
ret->get_load_handler = &client_get_load_handler;
ret->get_render_handler = &client_get_render_handler;
ret->get_request_handler = &client_get_request_handler;
ret->get_jsdialog_handler = &client_get_jsdialog_handler;
ret->get_context_menu_handler = &client_get_context_menu_handler;
ret->get_drag_handler = &client_get_drag_handler;
ret->get_display_handler = &client_get_display_handler;
ret->get_download_handler = &client_get_download_handler;
ret->on_process_message_received = &client_on_process_message_received;
ret->get_focus_handler = &client_get_focus_handler;
ret->get_geolocation_handler = &client_get_geolocation_handler;
return ret;
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
/* initialize basic functionality */
int res = init_base(uart, baudrate);
if (res != 0) {
return res;
}
/* register callbacks */
uart_config[uart].rx_cb = rx_cb;
uart_config[uart].arg = arg;
/* configure interrupts and enable RX interrupt */
switch (uart) {
case UART_0:
NVIC_SetPriority(UART_0_IRQ, UART_IRQ_PRIO);
NVIC_EnableIRQ(UART_0_IRQ);
UART_0_DEV.INTENSET.bit.RXC = 1;
break;
}
return 0;
}
int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
{
/* do basic initialization */
int res = init_base(uart, baudrate);
if (res < 0) {
return res;
}
/* remember callback addresses */
uart_config[uart].rx_cb = rx_cb;
uart_config[uart].arg = arg;
/* enable receive interrupt */
switch (uart) {
#if UART_0_EN
case UART_0:
NVIC_EnableIRQ(UART_0_IRQ_CHAN);
UART_0_DEV->CR1 |= USART_CR1_RXNEIE;
break;
#endif
#if UART_1_EN
case UART_1:
NVIC_EnableIRQ(UART_1_IRQ_CHAN);
UART_1_DEV->CR1 |= USART_CR1_RXNEIE;
break;
#endif
#if UART_2_EN
case UART_2:
NVIC_EnableIRQ(UART_2_IRQ_CHAN);
UART_2_DEV->CR1 |= USART_CR1_RXNEIE;
break;
#endif
}
return 0;
}
GradientCheckProbe::GradientCheckProbe()
: LayerProbe()
{
init_base();
// Derived classes should call initGradientCheckProbe
}
/**
* @probeName
* @hc
*/
GradientCheckProbe::GradientCheckProbe(const char * probeName, HyPerCol * hc) {
init_base();
}
