video_decoder_t *
video_decoder_create(media_pipe_t *mp, vd_frame_deliver_t *frame_delivery,
void *opaque)
{
video_decoder_t *vd = calloc(1, sizeof(video_decoder_t));
vd->vd_frame_deliver = frame_delivery;
vd->vd_opaque = opaque;
mp_ref_inc(mp);
vd->vd_mp = mp;
vd_init_timings(vd);
TAILQ_INIT(&vd->vd_spu_queue);
hts_mutex_init(&vd->vd_spu_mutex);
TAILQ_INIT(&vd->vd_overlay_queue);
hts_mutex_init(&vd->vd_overlay_mutex);
hts_thread_create_joinable("video decoder",
&vd->vd_decoder_thread, vd_thread, vd,
THREAD_PRIO_NORMAL);
return vd;
}
void
fa_imageloader_init(void)
{
#if ENABLE_LIBAV
hts_mutex_init(&image_from_video_mutex[0]);
hts_mutex_init(&image_from_video_mutex[1]);
thumbcodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
#endif
}
void
blobcache_init(void)
{
#ifndef BC_USE_FILE_LOCKS
int i;
for(i = 0; i < BC_NUM_FILE_LOCKS; i++)
hts_mutex_init(&blobcache_lock[i]);
#endif
hts_mutex_init(&blobcache_mutex);
callout_arm(&blobcache_callout, blobcache_do_prune, NULL, 1);
}
int
glw_init(glw_root_t *gr, const char *theme, const char *skin,
ui_t *ui, int primary,
const char *instance, const char *instance_title)
{
char buf[256];
skin = skin ?: "grey"; // Read from theme
snprintf(buf, sizeof(buf), "%s/skins/%s", theme, skin);
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_vpaths[0] = "theme";
gr->gr_vpaths[1] = theme;
gr->gr_vpaths[2] = "skin";
gr->gr_vpaths[3] = strdup(buf);
gr->gr_vpaths[4] = NULL;
gr->gr_uii.uii_ui = ui;
glw_text_bitmap_init(gr);
glw_init_settings(gr, instance, instance_title);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_frameduration = 1000000 / 60;
uii_register(&gr->gr_uii, primary);
return 0;
}
static int
gu_start(ui_t *ui, prop_t *root, int argc, char **argv, int primary)
{
gtk_ui_t *gu = calloc(1, sizeof(gtk_ui_t));
XInitThreads();
hts_mutex_init(&gu_mutex);
g_thread_init(NULL);
gdk_threads_set_lock_functions(gu_enter, gu_leave);
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
gu_pixbuf_init();
gu->gu_pc = prop_courier_create_thread(&gu_mutex, "GU");
gu_win_create(gu, prop_create(prop_get_global(), "nav"), 1);
/* Init popup controller */
gu_popup_init(gu);
gtk_main();
return 0;
}
void
lockmgr_init(lockmgr_t *lm, void (*release)(void *aux))
{
hts_mutex_init(&lm->lm_mutex);
lm->lm_release = release;
atomic_set(&lm->lm_refcount, 1);
}
static void
webpopup_init(void)
{
hts_mutex_init(&web_mutex);
hts_cond_init(&web_cond, &web_mutex);
shutdown_hook_add(web_shutdown, NULL, 2);
}
int
glw_init(glw_root_t *gr, const char *theme,
ui_t *ui, int primary,
const char *instance, const char *instance_title)
{
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_token_pool = pool_create("glwtokens", sizeof(token_t), POOL_ZERO_MEM);
gr->gr_clone_pool = pool_create("glwclone", sizeof(glw_clone_t),
POOL_ZERO_MEM);
gr->gr_vpaths[0] = "theme";
gr->gr_vpaths[1] = theme;
gr->gr_vpaths[2] = NULL;
gr->gr_uii.uii_ui = ui;
glw_text_bitmap_init(gr);
glw_init_settings(gr, instance, instance_title);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_frameduration = 1000000 / 60;
uii_register(&gr->gr_uii, primary);
return 0;
}
static rpi_pixmap_decoder_t *
pixmap_decoder_create(int cfmt)
{
rpi_pixmap_decoder_t *rpd = calloc(1, sizeof(rpi_pixmap_decoder_t));
hts_mutex_init(&rpd->rpd_mtx);
hts_cond_init(&rpd->rpd_cond, &rpd->rpd_mtx);
rpd->rpd_decoder = omx_component_create("OMX.broadcom.image_decode",
&rpd->rpd_mtx, &rpd->rpd_cond);
rpd->rpd_decoder->oc_port_settings_changed_cb = decoder_port_settings_changed;
rpd->rpd_decoder->oc_opaque = rpd;
rpd->rpd_resizer = omx_component_create("OMX.broadcom.resize",
&rpd->rpd_mtx, &rpd->rpd_cond);
omx_set_state(rpd->rpd_decoder, OMX_StateIdle);
OMX_IMAGE_PARAM_PORTFORMATTYPE fmt;
OMX_INIT_STRUCTURE(fmt);
fmt.nPortIndex = rpd->rpd_decoder->oc_inport;
fmt.eCompressionFormat = cfmt;
omxchk(OMX_SetParameter(rpd->rpd_decoder->oc_handle,
OMX_IndexParamImagePortFormat, &fmt));
#ifndef NOCOPY
omx_alloc_buffers(rpd->rpd_decoder, rpd->rpd_decoder->oc_inport);
omx_set_state(rpd->rpd_decoder, OMX_StateExecuting);
#endif
return rpd;
}
void
bookmarks_init(void)
{
htsmsg_field_t *f;
htsmsg_t *m, *n, *o;
hts_mutex_init(&bookmark_mutex);
bookmarks = prop_create(settings_add_dir(NULL, "Bookmarks", "bookmark", NULL),
"model");
prop_set_int(prop_create(bookmarks, "mayadd"), 1);
prop_subscribe(0,
PROP_TAG_CALLBACK, bookmarks_callback, NULL,
PROP_TAG_ROOT, prop_create(bookmarks, "nodes"),
PROP_TAG_MUTEX, &bookmark_mutex,
NULL);
if((m = htsmsg_store_load("bookmarks")) != NULL) {
n = htsmsg_get_map(m, "nodes");
HTSMSG_FOREACH(f, n) {
if((o = htsmsg_get_map_by_field(f)) == NULL)
continue;
bookmark_load(o);
}
htsmsg_destroy(m);
}
void
opensub_init(void)
{
prop_t *s;
hts_mutex_init(&opensub_mutex);
s = subtitle_settings_dir;
settings_create_divider(s, _p("Settings for opensubtitles.org"));
htsmsg_t *store = htsmsg_store_load("opensubtitles");
if(store == NULL)
store = htsmsg_create_map();
settings_create_bool(s, "enable", _p("Use opensubtitles.org"), 0,
store, set_enable, NULL,
SETTINGS_INITIAL_UPDATE, NULL,
settings_generic_save_settings,
(void *)"opensubtitles");
settings_create_string(s, "username", _p("Username"), NULL,
store, set_username, NULL,
SETTINGS_INITIAL_UPDATE, NULL,
settings_generic_save_settings,
(void *)"opensubtitles");
settings_create_string(s, "password", _p("Password"), NULL,
store, set_password, NULL,
SETTINGS_INITIAL_UPDATE | SETTINGS_PASSWORD, NULL,
settings_generic_save_settings,
(void *)"opensubtitles");
}
void
keyring_init(void)
{
hts_mutex_init(&keyring_mutex);
if((persistent_keyring = htsmsg_store_load("keyring")) == NULL)
persistent_keyring = htsmsg_create_map();
temporary_keyring = htsmsg_create_map();
}
void
trace_init(void)
{
TAILQ_INIT(&traces);
log_root = prop_create(prop_get_global(), "logbuffer");
hts_mutex_init(&trace_mutex);
trace_initialized = 1;
}
void
usage_init(void)
{
hts_mutex_init(&usage_mutex);
usage_time_base = arch_get_ts() / 1000000LL;
usage_counters = htsmsg_create_map();
plugin_counters = htsmsg_create_map();
}
static int
rvd_init(glw_video_t *gv)
{
rpi_video_display_t *rvd = calloc(1, sizeof(rpi_video_display_t));
rvd->rvd_pts = PTS_UNSET;
rvd->rvd_gv = gv;
gv->gv_aux = rvd;
hts_mutex_init(&rvd->rvd_mutex);
return 0;
}
void
keyring_init(void)
{
hts_mutex_init(&keyring_mutex);
if((persistent_keyring = htsmsg_store_load("keyring")) == NULL)
persistent_keyring = htsmsg_create_map();
temporary_keyring = htsmsg_create_map();
settings_create_action(settings_general, _p("Forget remembered passwords"),
keyring_clear, NULL, NULL);
}
void
notifications_init(void)
{
hts_mutex_init(&news_mutex);
prop_t *root = prop_create(prop_get_global(), "notifications");
if((dismissed_news_in = htsmsg_store_load("dismissed_news")) == NULL)
dismissed_news_in = htsmsg_create_map();
dismissed_news_out = htsmsg_create_map();
notify_prop_entries = prop_create(root, "nodes");
}
void
fa_imageloader_init(void)
{
hts_mutex_init(&image_from_video_mutex);
AVCodec *c = avcodec_find_encoder(CODEC_ID_PNG);
if(c != NULL) {
AVCodecContext *ctx = avcodec_alloc_context();
if(avcodec_open(ctx, c))
return;
pngencoder = ctx;
}
}
void
backend_init(void)
{
backend_t *be;
hts_lwmutex_init(&dyanamic_backends_mutex);
hts_mutex_init(&imageloader_mutex);
hts_cond_init(&imageloader_cond, &imageloader_mutex);
TAILQ_INIT(&cached_images);
LIST_FOREACH(be, &backends, be_global_link)
if(be->be_init != NULL)
be->be_init();
}
omx_component_t *
omx_component_create(const char *name, hts_mutex_t *mtx, hts_cond_t *avail)
{
omx_component_t *oc = calloc(1, sizeof(omx_component_t));
OMX_CALLBACKTYPE cb;
const OMX_INDEXTYPE types[] = {OMX_IndexParamAudioInit,
OMX_IndexParamVideoInit,
OMX_IndexParamImageInit,
OMX_IndexParamOtherInit};
oc->oc_avail_mtx = mtx;
oc->oc_avail_cond = avail;
hts_mutex_init(&oc->oc_event_mtx);
hts_cond_init(&oc->oc_event_cond, &oc->oc_event_mtx);
oc->oc_name = strdup(name);
cb.EventHandler = oc_event_handler;
cb.EmptyBufferDone = oc_empty_buffer_done;
cb.FillBufferDone = oc_fill_buffer_done;
// omxdbg("Creating %s\n", oc->oc_name);
omxchk(OMX_GetHandle(&oc->oc_handle, oc->oc_name, oc, &cb));
// Initially disable ports
int i;
for(i = 0; i < 4; i++) {
OMX_PORT_PARAM_TYPE ports;
ports.nSize = sizeof(OMX_PORT_PARAM_TYPE);
ports.nVersion.nVersion = OMX_VERSION;
omxchk(OMX_GetParameter(oc->oc_handle, types[i], &ports));
omxdbg("%s: type:%d: ports: %ld +%ld\n", name, i, ports.nStartPortNumber, ports.nPorts);
if(ports.nPorts > 0) {
oc->oc_inport = ports.nStartPortNumber;
oc->oc_outport = ports.nStartPortNumber + 1;
}
for(int j = 0; j < ports.nPorts; j++)
omx_send_command(oc, OMX_CommandPortDisable, ports.nStartPortNumber + j, NULL, 0);
}
return oc;
}
void
media_init(void)
{
media_codec_init();
hts_mutex_init(&media_mutex);
media_prop_root = prop_create(prop_get_global(), "media");
media_prop_sources = prop_create(media_prop_root, "sources");
media_prop_current = prop_create(media_prop_root, "current");
HTS_JOIN(sp, k0)[4] = 0x78;
prop_subscribe(0,
PROP_TAG_NAME("media", "eventSink"),
PROP_TAG_CALLBACK, media_global_eventsink, NULL,
PROP_TAG_MUTEX, &media_mutex,
PROP_TAG_ROOT, media_prop_root,
NULL);
}
void
gu_init(int *argc, char ***argv)
{
XInitThreads();
hts_mutex_init(&gu_mutex);
g_thread_init(NULL);
gdk_threads_set_lock_functions(gu_enter, gu_leave);
gdk_threads_init();
gdk_threads_enter();
gtk_init(argc, argv);
gu_pixbuf_init();
}
/**
* Linux main
*/
int
main(int argc, char **argv)
{
gconf.binary = argv[0];
posix_init();
XInitThreads();
hts_mutex_init(&gdk_mutex);
g_thread_init(NULL);
gdk_threads_set_lock_functions(gdk_obtain, gdk_release);
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
parse_opts(argc, argv);
linux_init();
main_init();
if(gconf.ui && !strcmp(gconf.ui, "gu"))
ui_wanted = &ui_gu;
glibcourier = glib_courier_create(g_main_context_default());
prop_subscribe(0,
PROP_TAG_NAME("global", "eventSink"),
PROP_TAG_CALLBACK_EVENT, linux_global_eventsink, NULL,
PROP_TAG_COURIER, glibcourier,
NULL);
add_xdg_paths();
mainloop();
main_fini();
arch_exit();
}
vdpau_dev_t *
vdpau_init_x11(Display *dpy, int screen,
void (*preempted)(void *opaque), void *opaque)
{
vdpau_dev_t *vd = calloc(1, sizeof(vdpau_dev_t));
vd->vd_dpy = dpy;
vd->vd_screen = screen;
vd->vd_preempted = preempted;
vd->vd_opaque = opaque;
hts_mutex_init(&vd->vd_mutex);
if(vdpau_setup_x11(vd)) {
TRACE(TRACE_DEBUG, "VDPAU", "Unable to create VDPAU device");
free(vd);
return NULL;
}
vdpau_info(vd);
return vd;
}
static int
fflockmgr(void **_mtx, enum AVLockOp op)
{
hts_mutex_t **mtx = (hts_mutex_t **)_mtx;
switch(op) {
case AV_LOCK_CREATE:
*mtx = malloc(sizeof(hts_mutex_t));
hts_mutex_init(*mtx);
break;
case AV_LOCK_OBTAIN:
hts_mutex_lock(*mtx);
break;
case AV_LOCK_RELEASE:
hts_mutex_unlock(*mtx);
break;
case AV_LOCK_DESTROY:
hts_mutex_destroy(*mtx);
break;
}
return 0;
}
void
notifications_init(void)
{
hts_mutex_init(&news_mutex);
prop_t *root = prop_create(prop_get_global(), "notifications");
if((dismissed_news_in = htsmsg_store_load("dismissed_news")) == NULL)
dismissed_news_in = htsmsg_create_map();
dismissed_news_out = htsmsg_create_map();
notify_prop_entries = prop_create(root, "nodes");
#if ENABLE_WEBPOPUP
prop_t *dir = setting_get_dir("general:misc");
setting_create(SETTING_BOOL, dir, SETTINGS_INITIAL_UPDATE,
SETTING_TITLE(_p("Show news on home screen")),
SETTING_VALUE(1),
SETTING_WRITE_BOOL(&shownews),
SETTING_STORE("notifications", "shownews"),
NULL);
#endif
}
int
glw_init(glw_root_t *gr, const char *instance)
{
char skinbuf[PATH_MAX];
const char *skin = gconf.skin;
if(skin == NULL) {
snprintf(skinbuf, sizeof(skinbuf),
"%s/glwskins/"SHOWTIME_GLW_DEFAULT_SKIN, showtime_dataroot());
skin = skinbuf;
}
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_token_pool = pool_create("glwtokens", sizeof(token_t), POOL_ZERO_MEM);
gr->gr_clone_pool = pool_create("glwclone", sizeof(glw_clone_t),
POOL_ZERO_MEM);
gr->gr_skin = strdup(skin);
gr->gr_vpaths[0] = "skin";
gr->gr_vpaths[1] = gr->gr_skin;
gr->gr_vpaths[2] = NULL;
gr->gr_font_domain = freetype_get_context();
glw_text_bitmap_init(gr);
glw_init_settings(gr, instance);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_framerate = 60;
gr->gr_frameduration = 1000000 / gr->gr_framerate;
gr->gr_ui_start = showtime_get_ts();
return 0;
}
static void __attribute__((constructor)) mallocsetup(void)
{
hts_mutex_init(&mutex);
#if 0
int size = MB(96);
Lv2Syscall3(348, size, 0x400, (u64)&taddr);
#else
int size = MB(256);
int psize = MB(96);
Lv2Syscall6(300, size, psize, 0xFFFFFFFFU, 0x200ULL, 1UL, (u64)&heap_base);
#endif
total_avail = size;
gpool = tlsf_create((void *)(intptr_t)heap_base, size);
// Malloc is initialized now so we can safely do this
http_path_add("/showtime/memstats", NULL, memstats, 1);
}
int
glw_init(glw_root_t *gr)
{
char skinbuf[PATH_MAX];
const char *skin = gconf.skin;
if(gr->gr_prop_dispatcher == NULL)
gr->gr_prop_dispatcher = &prop_courier_poll_timed;
gr->gr_prop_maxtime = -1;
assert(glw_settings.gs_settings != NULL);
if(prop_set_parent(gr->gr_prop_ui, prop_get_global()))
abort();
if(prop_set_parent(gr->gr_prop_nav, prop_get_global()))
abort();
if(skin == NULL) {
snprintf(skinbuf, sizeof(skinbuf),
"%s/glwskins/"SHOWTIME_GLW_DEFAULT_SKIN, showtime_dataroot());
skin = skinbuf;
}
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_token_pool = pool_create("glwtokens", sizeof(token_t), POOL_ZERO_MEM);
gr->gr_clone_pool = pool_create("glwclone", sizeof(glw_clone_t),
POOL_ZERO_MEM);
gr->gr_skin = strdup(skin);
gr->gr_vpaths[0] = "skin";
gr->gr_vpaths[1] = gr->gr_skin;
gr->gr_vpaths[2] = NULL;
gr->gr_font_domain = freetype_get_context();
glw_text_bitmap_init(gr);
prop_setv(gr->gr_prop_ui, "skin", "path", NULL,
PROP_SET_STRING, gr->gr_skin);
gr->gr_pointer_visible = prop_create(gr->gr_prop_ui, "pointerVisible");
gr->gr_is_fullscreen = prop_create(gr->gr_prop_ui, "fullscreen");
gr->gr_screensaver_active = prop_create(gr->gr_prop_ui, "screensaverActive");
gr->gr_prop_width = prop_create(gr->gr_prop_ui, "width");
gr->gr_prop_height = prop_create(gr->gr_prop_ui, "height");
prop_set_int(gr->gr_screensaver_active, 0);
gr->gr_evsub =
prop_subscribe(0,
PROP_TAG_CALLBACK, glw_eventsink, gr,
PROP_TAG_NAME("ui", "eventSink"),
PROP_TAG_ROOT, gr->gr_prop_ui,
PROP_TAG_COURIER, gr->gr_courier,
NULL);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_framerate = 60;
gr->gr_frameduration = 1000000 / gr->gr_framerate;
gr->gr_ui_start = showtime_get_ts();
gr->gr_open_osk = glw_osk_open;
return 0;
}
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;
}