/***************************************************************************** * Create: initialize and set pf_video_filter() *****************************************************************************/ static int Create( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; const vlc_chroma_description_t *p_chroma = vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma ); if( p_chroma == NULL || p_chroma->plane_count == 0 ) return VLC_EGENERIC; config_ChainParse( p_filter, CFG_PREFIX, ppsz_vfilter_options, p_filter->p_cfg ); p_filter->p_sys = p_sys = calloc( 1, sizeof( filter_sys_t ) ); if( p_filter->p_sys == NULL ) return VLC_ENOMEM; p_sys->p_image = image_HandlerCreate( p_this ); if( !p_sys->p_image ) { msg_Err( p_this, "Couldn't get handle to image conversion routines." ); free( p_sys ); return VLC_EGENERIC; } p_sys->psz_format = var_CreateGetString( p_this, CFG_PREFIX "format" ); p_sys->i_format = image_Type2Fourcc( p_sys->psz_format ); if( !p_sys->i_format ) { msg_Err( p_filter, "Could not find FOURCC for image type '%s'", p_sys->psz_format ); image_HandlerDelete( p_sys->p_image ); free( p_sys->psz_format ); free( p_sys ); return VLC_EGENERIC; } p_sys->i_width = var_CreateGetInteger( p_this, CFG_PREFIX "width" ); p_sys->i_height = var_CreateGetInteger( p_this, CFG_PREFIX "height" ); p_sys->i_ratio = var_CreateGetInteger( p_this, CFG_PREFIX "ratio" ); if( p_sys->i_ratio <= 0) p_sys->i_ratio = 1; p_sys->b_replace = var_CreateGetBool( p_this, CFG_PREFIX "replace" ); p_sys->psz_prefix = var_CreateGetString( p_this, CFG_PREFIX "prefix" ); p_sys->psz_path = var_GetNonEmptyString( p_this, CFG_PREFIX "path" ); if( p_sys->psz_path == NULL ) p_sys->psz_path = config_GetUserDir( VLC_PICTURES_DIR ); p_filter->pf_video_filter = Filter; return VLC_SUCCESS; }
/***************************************************************************** * OpenDecoder: probe the decoder and return score ***************************************************************************** * Tries to launch a decoder and return score so that the interface is able * to chose. *****************************************************************************/ static int OpenDecoder( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t*)p_this; decoder_sys_t *p_sys; if( p_dec->fmt_in.i_codec != VLC_CODEC_USF ) return VLC_EGENERIC; /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = calloc(1, sizeof(decoder_sys_t)) ) == NULL ) return VLC_ENOMEM; p_dec->pf_decode_sub = DecodeBlock; p_dec->fmt_out.i_cat = SPU_ES; p_dec->fmt_out.i_codec = 0; /* init of p_sys */ TAB_INIT( p_sys->i_ssa_styles, p_sys->pp_ssa_styles ); TAB_INIT( p_sys->i_images, p_sys->pp_images ); /* USF subtitles are mandated to be UTF-8, so don't need vlc_iconv */ p_sys->i_align = var_CreateGetInteger( p_dec, "subsdec-align" ); ParseImageAttachments( p_dec ); if( var_CreateGetBool( p_dec, "subsdec-formatted" ) ) { if( p_dec->fmt_in.i_extra > 0 ) ParseUSFHeader( p_dec ); } return VLC_SUCCESS; }
/***************************************************************************** * Open: initialize and create stuff *****************************************************************************/ static int Open( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t*)p_this; unsigned i_channels; filter_sys_t *p_sys; i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); p_sys = p_filter->p_sys = (filter_sys_t *)malloc( sizeof( *p_sys ) ); // sunqueen modify if( !p_sys ) return VLC_ENOMEM; p_sys->i_nb = var_CreateGetInteger( p_filter->p_parent, "norm-buff-size" ); p_sys->f_max = var_CreateGetFloat( p_filter->p_parent, "norm-max-level" ); if( p_sys->f_max <= 0 ) p_sys->f_max = 0.01; /* We need to store (nb_buffers+1)*nb_channels floats */ p_sys->p_last = (float *)calloc( i_channels * (p_filter->p_sys->i_nb + 2), sizeof(float) ); // sunqueen modify if( !p_sys->p_last ) { free( p_sys ); return VLC_ENOMEM; } p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32; p_filter->fmt_out.audio = p_filter->fmt_in.audio; p_filter->pf_audio_filter = DoWork; return VLC_SUCCESS; }
static sap_address_t *AddressCreate (vlc_object_t *obj, const char *group) { int fd = net_ConnectUDP (obj, group, IPPORT_SAP, 255); if (fd == -1) return NULL; sap_address_t *addr = malloc (sizeof (*addr)); if (addr == NULL) { net_Close (fd); return NULL; } strlcpy (addr->group, group, sizeof (addr->group)); addr->fd = fd; addr->origlen = sizeof (addr->orig); getsockname (fd, (struct sockaddr *)&addr->orig, &addr->origlen); addr->interval = var_CreateGetInteger (obj, "sap-interval"); vlc_mutex_init (&addr->lock); vlc_cond_init (&addr->wait); addr->session_count = 0; addr->first = NULL; if (vlc_clone (&addr->thread, RunThread, addr, VLC_THREAD_PRIORITY_LOW)) { msg_Err (obj, "unable to spawn SAP announce thread"); net_Close (fd); free (addr); return NULL; } return addr; }
/** * Log a message */ static void Overflow (msg_cb_data_t *p_sys, msg_item_t *p_item, unsigned overruns) { VLC_UNUSED(overruns); int verbosity = var_CreateGetInteger( p_sys->p_intf, "verbose" ); int priority = 0; switch( p_item->i_type ) { case VLC_MSG_WARN: priority = 1; break; case VLC_MSG_DBG: priority = 2; break; } if (verbosity < priority) return; int canc = vlc_savecancel(); switch( p_sys->i_mode ) { case MODE_HTML: HtmlPrint( p_item, p_sys->p_file ); break; #ifdef HAVE_SYSLOG_H case MODE_SYSLOG: SyslogPrint( p_item ); break; #endif case MODE_TEXT: default: TextPrint( p_item, p_sys->p_file ); break; } vlc_restorecancel( canc ); }
/** * Open() */ static int Open (vlc_object_t *obj) { access_t *access = (access_t*)obj; access_t *src = access->p_source; if (src->pf_read != NULL) access->pf_read = Read; else { msg_Err (obj, "block bandwidth limit not implemented"); return VLC_EGENERIC; } if (src->pf_seek != NULL) access->pf_seek = Seek; access->pf_control = Control; access->info = src->info; access_sys_t *p_sys = access->p_sys = calloc( 1, sizeof (*p_sys) ); if( !p_sys ) return VLC_ENOMEM; p_sys->bandwidth = var_CreateGetInteger (access, "access-bandwidth"); p_sys->last_time = mdate (); msg_Dbg (obj, "bandwidth limit: %lu bytes/s", (unsigned long)p_sys->bandwidth); return VLC_SUCCESS; }
/** * Open the module * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */ static int Open( vlc_object_t * p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) ); if( !p_sys ) return VLC_ENOMEM; /* Create the object for the thread */ p_sys->b_quit = false; p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); vlc_mutex_init( &p_sys->lock ); p_sys->p_buffer = NULL; p_sys->i_buffer_size = 0; p_sys->i_nb_samples = 0; /* Create the OpenGL context */ vout_window_cfg_t cfg; memset(&cfg, 0, sizeof (cfg)); cfg.width = var_CreateGetInteger( p_filter, "projectm-width" ); cfg.height = var_CreateGetInteger( p_filter, "projectm-height" ); p_sys->gl = vlc_gl_surface_Create( VLC_OBJECT(p_filter), &cfg, NULL ); if( p_sys->gl == NULL ) goto error; /* Create the thread */ if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) ) { vlc_gl_surface_Destroy( p_sys->gl ); goto error; } p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32; p_filter->fmt_out.audio = p_filter->fmt_in.audio; p_filter->pf_audio_filter = DoWork; return VLC_SUCCESS; error: vlc_mutex_destroy( &p_sys->lock ); free (p_sys ); return VLC_EGENERIC; }
static int Setup( vlc_va_t *p_external, void **pp_hw_ctx, vlc_fourcc_t *pi_chroma, int i_width, int i_height ) { vlc_va_vda_t *p_va = vlc_va_vda_Get( p_external ); if( p_va->hw_ctx.width == i_width && p_va->hw_ctx.height == i_height && p_va->hw_ctx.decoder ) { *pp_hw_ctx = &p_va->hw_ctx; *pi_chroma = p_va->i_chroma; return VLC_SUCCESS; } if( p_va->hw_ctx.decoder ) { ff_vda_destroy_decoder( &p_va->hw_ctx ); goto ok; } memset( &p_va->hw_ctx, 0, sizeof(p_va->hw_ctx) ); p_va->hw_ctx.width = i_width; p_va->hw_ctx.height = i_height; p_va->hw_ctx.format = 'avc1'; int i_pix_fmt = var_CreateGetInteger( p_va->p_log, "avcodec-vda-pix-fmt" ); switch( i_pix_fmt ) { case 1 : p_va->hw_ctx.cv_pix_fmt_type = kCVPixelFormatType_422YpCbCr8; p_va->i_chroma = VLC_CODEC_UYVY; break; case 0 : default : p_va->hw_ctx.cv_pix_fmt_type = kCVPixelFormatType_420YpCbCr8Planar; p_va->i_chroma = VLC_CODEC_I420; CopyInitCache( &p_va->image_cache, i_width ); } ok: /* Setup the ffmpeg hardware context */ *pp_hw_ctx = &p_va->hw_ctx; *pi_chroma = p_va->i_chroma; /* create the decoder */ int status = ff_vda_create_decoder( &p_va->hw_ctx, p_va->p_extradata, p_va->i_extradata ); if( status ) { msg_Err( p_va->p_log, "Failed to create the decoder : %i", status ); return VLC_EGENERIC; } return VLC_SUCCESS; }
/** * Common open function */ static int OpenCommon(vlc_object_t *p_this, bool b_sub) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; /* */ if (!b_sub && !es_format_IsSimilar(&p_filter->fmt_in, &p_filter->fmt_out)) { msg_Err(p_filter, "Input and output format does not match"); return VLC_EGENERIC; } /* */ p_filter->p_sys = p_sys = malloc(sizeof(*p_sys)); if (!p_sys) return VLC_ENOMEM; /* */ p_sys->p_blend = NULL; if (!b_sub) { p_sys->p_blend = filter_NewBlend(VLC_OBJECT(p_filter), &p_filter->fmt_in.video); if (!p_sys->p_blend) { free(p_sys); return VLC_EGENERIC; } } /* */ config_ChainParse(p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg); /* create and initialize variables */ p_sys->i_pos = var_CreateGetInteger(p_filter, CFG_PREFIX "position"); p_sys->i_pos_x = var_CreateGetInteger(p_filter, CFG_PREFIX "x"); p_sys->i_pos_y = var_CreateGetInteger(p_filter, CFG_PREFIX "y"); BarGraph_t *p_BarGraph = &p_sys->p_BarGraph; p_BarGraph->p_pic = NULL; p_BarGraph->i_alpha = var_CreateGetInteger(p_filter, CFG_PREFIX "transparency"); p_BarGraph->i_alpha = VLC_CLIP(p_BarGraph->i_alpha, 0, 255); p_BarGraph->i_values = NULL; parse_i_values(p_BarGraph, &(char){ 0 });
/***************************************************************************** * CreateFilter: allocates marquee video filter *****************************************************************************/ static int CreateFilter( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; vlc_object_t *p_pl; /* Allocate structure */ p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); if( p_sys == NULL ) { msg_Err( p_filter, "out of memory" ); return VLC_ENOMEM; } /* hook to the playlist */ p_pl = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); if( !p_pl ) { return VLC_ENOOBJ; } /* p_access->p_libvlc p_demux->p_libvlc */ p_sys->i_xoff = var_CreateGetInteger( p_pl , "marq-x" ); p_sys->i_yoff = var_CreateGetInteger( p_pl , "marq-y" ); p_sys->i_timeout = var_CreateGetInteger( p_pl , "marq-timeout" ); p_sys->psz_marquee = var_CreateGetString( p_pl, "marq-marquee" ); var_AddCallback( p_pl, "marq-x", MarqueeCallback, p_sys ); var_AddCallback( p_pl, "marq-y", MarqueeCallback, p_sys ); var_AddCallback( p_pl, "marq-marquee", MarqueeCallback, p_sys ); var_AddCallback( p_pl, "marq-timeout", MarqueeCallback, p_sys ); vlc_object_release( p_pl ); /* Misc init */ p_filter->pf_sub_filter = Filter; p_sys->last_time = ((time_t)-1); p_sys->b_need_update = VLC_TRUE; return VLC_SUCCESS; }
/***************************************************************************** * Create: allocates video thread ***************************************************************************** * This function allocates and initializes a vout method. *****************************************************************************/ static int Create( vlc_object_t *p_this ) { vout_thread_t *p_vout = ( vout_thread_t * )p_this; /* Allocate instance and initialize some members */ p_vout->p_sys = malloc( sizeof( vout_sys_t ) ); if( ! p_vout->p_sys ) return VLC_ENOMEM; p_vout->p_sys->psz_prefix = var_CreateGetString( p_this, "image-out-prefix" ); p_vout->p_sys->psz_format = var_CreateGetString( p_this, "image-out-format" ); p_vout->p_sys->i_width = var_CreateGetInteger( p_this, "image-width" ); p_vout->p_sys->i_height = var_CreateGetInteger( p_this, "image-height" ); p_vout->p_sys->i_ratio = var_CreateGetInteger( p_this, "image-out-ratio" ); p_vout->p_sys->b_replace = var_CreateGetBool( p_this, "image-out-replace" ); p_vout->p_sys->i_current = 0; p_vout->p_sys->p_image = image_HandlerCreate( p_vout ); if( !p_vout->p_sys->p_image ) { msg_Err( p_this, "unable to create image handler") ; FREE( p_vout->p_sys->psz_prefix ); FREE( p_vout->p_sys ); return VLC_EGENERIC; } p_vout->pf_init = Init; p_vout->pf_end = End; p_vout->pf_manage = NULL; p_vout->pf_render = Display; p_vout->pf_display = NULL; return VLC_SUCCESS; }
/***************************************************************************** * Open: initialize and create stuff *****************************************************************************/ static int Open( vlc_object_t *p_this ) { aout_filter_t *p_filter = (aout_filter_t*)p_this; bool b_fit = true; int i_channels; aout_filter_sys_t *p_sys; if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 || p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 ) { b_fit = false; p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32; p_filter->fmt_out.audio.i_format = VLC_CODEC_FL32; msg_Warn( p_filter, "bad input or output format" ); } if ( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) ) { b_fit = false; memcpy( &p_filter->fmt_out.audio, &p_filter->fmt_in.audio, sizeof(audio_sample_format_t) ); msg_Warn( p_filter, "input and output formats are not similar" ); } if ( ! b_fit ) { return VLC_EGENERIC; } p_filter->pf_do_work = DoWork; p_filter->b_in_place = true; i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->i_nb = var_CreateGetInteger( p_filter->p_parent, "norm-buff-size" ); p_sys->f_max = var_CreateGetFloat( p_filter->p_parent, "norm-max-level" ); if( p_sys->f_max <= 0 ) p_sys->f_max = 0.01; /* We need to store (nb_buffers+1)*nb_channels floats */ p_sys->p_last = calloc( i_channels * (p_filter->p_sys->i_nb + 2), sizeof(float) ); if( !p_sys->p_last ) { free( p_sys ); return VLC_ENOMEM; } return VLC_SUCCESS; }
/***************************************************************************** * Create: allocates omapfb video thread output method ***************************************************************************** * This function allocates and initializes a FB vout method. *****************************************************************************/ static int Create( vlc_object_t *p_this ) { vout_thread_t *p_vout = (vout_thread_t *)p_this; vout_sys_t *p_sys; if( p_vout->fmt_in.i_chroma != VLC_CODEC_I420 && p_vout->fmt_in.i_chroma != VLC_CODEC_YV12 ) return VLC_EGENERIC; /* Allocate instance and initialize some members */ p_vout->p_sys = p_sys = calloc( 1, sizeof( vout_sys_t ) ); if( p_vout->p_sys == NULL ) return VLC_ENOMEM; p_vout->pf_init = Init; p_vout->pf_end = End; p_vout->pf_manage = Manage; p_vout->pf_render = NULL; p_vout->pf_display = DisplayVideo; p_vout->pf_control = Control; p_sys->b_embed = var_CreateGetInteger( p_vout, "omap-embedded" ); p_sys->b_video_enabled = true; if( OpenDisplay( p_vout ) ) { free( p_vout->p_sys ); return VLC_EGENERIC; } if( InitWindow( p_vout ) ) { free( p_vout->p_sys ); return VLC_EGENERIC; } #ifdef HAVE_OSSO p_vout->p_sys->i_backlight_on_counter = i_backlight_on_interval; p_vout->p_sys->p_octx = osso_initialize( "vlc", VERSION, 0, NULL ); if ( p_vout->p_sys->p_octx == NULL ) { msg_Err( p_vout, "Could not get osso context" ); } else { msg_Dbg( p_vout, "Initialized osso context" ); } #endif return VLC_SUCCESS; }
/** * Open() */ static int Open (vlc_object_t *obj) { access_t *access = (access_t*)obj; access_t *src = access->p_source; if (!var_CreateGetBool (access, "dump-force")) { bool b; if ((access_Control (src, ACCESS_CAN_FASTSEEK, &b) == 0) && b) { msg_Dbg (obj, "dump filter useless"); return VLC_EGENERIC; } } if (src->pf_read != NULL) access->pf_read = Read; else access->pf_block = Block; if (src->pf_seek != NULL) access->pf_seek = Seek; access->pf_control = Control; access->info = src->info; access_sys_t *p_sys = access->p_sys = calloc( 1, sizeof (*p_sys) ); if( !p_sys ) return VLC_ENOMEM; # ifndef UNDER_CE if ((p_sys->stream = tmpfile ()) == NULL) # else char buf[75]; if(GetTempFileName("\\Temp\\","vlc",0,buf) || ((p_sys->stream = fopen(buf,"wb+")) ==NULL)) #endif { msg_Err (access, "cannot create temporary file: %m"); free (p_sys); return VLC_EGENERIC; } p_sys->tmp_max = ((int64_t)var_CreateGetInteger (access, "dump-margin")) << 20; var_AddCallback (access->p_libvlc, "key-action", KeyHandler, access); return VLC_SUCCESS; }
/***************************************************************************** * vout_RequestWindow: Create/Get a video window if possible. ***************************************************************************** * This function looks for the main interface and tries to request * a new video window. If it fails then the vout will still need to create the * window by itself. *****************************************************************************/ void *vout_RequestWindow( vout_thread_t *p_vout, int *pi_x_hint, int *pi_y_hint, unsigned int *pi_width_hint, unsigned int *pi_height_hint ) { /* Small kludge */ if( !var_Type( p_vout, "aspect-ratio" ) ) vout_IntfInit( p_vout ); /* Get requested coordinates */ *pi_x_hint = var_GetInteger( p_vout, "video-x" ); *pi_y_hint = var_GetInteger( p_vout, "video-y" ); *pi_width_hint = p_vout->i_window_width; *pi_height_hint = p_vout->i_window_height; /* Check whether someone provided us with a window ID */ int drawable = var_CreateGetInteger( p_vout, "drawable" ); if( drawable ) return (void *)(intptr_t)drawable; vout_window_t *wnd = vlc_custom_create (VLC_OBJECT(p_vout), sizeof (*wnd), VLC_OBJECT_GENERIC, "window"); if (wnd == NULL) return NULL; wnd->vout = p_vout; wnd->width = *pi_width_hint; wnd->height = *pi_height_hint; wnd->pos_x = *pi_x_hint; wnd->pos_y = *pi_y_hint; vlc_object_attach (wnd, p_vout); wnd->module = module_Need (wnd, "vout window", 0, 0); if (wnd->module == NULL) { msg_Dbg (wnd, "no window provider available"); vlc_object_release (wnd); return NULL; } p_vout->p_window = wnd; *pi_width_hint = wnd->width; *pi_height_hint = wnd->height; *pi_x_hint = wnd->pos_x; *pi_y_hint = wnd->pos_y; return wnd->handle; }
/***************************************************************************** * Open: initializes demux structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; const uint8_t *p_peek; es_format_t fmt; if( stream_Peek( p_demux->s, &p_peek, 5 ) < 5 ) return VLC_EGENERIC; if( p_peek[0] != 'B' || p_peek[1] != 'B' || p_peek[2] != 'C' || p_peek[3] != 'D') /* start of ParseInfo */ { if( !p_demux->b_force ) return VLC_EGENERIC; msg_Err( p_demux, "This doesn't look like a Dirac stream (incorrect parsecode)" ); msg_Warn( p_demux, "continuing anyway" ); } p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys = (demux_sys_t *)calloc( 1, sizeof( demux_sys_t ) ); // sunqueen modify if( !p_sys ) return VLC_ENOMEM; p_sys->i_pts_offset_lowtide = INT64_MAX; p_sys->i_state = DIRAC_DEMUX_FIRST; p_sys->i_dtsoffset = var_CreateGetInteger( p_demux, DEMUX_CFG_PREFIX DEMUX_DTSOFFSET ); /* Load the packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_DIRAC ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "dirac" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } return VLC_SUCCESS; }
int vout_OpenWrapper(vout_thread_t *vout, const char *splitter_name, const vout_display_state_t *state) { vout_thread_sys_t *sys = vout->p; msg_Dbg(vout, "Opening vout display wrapper"); /* */ sys->display.title = var_CreateGetNonEmptyString(vout, "video-title"); /* */ const mtime_t double_click_timeout = 300000; const mtime_t hide_timeout = var_CreateGetInteger(vout, "mouse-hide-timeout") * 1000; if (splitter_name) { sys->display.vd = vout_NewSplitter(vout, &vout->p->original, state, "$vout", splitter_name, double_click_timeout, hide_timeout); } else { sys->display.vd = vout_NewDisplay(vout, &vout->p->original, state, "$vout", double_click_timeout, hide_timeout); } if (!sys->display.vd) { free(sys->display.title); return VLC_EGENERIC; } /* */ #ifdef WIN32 var_Create(vout, "direct3d-desktop", VLC_VAR_BOOL|VLC_VAR_DOINHERIT); var_AddCallback(vout, "direct3d-desktop", Forward, NULL); var_Create(vout, "video-wallpaper", VLC_VAR_BOOL|VLC_VAR_DOINHERIT); var_AddCallback(vout, "video-wallpaper", Forward, NULL); #endif /* */ sys->decoder_pool = NULL; return VLC_SUCCESS; }
/***************************************************************************** * CreateFilter: allocates time video filter *****************************************************************************/ static int CreateFilter( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; /* Allocate structure */ p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); if( p_sys == NULL ) { msg_Err( p_filter, "out of memory" ); return VLC_ENOMEM; } p_sys->p_style = malloc( sizeof( text_style_t ) ); memcpy( p_sys->p_style, &default_text_style, sizeof( text_style_t ) ); /* Hook used for callback variables */ p_sys->i_xoff = var_CreateGetInteger( p_filter->p_libvlc , "time-x" ); p_sys->i_yoff = var_CreateGetInteger( p_filter->p_libvlc , "time-y" ); p_sys->psz_format = var_CreateGetString( p_filter->p_libvlc, "time-format" ); p_sys->i_pos = var_CreateGetInteger( p_filter->p_libvlc , "time-position" ); p_sys->p_style->i_font_alpha = 255 - var_CreateGetInteger( p_filter->p_libvlc , "time-opacity" ); p_sys->p_style->i_font_color = var_CreateGetInteger( p_filter->p_libvlc , "time-color" ); p_sys->p_style->i_font_size = var_CreateGetInteger( p_filter->p_libvlc , "time-size" ); var_AddCallback( p_filter->p_libvlc, "time-x", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-y", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-format", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-position", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-color", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-opacity", TimeCallback, p_sys ); var_AddCallback( p_filter->p_libvlc, "time-size", TimeCallback, p_sys ); /* Misc init */ p_filter->pf_sub_filter = Filter; p_sys->last_time = ((time_t)-1); return VLC_SUCCESS; }
static int Activate( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; unsigned i_canvas_width; /* width of output canvas */ unsigned i_canvas_height; /* height of output canvas */ unsigned i_canvas_aspect; /* canvas PictureAspectRatio */ es_format_t fmt; /* target format after up/down conversion */ char psz_croppadd[100]; int i_padd,i_offset; char *psz_aspect, *psz_parser; bool b_padd; unsigned i_fmt_in_aspect; if( !p_filter->b_allow_fmt_out_change ) { msg_Err( p_filter, "Picture format change isn't allowed" ); return VLC_EGENERIC; } if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma ) { msg_Err( p_filter, "Input and output chromas don't match" ); return VLC_EGENERIC; } config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg ); i_canvas_width = var_CreateGetInteger( p_filter, CFG_PREFIX "width" ); i_canvas_height = var_CreateGetInteger( p_filter, CFG_PREFIX "height" ); if( i_canvas_width == 0 || i_canvas_height == 0 ) { msg_Err( p_filter, "Width and height options must be set" ); return VLC_EGENERIC; } if( i_canvas_width & 1 || i_canvas_height & 1 ) { /* If this restriction were ever relaxed, it is very important to * get the field polatiry correct */ msg_Err( p_filter, "Width and height options must be even integers" ); return VLC_EGENERIC; } i_fmt_in_aspect = (int64_t)p_filter->fmt_in.video.i_sar_num * p_filter->fmt_in.video.i_width * VOUT_ASPECT_FACTOR / p_filter->fmt_in.video.i_sar_den / p_filter->fmt_in.video.i_height; psz_aspect = var_CreateGetNonEmptyString( p_filter, CFG_PREFIX "aspect" ); if( psz_aspect ) { psz_parser = strchr( psz_aspect, ':' ); int numerator = atoi( psz_aspect ); int denominator = psz_parser ? atoi( psz_parser+1 ) : 0; denominator = denominator == 0 ? 1 : denominator; i_canvas_aspect = numerator * VOUT_ASPECT_FACTOR / denominator; free( psz_aspect ); if( numerator <= 0 || denominator < 0 ) { msg_Err( p_filter, "Aspect ratio must be strictly positive" ); return VLC_EGENERIC; } } else { /* if there is no user supplied aspect ratio, assume the canvas * has the same sample aspect ratio as the subpicture */ /* aspect = subpic_sar * canvas_width / canvas_height * where subpic_sar = subpic_ph * subpic_par / subpic_pw */ i_canvas_aspect = (uint64_t) p_filter->fmt_in.video.i_height * i_fmt_in_aspect * i_canvas_width / (i_canvas_height * p_filter->fmt_in.video.i_width); } b_padd = var_CreateGetBool( p_filter, CFG_PREFIX "padd" ); filter_sys_t *p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_filter->p_sys = p_sys; p_sys->p_chain = filter_chain_New( p_filter, "video filter2", true, alloc_init, NULL, p_filter ); if( !p_sys->p_chain ) { msg_Err( p_filter, "Could not allocate filter chain" ); free( p_sys ); return VLC_EGENERIC; } es_format_Copy( &fmt, &p_filter->fmt_in ); /* one dimension will end up with one of the following: */ fmt.video.i_width = i_canvas_width; fmt.video.i_height = i_canvas_height; if( b_padd ) { /* Padd */ if( i_canvas_aspect > i_fmt_in_aspect ) { /* The canvas has a wider aspect than the subpicture: * ie, pillarbox the [scaled] subpicture */ /* The following is derived form: * width = upconverted_subpic_height * subpic_par / canvas_sar * where canvas_sar = canvas_width / (canvas_height * canvas_par) * then simplify */ fmt.video.i_width = i_canvas_width * i_fmt_in_aspect / i_canvas_aspect; if( fmt.video.i_width & 1 ) fmt.video.i_width -= 1; i_padd = (i_canvas_width - fmt.video.i_width) / 2; i_offset = (i_padd & 1); _snprintf( psz_croppadd, 100, "croppadd{paddleft=%d,paddright=%d}", i_padd - i_offset, i_padd + i_offset ); // sunqueen modify } else { /* The canvas has a taller aspect than the subpicture: * ie, letterbox the [scaled] subpicture */ fmt.video.i_height = i_canvas_height * i_canvas_aspect / i_fmt_in_aspect; if( fmt.video.i_height & 1 ) fmt.video.i_height -= 1; i_padd = (i_canvas_height - fmt.video.i_height ) / 2; i_offset = (i_padd & 1); _snprintf( psz_croppadd, 100, "croppadd{paddtop=%d,paddbottom=%d}", i_padd - i_offset, i_padd + i_offset ); // sunqueen modify } } else { /* Crop */ if( i_canvas_aspect < i_fmt_in_aspect ) { /* The canvas has a narrower aspect than the subpicture: * ie, crop the [scaled] subpicture horizontally */ fmt.video.i_width = i_canvas_width * i_fmt_in_aspect / i_canvas_aspect; if( fmt.video.i_width & 1 ) fmt.video.i_width -= 1; i_padd = (fmt.video.i_width - i_canvas_width) / 2; i_offset = (i_padd & 1); _snprintf( psz_croppadd, 100, "croppadd{cropleft=%d,cropright=%d}", i_padd - i_offset, i_padd + i_offset ); // sunqueen modify } else { /* The canvas has a shorter aspect than the subpicture: * ie, crop the [scaled] subpicture vertically */ fmt.video.i_height = i_canvas_height * i_canvas_aspect / i_fmt_in_aspect; if( fmt.video.i_height & 1 ) fmt.video.i_height -= 1; i_padd = (fmt.video.i_height - i_canvas_height) / 2; i_offset = (i_padd & 1); _snprintf( psz_croppadd, 100, "croppadd{croptop=%d,cropbottom=%d}", i_padd - i_offset, i_padd + i_offset ); // sunqueen modify } } /* xxx, should the clean area include the letter-boxing? * probably not, as some codecs can make use of that information * and it should be a scaled version of the input clean area * -- davidf */ fmt.video.i_visible_width = fmt.video.i_width; fmt.video.i_visible_height = fmt.video.i_height; filter_chain_Reset( p_sys->p_chain, &p_filter->fmt_in, &fmt ); /* Append scaling module */ filter_chain_AppendFilter( p_sys->p_chain, NULL, NULL, NULL, NULL ); /* Append padding module */ filter_chain_AppendFromString( p_sys->p_chain, psz_croppadd ); fmt = *filter_chain_GetFmtOut( p_sys->p_chain ); es_format_Copy( &p_filter->fmt_out, &fmt ); p_filter->fmt_out.video.i_sar_num = i_canvas_aspect * p_filter->fmt_out.video.i_height; p_filter->fmt_out.video.i_sar_den = VOUT_ASPECT_FACTOR * p_filter->fmt_out.video.i_width; if( p_filter->fmt_out.video.i_width != i_canvas_width || p_filter->fmt_out.video.i_height != i_canvas_height ) { msg_Warn( p_filter, "Looks like something went wrong. " "Output size is %dx%d while we asked for %dx%d", p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height, i_canvas_width, i_canvas_height ); } p_filter->pf_video_filter = Filter; return VLC_SUCCESS; }
/***************************************************************************** * InitVideo: initialize the video decoder ***************************************************************************** * the ffmpeg codec will be opened, some memory allocated. The vout is not yet * opened (done after the first decoded frame). *****************************************************************************/ int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context, AVCodec *p_codec, int i_codec_id, const char *psz_namecodec ) { decoder_sys_t *p_sys; int i_val; /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(decoder_sys_t) ) ) == NULL ) return VLC_ENOMEM; p_codec->type = CODEC_TYPE_VIDEO; p_context->codec_type = CODEC_TYPE_VIDEO; p_context->codec_id = i_codec_id; p_sys->p_context = p_context; p_sys->p_codec = p_codec; p_sys->i_codec_id = i_codec_id; p_sys->psz_namecodec = psz_namecodec; p_sys->p_ff_pic = avcodec_alloc_frame(); p_sys->b_delayed_open = true; p_sys->p_va = NULL; vlc_sem_init( &p_sys->sem_mt, 0 ); /* ***** Fill p_context with init values ***** */ p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_original_fourcc ?: p_dec->fmt_in.i_codec ); /* ***** Get configuration of ffmpeg plugin ***** */ p_sys->p_context->workaround_bugs = var_InheritInteger( p_dec, "ffmpeg-workaround-bugs" ); p_sys->p_context->error_recognition = var_InheritInteger( p_dec, "ffmpeg-error-resilience" ); if( var_CreateGetBool( p_dec, "grayscale" ) ) p_sys->p_context->flags |= CODEC_FLAG_GRAY; i_val = var_CreateGetInteger( p_dec, "ffmpeg-vismv" ); if( i_val ) p_sys->p_context->debug_mv = i_val; i_val = var_CreateGetInteger( p_dec, "ffmpeg-lowres" ); if( i_val > 0 && i_val <= 2 ) p_sys->p_context->lowres = i_val; i_val = var_CreateGetInteger( p_dec, "ffmpeg-skiploopfilter" ); if( i_val >= 4 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL; else if( i_val == 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY; else if( i_val == 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR; else if( i_val == 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF; if( var_CreateGetBool( p_dec, "ffmpeg-fast" ) ) p_sys->p_context->flags2 |= CODEC_FLAG2_FAST; /* ***** ffmpeg frame skipping ***** */ p_sys->b_hurry_up = var_CreateGetBool( p_dec, "ffmpeg-hurry-up" ); switch( var_CreateGetInteger( p_dec, "ffmpeg-skip-frame" ) ) { case -1: p_sys->p_context->skip_frame = AVDISCARD_NONE; break; case 0: p_sys->p_context->skip_frame = AVDISCARD_DEFAULT; break; case 1: p_sys->p_context->skip_frame = AVDISCARD_BIDIR; break; case 2: p_sys->p_context->skip_frame = AVDISCARD_NONKEY; break; case 3: p_sys->p_context->skip_frame = AVDISCARD_ALL; break; default: p_sys->p_context->skip_frame = AVDISCARD_NONE; break; } p_sys->i_skip_frame = p_sys->p_context->skip_frame; switch( var_CreateGetInteger( p_dec, "ffmpeg-skip-idct" ) ) { case -1: p_sys->p_context->skip_idct = AVDISCARD_NONE; break; case 0: p_sys->p_context->skip_idct = AVDISCARD_DEFAULT; break; case 1: p_sys->p_context->skip_idct = AVDISCARD_BIDIR; break; case 2: p_sys->p_context->skip_idct = AVDISCARD_NONKEY; break; case 3: p_sys->p_context->skip_idct = AVDISCARD_ALL; break; default: p_sys->p_context->skip_idct = AVDISCARD_NONE; break; } p_sys->i_skip_idct = p_sys->p_context->skip_idct; /* ***** ffmpeg direct rendering ***** */ p_sys->b_direct_rendering = false; p_sys->i_direct_rendering_used = -1; if( var_CreateGetBool( p_dec, "ffmpeg-dr" ) && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) && /* No idea why ... but this fixes flickering on some TSCC streams */ p_sys->i_codec_id != CODEC_ID_TSCC && !p_sys->p_context->debug_mv ) { /* Some codecs set pix_fmt only after the 1st frame has been decoded, * so we need to do another check in ffmpeg_GetFrameBuf() */ p_sys->b_direct_rendering = true; } /* ffmpeg doesn't properly release old pictures when frames are skipped */ //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = false; if( p_sys->b_direct_rendering ) { msg_Dbg( p_dec, "trying to use direct rendering" ); p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE; } else { msg_Dbg( p_dec, "direct rendering is disabled" ); } /* Always use our get_buffer wrapper so we can calculate the * PTS correctly */ p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf; p_sys->p_context->reget_buffer = ffmpeg_ReGetFrameBuf; p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf; p_sys->p_context->opaque = p_dec; #ifdef HAVE_AVCODEC_MT int i_thread_count = var_InheritInteger( p_dec, "ffmpeg-threads" ); if( i_thread_count <= 0 ) i_thread_count = vlc_GetCPUCount(); msg_Dbg( p_dec, "allowing %d thread(s) for decoding", i_thread_count ); p_sys->p_context->thread_count = i_thread_count; #endif #ifdef HAVE_AVCODEC_VA const bool b_use_hw = var_CreateGetBool( p_dec, "ffmpeg-hw" ); if( b_use_hw ) { #ifdef HAVE_AVCODEC_MT msg_Err( p_dec, "ffmpeg-hw is not compatible with ffmpeg-mt" ); #else p_sys->p_context->get_format = ffmpeg_GetFormat; #endif } #endif /* ***** misc init ***** */ p_sys->i_pts = VLC_TS_INVALID; p_sys->b_has_b_frames = false; p_sys->b_first_frame = true; p_sys->b_flush = false; p_sys->i_late_frames = 0; /* Set output properties */ p_dec->fmt_out.i_cat = VIDEO_ES; if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS ) { /* we are doomed. but not really, because most codecs set their pix_fmt later on */ p_dec->fmt_out.i_codec = VLC_CODEC_I420; } p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma; /* Setup palette */ memset( &p_sys->palette, 0, sizeof(p_sys->palette) ); if( p_dec->fmt_in.video.p_palette ) { p_sys->palette.palette_changed = 1; for( int i = 0; i < __MIN( AVPALETTE_COUNT, p_dec->fmt_in.video.p_palette->i_entries ); i++ ) { union { uint32_t u; uint8_t a[4]; } c; c.a[0] = p_dec->fmt_in.video.p_palette->palette[i][0]; c.a[1] = p_dec->fmt_in.video.p_palette->palette[i][1]; c.a[2] = p_dec->fmt_in.video.p_palette->palette[i][2]; c.a[3] = p_dec->fmt_in.video.p_palette->palette[i][3]; p_sys->palette.palette[i] = c.u; } p_sys->p_context->palctrl = &p_sys->palette; p_dec->fmt_out.video.p_palette = malloc( sizeof(video_palette_t) ); if( p_dec->fmt_out.video.p_palette ) *p_dec->fmt_out.video.p_palette = *p_dec->fmt_in.video.p_palette; } else if( p_sys->i_codec_id != CODEC_ID_MSVIDEO1 && p_sys->i_codec_id != CODEC_ID_CINEPAK ) { p_sys->p_context->palctrl = &p_sys->palette; } /* ***** init this codec with special data ***** */ ffmpeg_InitCodec( p_dec ); /* ***** Open the codec ***** */ if( ffmpeg_OpenCodec( p_dec ) < 0 ) { msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec ); av_free( p_sys->p_ff_pic ); vlc_sem_destroy( &p_sys->sem_mt ); free( p_sys ); return VLC_EGENERIC; } return VLC_SUCCESS; }
/***************************************************************************** * Open: *****************************************************************************/ static int Open( vlc_object_t *p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; char *psz_file; ifo_handle_t *p_vmg_file; if( !p_demux->psz_path || !*p_demux->psz_path ) { /* Only when selected */ if( !p_demux->psz_access || !*p_demux->psz_access ) return VLC_EGENERIC; psz_file = var_InheritString( p_this, "dvd" ); } else psz_file = strdup( p_demux->psz_path ); #ifdef WIN32 if( psz_file != NULL ) { size_t flen = strlen( psz_file ); if( flen > 0 && psz_file[flen - 1] == '\\' ) psz_file[flen - 1] = '\0'; } else psz_file = strdup(""); #endif if( unlikely(psz_file == NULL) ) return VLC_EGENERIC; /* Open dvdread */ const char *psz_path = ToLocale( psz_file ); dvd_reader_t *p_dvdread = DVDOpen( psz_path ); LocaleFree( psz_path ); if( p_dvdread == NULL ) { msg_Err( p_demux, "DVDRead cannot open source: %s", psz_file ); dialog_Fatal( p_demux, _("Playback failure"), _("DVDRead could not open the disc \"%s\"."), psz_file ); free( psz_file ); return VLC_EGENERIC; } free( psz_file ); /* Ifo allocation & initialisation */ if( !( p_vmg_file = ifoOpen( p_dvdread, 0 ) ) ) { msg_Warn( p_demux, "cannot open VMG info" ); return VLC_EGENERIC; } msg_Dbg( p_demux, "VMG opened" ); /* Fill p_demux field */ DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys; ps_track_init( p_sys->tk ); p_sys->i_sar_num = 0; p_sys->i_sar_den = 0; p_sys->i_title_cur_time = (mtime_t) 0; p_sys->i_cell_cur_time = (mtime_t) 0; p_sys->i_cell_duration = (mtime_t) 0; p_sys->p_dvdread = p_dvdread; p_sys->p_vmg_file = p_vmg_file; p_sys->p_title = NULL; p_sys->p_vts_file = NULL; p_sys->i_title = p_sys->i_chapter = -1; p_sys->i_mux_rate = 0; p_sys->i_angle = var_CreateGetInteger( p_demux, "dvdread-angle" ); if( p_sys->i_angle <= 0 ) p_sys->i_angle = 1; DemuxTitles( p_demux, &p_sys->i_angle ); if( DvdReadSetArea( p_demux, 0, 0, p_sys->i_angle ) != VLC_SUCCESS ) { Close( p_this ); msg_Err( p_demux, "DvdReadSetArea(0,0,%i) failed (can't decrypt DVD?)", p_sys->i_angle ); return VLC_EGENERIC; } /* Update default_pts to a suitable value for dvdread access */ var_Create( p_demux, "dvdread-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); return VLC_SUCCESS; }
/***************************************************************************** * Open: open a dummy audio device *****************************************************************************/ static int Open( vlc_object_t * p_this ) { aout_instance_t * p_aout = (aout_instance_t *)p_this; char * psz_name, * psz_format; const char * const * ppsz_compare = format_list; int i_channels, i = 0; psz_name = var_CreateGetString( p_this, "audiofile-file" ); if( !psz_name || !*psz_name ) { msg_Err( p_aout, "you need to specify an output file name" ); free( psz_name ); return VLC_EGENERIC; } /* Allocate structure */ p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) ); if( p_aout->output.p_sys == NULL ) return VLC_ENOMEM; if( !strcmp( psz_name, "-" ) ) p_aout->output.p_sys->p_file = stdout; else p_aout->output.p_sys->p_file = utf8_fopen( psz_name, "wb" ); free( psz_name ); if ( p_aout->output.p_sys->p_file == NULL ) { free( p_aout->output.p_sys ); return VLC_EGENERIC; } p_aout->output.pf_play = Play; /* Audio format */ psz_format = var_CreateGetString( p_this, "audiofile-format" ); while ( *ppsz_compare != NULL ) { if ( !strncmp( *ppsz_compare, psz_format, strlen(*ppsz_compare) ) ) { break; } ppsz_compare++; i++; } if ( *ppsz_compare == NULL ) { msg_Err( p_aout, "cannot understand the format string (%s)", psz_format ); if( p_aout->output.p_sys->p_file != stdout ) fclose( p_aout->output.p_sys->p_file ); free( p_aout->output.p_sys ); free( psz_format ); return VLC_EGENERIC; } free( psz_format ); p_aout->output.output.i_format = format_int[i]; if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) ) { p_aout->output.i_nb_samples = A52_FRAME_NB; p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE; p_aout->output.output.i_frame_length = A52_FRAME_NB; aout_VolumeNoneInit( p_aout ); } else { p_aout->output.i_nb_samples = FRAME_SIZE; aout_VolumeSoftInit( p_aout ); } /* Channels number */ i_channels = var_CreateGetInteger( p_this, "audiofile-channels" ); if( i_channels > 0 && i_channels <= CHANNELS_MAX ) { p_aout->output.output.i_physical_channels = pi_channels_maps[i_channels]; } /* WAV header */ p_aout->output.p_sys->b_add_wav_header = var_CreateGetBool( p_this, "audiofile-wav" ); if( p_aout->output.p_sys->b_add_wav_header ) { /* Write wave header */ WAVEHEADER *wh = &p_aout->output.p_sys->waveh; memset( wh, 0, sizeof(wh) ); switch( p_aout->output.output.i_format ) { case VLC_CODEC_FL32: wh->Format = WAVE_FORMAT_IEEE_FLOAT; wh->BitsPerSample = sizeof(float) * 8; break; case VLC_CODEC_U8: wh->Format = WAVE_FORMAT_PCM; wh->BitsPerSample = 8; break; case VLC_CODEC_S16L: default: wh->Format = WAVE_FORMAT_PCM; wh->BitsPerSample = 16; break; } wh->MainChunkID = VLC_FOURCC('R', 'I', 'F', 'F'); wh->Length = 0; /* temp, to be filled in as we go */ wh->ChunkTypeID = VLC_FOURCC('W', 'A', 'V', 'E'); wh->SubChunkID = VLC_FOURCC('f', 'm', 't', ' '); wh->SubChunkLength = 16; wh->Modus = aout_FormatNbChannels( &p_aout->output.output ); wh->SampleFreq = p_aout->output.output.i_rate; wh->BytesPerSample = wh->Modus * ( wh->BitsPerSample / 8 ); wh->BytesPerSec = wh->BytesPerSample * wh->SampleFreq; wh->DataChunkID = VLC_FOURCC('d', 'a', 't', 'a'); wh->DataLength = 0; /* temp, to be filled in as we go */ /* Header -> little endian format */ SetWLE( &wh->Format, wh->Format ); SetWLE( &wh->BitsPerSample, wh->BitsPerSample ); SetDWLE( &wh->SubChunkLength, wh->SubChunkLength ); SetWLE( &wh->Modus, wh->Modus ); SetDWLE( &wh->SampleFreq, wh->SampleFreq ); SetWLE( &wh->BytesPerSample, wh->BytesPerSample ); SetDWLE( &wh->BytesPerSec, wh->BytesPerSec ); if( fwrite( wh, sizeof(WAVEHEADER), 1, p_aout->output.p_sys->p_file ) != 1 ) { msg_Err( p_aout, "write error (%m)" ); } } return 0; }
/***************************************************************************** * Open: probe the decoder and return score ***************************************************************************** * Tries to launch a decoder and return score so that the interface is able * to chose. *****************************************************************************/ static int Open( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t *) p_this; decoder_sys_t *p_sys = NULL; if( p_dec->fmt_in.i_codec != VLC_CODEC_TELETEXT ) return VLC_EGENERIC; p_dec->pf_decode_sub = Decode; p_sys = p_dec->p_sys = calloc( 1, sizeof(decoder_sys_t) ); if( p_sys == NULL ) return VLC_ENOMEM; p_sys->i_key[0] = p_sys->i_key[1] = p_sys->i_key[2] = '*' - '0'; p_sys->b_update = false; p_sys->p_vbi_dec = vbi_decoder_new(); p_sys->p_dvb_demux = vbi_dvb_pes_demux_new( NULL, NULL ); vlc_mutex_init( &p_sys->lock ); if( (p_sys->p_vbi_dec == NULL) || (p_sys->p_dvb_demux == NULL) ) { msg_Err( p_dec, "VBI decoder/demux could not be created." ); Close( p_this ); return VLC_ENOMEM; } /* Some broadcasters in countries with level 1 and level 1.5 still not send a G0 to do * matches against table 32 of ETSI 300 706. We try to do some best effort guessing * This is not perfect, but might handle some cases where we know the vbi language * is known. It would be better if people started sending G0 */ for( int i = 0; ppsz_default_triplet[i] != NULL; i++ ) { if( p_dec->fmt_in.psz_language && !strcasecmp( p_dec->fmt_in.psz_language, ppsz_default_triplet[i] ) ) { vbi_teletext_set_default_region( p_sys->p_vbi_dec, pi_default_triplet[i]); msg_Dbg( p_dec, "overwriting default zvbi region: %d", pi_default_triplet[i] ); } } vbi_event_handler_register( p_sys->p_vbi_dec, VBI_EVENT_TTX_PAGE | VBI_EVENT_NETWORK | #ifdef ZVBI_DEBUG VBI_EVENT_CAPTION | VBI_EVENT_TRIGGER | VBI_EVENT_ASPECT | VBI_EVENT_PROG_INFO | VBI_EVENT_NETWORK_ID | #endif 0 , EventHandler, p_dec ); /* Create the var on vlc_global. */ p_sys->i_wanted_page = var_CreateGetInteger( p_dec, "vbi-page" ); var_AddCallback( p_dec, "vbi-page", RequestPage, p_sys ); /* Check if the Teletext track has a known "initial page". */ if( p_sys->i_wanted_page == 100 && p_dec->fmt_in.subs.teletext.i_magazine != -1 ) { p_sys->i_wanted_page = 100 * p_dec->fmt_in.subs.teletext.i_magazine + vbi_bcd2dec( p_dec->fmt_in.subs.teletext.i_page ); var_SetInteger( p_dec, "vbi-page", p_sys->i_wanted_page ); } p_sys->i_wanted_subpage = VBI_ANY_SUBNO; p_sys->b_opaque = var_CreateGetBool( p_dec, "vbi-opaque" ); var_AddCallback( p_dec, "vbi-opaque", Opaque, p_sys ); p_sys->i_align = var_CreateGetInteger( p_dec, "vbi-position" ); var_AddCallback( p_dec, "vbi-position", Position, p_sys ); p_sys->b_text = var_CreateGetBool( p_dec, "vbi-text" ); // var_AddCallback( p_dec, "vbi-text", Text, p_sys ); /* Listen for keys */ var_AddCallback( p_dec->p_libvlc, "key-pressed", EventKey, p_dec ); es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_CODEC_SPU ); if( p_sys->b_text ) p_dec->fmt_out.video.i_chroma = VLC_CODEC_TEXT; else p_dec->fmt_out.video.i_chroma = VLC_CODEC_RGBA; return VLC_SUCCESS; }
void vout_IntfInit( vout_thread_t *p_vout ) { vlc_value_t val, text, old_val; bool b_force_par = false; char *psz_buf; int i; /* Create a few object variables we'll need later on */ var_Create( p_vout, "snapshot-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-prefix", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-preview", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-sequential", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER ); var_SetInteger( p_vout, "snapshot-num", 1 ); var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); p_vout->i_alignment = var_CreateGetInteger( p_vout, "align" ); var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "mouse-hide-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); p_vout->b_title_show = var_CreateGetBool( p_vout, "video-title-show" ); p_vout->i_title_timeout = (mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" ); p_vout->i_title_position = var_CreateGetInteger( p_vout, "video-title-position" ); var_AddCallback( p_vout, "video-title-show", TitleShowCallback, NULL ); var_AddCallback( p_vout, "video-title-timeout", TitleTimeoutCallback, NULL ); var_AddCallback( p_vout, "video-title-position", TitlePositionCallback, NULL ); /* Zoom object var */ var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Zoom"); var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL ); var_Get( p_vout, "zoom", &old_val ); for( i = 0; p_zoom_values[i].f_value; i++ ) { if( old_val.f_float == p_zoom_values[i].f_value ) var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL ); val.f_float = p_zoom_values[i].f_value; text.psz_string = _( p_zoom_values[i].psz_label ); var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text ); } var_Set( p_vout, "zoom", old_val ); /* Is this really needed? */ var_AddCallback( p_vout, "zoom", ZoomCallback, NULL ); /* Crop offset vars */ var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "crop-left", CropCallback, NULL ); var_AddCallback( p_vout, "crop-top", CropCallback, NULL ); var_AddCallback( p_vout, "crop-right", CropCallback, NULL ); var_AddCallback( p_vout, "crop-bottom", CropCallback, NULL ); /* Crop object var */ var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Crop"); var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 ); for( i = 0; p_crop_values[i].psz_value; i++ ) { val.psz_string = (char*)p_crop_values[i].psz_value; text.psz_string = _( p_crop_values[i].psz_label ); var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text ); } /* update triggered every time the vout's crop parameters are changed */ var_Create( p_vout, "crop-update", VLC_VAR_VOID ); /* Add custom crop ratios */ psz_buf = config_GetPsz( p_vout, "custom-crop-ratios" ); AddCustomRatios( p_vout, "crop", psz_buf ); free( psz_buf ); var_AddCallback( p_vout, "crop", CropCallback, NULL ); var_Get( p_vout, "crop", &old_val ); if( old_val.psz_string && *old_val.psz_string ) var_Change( p_vout, "crop", VLC_VAR_TRIGGER_CALLBACKS, 0, 0 ); free( old_val.psz_string ); /* Monitor pixel aspect-ratio */ var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Get( p_vout, "monitor-par", &val ); if( val.psz_string && *val.psz_string ) { char *psz_parser = strchr( val.psz_string, ':' ); unsigned int i_aspect_num = 0, i_aspect_den = 0; float i_aspect = 0; if( psz_parser ) { i_aspect_num = strtol( val.psz_string, 0, 10 ); i_aspect_den = strtol( ++psz_parser, 0, 10 ); } else { i_aspect = atof( val.psz_string ); vlc_ureduce( &i_aspect_num, &i_aspect_den, i_aspect *VOUT_ASPECT_FACTOR, VOUT_ASPECT_FACTOR, 0 ); } if( !i_aspect_num || !i_aspect_den ) i_aspect_num = i_aspect_den = 1; p_vout->i_par_num = i_aspect_num; p_vout->i_par_den = i_aspect_den; vlc_ureduce( &p_vout->i_par_num, &p_vout->i_par_den, p_vout->i_par_num, p_vout->i_par_den, 0 ); msg_Dbg( p_vout, "overriding monitor pixel aspect-ratio: %i:%i", p_vout->i_par_num, p_vout->i_par_den ); b_force_par = true; } free( val.psz_string ); /* Aspect-ratio object var */ var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Aspect-ratio"); var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; var_Change( p_vout, "aspect-ratio", VLC_VAR_DELCHOICE, &val, 0 ); for( i = 0; p_aspect_ratio_values[i].psz_value; i++ ) { val.psz_string = (char*)p_aspect_ratio_values[i].psz_value; text.psz_string = _( p_aspect_ratio_values[i].psz_label ); var_Change( p_vout, "aspect-ratio", VLC_VAR_ADDCHOICE, &val, &text ); } /* Add custom aspect ratios */ psz_buf = config_GetPsz( p_vout, "custom-aspect-ratios" ); AddCustomRatios( p_vout, "aspect-ratio", psz_buf ); free( psz_buf ); var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL ); var_Get( p_vout, "aspect-ratio", &old_val ); if( (old_val.psz_string && *old_val.psz_string) || b_force_par ) var_Change( p_vout, "aspect-ratio", VLC_VAR_TRIGGER_CALLBACKS, 0, 0 ); free( old_val.psz_string ); /* Initialize the dimensions of the video window */ InitWindowSize( p_vout, &p_vout->i_window_width, &p_vout->i_window_height ); /* Add a variable to indicate if the window should be on top of others */ var_Create( p_vout, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); text.psz_string = _("Always on top"); var_Change( p_vout, "video-on-top", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "video-on-top", OnTopCallback, NULL ); /* Add a variable to indicate whether we want window decoration or not */ var_Create( p_vout, "video-deco", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); /* Add a fullscreen variable */ if( var_CreateGetBoolCommand( p_vout, "fullscreen" ) ) { /* user requested fullscreen */ p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE; } text.psz_string = _("Fullscreen"); var_Change( p_vout, "fullscreen", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "fullscreen", FullscreenCallback, NULL ); /* Add a snapshot variable */ var_Create( p_vout, "video-snapshot", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); text.psz_string = _("Snapshot"); var_Change( p_vout, "video-snapshot", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "video-snapshot", SnapshotCallback, NULL ); /* Mouse coordinates */ var_Create( p_vout, "mouse-x", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-y", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-moved", VLC_VAR_BOOL ); var_Create( p_vout, "mouse-clicked", VLC_VAR_INTEGER ); var_Create( p_vout, "intf-change", VLC_VAR_BOOL ); var_SetBool( p_vout, "intf-change", true ); }
/***************************************************************************** * CreateFilter: allocates RSS video filter *****************************************************************************/ static int CreateFilter( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; char *psz_urls; int i_ttl; /* Allocate structure */ p_sys = p_filter->p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) ); // sunqueen modify if( p_sys == NULL ) return VLC_ENOMEM; config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg ); /* Get the urls to parse: must be non empty */ psz_urls = var_CreateGetNonEmptyString( p_filter, CFG_PREFIX "urls" ); if( !psz_urls ) { msg_Err( p_filter, "The list of urls must not be empty" ); free( p_sys ); return VLC_EGENERIC; } /* Fill the p_sys structure with the configuration */ p_sys->i_title = var_CreateGetInteger( p_filter, CFG_PREFIX "title" ); p_sys->i_cur_feed = 0; p_sys->i_cur_item = p_sys->i_title == scroll_title ? -1 : 0; p_sys->i_cur_char = 0; p_sys->i_feeds = 0; p_sys->p_feeds = NULL; p_sys->i_speed = var_CreateGetInteger( p_filter, CFG_PREFIX "speed" ); p_sys->i_length = var_CreateGetInteger( p_filter, CFG_PREFIX "length" ); p_sys->b_images = var_CreateGetBool( p_filter, CFG_PREFIX "images" ); i_ttl = __MAX( 0, var_CreateGetInteger( p_filter, CFG_PREFIX "ttl" ) ); p_sys->psz_marquee = (char *)malloc( p_sys->i_length + 1 ); // sunqueen modify if( p_sys->psz_marquee == NULL ) { free( psz_urls ); free( p_sys ); return VLC_ENOMEM; } p_sys->psz_marquee[p_sys->i_length] = '\0'; p_sys->p_style = text_style_New(); if( p_sys->p_style == NULL ) goto error; p_sys->i_xoff = var_CreateGetInteger( p_filter, CFG_PREFIX "x" ); p_sys->i_yoff = var_CreateGetInteger( p_filter, CFG_PREFIX "y" ); p_sys->i_pos = var_CreateGetInteger( p_filter, CFG_PREFIX "position" ); p_sys->p_style->i_font_alpha = 255 - var_CreateGetInteger( p_filter, CFG_PREFIX "opacity" ); p_sys->p_style->i_font_color = var_CreateGetInteger( p_filter, CFG_PREFIX "color" ); p_sys->p_style->i_font_size = var_CreateGetInteger( p_filter, CFG_PREFIX "size" ); if( p_sys->b_images && p_sys->p_style->i_font_size == -1 ) { msg_Warn( p_filter, "rss-size wasn't specified. Feed images will thus be displayed without being resized" ); } /* Parse the urls */ if( ParseUrls( p_filter, psz_urls ) ) goto error; /* Misc init */ vlc_mutex_init( &p_sys->lock ); p_filter->pf_sub_source = Filter; p_sys->last_date = (mtime_t)0; p_sys->b_fetched = false; /* Create and arm the timer */ if( vlc_timer_create( &p_sys->timer, Fetch, p_filter ) ) { vlc_mutex_destroy( &p_sys->lock ); goto error; } vlc_timer_schedule( p_sys->timer, false, 1, (mtime_t)(i_ttl)*1000000 ); free( psz_urls ); return VLC_SUCCESS; error: if( p_sys->p_style ) text_style_Delete( p_sys->p_style ); free( p_sys->psz_marquee ); free( psz_urls ); free( p_sys ); return VLC_ENOMEM; }
/***************************************************************************** * InitVideo: initialize the video decoder ***************************************************************************** * the ffmpeg codec will be opened, some memory allocated. The vout is not yet * opened (done after the first decoded frame). *****************************************************************************/ int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context, AVCodec *p_codec, int i_codec_id, const char *psz_namecodec ) { decoder_sys_t *p_sys; int i_val; /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(decoder_sys_t) ) ) == NULL ) return VLC_ENOMEM; p_codec->type = AVMEDIA_TYPE_VIDEO; p_context->codec_type = AVMEDIA_TYPE_VIDEO; p_context->codec_id = i_codec_id; p_sys->p_context = p_context; p_sys->p_codec = p_codec; p_sys->i_codec_id = i_codec_id; p_sys->psz_namecodec = psz_namecodec; p_sys->p_ff_pic = avcodec_alloc_frame(); p_sys->b_delayed_open = true; p_sys->p_va = NULL; vlc_sem_init( &p_sys->sem_mt, 0 ); /* ***** Fill p_context with init values ***** */ p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_original_fourcc ? p_dec->fmt_in.i_original_fourcc : p_dec->fmt_in.i_codec ); // sunqueen modify /* ***** Get configuration of ffmpeg plugin ***** */ p_sys->p_context->workaround_bugs = var_InheritInteger( p_dec, "avcodec-workaround-bugs" ); p_sys->p_context->err_recognition = var_InheritInteger( p_dec, "avcodec-error-resilience" ); if( var_CreateGetBool( p_dec, "grayscale" ) ) p_sys->p_context->flags |= CODEC_FLAG_GRAY; /* ***** Output always the frames ***** */ #if LIBAVCODEC_VERSION_CHECK(55, 23, 1, 40, 101) p_sys->p_context->flags |= CODEC_FLAG_OUTPUT_CORRUPT; #endif i_val = var_CreateGetInteger( p_dec, "avcodec-vismv" ); if( i_val ) p_sys->p_context->debug_mv = i_val; i_val = var_CreateGetInteger( p_dec, "avcodec-skiploopfilter" ); if( i_val >= 4 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL; else if( i_val == 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY; else if( i_val == 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR; else if( i_val == 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF; if( var_CreateGetBool( p_dec, "avcodec-fast" ) ) p_sys->p_context->flags2 |= CODEC_FLAG2_FAST; /* ***** libavcodec frame skipping ***** */ p_sys->b_hurry_up = var_CreateGetBool( p_dec, "avcodec-hurry-up" ); i_val = var_CreateGetInteger( p_dec, "avcodec-skip-frame" ); if( i_val >= 4 ) p_sys->p_context->skip_frame = AVDISCARD_ALL; else if( i_val == 3 ) p_sys->p_context->skip_frame = AVDISCARD_NONKEY; else if( i_val == 2 ) p_sys->p_context->skip_frame = AVDISCARD_BIDIR; else if( i_val == 1 ) p_sys->p_context->skip_frame = AVDISCARD_NONREF; else if( i_val == -1 ) p_sys->p_context->skip_frame = AVDISCARD_NONE; else p_sys->p_context->skip_frame = AVDISCARD_DEFAULT; p_sys->i_skip_frame = p_sys->p_context->skip_frame; i_val = var_CreateGetInteger( p_dec, "avcodec-skip-idct" ); if( i_val >= 4 ) p_sys->p_context->skip_idct = AVDISCARD_ALL; else if( i_val == 3 ) p_sys->p_context->skip_idct = AVDISCARD_NONKEY; else if( i_val == 2 ) p_sys->p_context->skip_idct = AVDISCARD_BIDIR; else if( i_val == 1 ) p_sys->p_context->skip_idct = AVDISCARD_NONREF; else if( i_val == -1 ) p_sys->p_context->skip_idct = AVDISCARD_NONE; else p_sys->p_context->skip_idct = AVDISCARD_DEFAULT; p_sys->i_skip_idct = p_sys->p_context->skip_idct; /* ***** libavcodec direct rendering ***** */ p_sys->b_direct_rendering = false; p_sys->i_direct_rendering_used = -1; if( var_CreateGetBool( p_dec, "avcodec-dr" ) && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) && /* No idea why ... but this fixes flickering on some TSCC streams */ p_sys->i_codec_id != AV_CODEC_ID_TSCC && p_sys->i_codec_id != AV_CODEC_ID_CSCD && p_sys->i_codec_id != AV_CODEC_ID_CINEPAK && !p_sys->p_context->debug_mv ) { /* Some codecs set pix_fmt only after the 1st frame has been decoded, * so we need to do another check in ffmpeg_GetFrameBuf() */ p_sys->b_direct_rendering = true; } /* libavcodec doesn't properly release old pictures when frames are skipped */ //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = false; if( p_sys->b_direct_rendering ) { msg_Dbg( p_dec, "trying to use direct rendering" ); p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE; } else { msg_Dbg( p_dec, "direct rendering is disabled" ); } p_sys->p_context->get_format = ffmpeg_GetFormat; /* Always use our get_buffer wrapper so we can calculate the * PTS correctly */ #if LIBAVCODEC_VERSION_MAJOR >= 55 p_sys->p_context->get_buffer2 = lavc_GetFrame; #else p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf; p_sys->p_context->reget_buffer = avcodec_default_reget_buffer; p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf; #endif p_sys->p_context->opaque = p_dec; #ifdef HAVE_AVCODEC_MT int i_thread_count = var_InheritInteger( p_dec, "avcodec-threads" ); if( i_thread_count <= 0 ) { i_thread_count = vlc_GetCPUCount(); if( i_thread_count > 1 ) i_thread_count++; //FIXME: take in count the decoding time i_thread_count = __MIN( i_thread_count, 4 ); } i_thread_count = __MIN( i_thread_count, 16 ); msg_Dbg( p_dec, "allowing %d thread(s) for decoding", i_thread_count ); p_sys->p_context->thread_count = i_thread_count; p_sys->p_context->thread_safe_callbacks = true; switch( i_codec_id ) { case AV_CODEC_ID_MPEG4: case AV_CODEC_ID_H263: p_sys->p_context->thread_type = 0; break; case AV_CODEC_ID_MPEG1VIDEO: case AV_CODEC_ID_MPEG2VIDEO: p_sys->p_context->thread_type &= ~FF_THREAD_SLICE; /* fall through */ # if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55, 1, 0)) case AV_CODEC_ID_H264: case AV_CODEC_ID_VC1: case AV_CODEC_ID_WMV3: p_sys->p_context->thread_type &= ~FF_THREAD_FRAME; # endif } /* Workaround: frame multithreading is not compatible with * DXVA2. When a frame is being copied to host memory, the frame * is locked and cannot be used as a reference frame * simultaneously and thus decoding fails for some frames. This * causes major image corruption. */ # if defined(_WIN32) char *avcodec_hw = var_InheritString( p_dec, "avcodec-hw" ); if( avcodec_hw == NULL || strcasecmp( avcodec_hw, "none" ) ) { msg_Warn( p_dec, "threaded frame decoding is not compatible with DXVA2, disabled" ); p_sys->p_context->thread_type &= ~FF_THREAD_FRAME; } free( avcodec_hw ); # endif if( p_sys->p_context->thread_type & FF_THREAD_FRAME ) p_dec->i_extra_picture_buffers = 2 * p_sys->p_context->thread_count; #endif /* ***** misc init ***** */ p_sys->i_pts = VLC_TS_INVALID; p_sys->b_has_b_frames = false; p_sys->b_first_frame = true; p_sys->b_flush = false; p_sys->i_late_frames = 0; /* Set output properties */ p_dec->fmt_out.i_cat = VIDEO_ES; if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS ) { /* we are doomed. but not really, because most codecs set their pix_fmt later on */ p_dec->fmt_out.i_codec = VLC_CODEC_I420; } p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma; p_dec->fmt_out.video.orientation = p_dec->fmt_in.video.orientation; #if LIBAVCODEC_VERSION_MAJOR < 54 /* Setup palette */ memset( &p_sys->palette, 0, sizeof(p_sys->palette) ); if( p_dec->fmt_in.video.p_palette ) { p_sys->palette.palette_changed = 1; for( int i = 0; i < __MIN( AVPALETTE_COUNT, p_dec->fmt_in.video.p_palette->i_entries ); i++ ) { union { uint32_t u; uint8_t a[4]; } c; c.a[0] = p_dec->fmt_in.video.p_palette->palette[i][0]; c.a[1] = p_dec->fmt_in.video.p_palette->palette[i][1]; c.a[2] = p_dec->fmt_in.video.p_palette->palette[i][2]; c.a[3] = p_dec->fmt_in.video.p_palette->palette[i][3]; p_sys->palette.palette[i] = c.u; } p_sys->p_context->palctrl = &p_sys->palette; p_dec->fmt_out.video.p_palette = malloc( sizeof(video_palette_t) ); if( p_dec->fmt_out.video.p_palette ) *p_dec->fmt_out.video.p_palette = *p_dec->fmt_in.video.p_palette; } else if( p_sys->i_codec_id != CODEC_ID_MSVIDEO1 && p_sys->i_codec_id != CODEC_ID_CINEPAK ) { p_sys->p_context->palctrl = &p_sys->palette; } #else if( p_dec->fmt_in.video.p_palette ) { p_sys->palette_sent = false; p_dec->fmt_out.video.p_palette = malloc( sizeof(video_palette_t) ); if( p_dec->fmt_out.video.p_palette ) *p_dec->fmt_out.video.p_palette = *p_dec->fmt_in.video.p_palette; } else p_sys->palette_sent = true; #endif /* ***** init this codec with special data ***** */ ffmpeg_InitCodec( p_dec ); /* ***** Open the codec ***** */ if( ffmpeg_OpenCodec( p_dec ) < 0 ) { msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec ); avcodec_free_frame( &p_sys->p_ff_pic ); vlc_sem_destroy( &p_sys->sem_mt ); free( p_sys ); return VLC_EGENERIC; } if ( p_dec->fmt_in.i_codec == VLC_CODEC_VP9 ) p_dec->b_need_packetized = true; return VLC_SUCCESS; }
static int Start_LuaIntf( vlc_object_t *p_this, const char *name ) { intf_thread_t *p_intf = (intf_thread_t*)p_this; intf_sys_t *p_sys; lua_State *L; config_ChainParse( p_intf, "lua-", ppsz_intf_options, p_intf->p_cfg ); char *psz_config; bool b_config_set = false; if( name == NULL ) { char *n = var_InheritString( p_this, "lua-intf" ); if( unlikely(n == NULL) ) return VLC_EGENERIC; name = p_intf->psz_header = n; } else /* Cleaned up by vlc_object_release() */ p_intf->psz_header = strdup( name ); p_intf->p_sys = (intf_sys_t*)malloc( sizeof(intf_sys_t) ); if( !p_intf->p_sys ) { free( p_intf->psz_header ); p_intf->psz_header = NULL; return VLC_ENOMEM; } p_sys = p_intf->p_sys; p_sys->psz_filename = vlclua_find_file( p_this, "intf", name ); if( !p_sys->psz_filename ) { msg_Err( p_intf, "Couldn't find lua interface script \"%s\".", name ); goto error; } msg_Dbg( p_intf, "Found lua interface script: %s", p_sys->psz_filename ); L = luaL_newstate(); if( !L ) { msg_Err( p_intf, "Could not create new Lua State" ); goto error; } vlclua_set_this( L, p_intf ); vlclua_set_intf( L, p_sys ); luaL_openlibs( L ); /* register our functions */ luaL_register( L, "vlc", p_reg ); /* register submodules */ luaopen_acl( L ); luaopen_config( L ); luaopen_volume( L ); luaopen_httpd( L ); luaopen_input( L ); luaopen_msg( L ); luaopen_misc( L ); luaopen_net( L ); luaopen_object( L ); luaopen_osd( L ); luaopen_playlist( L ); luaopen_sd( L ); luaopen_stream( L ); luaopen_strings( L ); luaopen_variables( L ); luaopen_video( L ); luaopen_vlm( L ); luaopen_volume( L ); luaopen_gettext( L ); luaopen_xml( L ); luaopen_equalizer( L ); /* clean up */ lua_pop( L, 1 ); /* Setup the module search path */ if( vlclua_add_modules_path( p_intf, L, p_sys->psz_filename ) ) { msg_Warn( p_intf, "Error while setting the module search path for %s", p_sys->psz_filename ); lua_close( L ); goto error; } /* * Get the lua-config string. * If the string is empty, try with the old http-* or telnet-* options * and build the right configuration line */ psz_config = var_CreateGetNonEmptyString( p_intf, "lua-config" ); if( !psz_config ) { if( !strcmp( name, "http" ) ) { char *psz_http_src = var_CreateGetNonEmptyString( p_intf, "http-src" ); bool b_http_index = var_CreateGetBool( p_intf, "http-index" ); if( psz_http_src ) { char *psz_esc = config_StringEscape( psz_http_src ); if( psz_config ) { char *psz_tmp; asprintf( &psz_tmp, "%s,dir='%s'", psz_config, psz_esc ); free( psz_config ); psz_config = psz_tmp; } else asprintf( &psz_config, "http={dir='%s'", psz_esc ); free( psz_esc ); free( psz_http_src ); } if( psz_config ) { char *psz_tmp; asprintf( &psz_tmp, "%s,no_index=%s}", psz_config, b_http_index ? "true" : "false" ); free( psz_config ); psz_config = psz_tmp; } else asprintf( &psz_config, "http={no_index=%s}", b_http_index ? "true" : "false" ); } else if( !strcmp( name, "telnet" ) ) { char *psz_telnet_host = var_CreateGetString( p_intf, "telnet-host" ); if( !strcmp( psz_telnet_host, "*console" ) ) ; else { vlc_url_t url; vlc_UrlParse( &url, psz_telnet_host, 0 ); int i_telnet_port = var_CreateGetInteger( p_intf, "telnet-port" ); if ( url.i_port != 0 ) { if ( i_telnet_port == TELNETPORT_DEFAULT ) i_telnet_port = url.i_port; else if ( url.i_port != i_telnet_port ) msg_Warn( p_intf, "ignoring port %d (using %d)", url.i_port, i_telnet_port ); } char *psz_esc_host = config_StringEscape( url.psz_host ); free( psz_telnet_host ); vlc_UrlClean( &url ); asprintf( &psz_telnet_host, "telnet://%s:%d", psz_esc_host ? psz_esc_host : "", i_telnet_port ); free( psz_esc_host ); } char *psz_telnet_passwd = var_CreateGetString( p_intf, "telnet-password" ); char *psz_esc_passwd = config_StringEscape( psz_telnet_passwd ); asprintf( &psz_config, "telnet={host='%s',password='******'}", psz_telnet_host, psz_esc_passwd ); free( psz_esc_passwd ); free( psz_telnet_passwd ); free( psz_telnet_host ); } else if( !strcmp( name, "cli" ) ) { char *psz_rc_host = var_CreateGetNonEmptyString( p_intf, "rc-host" ); if( !psz_rc_host ) psz_rc_host = var_CreateGetNonEmptyString( p_intf, "cli-host" ); if( psz_rc_host ) { char *psz_esc_host = config_StringEscape( psz_rc_host ); asprintf( &psz_config, "cli={host='%s'}", psz_esc_host ); free( psz_esc_host ); free( psz_rc_host ); } } } if( psz_config ) { char *psz_buffer; if( asprintf( &psz_buffer, "config={%s}", psz_config ) != -1 ) { char *psz_log = StripPasswords( psz_buffer ); if( psz_log != NULL ) { msg_Dbg( p_intf, "Setting config variable: %s", psz_log ); free( psz_log ); } if( luaL_dostring( L, psz_buffer ) == 1 ) msg_Err( p_intf, "Error while parsing \"lua-config\"." ); free( psz_buffer ); lua_getglobal( L, "config" ); if( lua_istable( L, -1 ) ) { if( !strcmp( name, "cli" ) ) { lua_getfield( L, -1, "rc" ); if( lua_istable( L, -1 ) ) { /* msg_Warn( p_intf, "The `rc' lua interface script " "was renamed `cli', please update " "your configuration!" ); */ lua_setfield( L, -2, "cli" ); } else lua_pop( L, 1 ); } lua_getfield( L, -1, name ); if( lua_istable( L, -1 ) ) { lua_setglobal( L, "config" ); b_config_set = true; } } } free( psz_config ); } if( !b_config_set ) { lua_newtable( L ); lua_setglobal( L, "config" ); } /* Wrapper for legacy telnet config */ if ( !strcmp( name, "telnet" ) ) { /* msg_Warn( p_intf, "The `telnet' lua interface script was replaced " "by `cli', please update your configuration!" ); */ char *wrapped_file = vlclua_find_file( p_this, "intf", "cli" ); if( !wrapped_file ) { msg_Err( p_intf, "Couldn't find lua interface script \"cli\", " "needed by telnet wrapper" ); lua_close( p_sys->L ); goto error; } lua_pushstring( L, wrapped_file ); lua_setglobal( L, "wrapped_file" ); free( wrapped_file ); } p_sys->L = L; vlc_mutex_init( &p_sys->lock ); vlc_cond_init( &p_sys->wait ); p_sys->exiting = false; if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) ) { vlc_cond_destroy( &p_sys->wait ); vlc_mutex_destroy( &p_sys->lock ); lua_close( p_sys->L ); goto error; } return VLC_SUCCESS; error: free( p_sys->psz_filename ); free( p_sys ); free( p_intf->psz_header ); p_intf->psz_header = NULL; return VLC_EGENERIC; }
/***************************************************************************** * OpenDecoder: probe the decoder and return score *****************************************************************************/ static int OpenDecoder( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t*)p_this; decoder_sys_t *p_sys; char *psz_tmp; if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','a','k','e')) { return VLC_EGENERIC; } /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = malloc(sizeof(decoder_sys_t)) ) == NULL ) return VLC_ENOMEM; // get parametrs p_sys->i_width = var_CreateGetInteger( p_this, "invmem-width" ); p_sys->i_height = var_CreateGetInteger( p_this, "invmem-height" ); if( p_sys->i_width == 0 || p_sys->i_height == 0 ) { msg_Err( p_dec, "--vmem-width and --vmem-height must be > 0" ); free( p_sys ); return VLC_EGENERIC; } psz_tmp = var_CreateGetString( p_dec, "invmem-lock" ); p_sys->pf_lock = (void * (*) (void *))(intptr_t)atoll( psz_tmp ); free( psz_tmp ); psz_tmp = var_CreateGetString( p_dec, "invmem-unlock" ); p_sys->pf_unlock = (void (*) (void *))(intptr_t)atoll( psz_tmp ); free( psz_tmp ); psz_tmp = var_CreateGetString( p_dec, "invmem-data" ); p_sys->p_data = (void *)(intptr_t)atoll( psz_tmp ); free( psz_tmp ); if( !p_sys->pf_lock || !p_sys->pf_unlock ) { msg_Err( p_dec, "Invalid lock or unlock callbacks" ); free( p_sys ); return VLC_EGENERIC; } /* Set output properties */ //p_dec->fmt_out.i_codec = VLC_CODEC_RGBA; p_dec->fmt_out.i_codec = VLC_CODEC_RGB24; p_dec->fmt_out.video.i_width = p_dec->p_sys->i_width; p_dec->fmt_out.video.i_height = p_dec->p_sys->i_height; p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_dec->p_sys->i_width / p_dec->p_sys->i_height; p_dec->fmt_out.video.i_rmask = 0xff0000; p_dec->fmt_out.video.i_gmask = 0x00ff00; p_dec->fmt_out.video.i_bmask = 0x0000ff; p_dec->fmt_out.i_cat = VIDEO_ES; p_sys->i_pitch = p_sys->i_width*3 + p_sys->i_width%4; p_sys->p_pic = NULL; /* Set callbacks */ p_dec->pf_decode_video = DecodeBlock; return VLC_SUCCESS; }
/** * Probes and initializes. */ static int Open (vlc_object_t *obj) { demux_t *demux = (demux_t *)obj; int tp; /* transport protocol */ if (!strcmp (demux->psz_access, "dccp")) tp = IPPROTO_DCCP; else if (!strcmp (demux->psz_access, "rtptcp")) tp = IPPROTO_TCP; else if (!strcmp (demux->psz_access, "rtp")) tp = IPPROTO_UDP; else if (!strcmp (demux->psz_access, "udplite")) tp = IPPROTO_UDPLITE; else return VLC_EGENERIC; char *tmp = strdup (demux->psz_location); if (tmp == NULL) return VLC_ENOMEM; char *shost; char *dhost = strchr (tmp, '@'); if (dhost != NULL) { *(dhost++) = '\0'; shost = tmp; } else { dhost = tmp; shost = NULL; } /* Parses the port numbers */ int sport = 0, dport = 0; if (shost != NULL) sport = extract_port (&shost); if (dhost != NULL) dport = extract_port (&dhost); if (dport == 0) dport = 5004; /* avt-profile-1 port */ int rtcp_dport = var_CreateGetInteger (obj, "rtcp-port"); /* Try to connect */ int fd = -1, rtcp_fd = -1; switch (tp) { case IPPROTO_UDP: case IPPROTO_UDPLITE: fd = net_OpenDgram (obj, dhost, dport, shost, sport, tp); if (fd == -1) break; if (rtcp_dport > 0) /* XXX: source port is unknown */ rtcp_fd = net_OpenDgram (obj, dhost, rtcp_dport, shost, 0, tp); break; case IPPROTO_DCCP: #ifndef SOCK_DCCP /* provisional API (FIXME) */ # ifdef __linux__ # define SOCK_DCCP 6 # endif #endif #ifdef SOCK_DCCP var_Create (obj, "dccp-service", VLC_VAR_STRING); var_SetString (obj, "dccp-service", "RTPV"); /* FIXME: RTPA? */ fd = net_Connect (obj, dhost, dport, SOCK_DCCP, tp); #else msg_Err (obj, "DCCP support not included"); #endif break; case IPPROTO_TCP: fd = net_Connect (obj, dhost, dport, SOCK_STREAM, tp); break; } free (tmp); if (fd == -1) return VLC_EGENERIC; net_SetCSCov (fd, -1, 12); /* Initializes demux */ demux_sys_t *p_sys = malloc (sizeof (*p_sys)); if (p_sys == NULL) { net_Close (fd); if (rtcp_fd != -1) net_Close (rtcp_fd); return VLC_EGENERIC; } p_sys->chained_demux = NULL; #ifdef HAVE_SRTP p_sys->srtp = NULL; #endif p_sys->fd = fd; p_sys->rtcp_fd = rtcp_fd; p_sys->max_src = var_CreateGetInteger (obj, "rtp-max-src"); p_sys->timeout = var_CreateGetInteger (obj, "rtp-timeout") * CLOCK_FREQ; p_sys->max_dropout = var_CreateGetInteger (obj, "rtp-max-dropout"); p_sys->max_misorder = var_CreateGetInteger (obj, "rtp-max-misorder"); p_sys->thread_ready = false; p_sys->autodetect = true; demux->pf_demux = NULL; demux->pf_control = Control; demux->p_sys = p_sys; p_sys->session = rtp_session_create (demux); if (p_sys->session == NULL) goto error; #ifdef HAVE_SRTP char *key = var_CreateGetNonEmptyString (demux, "srtp-key"); if (key) { vlc_gcrypt_init (); p_sys->srtp = srtp_create (SRTP_ENCR_AES_CM, SRTP_AUTH_HMAC_SHA1, 10, SRTP_PRF_AES_CM, SRTP_RCC_MODE1); if (p_sys->srtp == NULL) { free (key); goto error; } char *salt = var_CreateGetNonEmptyString (demux, "srtp-salt"); int val = srtp_setkeystring (p_sys->srtp, key, salt ? salt : ""); free (salt); free (key); if (val) { msg_Err (obj, "bad SRTP key/salt combination (%s)", vlc_strerror_c(val)); goto error; } } #endif if (vlc_clone (&p_sys->thread, (tp != IPPROTO_TCP) ? rtp_dgram_thread : rtp_stream_thread, demux, VLC_THREAD_PRIORITY_INPUT)) goto error; p_sys->thread_ready = true; return VLC_SUCCESS; error: Close (obj); return VLC_EGENERIC; }
/***************************************************************************** * OpenScaler: probe the filter and return score *****************************************************************************/ static int OpenScaler( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t*)p_this; filter_sys_t *p_sys; int i_sws_mode; if( GetParameters( NULL, &p_filter->fmt_in.video, &p_filter->fmt_out.video, 0 ) ) return VLC_EGENERIC; /* */ p_filter->pf_video_filter = Filter; /* Allocate the memory needed to store the decoder's structure */ if( ( p_filter->p_sys = p_sys = malloc(sizeof(filter_sys_t)) ) == NULL ) return VLC_ENOMEM; /* Set CPU capabilities */ p_sys->i_cpu_mask = GetSwsCpuMask(); /* */ i_sws_mode = var_CreateGetInteger( p_filter, "swscale-mode" ); switch( i_sws_mode ) { case 0: p_sys->i_sws_flags = SWS_FAST_BILINEAR; break; case 1: p_sys->i_sws_flags = SWS_BILINEAR; break; case 2: p_sys->i_sws_flags = SWS_BICUBIC; break; case 3: p_sys->i_sws_flags = SWS_X; break; case 4: p_sys->i_sws_flags = SWS_POINT; break; case 5: p_sys->i_sws_flags = SWS_AREA; break; case 6: p_sys->i_sws_flags = SWS_BICUBLIN; break; case 7: p_sys->i_sws_flags = SWS_GAUSS; break; case 8: p_sys->i_sws_flags = SWS_SINC; break; case 9: p_sys->i_sws_flags = SWS_LANCZOS; break; case 10: p_sys->i_sws_flags = SWS_SPLINE; break; default: p_sys->i_sws_flags = SWS_BICUBIC; i_sws_mode = 2; break; } p_sys->p_src_filter = NULL; p_sys->p_dst_filter = NULL; /* Misc init */ p_sys->ctx = NULL; p_sys->ctxA = NULL; p_sys->p_src_a = NULL; p_sys->p_dst_a = NULL; p_sys->p_src_e = NULL; p_sys->p_dst_e = NULL; memset( &p_sys->fmt_in, 0, sizeof(p_sys->fmt_in) ); memset( &p_sys->fmt_out, 0, sizeof(p_sys->fmt_out) ); if( Init( p_filter ) ) { if( p_sys->p_src_filter ) sws_freeFilter( p_sys->p_src_filter ); free( p_sys ); return VLC_EGENERIC; } msg_Dbg( p_filter, "%ix%i chroma: %4.4s -> %ix%i chroma: %4.4s with scaling using %s", p_filter->fmt_in.video.i_width, p_filter->fmt_in.video.i_height, (char *)&p_filter->fmt_in.video.i_chroma, p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height, (char *)&p_filter->fmt_out.video.i_chroma, ppsz_mode_descriptions[i_sws_mode] ); return VLC_SUCCESS; }