/***************************************************************************** * 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 int Open( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t*)p_this; vlc_object_t *p_aout = p_filter->p_parent; float f_sample_rate = p_filter->fmt_in.audio.i_rate; float f_num; /* Initialize the filter parameter structure */ filter_sys_t *p_sys = p_filter->p_sys = (filter_sys_t *)calloc( 1, sizeof(*p_sys) ); // sunqueen modify if( !p_sys ) { return VLC_ENOMEM; } /* Initialize the attack lookup table */ p_sys->pf_as[0] = 1.0f; for( int i = 1; i < A_TBL; i++ ) { p_sys->pf_as[i] = expf( -1.0f / ( f_sample_rate * i / A_TBL ) ); } /* Calculate the RMS and lookahead sizes from the sample rate */ f_num = 0.01f * f_sample_rate; p_sys->rms.i_count = Round( Clamp( 0.5f * f_num, 1.0f, RMS_BUF_SIZE ) ); p_sys->la.i_count = Round( Clamp( f_num, 1.0f, LOOKAHEAD_SIZE ) ); /* Initialize decibel lookup tables */ DbInit( p_sys ); /* Restore the last saved settings */ p_sys->f_rms_peak = var_CreateGetFloat( p_aout, "compressor-rms-peak" ); p_sys->f_attack = var_CreateGetFloat( p_aout, "compressor-attack" ); p_sys->f_release = var_CreateGetFloat( p_aout, "compressor-release" ); p_sys->f_threshold = var_CreateGetFloat( p_aout, "compressor-threshold" ); p_sys->f_ratio = var_CreateGetFloat( p_aout, "compressor-ratio" ); p_sys->f_knee = var_CreateGetFloat( p_aout, "compressor-knee" ); p_sys->f_makeup_gain = var_CreateGetFloat( p_aout, "compressor-makeup-gain" ); /* Initialize the mutex */ vlc_mutex_init( &p_sys->lock ); /* Add our own callbacks */ var_AddCallback( p_aout, "compressor-rms-peak", RMSPeakCallback, p_sys ); var_AddCallback( p_aout, "compressor-attack", AttackCallback, p_sys ); var_AddCallback( p_aout, "compressor-release", ReleaseCallback, p_sys ); var_AddCallback( p_aout, "compressor-threshold", ThresholdCallback, p_sys ); var_AddCallback( p_aout, "compressor-ratio", RatioCallback, p_sys ); var_AddCallback( p_aout, "compressor-knee", KneeCallback, p_sys ); var_AddCallback( p_aout, "compressor-makeup-gain", MakeupGainCallback, p_sys ); /* Set the filter function */ 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; /* At this stage, we are ready! */ msg_Dbg( p_filter, "compressor successfully initialized" ); 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; }
static int Create( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; if( p_filter->fmt_in.video.i_chroma != VLC_CODEC_I420 && p_filter->fmt_in.video.i_chroma != VLC_CODEC_J420 && p_filter->fmt_in.video.i_chroma != VLC_CODEC_YV12 && p_filter->fmt_in.video.i_chroma != VLC_CODEC_I422 && p_filter->fmt_in.video.i_chroma != VLC_CODEC_J422 ) { /* We only want planar YUV 4:2:0 or 4:2:2 */ msg_Err( p_filter, "Unsupported input chroma (%4.4s)", (char*)&(p_filter->fmt_in.video.i_chroma) ); 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; } p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); if( p_filter->p_sys == NULL ) return VLC_ENOMEM; config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options, p_filter->p_cfg ); p_filter->pf_video_filter = Filter; p_filter->p_sys->f_sigma = var_CreateGetFloat( p_filter, FILTER_PREFIX "sigma" ); if( p_filter->p_sys->f_sigma <= 0. ) { msg_Err( p_filter, "sigma must be greater than zero" ); return VLC_EGENERIC; } gaussianblur_InitDistribution( p_filter->p_sys ); msg_Dbg( p_filter, "gaussian distribution is %d pixels wide", p_filter->p_sys->i_dim*2+1 ); p_filter->p_sys->pt_buffer = NULL; p_filter->p_sys->pt_scale = NULL; return VLC_SUCCESS; }
/***************************************************************************** * 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, 4 ) < 4 ) return VLC_EGENERIC; if( p_peek[0] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x01 || p_peek[3] != 0x0f ) /* Sequence header */ { if( !p_demux->b_force ) { msg_Warn( p_demux, "vc-1 module discarded (no startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like a VC-1 ES stream, " "continuing anyway" ); } p_sys = (demux_sys_t *)malloc( sizeof( demux_sys_t ) ); // sunqueen modify if( unlikely(p_sys == NULL) ) return VLC_ENOMEM; p_demux->pf_demux = Demux; p_demux->pf_control= Control; p_demux->p_sys = p_sys; p_sys->p_es = NULL; p_sys->i_dts = 0; p_sys->f_fps = var_CreateGetFloat( p_demux, "vc1-fps" ); if( p_sys->f_fps < 0.001 ) p_sys->f_fps = 0.0; /* Load the packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_VC1 ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "VC-1" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } return VLC_SUCCESS; }
/***************************************************************************** * 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] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x00 || p_peek[3] != 0x01 || (p_peek[4]&0x1F) != 7 ) /* SPS */ { if( !p_demux->b_force ) { msg_Warn( p_demux, "h264 module discarded (no startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like a H264 ES stream, " "continuing anyway" ); } p_demux->pf_demux = Demux; p_demux->pf_control= Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); p_sys->p_es = NULL; p_sys->i_dts = 0; p_sys->f_fps = var_CreateGetFloat( p_demux, "h264-fps" ); if( p_sys->f_fps < 0.001f ) p_sys->f_fps = 0.001f; msg_Dbg( p_demux, "using %.2f fps", (double) p_sys->f_fps ); /* Load the mpegvideo packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_H264 ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "h264" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } return VLC_SUCCESS; }
static int OpenPitch( vlc_object_t *p_this ) { int err = Open( p_this ); if( err ) return err; filter_t *p_filter = (filter_t *)p_this; vlc_object_t *p_aout = p_filter->obj.parent; filter_sys_t *p_sys = p_filter->p_sys; float pitch_shift = var_CreateGetFloat( p_aout, "pitch-shift" ); var_AddCallback( p_aout, "pitch-shift", PitchCallback, p_sys ); PitchSetRateShift( p_sys, pitch_shift ); p_sys->resampler = ResamplerCreate(p_filter); if( !p_sys->resampler ) return VLC_EGENERIC; p_filter->pf_audio_filter = DoPitchWork; return VLC_SUCCESS; }
/***************************************************************************** * 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] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x00 || p_peek[3] != 0x01 || (p_peek[4]&0xFE) != 0x40 ) /* VPS & forbidden zero bit*/ { if( !p_demux->b_force ) { msg_Warn( p_demux, "hevc module discarded (no startcode)" ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like a HEVC ES stream, " "continuing anyway" ); } p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); if( !p_demux->p_sys ) return VLC_ENOMEM; p_sys->p_es = NULL; p_sys->i_dts = VLC_TS_0; p_sys->f_force_fps = var_CreateGetFloat( p_demux, "hevc-force-fps" ); if( p_sys->f_force_fps != 0.0f ) { p_sys->f_fps = ( p_sys->f_force_fps < 0.001f )? 0.001f: p_sys->f_force_fps; msg_Dbg( p_demux, "using %.2f fps", (double) p_sys->f_fps ); } else p_sys->f_fps = 0.0f; /* Load the hevc packetizer */ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_HEVC ); p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "hevc" ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } p_sys->p_packetizer->fmt_out.b_packetized = true; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out); if( !p_sys->p_es ) { demux_PacketizerDestroy( p_sys->p_packetizer ); free( p_sys ); return VLC_ENOMEM; } p_demux->pf_demux = Demux; p_demux->pf_control= Control; return VLC_SUCCESS; }
static int EqzInit( aout_filter_t *p_filter, int i_rate ) { aout_filter_sys_t *p_sys = p_filter->p_sys; const eqz_config_t *p_cfg; int i, ch; vlc_value_t val1, val2, val3; aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent; /* Select the config */ if( i_rate == 48000 ) { p_cfg = &eqz_config_48000_10b; } else if( i_rate == 44100 ) { p_cfg = &eqz_config_44100_10b; } else { /* TODO compute the coeffs on the fly */ msg_Err( p_filter, "unsupported rate" ); return VLC_EGENERIC; } /* Create the static filter config */ p_sys->i_band = p_cfg->i_band; p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) ); p_sys->f_beta = malloc( p_sys->i_band * sizeof(float) ); p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) ); for( i = 0; i < p_sys->i_band; i++ ) { p_sys->f_alpha[i] = p_cfg->band[i].f_alpha; p_sys->f_beta[i] = p_cfg->band[i].f_beta; p_sys->f_gamma[i] = p_cfg->band[i].f_gamma; } /* Filter dyn config */ p_sys->b_2eqz = VLC_FALSE; p_sys->f_gamp = 1.0; p_sys->f_amp = malloc( p_sys->i_band * sizeof(float) ); for( i = 0; i < p_sys->i_band; i++ ) { p_sys->f_amp[i] = 0.0; } /* Filter state */ for( ch = 0; ch < 32; ch++ ) { p_sys->x[ch][0] = p_sys->x[ch][1] = p_sys->x2[ch][0] = p_sys->x2[ch][1] = 0.0; for( i = 0; i < p_sys->i_band; i++ ) { p_sys->y[ch][i][0] = p_sys->y[ch][i][1] = p_sys->y2[ch][i][0] = p_sys->y2[ch][i][1] = 0.0; } } var_CreateGetString( p_aout,"equalizer-bands" ); var_CreateGetString( p_aout, "equalizer-preset" ); p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" ); var_CreateGetFloat( p_aout, "equalizer-preamp" ); /* Get initial values */ var_Get( p_aout, "equalizer-preset", &val1 ); var_Get( p_aout, "equalizer-bands", &val2 ); var_Get( p_aout, "equalizer-preamp", &val3 ); p_sys->b_first = VLC_TRUE; PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys ); BandsCallback( VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys ); PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys ); p_sys->b_first = VLC_FALSE; /* Register preset bands (for intf) if : */ /* We have no bands info --> the preset info must be given to the intf */ /* or The bands info matches the preset */ if (p_sys->psz_newbands == NULL) { msg_Err(p_filter, "No preset selected"); return (VLC_EGENERIC); } if( ( *(val2.psz_string) && strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string ) { var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands ); var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp ); } /* Add our own callbacks */ var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys ); var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys ); var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys ); msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass", i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 ); for( i = 0; i < p_sys->i_band; i++ ) { msg_Dbg( p_filter, " %d Hz -> factor:%f alpha:%f beta:%f gamma:%f", (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i], p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]); } return VLC_SUCCESS; }
/***************************************************************************** * Open: check file and initializes structures *****************************************************************************/ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; int i_size; bool b_matched = false; float f_fps; p_sys = malloc( sizeof( demux_sys_t ) ); if( unlikely(p_sys == NULL) ) return VLC_ENOMEM; p_demux->pf_control = Control; p_demux->p_sys = p_sys; p_sys->p_es = NULL; p_sys->i_time = 0; p_sys->i_level = 0; p_sys->psz_separator = NULL; p_sys->i_frame_size_estimate = 15 * 1024; b_matched = CheckMimeHeader( p_demux, &i_size); if( b_matched ) { p_demux->pf_demux = MimeDemux; stream_Read( p_demux->s, NULL, i_size ); } else if( 0 == i_size ) { /* 0xffd8 identify a JPEG SOI */ if( p_sys->p_peek[0] == 0xFF && p_sys->p_peek[1] == 0xD8 ) { msg_Dbg( p_demux, "JPEG SOI marker detected" ); p_demux->pf_demux = MjpgDemux; p_sys->i_level++; } else { goto error; } } else { goto error; } f_fps = var_CreateGetFloat( p_demux, "mjpeg-fps" ); p_sys->i_frame_length = 0; /* Check for jpeg file extension */ p_sys->b_still = false; p_sys->i_still_end = 0; if( demux_IsPathExtension( p_demux, ".jpeg" ) || demux_IsPathExtension( p_demux, ".jpg" ) ) { p_sys->b_still = true; if( f_fps ) { p_sys->i_still_length = 1000000.0 / f_fps; } else { /* Defaults to 1fps */ p_sys->i_still_length = 1000000; } } else if ( f_fps ) { p_sys->i_frame_length = 1000000.0 / f_fps; } es_format_Init( &p_sys->fmt, VIDEO_ES, 0 ); p_sys->fmt.i_codec = VLC_CODEC_MJPG; p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt ); return VLC_SUCCESS; error: free( p_sys ); return VLC_EGENERIC; }
/** * Open: initialize and create stuff * @param p_this */ static int Open( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t*)p_this; filter_sys_t *p_sys = p_filter->p_sys = malloc( sizeof( *p_sys ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); p_sys->f_delayTime = var_CreateGetFloat( p_this, "delay-time" ); p_sys->f_sweepDepth = var_CreateGetFloat( p_this, "sweep-depth" ); p_sys->f_sweepRate = var_CreateGetFloat( p_this, "sweep-rate" ); p_sys->f_feedbackGain = var_CreateGetFloat( p_this, "feedback-gain" ); p_sys->f_dryLevel = var_CreateGetFloat( p_this, "dry-mix" ); p_sys->f_wetLevel = var_CreateGetFloat( p_this, "wet-mix" ); var_AddCallback( p_this, "delay-time", paramCallback, p_sys ); var_AddCallback( p_this, "sweep-depth", paramCallback, p_sys ); var_AddCallback( p_this, "sweep-rate", paramCallback, p_sys ); var_AddCallback( p_this, "feedback-gain", paramCallback, p_sys ); var_AddCallback( p_this, "dry-mix", paramCallback, p_sys ); var_AddCallback( p_this, "wet-mix", paramCallback, p_sys ); if( p_sys->f_delayTime < 0.f ) { msg_Err( p_filter, "Delay Time is invalid" ); free(p_sys); return VLC_EGENERIC; } if( p_sys->f_sweepDepth > p_sys->f_delayTime || p_sys->f_sweepDepth < 0.f ) { msg_Err( p_filter, "Sweep Depth is invalid" ); free( p_sys ); return VLC_EGENERIC; } if( p_sys->f_sweepRate < 0.f ) { msg_Err( p_filter, "Sweep Rate is invalid" ); free( p_sys ); return VLC_EGENERIC; } /* Max delay = delay + depth. Min = delay - depth */ p_sys->i_bufferLength = p_sys->i_channels * ( (int)( ( p_sys->f_delayTime + p_sys->f_sweepDepth ) * p_filter->fmt_in.audio.i_rate/1000 ) + 1 ); msg_Dbg( p_filter , "Buffer length:%d, Channels:%d, Sweep Depth:%f, Delay " "time:%f, Sweep Rate:%f, Sample Rate: %d", p_sys->i_bufferLength, p_sys->i_channels, (double) p_sys->f_sweepDepth, (double) p_sys->f_delayTime, (double) p_sys->f_sweepRate, p_filter->fmt_in.audio.i_rate ); if( p_sys->i_bufferLength <= 0 ) { msg_Err( p_filter, "Delay-time, Sample rate or Channels was incorrect" ); free(p_sys); return VLC_EGENERIC; } p_sys->p_delayLineStart = calloc( p_sys->i_bufferLength, sizeof( float ) ); if( !p_sys->p_delayLineStart ) { free( p_sys ); return VLC_ENOMEM; } p_sys->i_cumulative = 0; p_sys->i_step = p_sys->f_sweepRate > 0 ? 1 : 0; p_sys->f_offset = 0; p_sys->f_temp = 0; p_sys->p_delayLineEnd = p_sys->p_delayLineStart + p_sys->i_bufferLength; p_sys->p_write = p_sys->p_delayLineStart; if( p_sys->f_sweepDepth < small_value() || p_filter->fmt_in.audio.i_rate < small_value() ) { p_sys->f_sinMultiplier = 0.f; } else { p_sys->f_sinMultiplier = 11 * p_sys->f_sweepRate / ( 7 * p_sys->f_sweepDepth * p_filter->fmt_in.audio.i_rate ) ; } p_sys->i_sampleRate = p_filter->fmt_in.audio.i_rate; 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 int GenericOpen( demux_t *p_demux, const char *psz_module, vlc_fourcc_t i_codec, int(*pf_probe)(const uint8_t *, size_t, void *), void *p_ctx, const char **pp_psz_exts, const char **pp_psz_mimes ) { demux_sys_t *p_sys; const uint8_t *p_peek; es_format_t fmt; uint8_t annexb_startcode[] = {0,0,0,1}; int i_ret = 0; /* Restrict by type first */ if( !p_demux->obj.force && !check_Property( p_demux, pp_psz_exts, demux_IsPathExtension ) && !check_Property( p_demux, pp_psz_mimes, demux_IsContentType ) ) { return VLC_EGENERIC; } /* First check for first AnnexB header */ if( vlc_stream_Peek( p_demux->s, &p_peek, H26X_MIN_PEEK ) == H26X_MIN_PEEK && !memcmp( p_peek, annexb_startcode, 4 ) ) { size_t i_peek = H26X_MIN_PEEK; size_t i_peek_target = H26X_MIN_PEEK; size_t i_probe_offset = 4; const uint8_t *p_probe = p_peek; bool b_synced = true; unsigned i_bitflow = 0; for( unsigned i=0; i<H26X_NAL_COUNT; i++ ) { while( !b_synced ) { if( i_probe_offset + H26X_MIN_PEEK >= i_peek && i_peek_target + H26X_PEEK_CHUNK <= H26X_MAX_PEEK ) { i_peek_target += H26X_PEEK_CHUNK; i_peek = vlc_stream_Peek( p_demux->s, &p_peek, i_peek_target ); } if( i_probe_offset + H26X_MIN_PEEK >= i_peek ) break; p_probe = &p_peek[i_probe_offset]; i_bitflow = (i_bitflow << 1) | (!p_probe[0]); /* Check for annexB */ if( p_probe[0] == 0x01 && ((i_bitflow & 0x06) == 0x06) ) b_synced = true; i_probe_offset++; } if( b_synced ) { p_probe = &p_peek[i_probe_offset]; i_ret = pf_probe( p_probe, i_peek - i_probe_offset, p_ctx ); } if( i_ret != 0 ) break; i_probe_offset += 4; b_synced = false; } } if( i_ret < 1 ) { if( !p_demux->obj.force ) { msg_Warn( p_demux, "%s module discarded (no startcode)", psz_module ); return VLC_EGENERIC; } msg_Err( p_demux, "this doesn't look like a %s ES stream, " "continuing anyway", psz_module ); } p_demux->pf_demux = Demux; p_demux->pf_control= Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); p_sys->p_es = NULL; p_sys->frame_rate_num = 0; p_sys->frame_rate_den = 0; float f_fps = 0; char *psz_fpsvar; if( asprintf( &psz_fpsvar, "%s-fps", psz_module ) ) { f_fps = var_CreateGetFloat( p_demux, psz_fpsvar ); free( psz_fpsvar ); } if( f_fps ) { if ( f_fps < 0.001f ) f_fps = 0.001f; p_sys->frame_rate_den = 1000; p_sys->frame_rate_num = 1000 * f_fps; date_Init( &p_sys->dts, p_sys->frame_rate_num, p_sys->frame_rate_den ); } else date_Init( &p_sys->dts, 25000, 1000 ); date_Set( &p_sys->dts, VLC_TICK_0 ); /* Load the mpegvideo packetizer */ es_format_Init( &fmt, VIDEO_ES, i_codec ); if( f_fps ) { fmt.video.i_frame_rate = p_sys->dts.i_divider_num; fmt.video.i_frame_rate_base = p_sys->dts.i_divider_den; } p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, psz_module ); if( !p_sys->p_packetizer ) { free( p_sys ); return VLC_EGENERIC; } return VLC_SUCCESS; }
/** * Probes and initializes. */ static int Open (vlc_object_t *obj) { demux_t *demux = (demux_t *)obj; demux_sys_t *p_sys = malloc (sizeof (*p_sys)); if (p_sys == NULL) return VLC_ENOMEM; demux->p_sys = p_sys; /* Connect to X server */ char *display = var_CreateGetNonEmptyString (obj, "x11-display"); int snum; xcb_connection_t *conn = xcb_connect (display, &snum); free (display); if (xcb_connection_has_error (conn)) { free (p_sys); return VLC_EGENERIC; } p_sys->conn = conn; /* Find configured screen */ const xcb_setup_t *setup = xcb_get_setup (conn); const xcb_screen_t *scr = NULL; for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup); i.rem > 0; xcb_screen_next (&i)) { if (snum == 0) { scr = i.data; break; } snum--; } if (scr == NULL) { msg_Err (obj, "bad X11 screen number"); goto error; } /* Determine capture window */ p_sys->root = scr->root; if (!strcmp (demux->psz_access, "screen")) p_sys->window = p_sys->root; else if (!strcmp (demux->psz_access, "window")) { char *end; unsigned long ul = strtoul (demux->psz_path, &end, 0); if (*end || ul > 0xffffffff) { msg_Err (obj, "bad X11 drawable %s", demux->psz_path); goto error; } p_sys->window = ul; } else goto error; /* Window properties */ p_sys->x = var_CreateGetInteger (obj, "screen-left"); p_sys->y = var_CreateGetInteger (obj, "screen-top"); p_sys->w = var_CreateGetInteger (obj, "screen-width"); p_sys->h = var_CreateGetInteger (obj, "screen-height"); uint32_t chroma = 0; uint8_t bpp; for (const xcb_format_t *fmt = xcb_setup_pixmap_formats (setup), *end = fmt + xcb_setup_pixmap_formats_length (setup); fmt < end; fmt++) { if (fmt->depth != scr->root_depth) continue; bpp = fmt->depth; switch (fmt->depth) { case 32: if (fmt->bits_per_pixel == 32) chroma = VLC_CODEC_RGBA; break; case 24: if (fmt->bits_per_pixel == 32) { chroma = VLC_CODEC_RGB32; bpp = 32; } else if (fmt->bits_per_pixel == 24) chroma = VLC_CODEC_RGB24; break; case 16: if (fmt->bits_per_pixel == 16) chroma = VLC_CODEC_RGB16; break; case 15: if (fmt->bits_per_pixel == 16) chroma = VLC_CODEC_RGB15; break; case 8: /* XXX: screw grey scale! */ if (fmt->bits_per_pixel == 8) chroma = VLC_CODEC_RGB8; break; } if (chroma != 0) break; } if (!chroma) { msg_Err (obj, "unsupported pixmap formats"); goto error; } /* Initializes format */ float rate = var_CreateGetFloat (obj, "screen-fps"); if (!rate) goto error; p_sys->interval = (float)CLOCK_FREQ / rate; if (!p_sys->interval) goto error; var_Create (obj, "screen-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT); es_format_Init (&p_sys->fmt, VIDEO_ES, chroma); p_sys->fmt.video.i_chroma = chroma; p_sys->fmt.video.i_bits_per_pixel = bpp; p_sys->fmt.video.i_sar_num = p_sys->fmt.video.i_sar_den = 1; p_sys->fmt.video.i_frame_rate = 1000 * rate; p_sys->fmt.video.i_frame_rate_base = 1000; p_sys->es = NULL; p_sys->pts = VLC_TS_INVALID; vlc_mutex_init (&p_sys->lock); if (vlc_timer_create (&p_sys->timer, Demux, demux)) goto error; vlc_timer_schedule (p_sys->timer, false, 1, p_sys->interval); /* Initializes demux */ demux->pf_demux = NULL; demux->pf_control = Control; return VLC_SUCCESS; error: xcb_disconnect (p_sys->conn); free (p_sys); return VLC_EGENERIC; }