static void *NewGAPIVideoOutput() { GAPIPriv *priv; GF_VideoOutput *driv = (GF_VideoOutput *) gf_malloc(sizeof(GF_VideoOutput)); memset(driv, 0, sizeof(GF_VideoOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "GAPI Video Output", "gpac distribution") priv = (GAPIPriv *) gf_malloc(sizeof(GAPIPriv)); memset(priv, 0, sizeof(GAPIPriv)); priv->mx = gf_mx_new("GAPI"); driv->opaque = priv; #ifdef GPAC_USE_OGL_ES driv->hw_caps = GF_VIDEO_HW_OPENGL | GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA; #endif /*rgb, yuv to do*/ driv->Setup = GAPI_Setup; driv->Shutdown = GAPI_Shutdown; driv->Flush = GAPI_Flush; driv->ProcessEvent = GAPI_ProcessEvent; driv->Blit = NULL; driv->LockBackBuffer = GAPI_LockBackBuffer; driv->SetFullScreen = GAPI_SetFullScreen; return (void *)driv; }
static void *EPOC_vout_new() { EPOCVideo *priv; GF_VideoOutput *driv; GF_SAFEALLOC(driv, GF_VideoOutput); GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "EPOC Video Output", "gpac distribution") GF_SAFEALLOC(priv, EPOCVideo); driv->opaque = priv; /*alpha and keying to do*/ driv->hw_caps = 0; #ifdef GPAC_USE_OGL_ES /*no offscreen opengl with epoc at the moment*/ driv->hw_caps |= GF_VIDEO_HW_OPENGL; #endif driv->Setup = EVID_Setup; driv->Shutdown = EVID_Shutdown; driv->Flush = EVID_Flush; driv->ProcessEvent = EVID_ProcessEvent; driv->Blit = NULL; driv->LockBackBuffer = EVID_LockBackBuffer; driv->SetFullScreen = EVID_SetFullScreen; return (void *)driv; }
GF_BaseDecoder *NewISCodec(u32 PL) { ISPriv *priv; GF_SceneDecoder *tmp; tmp = (GF_SceneDecoder*) malloc(sizeof(GF_SceneDecoder)); if (!tmp) return NULL; memset(tmp, 0, sizeof(GF_SceneDecoder)); priv = (ISPriv *) malloc(sizeof(ISPriv)); memset(priv, 0, sizeof(ISPriv)); priv->is_nodes = gf_list_new(); priv->ddf = gf_list_new(); tmp->privateStack = priv; tmp->AttachStream = IS_AttachStream; tmp->DetachStream = IS_DetachStream; tmp->GetCapabilities = IS_GetCapabilities; tmp->SetCapabilities = IS_SetCapabilities; tmp->ProcessData = IS_ProcessData; /*we don't use this...*/ tmp->AttachScene = NULL; GF_REGISTER_MODULE_INTERFACE(tmp, GF_SCENE_DECODER_INTERFACE, "GPAC InputSensor Decoder", "gpac distribution") #if GPAC_HTK_DEMO priv->th = gf_th_new(); #endif return (GF_BaseDecoder *) tmp; }
GF_EXPORT GF_BaseInterface *LoadInterface(u32 InterfaceType) { GF_HYB_In *hyb_in; GF_InputService *plug; if (InterfaceType != GF_NET_CLIENT_INTERFACE) return NULL; GF_SAFEALLOC(plug, GF_InputService); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC HYBRID MEDIA Loader", "gpac distribution") plug->RegisterMimeTypes= HYB_RegisterMimeTypes; plug->CanHandleURL= HYB_CanHandleURL; plug->ConnectService= HYB_ConnectService; plug->CloseService= HYB_CloseService; plug->GetServiceDescriptor= HYB_GetServiceDesc; plug->ConnectChannel= HYB_ConnectChannel; plug->DisconnectChannel= HYB_DisconnectChannel; plug->ServiceCommand= HYB_ServiceCommand; plug->CanHandleURLInService=HYB_CanHandleURLInService; plug->ChannelGetSLP= HYB_ChannelGetSLP; plug->ChannelReleaseSLP= HYB_ChannelReleaseSLP; GF_SAFEALLOC(hyb_in, GF_HYB_In); plug->priv = hyb_in; return (GF_BaseInterface *)plug; }
void *NewLoaderInterface() { IMGLoader *priv; GF_InputService *plug; GF_SAFEALLOC(plug, GF_InputService); if (!plug) return NULL; GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC Image Reader", "gpac distribution") GF_SAFEALLOC(priv, IMGLoader); if (!priv) { gf_free(plug); return NULL; } plug->priv = priv; plug->RegisterMimeTypes = IMG_RegisterMimeTypes; plug->CanHandleURL = IMG_CanHandleURL; plug->CanHandleURLInService = NULL; plug->ConnectService = IMG_ConnectService; plug->CloseService = IMG_CloseService; plug->GetServiceDescriptor = IMG_GetServiceDesc; plug->ConnectChannel = IMG_ConnectChannel; plug->DisconnectChannel = IMG_DisconnectChannel; plug->ChannelGetSLP = IMG_ChannelGetSLP; plug->ChannelReleaseSLP = IMG_ChannelReleaseSLP; plug->ServiceCommand = IMG_ServiceCommand; return plug; }
GF_BaseDecoder *NewHEVCDec() { GF_MediaDecoder *ifcd; HEVCDec *dec; GF_SAFEALLOC(ifcd, GF_MediaDecoder); if (!ifcd) return NULL; GF_SAFEALLOC(dec, HEVCDec); if (!dec) { gf_free(ifcd); return NULL; } GF_REGISTER_MODULE_INTERFACE(ifcd, GF_MEDIA_DECODER_INTERFACE, "HEVC Decoder", "gpac distribution") ifcd->privateStack = dec; /*setup our own interface*/ ifcd->AttachStream = HEVC_AttachStream; ifcd->DetachStream = HEVC_DetachStream; ifcd->GetCapabilities = HEVC_GetCapabilities; ifcd->SetCapabilities = HEVC_SetCapabilities; ifcd->GetName = HEVC_GetCodecName; ifcd->CanHandleStream = HEVC_CanHandleStream; ifcd->ProcessData = HEVC_ProcessData; ifcd->GetOutputBuffer = HEVC_GetOutputBuffer; return (GF_BaseDecoder *) ifcd; }
GF_InputService *isor_client_load() { ISOMReader *reader; GF_InputService *plug; GF_SAFEALLOC(plug, GF_InputService); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC IsoMedia Reader", "gpac distribution") plug->RegisterMimeTypes = ISOR_RegisterMimeTypes; plug->CanHandleURL = ISOR_CanHandleURL; plug->ConnectService = ISOR_ConnectService; plug->CloseService = ISOR_CloseService; plug->GetServiceDescriptor = ISOR_GetServiceDesc; plug->ConnectChannel = ISOR_ConnectChannel; plug->DisconnectChannel = ISOR_DisconnectChannel; plug->ServiceCommand = ISOR_ServiceCommand; plug->CanHandleURLInService = ISOR_CanHandleURLInService; /*we do support pull mode*/ plug->ChannelGetSLP = ISOR_ChannelGetSLP; plug->ChannelReleaseSLP = ISOR_ChannelReleaseSLP; GF_SAFEALLOC(reader, ISOMReader); reader->channels = gf_list_new(); reader->segment_mutex = gf_mx_new("ISO Segment"); plug->priv = reader; return plug; }
GF_InputService *NewM2TSReader() { M2TSIn *reader; GF_InputService *plug = gf_malloc(sizeof(GF_InputService)); memset(plug, 0, sizeof(GF_InputService)); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC MPEG-2 TS Reader", "gpac distribution") plug->CanHandleURL = M2TS_CanHandleURL; plug->CanHandleURLInService = M2TS_CanHandleURLInService; plug->ConnectService = M2TS_ConnectService; plug->CloseService = M2TS_CloseService; plug->GetServiceDescriptor = M2TS_GetServiceDesc; plug->ConnectChannel = M2TS_ConnectChannel; plug->DisconnectChannel = M2TS_DisconnectChannel; plug->ServiceCommand = M2TS_ServiceCommand; plug->RegisterMimeTypes = M2TS_RegisterMimeTypes; reader = gf_malloc(sizeof(M2TSIn)); memset(reader, 0, sizeof(M2TSIn)); plug->priv = reader; reader->ts = gf_m2ts_demux_new(); reader->ts->on_event = M2TS_OnEvent; reader->ts->user = reader; reader->ts->demux_and_play = 1; reader->ts->th = gf_th_new("MPEG-2 TS Demux"); reader->mx = gf_mx_new("MPEG2 Demux"); return plug; }
GF_FontReader *ft_load() { GF_FontReader *dr; FTBuilder *ftpriv; dr = gf_malloc(sizeof(GF_FontReader)); memset(dr, 0, sizeof(GF_FontReader)); GF_REGISTER_MODULE_INTERFACE(dr, GF_FONT_READER_INTERFACE, "FreeType Font Reader", "gpac distribution"); ftpriv = gf_malloc(sizeof(FTBuilder)); memset(ftpriv, 0, sizeof(FTBuilder)); ftpriv->font_dirs = gf_list_new(); ftpriv->loaded_fonts = gf_list_new(); dr->udta = ftpriv; dr->init_font_engine = ft_init_font_engine; dr->shutdown_font_engine = ft_shutdown_font_engine; dr->set_font = ft_set_font; dr->get_font_info = ft_get_font_info; dr->get_glyphs = ft_get_glyphs; dr->load_glyph = ft_load_glyph; return dr; }
void *NewX11VideoOutput () { GF_VideoOutput *driv; XWindow *xWindow; GF_SAFEALLOC(driv, GF_VideoOutput); if (!driv) return NULL; GF_SAFEALLOC(xWindow, XWindow); if (!xWindow) { free(driv); return NULL; } GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "X11 Video Output", "gpac distribution") driv->opaque = xWindow; driv->Flush = X11_Flush; driv->SetFullScreen = X11_SetFullScreen; driv->Setup = X11_Setup; driv->Shutdown = X11_Shutdown; driv->LockBackBuffer = X11_LockBackBuffer; driv->ProcessEvent = X11_ProcessEvent; driv->hw_caps = GF_VIDEO_HW_HAS_OPENGL; return (void *) driv; }
void *SDL_NewAudio() { SDLAudCtx *ctx; GF_AudioOutput *dr; ctx = gf_malloc(sizeof(SDLAudCtx)); memset(ctx, 0, sizeof(SDLAudCtx)); dr = gf_malloc(sizeof(GF_AudioOutput)); memset(dr, 0, sizeof(GF_AudioOutput)); GF_REGISTER_MODULE_INTERFACE(dr, GF_AUDIO_OUTPUT_INTERFACE, "SDL Audio Output", "gpac distribution"); dr->opaque = ctx; dr->Setup = SDLAud_Setup; dr->Shutdown = SDLAud_Shutdown; dr->ConfigureOutput = SDLAud_ConfigureOutput; dr->SetVolume = SDLAud_SetVolume; dr->SetPan = SDLAud_SetPan; dr->Play = SDLAud_Play; dr->SetPriority = SDLAud_SetPriority; dr->GetAudioDelay = SDLAud_GetAudioDelay; dr->GetTotalBufferTime = SDLAud_GetTotalBufferTime; dr->QueryOutputSampleRate = SDLAud_QueryOutputSampleRate; /*always threaded*/ dr->SelfThreaded = 1; ctx->audioBuff = NULL; ctx->volume = SDL_MIX_MAXVOLUME; return dr; }
GF_BaseDecoder *NewFAADDec() { GF_MediaDecoder *ifce; FAADDec *dec; GF_SAFEALLOC(ifce, GF_MediaDecoder); if (!ifce) return NULL; GF_SAFEALLOC(dec, FAADDec); if (!dec) { gf_free(dec); return NULL; } GF_REGISTER_MODULE_INTERFACE(ifce, GF_MEDIA_DECODER_INTERFACE, "FAAD2 Decoder", "gpac distribution") ifce->privateStack = dec; /*setup our own interface*/ ifce->AttachStream = FAAD_AttachStream; ifce->DetachStream = FAAD_DetachStream; ifce->GetCapabilities = FAAD_GetCapabilities; ifce->SetCapabilities = FAAD_SetCapabilities; ifce->ProcessData = FAAD_ProcessData; ifce->CanHandleStream = FAAD_CanHandleStream; ifce->GetName = FAAD_GetCodecName; return (GF_BaseDecoder *) ifce; }
GF_VideoOutput *NewDektecVideoOutput() { GF_VideoOutput *driv = (GF_VideoOutput *) gf_malloc(sizeof(GF_VideoOutput)); memset(driv, 0, sizeof(GF_VideoOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "Dektec Video Output", "gpac distribution") DtDevice *dvc = new DtDevice; DtFrameBuffer *dtf = new DtFrameBuffer; if (!dtf || !dvc) { GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] DTA API couldn't be initialized.\n")); delete dvc; delete dtf; gf_free(driv); return NULL; } DtContext *dtc = new DtContext; memset(dtc, 0, sizeof(DtContext)); dtc->dvc = dvc; dtc->dtf = dtf; driv->opaque = (void*)dtc; driv->Flush = Dektec_Flush; driv->LockBackBuffer = Dektec_LockBackBuffer; driv->Setup = Dektec_Setup; driv->Shutdown = Dektec_Shutdown; driv->ProcessEvent = Dektec_ProcessEvent; driv->Blit = Dektec_Blit; driv->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY | GF_VIDEO_HW_HAS_YUV; return driv; }
void *NewALSAOutput() { ALSAContext *ctx; GF_AudioOutput*driv; GF_SAFEALLOC(ctx, ALSAContext); if(!ctx) return NULL; GF_SAFEALLOC(driv, GF_AudioOutput); if(!driv) { free(ctx); return NULL; } driv->opaque = ctx; driv->SelfThreaded = 0; driv->Setup = ALSA_Setup; driv->Shutdown = ALSA_Shutdown; driv->ConfigureOutput = ALSA_ConfigureOutput; driv->GetAudioDelay = ALSA_GetAudioDelay; driv->SetVolume = ALSA_SetVolume; driv->SetPan = ALSA_SetPan; driv->SetPriority = ALSA_SetPriority; driv->QueryOutputSampleRate = ALSA_QueryOutputSampleRate; driv->WriteAudio = ALSA_WriteAudio; GF_REGISTER_MODULE_INTERFACE(driv, GF_AUDIO_OUTPUT_INTERFACE, "ALSA Audio Output", "gpac distribution"); return driv; }
GF_InputService *RTP_Load() { RTPClient *priv; GF_InputService *plug; GF_SAFEALLOC(plug, GF_InputService); memset(plug, 0, sizeof(GF_InputService)); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC RTP/RTSP Client", "gpac distribution") plug->CanHandleURL = RP_CanHandleURL; plug->CanHandleURLInService = RP_CanHandleURLInService; plug->ConnectService = RP_ConnectService; plug->CloseService = RP_CloseService; plug->GetServiceDescriptor = RP_GetServiceDesc; plug->ConnectChannel = RP_ConnectChannel; plug->DisconnectChannel = RP_DisconnectChannel; plug->ServiceCommand = RP_ServiceCommand; plug->RegisterMimeTypes = RP_RegisterMimeTypes; /*PULL mode for embedded streams*/ plug->ChannelGetSLP = RP_ChannelGetSLP; plug->ChannelReleaseSLP = RP_ChannelReleaseSLP; GF_SAFEALLOC(priv, RTPClient); priv->sessions = gf_list_new(); priv->channels = gf_list_new(); plug->priv = priv; priv->time_out = 30000; priv->mx = gf_mx_new("RTPDemux"); priv->th = gf_th_new("RTPDemux"); return plug; }
void *NewWAVRender() { WAVContext *ctx; GF_AudioOutput *driv; ctx = malloc(sizeof(WAVContext)); memset(ctx, 0, sizeof(WAVContext)); ctx->num_buffers = 10; ctx->pan = 50; ctx->vol = 100; driv = malloc(sizeof(GF_AudioOutput)); memset(driv, 0, sizeof(GF_AudioOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_AUDIO_OUTPUT_INTERFACE, "Windows MME Output", "gpac distribution") driv->opaque = ctx; driv->SelfThreaded = 0; driv->Setup = WAV_Setup; driv->Shutdown = WAV_Shutdown; driv->ConfigureOutput = WAV_ConfigureOutput; driv->GetAudioDelay = WAV_GetAudioDelay; driv->GetTotalBufferTime = WAV_GetTotalBufferTime; driv->SetVolume = WAV_SetVolume; driv->SetPan = WAV_SetPan; driv->Play = WAV_Play; driv->QueryOutputSampleRate = WAV_QueryOutputSampleRate; driv->WriteAudio = WAV_WriteAudio; return driv; }
void *NewRawAudioOutput() { RawContext *ctx; GF_AudioOutput *driv; ctx = gf_malloc(sizeof(RawContext)); memset(ctx, 0, sizeof(RawContext)); driv = gf_malloc(sizeof(GF_AudioOutput)); memset(driv, 0, sizeof(GF_AudioOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_AUDIO_OUTPUT_INTERFACE, "Raw Audio Output", "gpac distribution") driv->opaque = ctx; driv->SelfThreaded = 0; driv->Setup = RAW_AudioSetup; driv->Shutdown = RAW_AudioShutdown; driv->ConfigureOutput = RAW_ConfigureOutput; driv->GetAudioDelay = RAW_GetAudioDelay; driv->GetTotalBufferTime = RAW_GetTotalBufferTime; driv->SetVolume = RAW_SetVolume; driv->SetPan = RAW_SetPan; driv->Play = RAW_Play; driv->QueryOutputSampleRate = RAW_QueryOutputSampleRate; driv->WriteAudio = RAW_WriteAudio; return driv; }
GF_BaseInterface *isow_load_cache() { ISOMReader *cache; GF_StreamingCache *plug; GF_SAFEALLOC(plug, GF_StreamingCache); if (!plug) return NULL; GF_REGISTER_MODULE_INTERFACE(plug, GF_STREAMING_MEDIA_CACHE, "GPAC IsoMedia Cache", "gpac distribution") GF_SAFEALLOC(cache, ISOMReader); if (!cache) { gf_free(plug); return NULL; } cache->channels = gf_list_new(); plug->priv = cache; plug->Open = ISOW_Open; plug->Close = ISOW_Close; plug->Write = ISOW_Write; plug->ChannelGetSLP = ISOW_ChannelGetSLP; plug->ChannelReleaseSLP = ISOW_ChannelReleaseSLP; plug->ServiceCommand = ISOW_ServiceCommand; return (GF_BaseInterface *) plug; }
GF_BaseDecoder *NewVTBDec() { GF_MediaDecoder *ifcd; VTBDec *dec; GF_SAFEALLOC(ifcd, GF_MediaDecoder); if (!ifcd) return NULL; GF_SAFEALLOC(dec, VTBDec); if (!dec) { gf_free(ifcd); return NULL; } GF_REGISTER_MODULE_INTERFACE(ifcd, GF_MEDIA_DECODER_INTERFACE, "VideoToolbox Decoder", "gpac distribution") ifcd->privateStack = dec; /*setup our own interface*/ ifcd->AttachStream = VTBDec_AttachStream; ifcd->DetachStream = VTBDec_DetachStream; ifcd->GetCapabilities = VTBDec_GetCapabilities; ifcd->SetCapabilities = VTBDec_SetCapabilities; ifcd->GetName = VTBDec_GetCodecName; ifcd->CanHandleStream = VTBDec_CanHandleStream; ifcd->ProcessData = VTBDec_ProcessData; return (GF_BaseDecoder *) ifcd; }
GPAC_MODULE_EXPORT GF_BaseInterface *LoadInterface(u32 InterfaceType) { DCReader *read; GF_InputService *plug; if (InterfaceType != GF_NET_CLIENT_INTERFACE) return NULL; GF_SAFEALLOC(plug, GF_InputService); memset(plug, 0, sizeof(GF_InputService)); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC Dummy Loader", "gpac distribution") plug->RegisterMimeTypes = DC_RegisterMimeTypes; plug->CanHandleURL = DC_CanHandleURL; plug->ConnectService = DC_ConnectService; plug->CloseService = DC_CloseService; plug->GetServiceDescriptor = DC_GetServiceDesc; plug->ConnectChannel = DC_ConnectChannel; plug->DisconnectChannel = DC_DisconnectChannel; plug->ServiceCommand = DC_ServiceCommand; plug->CanHandleURLInService = DC_CanHandleURLInService; plug->ChannelGetSLP = DC_ChannelGetSLP; plug->ChannelReleaseSLP = DC_ChannelReleaseSLP; GF_SAFEALLOC(read, DCReader); read->channels = gf_list_new(); plug->priv = read; return (GF_BaseInterface *)plug; }
GF_VideoOutput *NewRawVideoOutput() { AndroidContext *pCtx; GF_VideoOutput *driv = (GF_VideoOutput *) gf_malloc(sizeof(GF_VideoOutput)); LOG( ANDROID_LOG_INFO, TAG, "Android Video Initialization in progress..."); memset(driv, 0, sizeof(GF_VideoOutput)); GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "Android Video Output", "gpac distribution") pCtx = gf_malloc(sizeof(AndroidContext)); memset(pCtx, 0, sizeof(AndroidContext)); pCtx->texID = -1; pCtx->framebuff = -1; pCtx->depthbuff = -1; driv->opaque = pCtx; driv->Flush = droid_Flush; driv->LockBackBuffer = droid_LockBackBuffer; driv->Setup = droid_Setup; driv->Shutdown = droid_Shutdown; driv->ProcessEvent = droid_ProcessEvent; driv->max_screen_width = 1024; driv->max_screen_height = 1024; driv->hw_caps = GF_VIDEO_HW_OPENGL;// | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;//GF_VIDEO_HW_DIRECT_ONLY;// LOG( ANDROID_LOG_INFO, TAG, "Android Video Init Done.\n"); return (void *)driv; }
GF_EXPORT GF_BaseInterface *LoadInterface(u32 InterfaceType) { GF_MPD_In *mpdin; GF_InputService *plug; if (InterfaceType != GF_NET_CLIENT_INTERFACE) return NULL; GF_SAFEALLOC(plug, GF_InputService); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC MPD Loader", "gpac distribution") plug->RegisterMimeTypes = MPD_RegisterMimeTypes; plug->CanHandleURL = MPD_CanHandleURL; plug->ConnectService = MPD_ConnectService; plug->CloseService = MPD_CloseService; plug->GetServiceDescriptor = MPD_GetServiceDesc; plug->ConnectChannel = MPD_ConnectChannel; plug->DisconnectChannel = MPD_DisconnectChannel; plug->ServiceCommand = MPD_ServiceCommand; plug->CanHandleURLInService = MPD_CanHandleURLInService; plug->ChannelGetSLP = MPD_ChannelGetSLP; plug->ChannelReleaseSLP = MPD_ChannelReleaseSLP; GF_SAFEALLOC(mpdin, GF_MPD_In); plug->priv = mpdin; mpdin->plug = plug; return (GF_BaseInterface *)plug; }
/** * function DirectFBNewVideo * - creates a DirectFb module **/ void *DirectFBNewVideo() { DirectFBVidCtx *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, "DirectFB Video Output", "gpac distribution"); ctx = gf_malloc(DirectFBVid_GetCtxSizeOf()); memset(ctx, 0, DirectFBVid_GetCtxSizeOf()); /* GF_VideoOutput */ driv->opaque = ctx; driv->Setup = DirectFBVid_Setup; driv->Shutdown = DirectFBVid_Shutdown; driv->Flush = DirectFBVid_Flush; driv->SetFullScreen = DirectFBVid_SetFullScreen; driv->ProcessEvent = DirectFBVid_ProcessEvent; driv->LockBackBuffer = DirectFBVid_LockBackBuffer; driv->LockOSContext = NULL; driv->Blit = DirectFBVid_Blit; driv->hw_caps |= GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA | GF_VIDEO_HW_HAS_YUV | GF_VIDEO_HW_HAS_STRETCH; return driv; }
void *NewX11VideoOutput () { GF_VideoOutput *driv; XWindow *xWindow; GF_SAFEALLOC(driv, GF_VideoOutput); if (!driv) return NULL; GF_SAFEALLOC(xWindow, XWindow); if (!xWindow) { gf_free(driv); return NULL; } GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "X11 Video Output", "gpac distribution") driv->opaque = xWindow; driv->Flush = X11_Flush; driv->SetFullScreen = X11_SetFullScreen; driv->Setup = X11_Setup; driv->Shutdown = X11_Shutdown; driv->LockBackBuffer = X11_LockBackBuffer; driv->ProcessEvent = X11_ProcessEvent; driv->hw_caps = GF_VIDEO_HW_OPENGL; /*fixme - needs a better detection scheme*/ driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA; return (void *) driv; }
void *New_FFMPEG_Demux() { FFDemux *priv; GF_InputService *ffd = gf_malloc(sizeof(GF_InputService)); memset(ffd, 0, sizeof(GF_InputService)); GF_SAFEALLOC(priv, FFDemux); GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[FFMPEG Demuxer] Registering all ffmpeg plugins...\n") ); /* register all codecs, demux and protocols */ av_register_all(); GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[FFMPEG Demuxer] Registering all ffmpeg plugins DONE.\n") ); ffd->RegisterMimeTypes = FFD_RegisterMimeTypes; ffd->CanHandleURL = FFD_CanHandleURL; ffd->CloseService = FFD_CloseService; ffd->ConnectChannel = FFD_ConnectChannel; ffd->ConnectService = FFD_ConnectService; ffd->DisconnectChannel = FFD_DisconnectChannel; ffd->GetServiceDescriptor = FFD_GetServiceDesc; ffd->ServiceCommand = FFD_ServiceCommand; ffd->CanHandleURLInService = FFD_CanHandleURLInService; priv->thread = gf_th_new("FFMPEG Demux"); priv->mx = gf_mx_new("FFMPEG Demux"); GF_REGISTER_MODULE_INTERFACE(ffd, GF_NET_CLIENT_INTERFACE, "FFMPEG Demuxer", "gpac distribution"); ffd->priv = priv; return ffd; }
GF_EXPORT GF_BaseInterface *LoadInterface(u32 InterfaceType) { if (InterfaceType == GF_NET_CLIENT_INTERFACE) { LibPlayerIn *read; GF_InputService *plug; GF_SAFEALLOC(plug, GF_InputService); memset(plug, 0, sizeof(GF_InputService)); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "LibPlayer Input", "gpac distribution") plug->RegisterMimeTypes = LIBPLAYER_RegisterMimeTypes; plug->CanHandleURL = LIBPLAYER_CanHandleURL; plug->ConnectService = LIBPLAYER_ConnectService; plug->CloseService = LIBPLAYER_CloseService; plug->GetServiceDescriptor = LIBPLAYER_GetServiceDesc; plug->ConnectChannel = LIBPLAYER_ConnectChannel; plug->DisconnectChannel = LIBPLAYER_DisconnectChannel; plug->ServiceCommand = LIBPLAYER_ServiceCommand; plug->CanHandleURLInService = LIBPLAYER_CanHandleURLInService; GF_SAFEALLOC(read, LibPlayerIn); plug->priv = read; return (GF_BaseInterface *)plug; } else if (InterfaceType == GF_PRIVATE_MEDIA_DECODER_INTERFACE) { GF_PrivateMediaDecoder *ifce; GF_SAFEALLOC(ifce, GF_PrivateMediaDecoder); GF_REGISTER_MODULE_INTERFACE(ifce, GF_PRIVATE_MEDIA_DECODER_INTERFACE, "LibPlayer Decoder", "gpac distribution") /*setup our own interface*/ ifce->AttachStream = LIBPLAYER_AttachStream; ifce->DetachStream = LIBPLAYER_DetachStream; ifce->GetCapabilities = LIBPLAYER_GetCapabilities; ifce->SetCapabilities = LIBPLAYER_SetCapabilities; ifce->Control = LIBPLAYER_Control; ifce->CanHandleStream = LIBPLAYER_CanHandleStream; ifce->GetName = LIBPLAYER_GetName; return (GF_BaseInterface *) ifce; } return NULL; }
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; }
GF_TermExt *uir_new() { GF_TermExt *dr; GF_UIRecord *uir; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC UI Recorder", "gpac distribution"); GF_SAFEALLOC(uir, GF_UIRecord); dr->process = uir_process; dr->udta = uir; return dr; }
GF_TermExt *osd_new() { GF_TermExt *dr; GF_OSD *osd; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC OnSscreen Display", "gpac distribution"); GF_SAFEALLOC(osd, GF_OSD); dr->process = osd_process; dr->udta = osd; return dr; }
GF_TermExt *validator_new() { GF_TermExt *dr; GF_Validator *validator; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC Test Validator", "gpac distribution"); GF_SAFEALLOC(validator, GF_Validator); dr->process = validator_process; dr->udta = validator; return dr; }