void VTT_load_script(VTTDec *vttdec, GF_SceneGraph *graph) { GF_Node *n, *root; GF_FieldInfo info; const char *path; FILE *jsfile; if (!graph) return; gf_sg_add_namespace(graph, "http://www.w3.org/2000/svg", NULL); gf_sg_add_namespace(graph, "http://www.w3.org/1999/xlink", "xlink"); gf_sg_add_namespace(graph, "http://www.w3.org/2001/xml-events", "ev"); gf_sg_set_scene_size_info(graph, 800, 600, GF_TRUE); /* modify the scene with an Inline/Animation pointing to the VTT Renderer */ n = root = gf_node_new(graph, TAG_SVG_svg); gf_node_register(root, NULL); gf_sg_set_root_node(graph, root); gf_node_get_attribute_by_name(n, "xmlns", 0, GF_TRUE, GF_FALSE, &info); gf_svg_parse_attribute(n, &info, "http://www.w3.org/2000/svg", 0); VTT_UpdateSizeInfo(vttdec); gf_node_init(n); n = gf_node_new(graph, TAG_SVG_script); gf_node_register(n, root); gf_node_list_add_child(&((GF_ParentNode *)root)->children, n); path = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript"); if (!path) { /* try to find the JS renderer in the default GPAC installation folder */ const char *startuppath = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "General", "StartupFile"); path = gf_url_concatenate(startuppath, "webvtt-renderer.js"); jsfile = gf_fopen(path, "rt"); if (jsfile) { gf_modules_set_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript", path); gf_fclose(jsfile); } else { GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot find Rendering Script [WebVTT:RenderingScript] - check config file\n")); return; } } jsfile = gf_fopen(path, "rt"); if (jsfile) { gf_fclose(jsfile); gf_node_get_attribute_by_tag(n, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &info); if (strstr(path, ":\\")) { gf_svg_parse_attribute(n, &info, (char *) path, 0); } else { char szPath[GF_MAX_PATH]; strcpy(szPath, "file://"); strcat(szPath, path); gf_svg_parse_attribute(n, &info, (char *) szPath, 0); } vttdec->has_rendering_script = GF_TRUE; } else { GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot open Rendering Script - %s\n", path)); return; } gf_node_init(n); }
static GF_Err ALSA_Setup(GF_AudioOutput*dr, void *os_handle, u32 num_buffers, u32 total_duration) { int err; const char *opt; ALSAContext *ctx = (ALSAContext*)dr->opaque; opt = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "ForceSampleRate"); if (opt) ctx->force_sr = atoi(opt); ctx->dev_name = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "DeviceName"); if (!ctx->dev_name) { ctx->dev_name = "hw:0,0"; gf_modules_set_option((GF_BaseInterface *)dr, "ALSA", "DeviceName", ctx->dev_name); } /*test device*/ err = snd_pcm_open(&ctx->playback_handle, ctx->dev_name, SND_PCM_STREAM_PLAYBACK, 0); if (err < 0) { GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[ALSA] Cannot open audio device %s: %s\n", ctx->dev_name, snd_strerror (err)) ); return GF_IO_ERR; } ctx->num_buffers = num_buffers; ctx->total_duration = total_duration; return GF_OK; }
GF_Err RP_InitStream(RTPStream *ch, Bool ResetOnly) { gf_rtp_depacketizer_reset(ch->depacketizer, !ResetOnly); if (!ResetOnly) { const char *ip_ifce = NULL; u32 reorder_size = 0; if (!ch->owner->transport_mode) { const char *sOpt = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Streaming", "ReorderSize"); if (sOpt) reorder_size = atoi(sOpt); else reorder_size = 10; ip_ifce = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "DefaultMCastInterface"); if (!ip_ifce) { const char *mob_on = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "MobileIPEnabled"); if (mob_on && !strcmp(mob_on, "yes")) { ip_ifce = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "MobileIP"); ch->flags |= RTP_MOBILEIP; } } } return gf_rtp_initialize(ch->rtp_ch, RTP_BUFFER_SIZE, 0, 0, reorder_size, 200, (char *)ip_ifce); } //just reset the sockets gf_rtp_reset_buffers(ch->rtp_ch); return GF_OK; }
static GF_Err ft_init_font_engine(GF_FontReader *dr) { const char *sOpt; FTBuilder *ftpriv = (FTBuilder *)dr->udta; sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontDirectory"); if (!sOpt) return GF_BAD_PARAM; /*inits freetype*/ if (FT_Init_FreeType(&ftpriv->library) ) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[FreeType] Cannot initialize FreeType\n")); return GF_IO_ERR; } while (sOpt) { char dir[GF_MAX_PATH]; char *sep = (char *) strchr(sOpt, ','); if (sep) sep[0] = 0; strcpy(dir, sOpt); while ( (dir[strlen(dir)-1] == '\n') || (dir[strlen(dir)-1] == '\r') ) dir[strlen(dir)-1] = 0; if (dir[strlen(dir)-1] != GF_PATH_SEPARATOR) { char ext[2]; ext[0] = GF_PATH_SEPARATOR; ext[1] = 0; strcat(dir, ext); } gf_list_add(ftpriv->font_dirs, gf_strdup(dir) ); if (!sep) break; sep[0] = ','; sOpt = sep+1; } sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "RescanFonts"); if (!sOpt || !strcmp(sOpt, "yes") ) ft_rescan_fonts(dr); if (!ftpriv->font_serif) { sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif"); ftpriv->font_serif = gf_strdup(sOpt ? sOpt : ""); } if (!ftpriv->font_sans) { sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans"); ftpriv->font_sans = gf_strdup(sOpt ? sOpt : ""); } if (!ftpriv->font_fixed) { sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed"); ftpriv->font_fixed = gf_strdup(sOpt ? sOpt : ""); } GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Init OK - %d font directory (first %s)\n", gf_list_count(ftpriv->font_dirs), gf_list_get(ftpriv->font_dirs, 0) )); return GF_OK; }
static void dd_init_gl_offscreen(GF_VideoOutput *driv) { const char *opt; DDContext *dd = driv->opaque; opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode"); #ifndef _WIN32_WCE wglCreatePbufferARB = (CREATEPBUFFERARB) wglGetProcAddress("wglCreatePbufferARB"); if (opt && strcmp(opt, "PBuffer")) wglCreatePbufferARB = NULL; if (wglCreatePbufferARB) { wglChoosePixelFormatARB = (CHOOSEPFFORMATARB) wglGetProcAddress("wglChoosePixelFormatARB"); wglDestroyPbufferARB = (DESTROYBUFFERARB) wglGetProcAddress("wglDestroyPbufferARB"); wglGetPbufferDCARB = (GETPBUFFERDCARB ) wglGetProcAddress("wglGetPbufferDCARB"); wglReleasePbufferDCARB = (RELEASEPBUFFERDCARB ) wglGetProcAddress("wglReleasePbufferDCARB"); GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using PBuffer for OpenGL Offscreen Rendering\n")); driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA; if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "PBuffer"); } else #endif { u32 gl_type = 1; HINSTANCE hInst; #ifndef _WIN32_WCE hInst = GetModuleHandle("gm_dx_hw.dll"); #else hInst = GetModuleHandle(_T("gm_dx_hw.dll")); #endif opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode"); if (opt) { if (!strcmp(opt, "Window")) gl_type = 1; else if (!strcmp(opt, "VisibleWindow")) gl_type = 2; else gl_type = 0; } else { gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "Window"); } if (gl_type) { #ifdef _WIN32_WCE dd->gl_hwnd = CreateWindow(_T("GPAC DirectDraw Output"), _T("GPAC OpenGL Offscreen"), WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL); #else dd->gl_hwnd = CreateWindow("GPAC DirectDraw Output", "GPAC OpenGL Offscreen", WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL); #endif if (!dd->gl_hwnd) return; ShowWindow(dd->gl_hwnd, (gl_type == 2) ? SW_SHOW : SW_HIDE); GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using %s window for OpenGL Offscreen Rendering\n", (gl_type == 2) ? "Visible" : "Hidden")); driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA; } } }
static GF_Err CTXLoad_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd) { const char *ext; GF_BitStream *bs; u32 size; CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack; if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED; /*animation stream like*/ if (priv->ctx) { GF_StreamContext *sc; u32 i = 0; while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) { if (esd->ESID == sc->ESID) { priv->nb_streams++; return GF_OK; } } return GF_NON_COMPLIANT_BITSTREAM; } /*main dummy stream we need a dsi*/ if (!esd->decoderConfig->decoderSpecificInfo) return GF_NON_COMPLIANT_BITSTREAM; bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ); priv->file_size = gf_bs_read_u32(bs); gf_bs_del(bs); size = esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32); priv->file_name = (char *) gf_malloc(sizeof(char)*(1 + size) ); memcpy(priv->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), sizeof(char)*(esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) ); priv->file_name[size] = 0; priv->nb_streams = 1; priv->load_flags = 0; priv->base_stream_id = esd->ESID; priv->service_url = esd->service_url; CTXLoad_Setup(plug); priv->progressive_support = GF_FALSE; priv->sax_max_duration = 0; ext = strrchr(priv->file_name, '.'); if (!ext) return GF_OK; ext++; if (!stricmp(ext, "xmt") || !stricmp(ext, "xmtz") || !stricmp(ext, "xmta") || !stricmp(ext, "x3d") || !stricmp(ext, "x3dz") ) { ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive"); priv->progressive_support = (ext && !stricmp(ext, "yes")) ? GF_TRUE : GF_FALSE; } if (priv->progressive_support) { ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration"); if (ext) priv->sax_max_duration = atoi(ext); } return GF_OK; }
static Bool uir_process(GF_TermExt *termext, u32 action, void *param) { const char *opt, *uifile; GF_UIRecord *uir = termext->udta; switch (action) { case GF_TERM_EXT_START: uir->term = (GF_Terminal *) param; opt = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "Mode"); if (!opt) return 0; uifile = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "File"); if (!opt) return 0; if (!strcmp(opt, "Play")) { uir->uif = gf_f64_open(uifile, "rb"); if (!uir->uif) return 0; uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_READ); termext->caps |= GF_TERM_EXTENSION_NOT_THREADED; uir->evt_filter.on_event = uir_on_event_play; uir->evt_filter.udta = uir; gf_term_add_event_filter(uir->term, &uir->evt_filter); uir_load_event(uir); } else if (!strcmp(opt, "Record")) { uir->uif = fopen(uifile, "wb"); if (!uir->uif) return 0; uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_WRITE); uir->evt_filter.on_event = uir_on_event_record; uir->evt_filter.udta = uir; gf_term_add_event_filter(uir->term, &uir->evt_filter); } else { return 0; } return 1; case GF_TERM_EXT_STOP: if (uir->uif) fclose(uir->uif); if (uir->bs) gf_bs_del(uir->bs); gf_term_remove_event_filter(uir->term, &uir->evt_filter); uir->term = NULL; /*auto-disable the plugin by default*/ gf_modules_set_option((GF_BaseInterface*)termext, "UIRecord", "Mode", "Disable"); break; case GF_TERM_EXT_PROCESS: /*flush all events until current time if reached*/ while (uir->evt_loaded && uir->ck && (uir->next_time <= gf_clock_time(uir->ck) )) { uir->term->compositor->video_out->on_event(uir->term->compositor->video_out->evt_cbk_hdl, &uir->next_event); uir_load_event(uir); } break; } return 0; }
GF_Err SDLVid_ResizeWindow(GF_VideoOutput *dr, u32 width, u32 height) { SDLVID(); GF_Event evt; /*lock X mutex to make sure the event queue is not being processed*/ gf_mx_p(ctx->evt_mx); if (ctx->output_3d_type==1) { u32 flags, nb_bits; const char *opt; if ((ctx->width==width) && (ctx->height==height) ) { gf_mx_v(ctx->evt_mx); return GF_OK; } flags = SDL_GL_WINDOW_FLAGS; if (ctx->os_handle) flags &= ~SDL_RESIZABLE; if (ctx->fullscreen) flags |= SDL_FULLSCREEN_FLAGS; if (!ctx->screen) ctx->screen = SDL_SetVideoMode(width, height, 0, flags); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "GLNbBitsDepth"); nb_bits = opt ? atoi(opt) : 16; SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, nb_bits); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0); opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "GLNbBitsPerComponent"); nb_bits = opt ? atoi(opt) : 5; SDL_GL_SetAttribute(SDL_GL_RED_SIZE, nb_bits); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, nb_bits); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, nb_bits); assert(width); assert(height); ctx->screen = SDL_SetVideoMode(width, height, 0, flags); assert(ctx->screen); ctx->width = width; ctx->height = height; memset(&evt, 0, sizeof(GF_Event)); evt.type = GF_EVENT_VIDEO_SETUP; dr->on_event(dr->evt_cbk_hdl, &evt); } else { u32 flags; #ifdef GPAC_IPHONE flags = SDL_FULLSCREEN_FLAGS; //SDL readme says it would make us faster SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0); SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 1); #else flags = SDL_WINDOW_FLAGS; #endif if (ctx->os_handle) flags &= ~SDL_RESIZABLE; ctx->screen = SDL_SetVideoMode(width, height, 0, flags); } gf_mx_v(ctx->evt_mx); return ctx->screen ? GF_OK : GF_IO_ERR; }
static GF_Err SVG_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd) { const char *sOpt; GF_BitStream *bs; SVGIn *svgin = (SVGIn *)plug->privateStack; if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED; svgin->loader.type = GF_SM_LOAD_SVG; /* decSpecInfo is not null only when reading from an SVG file (local or distant, cached or not) */ switch (esd->decoderConfig->objectTypeIndication) { case GPAC_OTI_SCENE_SVG: case GPAC_OTI_SCENE_SVG_GZ: svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING; /*no decSpecInfo defined for streaming svg yet*/ break; case GPAC_OTI_SCENE_DIMS: svgin->loader.type = GF_SM_LOAD_DIMS; svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING; /*decSpecInfo not yet supported for DIMS svg - we need properties at the scene level to store the various indications*/ break; case GPAC_OTI_PRIVATE_SCENE_SVG: default: if (!esd->decoderConfig->decoderSpecificInfo) return GF_NON_COMPLIANT_BITSTREAM; bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ); svgin->file_size = gf_bs_read_u32(bs); svgin->file_pos = 0; gf_bs_del(bs); svgin->file_name = (char *) gf_malloc(sizeof(char)*(1 + esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) ); memcpy(svgin->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) ); svgin->file_name[esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) ] = 0; break; } svgin->oti = esd->decoderConfig->objectTypeIndication; if (!esd->dependsOnESID) svgin->base_es_id = esd->ESID; sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive"); if (sOpt && !strcmp(sOpt, "yes")) { svgin->sax_max_duration = 30; sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration"); if (sOpt) { svgin->sax_max_duration = atoi(sOpt); } else { svgin->sax_max_duration = 30; gf_modules_set_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration", "30"); } } else { svgin->sax_max_duration = (u32) -1; } return GF_OK; }
GF_Err gdip_init_font_engine(GF_FontReader *dr) { const char *sOpt; FontPriv *ctx = (FontPriv *)dr->udta; sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif"); strcpy(ctx->font_serif, sOpt ? sOpt : "Times New Roman"); sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans"); strcpy(ctx->font_sans, sOpt ? sOpt : "Arial"); sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed"); strcpy(ctx->font_fixed, sOpt ? sOpt : "Courier New"); return GF_OK; }
static void M2TS_GetNetworkType(GF_InputService *plug,M2TSIn *reader) { const char *mob_on; const char *mcast_ifce; mob_on = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "MobileIPEnabled"); if(mob_on && !strcmp(mob_on, "yes")) { reader->ts->MobileIPEnabled = 1; reader->ts->network_type = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "MobileIP"); } mcast_ifce = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "DefaultMCastInterface"); if(mcast_ifce) reader->ts->network_type = gf_strdup(mcast_ifce); }
static GF_Err ft_init_font_engine(GF_FontReader *dr) { const char *sOpt; FTBuilder *ftpriv = (FTBuilder *)dr->udta; sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontDirectory"); if (!sOpt) return GF_BAD_PARAM; /*inits freetype*/ if (FT_Init_FreeType(&ftpriv->library) ) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[FreeType] Cannot initialize FreeType\n")); return GF_IO_ERR; } /*remove the final delimiter*/ ftpriv->font_dir = gf_strdup(sOpt); while ( (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] == '\n') || (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] == '\r') ) ftpriv->font_dir[strlen(ftpriv->font_dir)-1] = 0; /*store font path*/ if (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] != GF_PATH_SEPARATOR) { char ext[2], *temp; ext[0] = GF_PATH_SEPARATOR; ext[1] = 0; temp = gf_malloc(sizeof(char) * (strlen(ftpriv->font_dir) + 2)); strcpy(temp, ftpriv->font_dir); strcat(temp, ext); gf_free(ftpriv->font_dir); ftpriv->font_dir = temp; } sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "RescanFonts"); if (!sOpt || !strcmp(sOpt, "yes") ) ft_rescan_fonts(dr); sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif"); ftpriv->font_serif = gf_strdup(sOpt ? sOpt : ""); sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans"); ftpriv->font_sans = gf_strdup(sOpt ? sOpt : ""); sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed"); ftpriv->font_fixed = gf_strdup(sOpt ? sOpt : ""); GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Init OK - font directory %s\n", ftpriv->font_dir)); return GF_OK; }
GF_Err SDLVid_SetFullScreen(GF_VideoOutput *dr, u32 bFullScreenOn, u32 *screen_width, u32 *screen_height) { u32 bpp, pref_bpp; SDLVID(); if (ctx->fullscreen==bFullScreenOn) return GF_OK; /*lock to get sure the event queue is not processed under X*/ gf_mx_p(ctx->evt_mx); ctx->fullscreen = bFullScreenOn; pref_bpp = bpp = ctx->screen->format->BitsPerPixel; if (ctx->fullscreen) { u32 flags; Bool switch_res = 0; const char *sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "SwitchResolution"); if (sOpt && !stricmp(sOpt, "yes")) switch_res = 1; if (!dr->max_screen_width || !dr->max_screen_height) switch_res = 1; flags = (ctx->output_3d_type==1) ? SDL_GL_FULLSCREEN_FLAGS : SDL_FULLSCREEN_FLAGS; ctx->store_width = *screen_width; ctx->store_height = *screen_height; if (switch_res) { u32 i; ctx->fs_width = *screen_width; ctx->fs_height = *screen_height; for(i=0; i<nb_video_modes; i++) { if (ctx->fs_width<=video_modes[2*i] && ctx->fs_height<=video_modes[2*i + 1]) { if ((pref_bpp = SDL_VideoModeOK(video_modes[2*i], video_modes[2*i+1], bpp, flags))) { ctx->fs_width = video_modes[2*i]; ctx->fs_height = video_modes[2*i + 1]; break; } } } } else { ctx->fs_width = dr->max_screen_width; ctx->fs_height = dr->max_screen_height; } ctx->screen = SDL_SetVideoMode(ctx->fs_width, ctx->fs_height, pref_bpp, flags); /*we switched bpp, clean all objects*/ if (bpp != pref_bpp) SDLVid_DestroyObjects(ctx); *screen_width = ctx->fs_width; *screen_height = ctx->fs_height; /*GL has changed*/ if (ctx->output_3d_type==1) { GF_Event evt; evt.type = GF_EVENT_VIDEO_SETUP; dr->on_event(dr->evt_cbk_hdl, &evt); } } else { SDLVid_ResizeWindow(dr, ctx->store_width, ctx->store_height); *screen_width = ctx->store_width; *screen_height = ctx->store_height; } gf_mx_v(ctx->evt_mx); if (!ctx->screen) return GF_IO_ERR; return GF_OK; }
GF_Err SDLVid_SetBackbufferSize(GF_VideoOutput *dr, u32 newWidth, u32 newHeight, Bool system_mem) { u32 col; const char *opt; SDLVID(); if (ctx->output_3d_type==1) return GF_BAD_PARAM; opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "HardwareMemory"); if (system_mem) { if (opt && !strcmp(opt, "Always")) system_mem = 0; } else { if (opt && !strcmp(opt, "Never")) system_mem = 1; } ctx->use_systems_memory = system_mem; /*clear screen*/ col = SDL_MapRGB(ctx->screen->format, 0, 0, 0); SDL_FillRect(ctx->screen, NULL, col); SDL_Flip(ctx->screen); if (ctx->back_buffer && ((u32) ctx->back_buffer->w==newWidth) && ((u32) ctx->back_buffer->h==newHeight)) { return GF_OK; } if (ctx->back_buffer) SDL_FreeSurface(ctx->back_buffer); ctx->back_buffer = SDL_CreateRGBSurface(ctx->use_systems_memory ? SDL_SWSURFACE : SDL_HWSURFACE, newWidth, newHeight, ctx->screen->format->BitsPerPixel, ctx->screen->format->Rmask, ctx->screen->format->Gmask, ctx->screen->format->Bmask, 0); ctx->width = newWidth; ctx->height = newHeight; if (!ctx->back_buffer) return GF_IO_ERR; return GF_OK; }
static Bool WII_RegisterDevice(struct __input_device *ifce, const char *urn, GF_BitStream *dsi, void (*AddField)(struct __input_device *_this, u32 fieldType, const char *name)) { const char *opt; GF_WiiMote *wii = (GF_WiiMote *)ifce->udta; if (strcmp(urn, "WiiMote")) return 0; /*init wiiuse lib*/ opt = gf_modules_get_option((GF_BaseInterface*)ifce, "WII", "MaxWiimotes"); if (opt) wii->nb_wiimotes = atoi(opt); if (!wii->nb_wiimotes) wii->nb_wiimotes = 1; wii->wiimotes = wiiuse_init(wii->nb_wiimotes); if (!wii->wiimotes) { GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[Wii] Cannot initialize wiiuse library\n")); return 0; } /*declare the interface*/ AddField(ifce, GF_SG_VRML_SFINT32, "uid"); AddField(ifce, GF_SG_VRML_SFBOOL, "1"); AddField(ifce, GF_SG_VRML_SFBOOL, "2"); AddField(ifce, GF_SG_VRML_SFBOOL, "A"); AddField(ifce, GF_SG_VRML_SFBOOL, "B"); AddField(ifce, GF_SG_VRML_SFBOOL, "-"); AddField(ifce, GF_SG_VRML_SFBOOL, "home"); AddField(ifce, GF_SG_VRML_SFBOOL, "+"); AddField(ifce, GF_SG_VRML_SFBOOL, "left"); AddField(ifce, GF_SG_VRML_SFBOOL, "right"); AddField(ifce, GF_SG_VRML_SFBOOL, "down"); AddField(ifce, GF_SG_VRML_SFBOOL, "up"); AddField(ifce, GF_SG_VRML_SFVEC3F, "ypr"); AddField(ifce, GF_SG_VRML_SFVEC3F, "gravity"); return 1; }
RTSPSession *RP_NewSession(RTPClient *rtp, char *session_control) { char *szCtrl, *szExt; RTSPSession *tmp; GF_RTSPSession *rtsp; if (!session_control) return NULL; /*little fix: some servers don't understand DESCRIBE URL/trackID=, so remove the trackID...*/ szCtrl = gf_strdup(session_control); szExt = szCtrl ? strrchr(szCtrl, '.') : NULL; if (szExt) { szExt = strchr(szExt, '/'); if (szExt) { if (!strnicmp(szExt+1, "trackID=", 8) || !strnicmp(szExt+1, "ESID=", 5) || !strnicmp(szExt+1, "ES_ID=", 6)) szExt[0] = 0; } } rtsp = gf_rtsp_session_new(szCtrl, rtp->default_port); gf_free(szCtrl); if (!rtsp) return NULL; GF_SAFEALLOC(tmp, RTSPSession); tmp->owner = rtp; tmp->session = rtsp; szCtrl = (char *)gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(rtp->service), "Network", "MobileIPEnabled"); if (szCtrl && !strcmp(szCtrl, "yes")) { char *ip = (char *)gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(rtp->service), "Network", "MobileIP"); gf_rtsp_set_mobile_ip(rtsp, ip); } if (rtp->transport_mode) { gf_rtsp_set_buffer_size(rtsp, RTSP_TCP_BUFFER_SIZE); } else { gf_rtsp_set_buffer_size(rtsp, RTSP_BUFFER_SIZE); } tmp->rtsp_commands = gf_list_new(); tmp->rtsp_rsp = gf_rtsp_response_new(); gf_list_add(rtp->sessions, tmp); return tmp; }
static GF_Err M2TS_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url) { GF_Err e; const char *opt; M2TSIn *m2ts = plug->priv; M2TS_GetNetworkType(plug,m2ts); m2ts->owner = plug; opt = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "HybRadio", "Activated"); if (opt && !strcmp(opt, "true")) { m2ts->hybrid_on = 1; } m2ts->ts->record_to = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "M2TS", "RecordTo"); m2ts->service = serv; if (m2ts->owner->query_proxy) { m2ts->ts->query_next = M2TS_QueryNextFile; m2ts->ts->query_udta = m2ts; } opt = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "DSMCC", "Activated"); if (opt && !strcmp(opt, "yes")) { gf_m2ts_demux_dmscc_init(m2ts->ts); } if (url && !strnicmp(url, "http://", 7)) { m2ts->ts->dnload = gf_term_download_new(m2ts->service, url, GF_NETIO_SESSION_NOT_THREADED | GF_NETIO_SESSION_NOT_CACHED, m2ts_net_io, m2ts); if (!m2ts->ts->dnload){ gf_term_on_connect(m2ts->service, NULL, GF_NOT_SUPPORTED); return GF_OK; } else { e = gf_m2ts_demuxer_play(m2ts->ts); } } else { e = gf_m2ts_demuxer_setup(m2ts->ts,url,0); } if (e) { gf_term_on_connect(m2ts->service, NULL, e); } return e; }
static GF_Err XVID_GetCapabilities(GF_BaseDecoder *ifcg, GF_CodecCapability *capability) { XVIDCTX(); switch (capability->CapCode) { case GF_CODEC_RESILIENT: capability->cap.valueInt = 1; break; case GF_CODEC_WIDTH: capability->cap.valueInt = ctx->width; break; case GF_CODEC_HEIGHT: capability->cap.valueInt = ctx->height; break; case GF_CODEC_STRIDE: capability->cap.valueInt = ctx->width; break; case GF_CODEC_FPS: capability->cap.valueFloat = ctx->FPS; break; case GF_CODEC_PAR: capability->cap.valueInt = ctx->pixel_ar; break; case GF_CODEC_OUTPUT_SIZE: capability->cap.valueInt = ctx->out_size; break; case GF_CODEC_PIXEL_FORMAT: capability->cap.valueInt = ctx->depth_codec ? GF_PIXEL_YUVD : GF_PIXEL_YV12; break; case GF_CODEC_BUFFER_MIN: capability->cap.valueInt = 1; break; case GF_CODEC_BUFFER_MAX: capability->cap.valueInt = 4; break; /*by default we use 4 bytes padding (otherwise it happens that XviD crashes on some videos...)*/ case GF_CODEC_PADDING_BYTES: capability->cap.valueInt = 32; break; /*XviD performs frame reordering internally*/ case GF_CODEC_REORDER: capability->cap.valueInt = 1; break; case GF_CODEC_WANTS_THREAD: { const char *sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "XviD", "Threaded"); capability->cap.valueInt = (sOpt && stricmp(sOpt, "yes")) ? 1 : 0; } break; /*not known at our level...*/ case GF_CODEC_CU_DURATION: default: capability->cap.valueInt = 0; break; } return GF_OK; }
GF_Err Dektec_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags) { GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[Dektec Out] Dektec_Setup\n")); DtContext *dtc = (DtContext*)dr->opaque; dtc->bpp = 3; //needed because lock_buffer expects RGB dtc->pixel_format = GF_PIXEL_YV12; dtc->isSending = false; Dektec_resize(dr, DWIDTH, DHEIGHT); int port = 1; const char *opt; opt = gf_modules_get_option((GF_BaseInterface *)dr, "DektecVideo", "SDIOutput"); if (opt) { port = atoi(opt); } else { GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("[Dektec Out] No port specified, using default port: %d\n", port)); } // Attach device and output channel objects to hardware DtDevice *dvc = dtc->dvc; DtFrameBuffer *dtf = dtc->dtf; DTAPI_RESULT res; res = dvc->AttachToType(2154); if (res != DTAPI_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] No DTA-2154 in system: %s\n", DtapiResult2Str(res))); return GF_BAD_PARAM; } res = dvc->SetIoConfig(port, DTAPI_IOCONFIG_IODIR, DTAPI_IOCONFIG_OUTPUT, DTAPI_IOCONFIG_OUTPUT); if (res != DTAPI_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't set I/O config for the device: %s\n", DtapiResult2Str(res))); return GF_BAD_PARAM; } res = dtf->AttachToOutput(dvc, port, 0); if (res != DTAPI_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't attach to port %d: %s\n", port, DtapiResult2Str(res))); return GF_BAD_PARAM; } int IoStdValue=-1, IoStdSubValue=-1; res = DtapiVidStd2IoStd(DFORMAT, IoStdValue, IoStdSubValue); if (res != DTAPI_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Unknown VidStd: %s\n", DtapiResult2Str(res))); return GF_BAD_PARAM; } res = dtf->SetIoConfig(DTAPI_IOCONFIG_IOSTD, IoStdValue, IoStdSubValue); if (res != DTAPI_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't set I/O config: %s\n", DtapiResult2Str(res))); return GF_BAD_PARAM; } dtc->frameNum = -1; return GF_OK; }
static Bool M2TS_CanHandleURLInService(GF_InputService *plug, const char *url) { Bool ret = 0; M2TSIn *m2ts; if (!plug || !url) return 0; m2ts = (M2TSIn *)plug->priv; if (!m2ts) return 0; if (!strnicmp(url, "pid://", 6)) { u32 pid = atoi(url+6); if (pid>=GF_M2TS_MAX_STREAMS) return 0; if (m2ts->ts->ess[pid]) return 1; return 0; } #ifdef GPAC_HAS_LINUX_DVB if (!stricmp(url, "dvb://EPG")) return 1; if (!strnicmp(url, "dvb://", 6)) { GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Checking reuse of the same tuner for %s\n", url)); const char *chan_conf = gf_modules_get_option((GF_BaseInterface *)plug, "DVB", "ChannelsFile"); if (!chan_conf) { GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[DVBIn] Cannot locate channel configuration file\n")); ret = 0; } /* if the tuner is already tuned to the same frequence, nothing needs to be done */ else if (m2ts->ts->tuner->freq != 0) { char *frag = strchr(url, '#'); if (frag) frag[0] = 0; if (m2ts->ts->tuner->freq == gf_dvb_get_freq_from_url(chan_conf, url)) { GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Reusing the same tuner for %s\n", url)); ret = 1; } if (frag) frag[0] = '#'; } } else #endif if (!strnicmp(url, "udp://", 6) || !strnicmp(url, "mpegts-udp://", 13) || !strnicmp(url, "mpegts-tcp://", 13)) { /* TODO: check IP address ...*/ ret = 0; } else { char *frag = strchr(url, '#'); if (frag) frag[0] = 0; if (!strlen(url) || !strcmp(url, m2ts->ts->filename)) { GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Reusing the same input file for %s\n", url)); ret = 1; } if (frag) frag[0] = '#'; } return ret; }
void *SDL_NewVideo() { SDLVidCtx *ctx; GF_VideoOutput *driv; driv = gf_malloc(sizeof(GF_VideoOutput)); memset(driv, 0, sizeof(GF_VideoOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "SDL Video Output", "gpac distribution"); ctx = gf_malloc(sizeof(SDLVidCtx)); memset(ctx, 0, sizeof(SDLVidCtx)); #ifdef SDL_WINDOW_THREAD ctx->sdl_th = gf_th_new("SDLVideo"); #endif ctx->evt_mx = gf_mx_new("SDLEvents"); driv->opaque = ctx; driv->Setup = SDLVid_Setup; driv->Shutdown = SDLVid_Shutdown; driv->SetFullScreen = SDLVid_SetFullScreen; driv->Flush = SDLVid_Flush; driv->ProcessEvent = SDLVid_ProcessEvent; /*no offscreen opengl with SDL*/ driv->hw_caps |= GF_VIDEO_HW_OPENGL; /*no YUV hardware blitting in SDL (only overlays)*/ driv->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY | GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA; driv->Blit = SDL_Blit; driv->LockBackBuffer = SDLVid_LockBackBuffer; driv->LockOSContext = NULL; /*color keying with overlays are not supported in SDL ...*/ #if 0 /*get YUV overlay key*/ opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey"); /*no set is the default*/ if (!opt) { opt = "0101FE"; gf_modules_set_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey", "0101FE"); } sscanf(opt, "%06x", &driv->overlay_color_key); if (driv->overlay_color_key) driv->overlay_color_key |= 0xFF000000; GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[SDL Out] YUV Overlays enabled - ColorKey enabled: %s (key %x)\n", driv->overlay_color_key ? "Yes" : "No", driv->overlay_color_key )); #endif #ifndef SDL_TEXTINPUTEVENT_TEXT_SIZE SDL_EnableUNICODE(1); #else SDL_StartTextInput(); #endif /* SDL_TEXTINPUTEVENT_TEXT_SIZE */ return driv; }
static GF_Err HEVC_AttachStream(GF_BaseDecoder *ifcg, GF_ESD *esd) { GF_SystemRTInfo rti; const char *sOpt; u32 nb_threads = 1; HEVCDec *ctx = (HEVCDec*) ifcg->privateStack; if (gf_sys_get_rti(0, &rti, 0) ) { nb_threads = (rti.nb_cores>1) ? rti.nb_cores-1 : 1; } sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads"); if (!sOpt) { char szO[100]; sprintf(szO, "%d", nb_threads); gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads", szO); ctx->nb_threads = nb_threads; GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads\n", ctx->nb_threads)); } else { ctx->nb_threads = atoi(sOpt); if (ctx->nb_threads > nb_threads) { GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads but only %d available cores detected on the system\n", ctx->nb_threads, rti.nb_cores)); } } sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType"); if (sOpt && !strcmp(sOpt, "wpp")) ctx->threading_type = 2; else if (sOpt && !strcmp(sOpt, "frame+wpp")) ctx->threading_type = 4; else { ctx->threading_type = 1; if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType", "frame"); } sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit"); if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit", (ctx->display_bpp>8) ? "no" : "yes"); if (sOpt && !strcmp(sOpt, "yes")) ctx->output_as_8bit = GF_TRUE; sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits"); if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits", "4"); if (sOpt) ctx->output_cb_size = atoi(sOpt); if (!ctx->output_cb_size) ctx->output_cb_size = 4; sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR"); if (sOpt && !strcmp(sOpt, "yes") ) ctx->pack_mode = GF_TRUE; else if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR", "no"); if (!ctx->raw_out) { sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "InputRipFile"); if (sOpt) ctx->raw_out = fopen(sOpt, "wb"); } /*RTP case: configure enhancement now*/ if (esd->dependsOnESID) { HEVC_ConfigurationScalableStream(ctx, esd); return GF_OK; } ctx->esd = esd; return HEVC_ConfigureStream(ctx, esd); }
GF_EXPORT Bool gf_term_check_extension(GF_InputService *ifce, const char *mimeType, const char *extList, const char *description, const char *fileExt) { const char *szExtList; char *ext, szExt[500]; if (!ifce || !mimeType || !extList || !description || !fileExt) return 0; memset(szExt, 0, sizeof(szExt)); /*this is a URL*/ if ( (strlen(fileExt)>20) || strchr(fileExt, '/')) return 0; if (fileExt[0]=='.') fileExt++; strcpy(szExt, fileExt); strlwr(szExt); ext = strchr(szExt, '#'); if (ext) ext[0]=0; szExtList = gf_modules_get_option((GF_BaseInterface *)(GF_BaseInterface *)ifce, "MimeTypes", mimeType); if (!szExtList) { gf_term_register_mime_type(ifce, mimeType, extList, description); szExtList = gf_modules_get_option((GF_BaseInterface *)(GF_BaseInterface *)ifce, "MimeTypes", mimeType); } if (!strstr(szExtList, ifce->module_name)) return 0; return check_extension((char *)szExtList, szExt); }
static GF_Err SVG_AttachScene(GF_SceneDecoder *plug, GF_Scene *scene, Bool is_scene_decoder) { SVGIn *svgin = (SVGIn *)plug->privateStack; memset(&svgin->loader, 0, sizeof(GF_SceneLoader)); svgin->loader.is = scene; svgin->scene = scene; svgin->loader.scene_graph = scene->graph; svgin->loader.localPath = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory"); /*Warning: svgin->loader.type may be overriden in attach stream */ svgin->loader.type = GF_SM_LOAD_SVG; svgin->loader.flags = GF_SM_LOAD_FOR_PLAYBACK; if (svgin->oti!= GPAC_OTI_PRIVATE_SCENE_SVG) gf_sm_load_init(&svgin->loader); return GF_OK; }
static GF_Err CTXLoad_Setup(GF_BaseDecoder *plug) { CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack; if (!priv->file_name) return GF_BAD_PARAM; priv->ctx = gf_sm_new(priv->scene->graph); memset(&priv->load, 0, sizeof(GF_SceneLoader)); priv->load.ctx = priv->ctx; priv->load.is = priv->scene; priv->load.scene_graph = priv->scene->graph; priv->load.fileName = priv->file_name; priv->load.flags = GF_SM_LOAD_FOR_PLAYBACK; priv->load.localPath = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory"); priv->load.swf_import_flags = GF_SM_SWF_STATIC_DICT | GF_SM_SWF_QUAD_CURVE | GF_SM_SWF_SCALABLE_LINE | GF_SM_SWF_SPLIT_TIMELINE; return GF_OK; }
static Bool osd_process(GF_TermExt *termext, u32 action, void *param) { const char *opt; GF_OSD *osd = termext->udta; switch (action) { case GF_TERM_EXT_START: osd->term = (GF_Terminal *) param; opt = gf_modules_get_option((GF_BaseInterface*)termext, "OSD", "Enabled"); if (opt && strcmp(opt, "yes")) return 0; /*load scene*/ if (! osd_load_scene(osd)) return 0; /*attach scene to compositor*/ gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 0); /*we are not threaded*/ termext->caps |= GF_TERM_EXTENSION_NOT_THREADED; osd->refresh_time_ms = 500; osd->evt_filter.on_event = osd_on_event_play; osd->evt_filter.udta = osd; gf_term_add_event_filter(osd->term, &osd->evt_filter); return 1; case GF_TERM_EXT_STOP: osd->text->string.vals[0] = NULL; /*remove scene to compositor*/ gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 1); gf_odm_disconnect(osd->odm, 1); osd->odm = NULL; gf_term_remove_event_filter(osd->term, &osd->evt_filter); osd->term = NULL; break; case GF_TERM_EXT_PROCESS: /*flush all events until current time if reached*/ if ((osd->visible->whichChoice==0) && gf_sys_get_rti(osd->refresh_time_ms, &osd->rti, 0)) { sprintf(osd->statBuffer, "CPU %02d - FPS %02.2f - MEM "LLU" KB", osd->rti.process_cpu_usage, gf_sc_get_fps(osd->term->compositor, 0), osd->rti.process_memory/1000); gf_node_dirty_set((GF_Node *) osd->text, GF_SG_NODE_DIRTY, 1); } break; } return 0; }
static GF_Err RP_CloseService(GF_InputService *plug) { u32 i; const char *opt; RTSPSession *sess; RTPClient *rtp = (RTPClient *)plug->priv; GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("[RTP] Closing service\n")); RP_FlushCommands(rtp); if (rtp->session_migration) { opt = gf_modules_get_option((GF_BaseInterface *) plug, "Streaming", "SessionMigrationPause"); if (opt && !strcmp(opt, "yes")) { GF_NetworkCommand com; com.command_type = GF_NET_CHAN_PAUSE; com.base.on_channel = NULL; /*send pause on all sessions*/ i=0; while ((sess = (RTSPSession *)gf_list_enum(rtp->sessions, &i))) { RP_UserCommand(sess, NULL, &com); } } RP_SaveSessionState(rtp); } else { /*remove session state file*/ if (rtp->session_state_data) { gf_free(rtp->session_state_data); rtp->session_state_data = NULL; } /*send teardown on all sessions*/ i=0; while ((sess = (RTSPSession *)gf_list_enum(rtp->sessions, &i))) { RP_Teardown(sess, NULL); } } RP_FlushCommands(rtp); /*shutdown thread*/ if (rtp->th_state==1) rtp->th_state = 0; /*confirm close*/ gf_term_on_disconnect(rtp->service, NULL, GF_OK); return GF_OK; }
static void SetWindowless(GF_VideoOutput *vout, HWND hWnd) { const char *opt; u32 a, r, g, b; COLORREF ckey; typSetLayeredWindowAttributes _SetLayeredWindowAttributes; HMODULE hUser32; u32 isWin2K; OSVERSIONINFO Version = {sizeof(OSVERSIONINFO)}; GetVersionEx(&Version); isWin2K = (Version.dwPlatformId == VER_PLATFORM_WIN32_NT && Version.dwMajorVersion >= 5); if (!isWin2K) return; GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Enabling windowless mode\n")); hUser32 = GetModuleHandle("USER32.DLL"); if (hUser32 == NULL) return; _SetLayeredWindowAttributes = (typSetLayeredWindowAttributes) GetProcAddress(hUser32,"SetLayeredWindowAttributes"); if (_SetLayeredWindowAttributes == NULL) { GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("[DX Out] Win32 layered windows not supported\n")); return; } SetWindowLong(hWnd, GWL_EXSTYLE, GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED); /*get background ckey*/ opt = gf_modules_get_option((GF_BaseInterface *)vout, "Rendering", "ColorKey"); if (!opt) { gf_modules_set_option((GF_BaseInterface *)vout, "Rendering", "ColorKey", "FFFEFEFE"); opt = "FFFEFEFE"; } sscanf(opt, "%02X%02X%02X%02X", &a, &r, &g, &b); ckey = RGB(r, g, b); if (a<255) _SetLayeredWindowAttributes(hWnd, ckey, (u8) a, LWA_COLORKEY|LWA_ALPHA); else _SetLayeredWindowAttributes(hWnd, ckey, 0, LWA_COLORKEY); GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Using color key %s\n", opt)); }
GF_Err TTIn_LoadFile(GF_InputService *plug, const char *url, Bool is_cache) { GF_Err e; GF_MediaImporter import; char szFILE[GF_MAX_PATH]; TTIn *tti = (TTIn *)plug->priv; const char *cache_dir; if (!tti || !url) return GF_BAD_PARAM; cache_dir = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory"); if (cache_dir && strlen(cache_dir)) { if (cache_dir[strlen(cache_dir)-1] != GF_PATH_SEPARATOR) { sprintf(szFILE, "%s%csrt_%p_mp4", cache_dir, GF_PATH_SEPARATOR, tti); } else { sprintf(szFILE, "%ssrt_%p_mp4", cache_dir, tti); } } else { sprintf(szFILE, "%p_temp_mp4", tti); } tti->mp4 = gf_isom_open(szFILE, GF_ISOM_OPEN_WRITE, NULL); if (!tti->mp4) return gf_isom_last_error(NULL); if (tti->szFile) gf_free(tti->szFile); tti->szFile = gf_strdup(szFILE); memset(&import, 0, sizeof(GF_MediaImporter)); import.dest = tti->mp4; /*override layout from sub file*/ import.flags = GF_IMPORT_SKIP_TXT_BOX; import.in_name = gf_strdup(url); e = gf_media_import(&import); if (!e) { tti->tt_track = 1; gf_isom_text_set_streaming_mode(tti->mp4, 1); } if (import.in_name) gf_free(import.in_name); return e; }
GF_Err RAW_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags) { const char *opt; RAWCTX; opt = gf_modules_get_option((GF_BaseInterface *)dr, "RAWVideo", "RawOutput"); if (opt && !strcmp(opt, "null")) { rc->passthrough = 1; dr->Blit = RAW_BlitPassthrough; dr->hw_caps |= GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA | GF_VIDEO_HW_HAS_STRETCH | GF_VIDEO_HW_HAS_YUV | GF_VIDEO_HW_OPENGL | GF_VIDEO_HW_HAS_YUV_OVERLAY; } if (init_flags & GF_TERM_WINDOW_TRANSPARENT) { rc->bpp = 4; rc->pixel_format = GF_PIXEL_ARGB; } else { rc->bpp = 3; rc->pixel_format = GF_PIXEL_RGB_24; } raw_resize(dr, 100, 100); return GF_OK; }