/***************************************************************************** * CloseDecoder: decoder destruction *****************************************************************************/ static void CloseDecoder( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t *)p_this; decoder_sys_t *p_sys = p_dec->p_sys; switch( p_sys->i_cat ) { case AUDIO_ES: E_( EndAudioDec )( p_dec ); break; case VIDEO_ES: E_( EndVideoDec )( p_dec ); break; } if( p_sys->p_context ) { if( p_sys->p_context->extradata ) free( p_sys->p_context->extradata ); avcodec_close( p_sys->p_context ); msg_Dbg( p_dec, "ffmpeg codec (%s) stopped", p_sys->psz_namecodec ); av_free( p_sys->p_context ); } free( p_sys ); }
void eqnsys<nr_type_t>::factorize_svd (void) { int i, j, l; nr_type_t t; // allocate space for vectors and matrices delete R; R = new tvector<nr_type_t> (N); delete T; T = new tvector<nr_type_t> (N); delete V; V = new tmatrix<nr_type_t> (N); delete S; S = new tvector<nr_double_t> (N); delete E; E = new tvector<nr_double_t> (N); // bidiagonalization through householder transformations for (i = 0; i < N; i++) { T_(i) = householder_left (i); if (i < N - 1) R_(i) = householder_right (i); } // copy over the real valued bidiagonal values for (i = 0; i < N; i++) S_(i) = real (A_(i, i)); for (E_(0) = 0, i = 1; i < N; i++) E_(i) = real (A_(i - 1, i)); // backward accumulation of right-hand householder transformations // yields the V' matrix for (l = N, i = N - 1; i >= 0; l = i--) { if (i < N - 1) { if ((t = R_(i)) != 0.0) { householder_apply_right_extern (i, cond_conj (t)); } else for (j = l; j < N; j++) // cleanup this row V_(i, j) = V_(j, i) = 0.0; } V_(i, i) = 1.0; } // backward accumulation of left-hand householder transformations // yields the U matrix in place of the A matrix for (l = N, i = N - 1; i >= 0; l = i--) { for (j = l; j < N; j++) // cleanup upper row A_(i, j) = 0.0; if ((t = T_(i)) != 0.0) { householder_apply_left (i, cond_conj (t)); for (j = l; j < N; j++) A_(j, i) *= -t; } else for (j = l; j < N; j++) // cleanup this column A_(j, i) = 0.0; A_(i, i) = 1.0 - t; } // S and E contain diagonal and super-diagonal, A contains U, V' // calculated; now diagonalization can begin diagonalize_svd (); }
int main(int argc, char ** argv) { float cutoff = 2000; if(argc > 1) { cutoff = atoi(argv[1]); } if(argc > 2) { gamp = atoi(argv[2]); } float freqs[] = {C_(1), D_(1), E_(1), E_(1), C_(1), D_(1), E_(1), C_(1), D_(1), E_(1), D_(1), C_(1), D_(1), C_(1)}; gsequence = make_sequence(freqs, array_size(freqs), gamp, 0.13); gfilter = lowpass_make((Sampler)gsequence, cutoff, SAMPLE_FREQ); FILE * seqfile = fopen("seq.csv", "w"); sample_to_file((Sampler)gsequence, SAMPLE_FREQ, 1.0, seqfile); fclose(seqfile); SDL_AudioSpec wanted; // Set the audio format wanted.freq = SAMPLE_FREQ; wanted.format = AUDIO_S16SYS; wanted.channels = 1; // 1 = mono, 2 = stereo wanted.samples = 1024; // Good low-latency value for callback //wanted.size = 4096; wanted.padding = 0; wanted.callback = fill_audio; wanted.userdata = NULL; // Open the audio device, forcing the desired format if ( SDL_OpenAudio(&wanted, NULL) < 0 ) { fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError()); return(-1); } SDL_PauseAudio(0); SDL_Delay(2500); RELEASE_SAMPLER(gfilter); SDL_CloseAudio(); return 0; }
/***************************************************************************** * Import_PLS: main import function *****************************************************************************/ int E_(Import_PLS)( vlc_object_t *p_this ) { demux_t *p_demux = (demux_t *)p_this; uint8_t *p_peek; char *psz_ext; if( stream_Peek( p_demux->s , &p_peek, 7 ) < 7 ) return VLC_EGENERIC; psz_ext = strrchr ( p_demux->psz_path, '.' ); if( !strncasecmp( (char *)p_peek, "[playlist]", 10 ) ) { ; } else if( ( psz_ext && !strcasecmp( psz_ext, ".pls") ) || ( p_demux->psz_demux && !strcmp(p_demux->psz_demux, "pls") ) ) { ; } else return VLC_EGENERIC; msg_Dbg( p_demux, "found valid PLS playlist file"); p_demux->pf_control = Control; p_demux->pf_demux = Demux; p_demux->p_sys = malloc( sizeof(demux_sys_t) ); if( p_demux->p_sys == NULL ) { msg_Err( p_demux, "out of memory" ); return VLC_ENOMEM; } p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux ); return VLC_SUCCESS; }
static char * _format_month_year(struct tm *selected_time) { char buf[32]; if (!strftime(buf, sizeof(buf), E_("%B %Y"), selected_time)) return NULL; return strdup(buf); }
/***************************************************************************** * EndVideo: decoder destruction ***************************************************************************** * This function is called when the thread ends after a sucessful * initialization. *****************************************************************************/ void E_(EndVideoDec)( decoder_t *p_dec ) { decoder_sys_t *p_sys = p_dec->p_sys; if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic ); #ifdef LIBAVCODEC_PP E_(ClosePostproc)( p_dec, p_sys->p_pp ); #endif free( p_sys->p_buffer_orig ); }
/***************************************************************************** * DestroyOpenGL: destroys an OpenGL provider *****************************************************************************/ static void DestroyOpenGL( vlc_object_t *p_this ) { vout_thread_t *p_vout = (vout_thread_t *)p_this; vout_sys_t *p_sys = p_vout->p_sys; glXDestroyContext( p_sys->p_display, p_sys->gwctx ); if( p_sys->b_glx13 ) { glXDestroyWindow( p_sys->p_display, p_sys->gwnd ); } E_(Deactivate)( p_this ); }
static void _activate(Evas_Object *obj) { ELM_BUTTON_DATA_GET_OR_RETURN(obj, sd); ELM_SAFE_FREE(sd->timer, ecore_timer_del); sd->repeating = EINA_FALSE; if ((_elm_config->access_mode == ELM_ACCESS_MODE_OFF) || (_elm_access_2nd_click_timeout(obj))) { if (_elm_config->access_mode != ELM_ACCESS_MODE_OFF) _elm_access_say(E_("Clicked")); if (!elm_widget_disabled_get(obj) && !evas_object_freeze_events_get(obj)) evas_object_smart_callback_call(obj, SIG_CLICKED, NULL); } }
/***************************************************************************** * CreateOpenGL: initialize an OpenGL provider *****************************************************************************/ static int CreateOpenGL( vlc_object_t *p_this ) { vout_thread_t *p_vout = (vout_thread_t *)p_this; vlc_bool_t b_glx13; if( CheckGLX( p_this, &b_glx13 ) != VLC_SUCCESS ) { msg_Err( p_vout, "no GLX support" ); return VLC_EGENERIC; } if( E_(Activate)( p_this ) != VLC_SUCCESS ) { return VLC_EGENERIC; } /* Set the function pointer */ p_vout->pf_init = InitOpenGL; p_vout->pf_swap = SwapBuffers; p_vout->p_sys->b_glx13 = b_glx13; return VLC_SUCCESS; }
/***************************************************************************** * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a * picture_t structure (when not in direct rendering mode). *****************************************************************************/ static void ffmpeg_CopyPicture( decoder_t *p_dec, picture_t *p_pic, AVFrame *p_ff_pic ) { decoder_sys_t *p_sys = p_dec->p_sys; if( ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) ) { int i_plane, i_size, i_line; uint8_t *p_dst, *p_src; int i_src_stride, i_dst_stride; #ifdef LIBAVCODEC_PP if( p_sys->p_pp && p_sys->b_pp ) E_(PostprocPict)( p_dec, p_sys->p_pp, p_pic, p_ff_pic ); else #endif for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ ) { p_src = p_ff_pic->data[i_plane]; p_dst = p_pic->p[i_plane].p_pixels; i_src_stride = p_ff_pic->linesize[i_plane]; i_dst_stride = p_pic->p[i_plane].i_pitch; i_size = __MIN( i_src_stride, i_dst_stride ); for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ ) { p_dec->p_vlc->pf_memcpy( p_dst, p_src, i_size ); p_src += i_src_stride; p_dst += i_dst_stride; } } } else { AVPicture dest_pic; int i; /* we need to convert to I420 */ switch( p_sys->p_context->pix_fmt ) { case PIX_FMT_YUV410P: case PIX_FMT_YUV411P: case PIX_FMT_PAL8: for( i = 0; i < p_pic->i_planes; i++ ) { dest_pic.data[i] = p_pic->p[i].p_pixels; dest_pic.linesize[i] = p_pic->p[i].i_pitch; } img_convert( &dest_pic, PIX_FMT_YUV420P, (AVPicture *)p_ff_pic, p_sys->p_context->pix_fmt, p_sys->p_context->width, p_sys->p_context->height ); break; default: msg_Err( p_dec, "don't know how to convert chroma %i", p_sys->p_context->pix_fmt ); p_dec->b_error = 1; break; } } }
int E_(OpenEncoder)( vlc_object_t *p_this ) { encoder_t *p_enc = (encoder_t *)p_this; encoder_sys_t *p_sys = p_enc->p_sys; AVCodecContext *p_context; AVCodec *p_codec; int i_codec_id, i_cat; char *psz_namecodec; vlc_value_t val; if( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id, &psz_namecodec ) ) { if( E_(GetFfmpegChroma)( p_enc->fmt_out.i_codec ) < 0 ) { /* handed chroma output */ return VLC_EGENERIC; } i_cat = VIDEO_ES; i_codec_id = CODEC_ID_RAWVIDEO; psz_namecodec = "Raw video"; } if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES ) { msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec ); return VLC_EGENERIC; } if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES ) { msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec ); return VLC_EGENERIC; } /* Initialization must be done before avcodec_find_decoder() */ E_(InitLibavcodec)(p_this); p_codec = avcodec_find_encoder( i_codec_id ); if( !p_codec ) { msg_Err( p_enc, "cannot find encoder %s", psz_namecodec ); return VLC_EGENERIC; } /* Allocate the memory needed to store the decoder's structure */ if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL ) { msg_Err( p_enc, "out of memory" ); return VLC_EGENERIC; } memset( p_sys, 0, sizeof(encoder_sys_t) ); p_enc->p_sys = p_sys; p_sys->p_codec = p_codec; p_enc->pf_encode_video = EncodeVideo; p_enc->pf_encode_audio = EncodeAudio; p_sys->p_buffer_out = NULL; p_sys->p_buffer = NULL; p_sys->p_context = p_context = avcodec_alloc_context(); /* Set CPU capabilities */ p_context->dsp_mask = 0; if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMX) ) { p_context->dsp_mask |= FF_MM_MMX; } if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMXEXT) ) { p_context->dsp_mask |= FF_MM_MMXEXT; } if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_3DNOW) ) { p_context->dsp_mask |= FF_MM_3DNOW; } if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_SSE) ) { p_context->dsp_mask |= FF_MM_SSE; p_context->dsp_mask |= FF_MM_SSE2; } sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg ); var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val ); p_sys->i_key_int = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val ); p_sys->i_b_frames = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "vt", &val ); p_sys->i_vtolerance = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val ); p_sys->b_interlace = val.b_bool; var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val ); p_sys->b_pre_me = val.b_bool; var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val ); p_sys->b_hurry_up = val.b_bool; if( p_sys->b_hurry_up ) { /* hurry up mode needs noise reduction, even small */ p_sys->i_noise_reduction = 1; } var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val ); p_sys->b_strict_rc = val.b_bool; var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val ); p_sys->i_rc_buffer_size = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val ); p_sys->f_rc_buffer_aggressivity = val.f_float; var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val ); p_sys->f_i_quant_factor = val.f_float; var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val ); p_sys->i_noise_reduction = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val ); p_sys->b_mpeg4_matrix = val.b_bool; var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val ); if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0; p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5); var_Get( p_enc, ENC_CFG_PREFIX "hq", &val ); if( val.psz_string && *val.psz_string ) { if( !strcmp( val.psz_string, "rd" ) ) p_sys->i_hq = FF_MB_DECISION_RD; else if( !strcmp( val.psz_string, "bits" ) ) p_sys->i_hq = FF_MB_DECISION_BITS; else if( !strcmp( val.psz_string, "simple" ) ) p_sys->i_hq = FF_MB_DECISION_SIMPLE; else p_sys->i_hq = FF_MB_DECISION_RD; } if( val.psz_string ) free( val.psz_string ); var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val ); p_sys->i_qmin = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val ); p_sys->i_qmax = val.i_int; var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val ); p_sys->b_trellis = val.b_bool; var_Get( p_enc, ENC_CFG_PREFIX "strict", &val ); if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0; p_context->strict_std_compliance = val.i_int; if( p_enc->fmt_in.i_cat == VIDEO_ES ) { int i_aspect_num, i_aspect_den; if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height ) { msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width, p_enc->fmt_in.video.i_height ); free( p_sys ); return VLC_EGENERIC; } p_context->width = p_enc->fmt_in.video.i_width; p_context->height = p_enc->fmt_in.video.i_height; p_context->frame_rate = p_enc->fmt_in.video.i_frame_rate; p_context->frame_rate_base= p_enc->fmt_in.video.i_frame_rate_base; /* Defaults from ffmpeg.c */ p_context->qblur = 0.5; p_context->qcompress = 0.5; p_context->b_quant_offset = 1.25; p_context->b_quant_factor = 1.25; p_context->i_quant_offset = 0.0; p_context->i_quant_factor = -0.8; if( p_sys->i_key_int > 0 ) p_context->gop_size = p_sys->i_key_int; p_context->max_b_frames = __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 ); p_context->b_frame_strategy = 0; #if LIBAVCODEC_BUILD >= 4687 av_reduce( &i_aspect_num, &i_aspect_den, p_enc->fmt_in.video.i_aspect, VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ ); av_reduce( &p_context->sample_aspect_ratio.num, &p_context->sample_aspect_ratio.den, i_aspect_num * (int64_t)p_context->height, i_aspect_den * (int64_t)p_context->width, 1 << 30 ); #else p_context->aspect_ratio = ((float)p_enc->fmt_in.video.i_aspect) / VOUT_ASPECT_FACTOR; #endif p_sys->p_buffer_out = malloc( AVCODEC_MAX_VIDEO_FRAME_SIZE ); p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0'); if ( p_sys->b_strict_rc ) { p_context->rc_max_rate = p_enc->fmt_out.i_bitrate; p_context->rc_buffer_size = p_sys->i_rc_buffer_size; p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity; } if ( p_sys->f_i_quant_factor != 0.0 ) p_context->i_quant_factor = p_sys->f_i_quant_factor; #if LIBAVCODEC_BUILD >= 4690 p_context->noise_reduction = p_sys->i_noise_reduction; #endif if ( p_sys->b_mpeg4_matrix ) { p_context->intra_matrix = ff_mpeg4_default_intra_matrix; p_context->inter_matrix = ff_mpeg4_default_non_intra_matrix; } if ( p_sys->b_pre_me ) { p_context->pre_me = 1; p_context->me_pre_cmp = FF_CMP_CHROMA; } if ( p_sys->b_interlace ) { p_context->flags |= CODEC_FLAG_INTERLACED_DCT; #if LIBAVCODEC_BUILD >= 4698 p_context->flags |= CODEC_FLAG_INTERLACED_ME; #endif } if ( p_sys->b_trellis ) p_context->flags |= CODEC_FLAG_TRELLIS_QUANT; #if LIBAVCODEC_BUILD >= 4702 if ( p_enc->i_threads >= 1 ) p_context->thread_count = p_enc->i_threads; #endif if( p_sys->i_vtolerance > 0 ) p_context->bit_rate_tolerance = p_sys->i_vtolerance; if( p_sys->i_qmin > 0 ) p_context->mb_qmin = p_context->qmin = p_sys->i_qmin; if( p_sys->i_qmax > 0 ) p_context->mb_qmax = p_context->qmax = p_sys->i_qmax; p_context->max_qdiff = 3; p_context->mb_decision = p_sys->i_hq; if( p_sys->i_quality ) { p_context->flags |= CODEC_FLAG_QSCALE; #if LIBAVCODEC_BUILD >= 4668 p_context->global_quality = p_sys->i_quality; #endif } } else if( p_enc->fmt_in.i_cat == AUDIO_ES ) { p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE; p_context->sample_rate = p_enc->fmt_in.audio.i_rate; p_context->channels = p_enc->fmt_in.audio.i_channels; } /* Misc parameters */ p_context->bit_rate = p_enc->fmt_out.i_bitrate; if( i_codec_id == CODEC_ID_RAWVIDEO ) { /* XXX: hack: Force same codec (will be handled by transcode) */ p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec; p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec ); } /* Make sure we get extradata filled by the encoder */ p_context->extradata_size = 0; p_context->extradata = NULL; p_context->flags |= CODEC_FLAG_GLOBAL_HEADER; if( avcodec_open( p_context, p_codec ) ) { if( p_enc->fmt_in.i_cat == AUDIO_ES && p_context->channels > 2 ) { p_context->channels = 2; p_enc->fmt_in.audio.i_channels = 2; // FIXME if( avcodec_open( p_context, p_codec ) ) { msg_Err( p_enc, "cannot open encoder" ); free( p_sys ); return VLC_EGENERIC; } msg_Warn( p_enc, "stereo mode selected (codec limitation)" ); } else { msg_Err( p_enc, "cannot open encoder" ); free( p_sys ); return VLC_EGENERIC; } } p_enc->fmt_out.i_extra = p_context->extradata_size; p_enc->fmt_out.p_extra = p_context->extradata; p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER; if( p_enc->fmt_in.i_cat == AUDIO_ES ) { p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE ); p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels; p_sys->p_buffer = malloc( p_sys->i_frame_size ); } msg_Dbg( p_enc, "found encoder %s", psz_namecodec ); 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 E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context, AVCodec *p_codec, int i_codec_id, char *psz_namecodec ) { decoder_sys_t *p_sys; vlc_value_t lockval; vlc_value_t val; var_Get( p_dec->p_libvlc, "avcodec", &lockval ); /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL ) { msg_Err( p_dec, "out of memory" ); return VLC_EGENERIC; } p_dec->p_sys->p_context = p_context; p_dec->p_sys->p_codec = p_codec; p_dec->p_sys->i_codec_id = i_codec_id; p_dec->p_sys->psz_namecodec = psz_namecodec; p_sys->p_ff_pic = avcodec_alloc_frame(); /* ***** Fill p_context with init values ***** */ p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec ); p_sys->p_context->width = p_dec->fmt_in.video.i_width; p_sys->p_context->height = p_dec->fmt_in.video.i_height; p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel; /* ***** Get configuration of ffmpeg plugin ***** */ p_sys->p_context->workaround_bugs = config_GetInt( p_dec, "ffmpeg-workaround-bugs" ); p_sys->p_context->error_resilience = config_GetInt( p_dec, "ffmpeg-error-resilience" ); var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "grayscale", &val ); if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY; var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-vismv", &val ); #if LIBAVCODEC_BUILD >= 4698 if( val.i_int ) p_sys->p_context->debug_mv = val.i_int; #endif var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-lowres", &val ); #if LIBAVCODEC_BUILD >= 4723 if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int; #endif var_Create( p_dec, "ffmpeg-skiploopfilter", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-skiploopfilter", &val ); #if LIBAVCODEC_BUILD >= 4758 if( val.i_int > 0 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF; if( val.i_int > 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR; if( val.i_int > 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY; if( val.i_int > 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL; #endif /* ***** ffmpeg frame skipping ***** */ var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-hurry-up", &val ); p_sys->b_hurry_up = val.b_bool; /* ***** ffmpeg direct rendering ***** */ p_sys->b_direct_rendering = 0; var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-dr", &val ); if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) && /* Apparently direct rendering doesn't work with YUV422P */ p_sys->p_context->pix_fmt != PIX_FMT_YUV422P && /* H264 uses too many reference frames */ p_sys->i_codec_id != CODEC_ID_H264 && #if LIBAVCODEC_BUILD >= 4698 !p_sys->p_context->debug_mv ) #else 1 ) #endif { /* 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 = 1; } #ifdef LIBAVCODEC_PP p_sys->p_pp = NULL; p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = VLC_FALSE; p_sys->p_pp = E_(OpenPostproc)( p_dec, &p_sys->b_pp_async ); #endif /* ffmpeg doesn't properly release old pictures when frames are skipped */ //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0; if( p_sys->b_direct_rendering ) { msg_Dbg( p_dec, "using direct rendering" ); p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE; } /* 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->release_buffer = ffmpeg_ReleaseFrameBuf; p_sys->p_context->opaque = p_dec; /* ***** init this codec with special data ***** */ ffmpeg_InitCodec( p_dec ); /* ***** misc init ***** */ p_sys->input_pts = p_sys->input_dts = 0; p_sys->i_pts = 0; p_sys->b_has_b_frames = VLC_FALSE; p_sys->b_first_frame = VLC_TRUE; p_sys->i_late_frames = 0; p_sys->i_buffer = 0; p_sys->i_buffer_orig = 1; p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig ); /* Set output properties */ p_dec->fmt_out.i_cat = VIDEO_ES; p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt ); /* Setup palette */ #if LIBAVCODEC_BUILD >= 4688 if( p_dec->fmt_in.video.p_palette ) p_sys->p_context->palctrl = (AVPaletteControl *)p_dec->fmt_in.video.p_palette; else p_sys->p_context->palctrl = &palette_control; #endif /* ***** Open the codec ***** */ vlc_mutex_lock( lockval.p_address ); if( avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0 ) { vlc_mutex_unlock( lockval.p_address ); msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec ); free( p_sys ); return VLC_EGENERIC; } vlc_mutex_unlock( lockval.p_address ); msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec ); return VLC_SUCCESS; }
/***************************************************************************** * OpenDecoder: probe the decoder and return score *****************************************************************************/ static int OpenDecoder( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t*) p_this; int i_cat, i_codec_id, i_result; char *psz_namecodec; AVCodecContext *p_context; AVCodec *p_codec; /* *** determine codec type *** */ if( !E_(GetFfmpegCodec)( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id, &psz_namecodec ) ) { return VLC_EGENERIC; } /* Bail out if buggy decoder */ if( i_codec_id == CODEC_ID_AAC ) { msg_Dbg( p_dec, "refusing to use ffmpeg's (%s) decoder which is buggy", psz_namecodec ); return VLC_EGENERIC; } /* Initialization must be done before avcodec_find_decoder() */ E_(InitLibavcodec)(p_this); /* *** ask ffmpeg for a decoder *** */ if( !( p_codec = avcodec_find_decoder( i_codec_id ) ) ) { msg_Dbg( p_dec, "codec not found (%s)", psz_namecodec ); return VLC_EGENERIC; } /* *** get a p_context *** */ p_context = avcodec_alloc_context(); p_context->debug = config_GetInt( p_dec, "ffmpeg-debug" ); /* Set CPU capabilities */ p_context->dsp_mask = 0; if( !(p_dec->p_libvlc->i_cpu & CPU_CAPABILITY_MMX) ) { p_context->dsp_mask |= FF_MM_MMX; } if( !(p_dec->p_libvlc->i_cpu & CPU_CAPABILITY_MMXEXT) ) { p_context->dsp_mask |= FF_MM_MMXEXT; } if( !(p_dec->p_libvlc->i_cpu & CPU_CAPABILITY_3DNOW) ) { p_context->dsp_mask |= FF_MM_3DNOW; } if( !(p_dec->p_libvlc->i_cpu & CPU_CAPABILITY_SSE) ) { p_context->dsp_mask |= FF_MM_SSE; } if( !(p_dec->p_libvlc->i_cpu & CPU_CAPABILITY_SSE2) ) { p_context->dsp_mask |= FF_MM_SSE2; } switch( i_cat ) { case VIDEO_ES: p_dec->b_need_packetized = VLC_TRUE; p_dec->pf_decode_video = E_(DecodeVideo); i_result = E_( InitVideoDec )( p_dec, p_context, p_codec, i_codec_id, psz_namecodec ); break; case AUDIO_ES: p_dec->pf_decode_audio = E_(DecodeAudio); i_result = E_( InitAudioDec )( p_dec, p_context, p_codec, i_codec_id, psz_namecodec ); break; default: i_result = VLC_EGENERIC; } if( i_result == VLC_SUCCESS ) p_dec->p_sys->i_cat = i_cat; return i_result; }
" %% : a % \n") /***************************************************************************** * Module descriptor *****************************************************************************/ vlc_module_begin(); add_usage_hint( N_("cddax://[device-or-file][@[T]track]") ); set_description( _("Compact Disc Digital Audio (CD-DA) input") ); set_capability( "access2", 10 /* compare with priority of cdda */ ); set_callbacks( E_(CDDAOpen), E_(CDDAClose) ); add_shortcut( "cddax" ); add_shortcut( "cd" ); /* Configuration options */ add_integer ( MODULE_STRING "-debug", 0, E_(CDDADebugCB), N_("If nonzero, this gives additional debug information."), DEBUG_LONGTEXT, VLC_TRUE ); add_integer( MODULE_STRING "-caching", DEFAULT_PTS_DELAY / MILLISECONDS_PER_SEC, NULL, N_("Caching value in microseconds"), CACHING_LONGTEXT, VLC_TRUE ); add_integer( MODULE_STRING "-blocks-per-read", DEFAULT_BLOCKS_PER_READ, E_(CDDABlocksPerReadCB), N_("Number of blocks per CD read"), BLOCKS_PER_READ_LONGTEXT, VLC_TRUE ); add_string( MODULE_STRING "-author-format", "%A - %a %C %I", NULL,
" %% : a % \n") /***************************************************************************** * Module descriptor *****************************************************************************/ vlc_module_begin(); add_usage_hint( N_("vcdx://[device-or-file][@{P,S,T}num]") ); set_description( _("Video CD (VCD 1.0, 1.1, 2.0, SVCD, HQVCD) input") ); set_capability( "access", 85 /* slightly higher than vcd */ ); set_callbacks( E_(Open), E_(Close) ); add_shortcut( "vcd" ); add_shortcut( "vcdx" ); /* Configuration options */ add_integer ( MODULE_STRING "-debug", 0, E_(DebugCallback), N_("If nonzero, this gives additional debug information."), DEBUG_LONGTEXT, VLC_TRUE ); add_bool( MODULE_STRING "-PBC", 0, NULL, N_("Use playback control?"), N_("If VCD is authored with playback control, use it. " "Otherwise we play by tracks."), VLC_FALSE ); add_string( MODULE_STRING "-author-format", "%v - %F disc %c of %C", NULL, N_("Format to use in playlist \"author\""), VCD_TITLE_FMT_LONGTEXT, VLC_TRUE );
/***************************************************************************** * Open : creates a handle and opens an alsa device ***************************************************************************** * This function opens an alsa device, through the alsa API *****************************************************************************/ int E_(OpenAudio)( vlc_object_t *p_this ) { aout_instance_t *p_aout = (aout_instance_t *)p_this; int i_ret; int i_bytes_per_sample; int i_nb_channels; snd_pcm_channel_info_t pi; snd_pcm_channel_params_t pp; aout_instance_t *p_aout = (aout_instance_t *)p_this; /* allocate structure */ p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) ); if( p_aout->output.p_sys == NULL ) { msg_Err( p_aout, "out of memory" ); return -1; } /* open audio device */ if( ( i_ret = snd_pcm_open_preferred( &p_aout->output.p_sys->p_pcm_handle, &p_aout->output.p_sys->i_card, &p_aout->output.p_sys->i_device, SND_PCM_OPEN_PLAYBACK ) ) < 0 ) { msg_Err( p_aout, "unable to open audio device (%s)", snd_strerror( i_ret ) ); free( p_aout->output.p_sys ); return -1; } /* disable mmap */ if( ( i_ret = snd_pcm_plugin_set_disable( p_aout->output.p_sys->p_pcm_handle, PLUGIN_DISABLE_MMAP ) ) < 0 ) { msg_Err( p_aout, "unable to disable mmap (%s)", snd_strerror(i_ret) ); E_(CloseAudio)( p_this ); free( p_aout->output.p_sys ); return -1; } p_aout->output.p_sys->p_silent_buffer = malloc( DEFAULT_FRAME_SIZE * 4 ); p_aout->output.pf_play = Play; aout_VolumeSoftInit( p_aout ); memset( &pi, 0, sizeof(pi) ); memset( &pp, 0, sizeof(pp) ); pi.channel = SND_PCM_CHANNEL_PLAYBACK; if( ( i_ret = snd_pcm_plugin_info( p_aout->output.p_sys->p_pcm_handle, &pi ) ) < 0 ) { msg_Err( p_aout, "unable to get plugin info (%s)", snd_strerror( i_ret ) ); E_(CloseAudio)( p_this ); free( p_aout->output.p_sys ); return -1; } pp.mode = SND_PCM_MODE_BLOCK; pp.channel = SND_PCM_CHANNEL_PLAYBACK; pp.start_mode = SND_PCM_START_FULL; pp.stop_mode = SND_PCM_STOP_STOP; pp.buf.block.frags_max = 3; pp.buf.block.frags_min = 1; pp.format.interleave = 1; pp.format.rate = p_aout->output.output.i_rate; i_nb_channels = aout_FormatNbChannels( &p_aout->output.output ); if ( i_nb_channels > 2 ) { /* I don't know if QNX supports more than two channels. */ i_nb_channels = 2; p_aout->output.output.i_channels = AOUT_CHAN_STEREO; } pp.format.voices = i_nb_channels; p_aout->output.output.i_format = AOUT_FMT_S16_NE; p_aout->output.i_nb_samples = DEFAULT_FRAME_SIZE; pp.format.format = SND_PCM_SFMT_S16; i_bytes_per_sample = 2; pp.buf.block.frag_size = p_aout->output.i_nb_samples * p_aout->output.output.i_channels * i_bytes_per_sample; /* set parameters */ if( ( i_ret = snd_pcm_plugin_params( p_aout->output.p_sys->p_pcm_handle, &pp ) ) < 0 ) { msg_Err( p_aout, "unable to set parameters (%s)", snd_strerror(i_ret) ); E_(CloseAudio)( p_this ); free( p_aout->output.p_sys ); return -1; } /* prepare channel */ if( ( i_ret = snd_pcm_plugin_prepare( p_aout->output.p_sys->p_pcm_handle, SND_PCM_CHANNEL_PLAYBACK ) ) < 0 ) { msg_Err( p_aout, "unable to prepare channel (%s)", snd_strerror( i_ret ) ); E_(CloseAudio)( p_this ); free( p_aout->output.p_sys ); return -1; } /* Create audio thread and wait for its readiness. */ if( vlc_thread_create( p_aout, "aout", QNXaoutThread, VLC_THREAD_PRIORITY_OUTPUT, VLC_FALSE ) ) { msg_Err( p_aout, "cannot create QNX audio thread (%s)", strerror(errno) ); E_(CloseAudio)( p_this ); free( p_aout->output.p_sys ); return -1; } return( 0 ); }
/***************************************************************************** * Manage: manage main thread messages ***************************************************************************** * In this function, called approx. 10 times a second, we check what the * main program wanted to tell us. *****************************************************************************/ static int Manage( intf_thread_t *p_intf ) { GtkListStore *p_liststore; vlc_mutex_lock( &p_intf->change_lock ); /* Update the input */ if( p_intf->p_sys->p_input == NULL ) { p_intf->p_sys->p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE ); } else if( p_intf->p_sys->p_input->b_dead ) { vlc_object_release( p_intf->p_sys->p_input ); p_intf->p_sys->p_input = NULL; } if( p_intf->p_sys->p_input ) { input_thread_t *p_input = p_intf->p_sys->p_input; int64_t i_time = 0, i_length = 0; vlc_mutex_lock( &p_input->object_lock ); if( !p_input->b_die ) { playlist_t *p_playlist; E_(GtkModeManage)( p_intf ); p_intf->p_sys->b_playing = 1; /* update playlist interface */ p_playlist = (playlist_t *) vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); if (p_playlist != NULL) { p_liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_liststore, p_playlist); gtk_tree_view_set_model(p_intf->p_sys->p_tvplaylist, (GtkTreeModel*) p_liststore); g_object_unref(p_liststore); vlc_object_release( p_playlist ); } /* Manage the slider */ i_time = var_GetTime( p_intf->p_sys->p_input, "time" ); i_length = var_GetTime( p_intf->p_sys->p_input, "length" ); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) { /* Manage the slider for CPU_CAPABILITY_FPU hardware */ if( p_intf->p_sys->b_playing ) { float newvalue = p_intf->p_sys->p_adj->value; /* If the user hasn't touched the slider since the last time, * then the input can safely change it */ if( newvalue == p_intf->p_sys->f_adj_oldvalue ) { /* Update the value */ p_intf->p_sys->p_adj->value = p_intf->p_sys->f_adj_oldvalue = ( 100 * i_time ) / i_length; g_signal_emit_by_name( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed" ); } /* Otherwise, send message to the input if the user has * finished dragging the slider */ else if( p_intf->p_sys->b_slider_free ) { double f_pos = (double)newvalue / 100.0; /* release the lock to be able to seek */ vlc_mutex_unlock( &p_input->object_lock ); var_SetFloat( p_input, "position", f_pos ); vlc_mutex_lock( &p_input->object_lock ); /* Update the old value */ p_intf->p_sys->f_adj_oldvalue = newvalue; } } } else { /* Manage the slider without CPU_CAPABILITY_FPU hardware */ if( p_intf->p_sys->b_playing ) { off_t newvalue = p_intf->p_sys->p_adj->value; /* If the user hasn't touched the slider since the last time, * then the input can safely change it */ if( newvalue == p_intf->p_sys->i_adj_oldvalue ) { /* Update the value */ p_intf->p_sys->p_adj->value = p_intf->p_sys->i_adj_oldvalue = ( 100 * i_time ) / i_length; g_signal_emit_by_name( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed" ); } /* Otherwise, send message to the input if the user has * finished dragging the slider */ else if( p_intf->p_sys->b_slider_free ) { double f_pos = (double)newvalue / 100.0; /* release the lock to be able to seek */ vlc_mutex_unlock( &p_input->object_lock ); var_SetFloat( p_input, "position", f_pos ); vlc_mutex_lock( &p_input->object_lock ); /* Update the old value */ p_intf->p_sys->i_adj_oldvalue = newvalue; } } } } vlc_mutex_unlock( &p_input->object_lock ); } else if( p_intf->p_sys->b_playing && !p_intf->b_die ) { E_(GtkModeManage)( p_intf ); p_intf->p_sys->b_playing = 0; } #ifndef NEED_GTK2_MAIN if( p_intf->b_die ) { vlc_mutex_unlock( &p_intf->change_lock ); /* Prepare to die, young Skywalker */ gtk_main_quit(); return FALSE; } #endif vlc_mutex_unlock( &p_intf->change_lock ); return TRUE; }
static int Demux( demux_t *p_demux ) { mtime_t i_duration = -1; char *psz_name = NULL; char *psz_line; char *psz_mrl = NULL; char *psz_key; char *psz_value; playlist_t *p_playlist; int i_position; int i_item = -1; int i_new_item = 0; int i_key_length; playlist_item_t *p_parent; vlc_bool_t b_play; p_playlist = (playlist_t *) vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); if( !p_playlist ) { msg_Err( p_demux, "can't find playlist" ); return -1; } b_play = E_(FindItem)( p_demux, p_playlist, &p_parent ); p_parent->input.i_type = ITEM_TYPE_PLAYLIST; /* Change the item to a node */ if( p_parent->i_children == -1) { playlist_ItemToNode( p_playlist,p_parent ); } while( ( psz_line = stream_ReadLine( p_demux->s ) ) ) { if( !strncasecmp( psz_line, "[playlist]", sizeof("[playlist]")-1 ) ) { free( psz_line ); continue; } psz_key = psz_line; psz_value = strchr( psz_line, '=' ); if( psz_value ) { *psz_value='\0'; psz_value++; } else { msg_Warn( p_demux, "invalid line in pls file" ); free( psz_line ); continue; } if( !strcasecmp( psz_key, "version" ) ) { msg_Dbg( p_demux, "pls file version: %s", psz_value ); free( psz_line ); continue; } /* find the number part of of file1, title1 or length1 etc */ i_key_length = strlen( psz_key ); if( i_key_length >= 5 ) /* file1 type case */ { i_new_item = atoi( psz_key + 4 ); if( i_new_item == 0 && i_key_length >= 6 ) /* title1 type case */ { i_new_item = atoi( psz_key + 5 ); if( i_new_item == 0 && i_key_length >= 7 ) /* length1 type case */ { i_new_item = atoi( psz_key + 6 ); } } } if( i_new_item == 0 ) { msg_Warn( p_demux, "couldn't find number of items" ); free( psz_line ); continue; } if( i_item == -1 ) { i_item = i_new_item; } /* we found a new item, insert the previous */ if( i_item != i_new_item ) { if( psz_mrl ) { playlist_item_t *p_item = playlist_ItemNew( p_playlist, psz_mrl, psz_name ); playlist_NodeAddItem( p_playlist,p_item, p_parent->pp_parents[0]->i_view, p_parent, PLAYLIST_APPEND, PLAYLIST_END ); playlist_CopyParents( p_parent, p_item ); if( i_duration != -1 ) { //playlist_SetDuration( p_playlist, i_position, i_duration ); } i_position++; free( psz_mrl ); psz_mrl = NULL; vlc_input_item_CopyOptions( &p_parent->input, &p_item->input ); } else { msg_Warn( p_demux, "no file= part found for item %d", i_item ); } if( psz_name ) { free( psz_name ); psz_name = NULL; } i_duration = -1; i_item = i_new_item; i_new_item = 0; } if( !strncasecmp( psz_key, "file", sizeof("file") -1 ) ) { psz_mrl = E_(ProcessMRL)( psz_value, p_demux->p_sys->psz_prefix ); } else if( !strncasecmp( psz_key, "title", sizeof("title") -1 ) ) { psz_name = strdup( psz_value ); } else if( !strncasecmp( psz_key, "length", sizeof("length") -1 ) ) { i_duration = atoi( psz_value ); if( i_duration != -1 ) { i_duration *= 1000000; } } else { msg_Warn( p_demux, "unknown key found in pls file: %s", psz_key ); } free( psz_line ); } /* Add last object */ if( psz_mrl ) { playlist_item_t *p_item = playlist_ItemNew( p_playlist, psz_mrl, psz_name ); playlist_NodeAddItem( p_playlist,p_item, p_parent->pp_parents[0]->i_view, p_parent, PLAYLIST_APPEND, PLAYLIST_END ); playlist_CopyParents( p_parent, p_item ); if( i_duration != -1 ) { //playlist_SetDuration( p_playlist, i_position, i_duration ); } free( psz_mrl ); psz_mrl = NULL; vlc_input_item_CopyOptions( &p_parent->input, &p_item->input ); } else { msg_Warn( p_demux, "no file= part found for item %d", i_item ); } if( psz_name ) { free( psz_name ); psz_name = NULL; } if( b_play && p_playlist->status.p_item && p_playlist->status.p_item->i_children > 0 ) { playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, p_playlist->status.i_view, p_playlist->status.p_item, p_playlist->status.p_item->pp_children[0] ); } vlc_object_release( p_playlist ); 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 E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context, AVCodec *p_codec, int i_codec_id, char *psz_namecodec ) { decoder_sys_t *p_sys; vlc_value_t lockval; vlc_value_t val; var_Get( p_dec->p_libvlc, "avcodec", &lockval ); /* Allocate the memory needed to store the decoder's structure */ if( ( p_dec->p_sys = p_sys = (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL ) { msg_Err( p_dec, "out of memory" ); return VLC_EGENERIC; } p_dec->p_sys->p_context = p_context; p_dec->p_sys->p_codec = p_codec; p_dec->p_sys->i_codec_id = i_codec_id; p_dec->p_sys->psz_namecodec = psz_namecodec; p_sys->p_ff_pic = avcodec_alloc_frame(); /* ***** Fill p_context with init values ***** */ /* FIXME: remove when ffmpeg deals properly with avc1 */ if( p_dec->fmt_in.i_codec != VLC_FOURCC('a','v','c','1') ) /* End FIXME */ p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec ); p_sys->p_context->width = p_dec->fmt_in.video.i_width; p_sys->p_context->height = p_dec->fmt_in.video.i_height; p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel; /* ***** Get configuration of ffmpeg plugin ***** */ p_sys->p_context->workaround_bugs = config_GetInt( p_dec, "ffmpeg-workaround-bugs" ); p_sys->p_context->error_resilience = config_GetInt( p_dec, "ffmpeg-error-resilience" ); var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "grayscale", &val ); if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY; var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-vismv", &val ); #if LIBAVCODEC_BUILD >= 4698 if( val.i_int ) p_sys->p_context->debug_mv = val.i_int; #endif var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-lowres", &val ); #if LIBAVCODEC_BUILD >= 4723 if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int; #endif /* ***** ffmpeg frame skipping ***** */ var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-hurry-up", &val ); p_sys->b_hurry_up = val.b_bool; /* ***** ffmpeg direct rendering ***** */ p_sys->b_direct_rendering = 0; var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Get( p_dec, "ffmpeg-dr", &val ); if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) && ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) && /* Apparently direct rendering doesn't work with YUV422P */ p_sys->p_context->pix_fmt != PIX_FMT_YUV422P && /* H264 uses too many reference frames */ p_sys->i_codec_id != CODEC_ID_H264 && !(p_sys->p_context->width % 16) && !(p_sys->p_context->height % 16) && #if LIBAVCODEC_BUILD >= 4698 !p_sys->p_context->debug_mv ) #else 1 ) #endif { /* 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 = 1; } #ifdef LIBAVCODEC_PP p_sys->p_pp = NULL; p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = VLC_FALSE; p_sys->p_pp = E_(OpenPostproc)( p_dec, &p_sys->b_pp_async ); #endif /* ffmpeg doesn't properly release old pictures when frames are skipped */ //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0; if( p_sys->b_direct_rendering ) { msg_Dbg( p_dec, "using direct rendering" ); p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE; } /* 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->release_buffer = ffmpeg_ReleaseFrameBuf; p_sys->p_context->opaque = p_dec; /* ***** init this codec with special data ***** */ if( p_dec->fmt_in.i_extra ) { int i_size = p_dec->fmt_in.i_extra; if( p_sys->i_codec_id == CODEC_ID_SVQ3 ) { uint8_t *p; p_sys->p_context->extradata_size = i_size + 12; p = p_sys->p_context->extradata = malloc( p_sys->p_context->extradata_size ); memcpy( &p[0], "SVQ3", 4 ); memset( &p[4], 0, 8 ); memcpy( &p[12], p_dec->fmt_in.p_extra, i_size ); /* Now remove all atoms before the SMI one */ if( p_sys->p_context->extradata_size > 0x5a && strncmp( &p[0x56], "SMI ", 4 ) ) { uint8_t *psz = &p[0x52]; while( psz < &p[p_sys->p_context->extradata_size - 8] ) { int i_size = GetDWBE( psz ); if( i_size <= 1 ) { /* FIXME handle 1 as long size */ break; } if( !strncmp( &psz[4], "SMI ", 4 ) ) { memmove( &p[0x52], psz, &p[p_sys->p_context->extradata_size] - psz ); break; } psz += i_size; } } } else if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '0' ) || p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '3' ) || p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '2', '0' ) ) { if( p_dec->fmt_in.i_extra == 8 ) { p_sys->p_context->extradata_size = 8; p_sys->p_context->extradata = malloc( 8 ); memcpy( p_sys->p_context->extradata, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra ); p_sys->p_context->sub_id= ((uint32_t*)p_dec->fmt_in.p_extra)[1]; msg_Warn( p_dec, "using extra data for RV codec sub_id=%08x", p_sys->p_context->sub_id ); } } /* FIXME: remove when ffmpeg deals properly with avc1 */ else if( p_dec->fmt_in.i_codec == VLC_FOURCC('a','v','c','1') ) { ; } /* End FIXME */ else { p_sys->p_context->extradata_size = i_size; p_sys->p_context->extradata = malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE ); memcpy( p_sys->p_context->extradata, p_dec->fmt_in.p_extra, i_size ); memset( &((uint8_t*)p_sys->p_context->extradata)[i_size], 0, FF_INPUT_BUFFER_PADDING_SIZE ); } } /* ***** misc init ***** */ p_sys->input_pts = p_sys->input_dts = 0; p_sys->i_pts = 0; p_sys->b_has_b_frames = VLC_FALSE; p_sys->b_first_frame = VLC_TRUE; p_sys->i_late_frames = 0; p_sys->i_buffer = 0; p_sys->i_buffer_orig = 1; p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig ); /* Set output properties */ p_dec->fmt_out.i_cat = VIDEO_ES; p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt ); /* Setup palette */ #if LIBAVCODEC_BUILD >= 4688 if( p_dec->fmt_in.video.p_palette ) p_sys->p_context->palctrl = (AVPaletteControl *)p_dec->fmt_in.video.p_palette; else p_sys->p_context->palctrl = &palette_control; #endif /* ***** Open the codec ***** */ vlc_mutex_lock( lockval.p_address ); if( avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0 ) { vlc_mutex_unlock( lockval.p_address ); msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec ); free( p_sys ); return VLC_EGENERIC; } vlc_mutex_unlock( lockval.p_address ); msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec ); return VLC_SUCCESS; }
/* Returns a new picture buffer */ static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec, AVCodecContext *p_context ) { decoder_sys_t *p_sys = p_dec->p_sys; picture_t *p_pic; p_dec->fmt_out.video.i_width = p_context->width; p_dec->fmt_out.video.i_height = p_context->height; p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt ); if( !p_context->width || !p_context->height ) { return NULL; /* invalid display size */ } if( !p_dec->fmt_out.i_codec ) { /* we make conversion if possible*/ p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0'); } /* If an aspect-ratio was specified in the input format then force it */ if( p_dec->fmt_in.video.i_aspect ) { p_dec->fmt_out.video.i_aspect = p_dec->fmt_in.video.i_aspect; } else { #if LIBAVCODEC_BUILD >= 4687 p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * ( av_q2d(p_context->sample_aspect_ratio) * p_context->width / p_context->height ); #else p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_context->aspect_ratio; #endif if( p_dec->fmt_out.video.i_aspect == 0 ) { p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_context->width / p_context->height; } } if( p_context->frame_rate > 0 && p_context->frame_rate_base > 0 ) { p_dec->fmt_out.video.i_frame_rate = p_context->frame_rate; p_dec->fmt_out.video.i_frame_rate_base = p_context->frame_rate_base; } p_pic = p_dec->pf_vout_buffer_new( p_dec ); #ifdef LIBAVCODEC_PP if( p_sys->p_pp && p_sys->b_pp && !p_sys->b_pp_init ) { E_(InitPostproc)( p_dec, p_sys->p_pp, p_context->width, p_context->height, p_context->pix_fmt ); p_sys->b_pp_init = VLC_TRUE; } #endif return p_pic; }
void eqnsys<nr_type_t>::diagonalize_svd (void) { bool split; int i, l, j, its, k, n, MaxIters = 30; nr_double_t an, f, g, h, d, c, s, b, a; // find largest bidiagonal value for (an = 0, i = 0; i < N; i++) an = MAX (an, fabs (S_(i)) + fabs (E_(i))); // diagonalize the bidiagonal matrix (stored as super-diagonal // vector E and diagonal vector S) for (k = N - 1; k >= 0; k--) { // loop over singular values for (its = 0; its <= MaxIters; its++) { split = true; // check for a zero entry along the super-diagonal E, if there // is one, it is possible to QR iterate on two separate matrices // above and below it for (n = 0, l = k; l >= 1; l--) { // note that E_(0) is always zero n = l - 1; if (fabs (E_(l)) + an == an) { split = false; break; } if (fabs (S_(n)) + an == an) break; } // if there is a zero on the diagonal S, it is possible to zero // out the corresponding super-diagonal E entry to its right if (split) { // cancellation of E_(l), if l > 0 c = 0.0; s = 1.0; for (i = l; i <= k; i++) { f = -s * E_(i); E_(i) *= c; if (fabs (f) + an == an) break; g = S_(i); S_(i) = givens (f, g, c, s); // apply inverse rotation to U givens_apply_u (n, i, c, s); } } d = S_(k); // convergence if (l == k) { // singular value is made non-negative if (d < 0.0) { S_(k) = -d; for (j = 0; j < N; j++) V_(k, j) = -V_(k, j); } break; } if (its == MaxIters) { logprint (LOG_ERROR, "WARNING: no convergence in %d SVD iterations\n", MaxIters); } // shift from bottom 2-by-2 minor a = S_(l); n = k - 1; b = S_(n); g = E_(n); h = E_(k); // compute QR shift value (as close as possible to the largest // eigenvalue of the 2-by-2 minor matrix) f = (b - d) * (b + d) + (g - h) * (g + h); f /= 2.0 * h * b; f += sign_(f) * xhypot (f, 1.0); f = ((a - d) * (a + d) + h * (b / f - h)) / a; // f => (B_{ll}^2 - u) / B_{ll} // u => eigenvalue of T = B' * B nearer T_{22} (Wilkinson shift) // next QR transformation c = s = 1.0; for (j = l; j <= n; j++) { i = j + 1; g = E_(i); b = S_(i); h = s * g; // h => right-hand non-zero to annihilate g *= c; E_(j) = givens (f, h, c, s); // perform the rotation f = a * c + g * s; g = g * c - a * s; h = b * s; b *= c; // here: +- -+ // | f g | = B * V'_j (also first V'_1) // | h b | // +- -+ // accumulate the rotation in V' givens_apply_v (j, i, c, s); d = S_(j) = xhypot (f, h); // rotation can be arbitrary if d = 0 if (d != 0.0) { // d => non-zero result on diagonal d = 1.0 / d; // rotation coefficients to annihilate the lower non-zero c = f * d; s = h * d; } f = c * g + s * b; a = c * b - s * g; // here: +- -+ // | d f | => U_j * B // | 0 a | // +- -+ // accumulate rotation into U givens_apply_u (j, i, c, s); } E_(l) = 0; E_(k) = f; S_(k) = a; } } }
/***************************************************************************** * Demux: The important stuff *****************************************************************************/ static int Demux( demux_t *p_demux ) { playlist_t *p_playlist; char *psz_line; playlist_item_t *p_current; vlc_bool_t b_play; p_playlist = (playlist_t *) vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); if( !p_playlist ) { msg_Err( p_demux, "can't find playlist" ); return -1; } b_play = E_(FindItem)( p_demux, p_playlist, &p_current ); playlist_ItemToNode( p_playlist, p_current ); p_current->input.i_type = ITEM_TYPE_PLAYLIST; while( (psz_line = stream_ReadLine( p_demux->s )) ) { playlist_item_t *p_item; char **ppsz_options = NULL; int i, i_options = 0; char *psz_name = NULL; if( !ParseLine( psz_line, &psz_name, &ppsz_options, &i_options ) ) { free( psz_line ); continue; } EnsureUTF8( psz_name ); p_item = playlist_ItemNew( p_playlist, "dvb:", psz_name ); for( i = 0; i< i_options; i++ ) { EnsureUTF8( ppsz_options[i] ); playlist_ItemAddOption( p_item, ppsz_options[i] ); } playlist_NodeAddItem( p_playlist, p_item, p_current->pp_parents[0]->i_view, p_current, PLAYLIST_APPEND, PLAYLIST_END ); /* We need to declare the parents of the node as the * * same of the parent's ones */ playlist_CopyParents( p_current, p_item ); vlc_input_item_CopyOptions( &p_current->input, &p_item->input ); while( i_options-- ) free( ppsz_options[i_options] ); if( ppsz_options ) free( ppsz_options ); free( psz_line ); } /* Go back and play the playlist */ if( b_play && p_playlist->status.p_item && p_playlist->status.p_item->i_children > 0 ) { playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, p_playlist->status.i_view, p_playlist->status.p_item, p_playlist->status.p_item->pp_children[0] ); } vlc_object_release( p_playlist ); return VLC_SUCCESS; }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }