static int no_lib(media_pipe_t *mp, const char *codec) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to accelerate %s, library not loaded."), codec); return 1; }
static void * audio_output_thread(void *aux) { audio_mode_t *am; int r; audio_fifo_t *af = &af0; thefifo = af; am = audio_mode_current; while(audio_run) { r = am->am_entry(am, af); am = audio_mode_current; if(r == -1) { /* Device error, sleep to avoid busy looping. Hopefully the error will resolve itself (if another app is blocking output, etc) */ sleep(1); } else { if(am) notify_add(NULL, NOTIFY_INFO, NULL, 5, _("Switching audio output to %s"), am->am_title); } } return NULL; }
static JSBool js_notify(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { const char *text; int delay; const char *icon = NULL; if(!JS_ConvertArguments(cx, argc, argv, "si/s", &text, &delay, &icon)) return JS_FALSE; notify_add(NULL, NOTIFY_INFO, icon, delay, rstr_alloc("%s"), text); return JS_TRUE; }
static void keyring_clear(void *opaque, prop_event_t event, ...) { hts_mutex_lock(&keyring_mutex); htsmsg_release(persistent_keyring); htsmsg_release(temporary_keyring); persistent_keyring = htsmsg_create_map(); temporary_keyring = htsmsg_create_map(); htsmsg_store_save(persistent_keyring, "keyring"); hts_mutex_unlock(&keyring_mutex); notify_add(NULL, NOTIFY_WARNING, NULL, 3, _("Rembered passwords erased")); }
static void dvdprobe(callout_t *co, void *aux) { disc_scanner_t *ds = aux; callout_arm(&ds->ds_timer, dvdprobe, ds, 1); if(ds->ds_disc_inserted == 0) { DI_Mount(); if(DI_GetStatus() == DVD_NO_DISC) return; TRACE(TRACE_INFO, "DVD", "DVD inserted"); ds->ds_disc_inserted = 1; ds->ds_disc_ready = 0; } else { uint32_t s = DI_GetStatus(); if(s == DVD_UNKNOWN) { ds->ds_disc_inserted = 0; notify_add(NOTIFY_ERROR, NULL, 5, "Unknown disc inserted, ejecting..."); DI_Eject(); return; } if(!(s & DVD_READY)) { TRACE(TRACE_DEBUG, "DVD", "Waiting for disc ready state = %x", s); return; } if(!ds->ds_disc_ready) check_disc_type(ds); if(DI_GetCoverRegister(&s) || !(s & DVD_COVER_DISC_INSERTED)) { ds->ds_disc_inserted = 0; TRACE(TRACE_INFO, "DVD", "DVD no longer present"); if(ds->ds_service != NULL) { service_destroy(ds->ds_service); ds->ds_service = NULL; } } } }
static void * video_player_idle(void *aux) { video_playback_t *vp = aux; int run = 1; event_t *e = NULL, *next; media_pipe_t *mp = vp->vp_mp; char errbuf[256]; prop_t *errprop = prop_ref_inc(prop_create(mp->mp_prop_root, "error")); while(run) { if(e == NULL) e = mp_dequeue_event(mp); if(event_is_type(e, EVENT_PLAY_URL)) { prop_set_void(errprop); event_playurl_t *ep = (event_playurl_t *)e; int flags = 0; if(ep->primary) flags |= BACKEND_VIDEO_PRIMARY; if(ep->no_audio) flags |= BACKEND_VIDEO_NO_AUDIO; next = backend_play_video(ep->url, mp, flags, ep->priority, errbuf, sizeof(errbuf)); if(next == NULL) { notify_add(NOTIFY_ERROR, NULL, 5, "URL: %s\nError: %s", ep->url, errbuf); prop_set_string(errprop, errbuf); } event_release(e); e = next; continue; } else if(event_is_type(e, EVENT_EXIT)) { event_release(e); break; } event_release(e); e = NULL; } prop_ref_dec(errprop); return NULL; }
static int ln_add(lua_State *L) { struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY); const char *name = luaL_checkstring(L, 2); int flags = luaL_optinteger(L, 3, NOTIFY_ALL); int error; if ((error = notify_add(N->notify, name, flags))) { lua_pushboolean(L, 0); lua_pushinteger(L, error); return 2; } else { lua_pushboolean(L, 1); return 1; } } /* ln_add() */
/** * e_data_cal_view_notify_objects_added: * @query: A query object. * @objects: List of objects that have been added. * * Notifies all query listeners of the addition of a list of objects. */ void e_data_cal_view_notify_objects_added (EDataCalView *view, const GList *objects) { EDataCalViewPrivate *priv; const GList *l; g_return_if_fail (view && E_IS_DATA_CAL_VIEW (view)); priv = view->priv; if (objects == NULL) return; g_mutex_lock (priv->pending_mutex); for (l = objects; l; l = l->next) { notify_add (view, e_util_utf8_make_valid (l->data)); } g_mutex_unlock (priv->pending_mutex); }
static void handle_method_call(GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *param, GDBusMethodInvocation *inv, gpointer user_data) { TRACE(TRACE_DEBUG, "CONNMAN", "agent method call: %s", method_name); if(!strcmp(method_name, "ReportError")) { connman_service_t *cs = connman_service_from_params(param); const char *msg = g_variant_get_string(g_variant_get_child_value(param, 1), NULL); notify_add(NULL, NOTIFY_ERROR, NULL, 3, rstr_alloc("%s\n%s"), cs ? cs->cs_name : "Unknown network", msg); g_dbus_method_invocation_return_value(inv, NULL); } else if(!strcmp(method_name, "RequestInput")) { connman_service_t *cs = connman_service_from_params(param); if(cs == NULL) { g_dbus_method_invocation_return_error_literal(inv, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Unknown service"); return; } agent_request_input(cs, g_variant_get_child_value(param, 1), inv); } else { g_dbus_method_invocation_return_error(inv, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Unknown method %s", method_name); return; } }
/** * e_data_book_view_notify_update: * @book_view: an #EDataBookView * @contact: an #EContact * * Notify listeners that @contact has changed. This can * trigger an add, change or removal event depending on * whether the change causes the contact to start matching, * no longer match, or stay matching the query specified * by @book_view. **/ void e_data_book_view_notify_update (EDataBookView *book_view, EContact *contact) { EDataBookViewPrivate *priv = book_view->priv; gboolean currently_in_view, want_in_view; const gchar *id; gchar *vcard; if (!priv->running) return; g_mutex_lock (priv->pending_mutex); id = e_contact_get_const (contact, E_CONTACT_UID); currently_in_view = id_is_in_view (book_view, id); want_in_view = e_book_backend_sexp_match_contact (priv->card_sexp, contact); if (want_in_view) { vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30); if (currently_in_view) notify_change (book_view, vcard); else notify_add (book_view, id, vcard); g_free (vcard); } else { if (currently_in_view) notify_remove (book_view, id); /* else nothing; we're removing a card that wasn't there */ } g_mutex_unlock (priv->pending_mutex); }
/** * e_data_book_view_notify_update_vcard: * @book_view: an #EDataBookView * @vcard: a plain vCard * * Notify listeners that @vcard has changed. This can * trigger an add, change or removal event depending on * whether the change causes the contact to start matching, * no longer match, or stay matching the query specified * by @book_view. This method should be preferred over * #e_data_book_view_notify_update when the native * representation of a contact is a vCard. **/ void e_data_book_view_notify_update_vcard (EDataBookView *book_view, gchar *vcard) { EDataBookViewPrivate *priv = book_view->priv; gboolean currently_in_view, want_in_view; const gchar *id; EContact *contact; if (!priv->running) { g_free (vcard); return; } g_mutex_lock (priv->pending_mutex); contact = e_contact_new_from_vcard (vcard); id = e_contact_get_const (contact, E_CONTACT_UID); currently_in_view = id_is_in_view (book_view, id); want_in_view = e_book_backend_sexp_match_contact (priv->card_sexp, contact); if (want_in_view) { if (currently_in_view) notify_change (book_view, vcard); else notify_add (book_view, id, vcard); } else { if (currently_in_view) notify_remove (book_view, id); } /* Do this last so that id is still valid when notify_ is called */ g_object_unref (contact); g_free (vcard); g_mutex_unlock (priv->pending_mutex); }
static void check_disc_type(disc_scanner_t *ds) { char *buf = memalign(32, 2048); char title[64]; int r = DI_ReadDVD(buf, 1, 16); if(r) { notify_add(NOTIFY_ERROR, NULL, 5, "Unable to read disc, ejecting..."); DI_Eject(); } else { char *p = &buf[40]; while(*p > 32 && p != &buf[72]) p++; *p = 0; snprintf(title, sizeof(title), "DVD: %s", buf + 40); ds->ds_service = service_create(title, "dvd:/dev/di", SVC_TYPE_VIDEO, NULL, 0); ds->ds_disc_ready = 1; } free(buf); }
/** * e_data_book_view_notify_update_prefiltered_vcard: * @book_view: an #EDataBookView * @id: the UID of this contact * @vcard: a plain vCard * * Notify listeners that @vcard has changed. This can * trigger an add, change or removal event depending on * whether the change causes the contact to start matching, * no longer match, or stay matching the query specified * by @book_view. This method should be preferred over * #e_data_book_view_notify_update when the native * representation of a contact is a vCard. * * The important difference between this method and * #e_data_book_view_notify_update and #e_data_book_view_notify_update_vcard is * that it doesn't match the contact against the book view query to see if it * should be included, it assumes that this has been done and the contact is * known to exist in the view. **/ void e_data_book_view_notify_update_prefiltered_vcard (EDataBookView *book_view, const gchar *id, gchar *vcard) { EDataBookViewPrivate *priv = book_view->priv; gboolean currently_in_view; if (!priv->running) { g_free (vcard); return; } g_mutex_lock (priv->pending_mutex); currently_in_view = id_is_in_view (book_view, id); if (currently_in_view) notify_change (book_view, vcard); else notify_add (book_view, id, vcard); g_free (vcard); g_mutex_unlock (priv->pending_mutex); }
static int video_ps3_vdec_codec_create(media_codec_t *mc, const media_codec_params_t *mcp, media_pipe_t *mp) { vdec_decoder_t *vdd; struct vdec_type dec_type = {0}; struct vdec_attr dec_attr = {0}; int spu_threads; int r; switch(mc->codec_id) { case AV_CODEC_ID_MPEG2VIDEO: if(!vdec_mpeg2_loaded) return no_lib(mp, "MPEG-2"); dec_type.codec_type = VDEC_CODEC_TYPE_MPEG2; dec_type.profile_level = VDEC_MPEG2_MP_HL; spu_threads = 1; break; case AV_CODEC_ID_H264: if(mcp != NULL) { if(mcp->profile == FF_PROFILE_H264_CONSTRAINED_BASELINE) return 1; // can't play this if(mcp->profile >= FF_PROFILE_H264_HIGH_10) return 1; // No 10bit support if(mcp->extradata != NULL) { h264_parser_t hp; hexdump("extradata", mcp->extradata, mcp->extradata_size); if(h264_parser_init(&hp, mcp->extradata, mcp->extradata_size)) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Cell-h264: Broken headers, Disabling acceleration")); return -1; } TRACE(TRACE_DEBUG, "VDEC", "Dumping SPS"); int too_big_refframes = 0; for(int i = 0; i < H264_PARSER_NUM_SPS; i++) { const h264_sps_t *s = &hp.sps_array[i]; if(!s->present) continue; TRACE(TRACE_DEBUG, "VDEC", "SPS[%d]: %d x %d profile:%d level:%d.%d ref-frames:%d", i, s->mb_width * 16, s->mb_height * 16, s->profile, s->level / 10, s->level % 10, s->num_ref_frames); if(s->mb_height >= 68 && s->num_ref_frames > 4) too_big_refframes = s->num_ref_frames; } h264_parser_fini(&hp); if(too_big_refframes) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Cell-h264: %d Ref-frames for 1080 content is incompatible with PS3 HW decoder. Disabling acceleration"), too_big_refframes); return -1; } } } if(!vdec_h264_loaded) return no_lib(mp, "h264"); dec_type.codec_type = VDEC_CODEC_TYPE_H264; if(mcp != NULL && mcp->level > 42) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Cell-h264: Forcing level 4.2 for content in level %d.%d. This may break video playback."), mcp->level / 10, mcp->level % 10); } dec_type.profile_level = 42; spu_threads = 4; break; default: return 1; } r = vdec_query_attr(&dec_type, &dec_attr); if(r) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to query Cell codec. Error 0x%x"), r); return 1; } vdd = calloc(1, sizeof(vdec_decoder_t)); #define ROUND_UP(p, round) ((p + round - 1) & ~(round - 1)) size_t allocsize = ROUND_UP(dec_attr.mem_size, 1024*1024); u32 taddr; if(Lv2Syscall3(348, allocsize, 0x400, (u64)&taddr)) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to open Cell codec. Unable to allocate %d bytes of RAM"), dec_attr.mem_size); return 1; } vdd->mem = (void *)(uint64_t)taddr; TRACE(TRACE_DEBUG, "VDEC", "Opening codec %s level %d using %d bytes of RAM", mc->codec_id == AV_CODEC_ID_H264 ? "h264" : "MPEG2", dec_type.profile_level, dec_attr.mem_size); vdd->config.mem_addr = (intptr_t)vdd->mem; vdd->config.mem_size = dec_attr.mem_size; vdd->config.num_spus = spu_threads; vdd->config.ppu_thread_prio = VDEC_PPU_PRIO; vdd->config.spu_thread_prio = VDEC_SPU_PRIO; vdd->config.ppu_thread_stack_size = 1 << 14; vdec_closure c; c.fn = (intptr_t)OPD32(decoder_callback); c.arg = (intptr_t)vdd; r = vdec_open(&dec_type, &vdd->config, &c, &vdd->handle); if(r) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to open Cell codec. Error 0x%x"), r); Lv2Syscall1(349, (uint64_t)vdd->mem); free(vdd); return 1; } if(mcp != NULL) { vdd->level_major = mcp->level / 10; vdd->level_minor = mcp->level % 10; } if(mc->codec_id == AV_CODEC_ID_H264 && mcp != NULL && mcp->extradata_size) h264_to_annexb_init(&vdd->annexb, mcp->extradata, mcp->extradata_size); vdd->max_order = -1; hts_mutex_init(&vdd->mtx); hts_cond_init(&vdd->audone, &vdd->mtx); hts_cond_init(&vdd->seqdone, &vdd->mtx); TRACE(TRACE_DEBUG, "VDEC", "Cell accelerated codec created using %d bytes of RAM", dec_attr.mem_size); mc->opaque = vdd; mc->decode = decoder_decode; mc->flush = decoder_flush; mc->close = decoder_close; vdec_start_sequence(vdd->handle); return 0; }
int cc_notify(buffer_t* out, command_t* cmd, uint8_t argc, char** argv) { unsigned int session_id = 0, i; connection_t* c; char* endp = NULL; uint8_t arg = 1; unsigned int on_off = 1, valid; enum notify_type type; const char* name,* alias_name = NULL; if (NULL == argv) return EFAULT; c = connect_findbybuffer(out); if (NULL == c) return EDOOFUS; if (arg < argc) { session_id = strtol(argv[arg], &endp, 0); if (session_id) { if (errno || NULL == endp || '\0' != *endp) return EUSAGE; if (!c->info.has_admin) return EACCES; c = connect_findbyid(session_id); if (NULL == c) return ENOSESSION; arg++; } } if (!(arg < argc)) { rset_t* rset; char* typestr; /* display a list of notifications for this client and exit */ rset = rset_new(NULL, 2, c->notify_count); if (NULL == rset || rset->num_fields < 2 || rset->num_records < c->notify_count || NULL == (rset->fields[0] = strdup("type")) || NULL == (rset->fields[1] = strdup("name"))) { rset_free(rset); return errno; } for (i = 0; i < c->notify_count; i++) { switch (c->notify_list[i].type) { case NOTIFY_VAR: typestr = "env"; break; case NOTIFY_DB: typestr = "rset"; break; default: typestr = NULL; break; } if (NULL != typestr) rset_setval(rset, i, 0, typestr); rset_setval(rset, i, 1, c->notify_list[i].name); } output_rset(out, NULL, NULL, rset); rset_free(rset); return ENONE; } if (!strcasecmp(argv[arg], "on")) on_off = 1; else if (!strcasecmp(argv[arg], "off")) on_off = 0; else if (session_id) return EUSAGE; else arg--; arg++; do { if (!(arg < argc)) { if (on_off) return EUSAGE; for (i = c->notify_count; i > 0; i--) notify_del(c, c->notify_list[i - 1].type, c->notify_list[i - 1].name); return ENONE; } if (!strcasecmp(argv[arg], "env")) { arg++; type = NOTIFY_VAR; } else if (!strcasecmp(argv[arg], "rset")) { arg++; type = NOTIFY_DB; } else type = NOTIFY_VAR; if (!(arg < argc)) return EUSAGE; if (NULL == (name = argv[arg++])) return EINVAL; valid = NOTIFY_DB == type ? rset_validname(name) : var_validname(name); if (!valid) { buf_append(out, "ERR: name cannot contain illegal chars\n"); return EIGNORE; } if (on_off) { if (arg < argc) { if (arg + 2 != argc || strcasecmp(argv[arg++], "as")) return EUSAGE; alias_name = argv[arg]; valid = NOTIFY_DB == type ? rset_validname(name) : var_validname(name); if (!valid) { buf_append(out, "ERR: alias name cannot contain illegal chars\n"); return EIGNORE; } if (!strcmp(name, alias_name)) alias_name = NULL; } notify_add(c, type, name, alias_name); if (NOTIFY_DB == type) server_listen4rset(name); return ENONE; } /* loop on "off" names */ notify_del(c, type, name); } while (arg < argc); return ENOSYS; }
static int video_ps3_vdec_codec_create(media_codec_t *mc, const media_codec_params_t *mcp, media_pipe_t *mp) { vdec_decoder_t *vdd; struct vdec_type dec_type = {0}; struct vdec_attr dec_attr = {0}; int spu_threads; int r; switch(mc->codec_id) { case CODEC_ID_MPEG2VIDEO: if(!vdec_mpeg2_loaded) return no_lib(mp, "MPEG-2"); dec_type.codec_type = VDEC_CODEC_TYPE_MPEG2; dec_type.profile_level = VDEC_MPEG2_MP_HL; spu_threads = 1; break; case CODEC_ID_H264: if(mcp != NULL && mcp->profile == FF_PROFILE_H264_CONSTRAINED_BASELINE) return 1; // can't play this if(!vdec_h264_loaded) return no_lib(mp, "h264"); dec_type.codec_type = VDEC_CODEC_TYPE_H264; if(mcp != NULL && mcp->level > 42) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Cell-h264: Forcing level 4.2 for content in level %d.%d. This may break video playback."), mcp->level / 10, mcp->level % 10); } dec_type.profile_level = 42; spu_threads = 4; break; default: return 1; } r = vdec_query_attr(&dec_type, &dec_attr); if(r) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to query Cell codec. Error 0x%x"), r); return 1; } vdd = calloc(1, sizeof(vdec_decoder_t)); #define ROUND_UP(p, round) ((p + round - 1) & ~(round - 1)) size_t allocsize = ROUND_UP(dec_attr.mem_size, 1024*1024); u32 taddr; if(Lv2Syscall3(348, allocsize, 0x400, (u64)&taddr)) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to open Cell codec. Unable to allocate %d bytes of RAM"), dec_attr.mem_size); return 1; } vdd->mem = (void *)(uint64_t)taddr; TRACE(TRACE_DEBUG, "VDEC", "Opening codec %s level %d using %d bytes of RAM", mc->codec_id == CODEC_ID_H264 ? "h264" : "MPEG2", dec_type.profile_level, dec_attr.mem_size); vdd->config.mem_addr = (intptr_t)vdd->mem; vdd->config.mem_size = dec_attr.mem_size; vdd->config.num_spus = spu_threads; vdd->config.ppu_thread_prio = VDEC_PPU_PRIO; vdd->config.spu_thread_prio = VDEC_SPU_PRIO; vdd->config.ppu_thread_stack_size = 1 << 14; vdec_closure c; c.fn = (intptr_t)OPD32(decoder_callback); c.arg = (intptr_t)vdd; r = vdec_open(&dec_type, &vdd->config, &c, &vdd->handle); if(r) { notify_add(mp->mp_prop_notifications, NOTIFY_WARNING, NULL, 10, _("Unable to open Cell codec. Error 0x%x"), r); Lv2Syscall1(349, (uint64_t)vdd->mem); free(vdd); return 1; } if(mcp != NULL) { vdd->level_major = mcp->level / 10; vdd->level_minor = mcp->level % 10; } if(mc->codec_id == CODEC_ID_H264 && mcp != NULL && mcp->extradata_size) h264_to_annexb_init(&vdd->annexb, mcp->extradata, mcp->extradata_size); vdd->max_order = -1; hts_mutex_init(&vdd->mtx); hts_cond_init(&vdd->audone, &vdd->mtx); hts_cond_init(&vdd->seqdone, &vdd->mtx); TRACE(TRACE_DEBUG, "VDEC", "Cell accelerated codec created using %d bytes of RAM", dec_attr.mem_size); mc->opaque = vdd; mc->decode = decoder_decode; mc->flush = decoder_flush; mc->close = decoder_close; vdec_start_sequence(vdd->handle); return 0; }