/***************************************************************************** * DecodeVideo: Called to decode one or more frames *****************************************************************************/ picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block ) { decoder_sys_t *p_sys = p_dec->p_sys; AVCodecContext *p_context = p_sys->p_context; int b_drawpicture; block_t *p_block; if( !pp_block ) return NULL; if( !p_context->extradata_size && p_dec->fmt_in.i_extra ) { ffmpeg_InitCodec( p_dec ); if( p_sys->b_delayed_open ) { if( ffmpeg_OpenCodec( p_dec ) ) msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec ); } } p_block = *pp_block; if(!p_block && !(p_sys->p_codec->capabilities & CODEC_CAP_DELAY) ) return NULL; if( p_sys->b_delayed_open ) { if( p_block ) block_Release( p_block ); return NULL; } if( p_block) { if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) ) { p_sys->i_pts = VLC_TS_INVALID; /* To make sure we recover properly */ p_sys->i_late_frames = 0; post_mt( p_sys ); if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY ) avcodec_flush_buffers( p_context ); wait_mt( p_sys ); block_Release( p_block ); return NULL; } if( p_block->i_flags & BLOCK_FLAG_PREROLL ) { /* Do not care about late frames when prerolling * TODO avoid decoding of non reference frame * (ie all B except for H264 where it depends only on nal_ref_idc) */ p_sys->i_late_frames = 0; } } if( !p_dec->b_pace_control && (p_sys->i_late_frames > 0) && (mdate() - p_sys->i_late_frames_start > INT64_C(5000000)) ) { if( p_sys->i_pts > VLC_TS_INVALID ) { p_sys->i_pts = VLC_TS_INVALID; /* To make sure we recover properly */ } if( p_block ) block_Release( p_block ); p_sys->i_late_frames--; msg_Err( p_dec, "more than 5 seconds of late video -> " "dropping frame (computer too slow ?)" ); return NULL; } /* A good idea could be to decode all I pictures and see for the other */ if( !p_dec->b_pace_control && p_sys->b_hurry_up && (p_sys->i_late_frames > 4) ) { b_drawpicture = 0; if( p_sys->i_late_frames < 12 ) { p_context->skip_frame = (p_sys->i_skip_frame <= AVDISCARD_NONREF) ? AVDISCARD_NONREF : p_sys->i_skip_frame; } else { /* picture too late, won't decode * but break picture until a new I, and for mpeg4 ...*/ p_sys->i_late_frames--; /* needed else it will never be decrease */ if( p_block ) block_Release( p_block ); msg_Warn( p_dec, "More than 4 late frames, dropping frame" ); return NULL; } } else { if( p_sys->b_hurry_up ) p_context->skip_frame = p_sys->i_skip_frame; if( !p_block || !(p_block->i_flags & BLOCK_FLAG_PREROLL) ) b_drawpicture = 1; else b_drawpicture = 0; } if( p_context->width <= 0 || p_context->height <= 0 ) { if( p_sys->b_hurry_up ) p_context->skip_frame = p_sys->i_skip_frame; } else if( !b_drawpicture ) { /* It creates broken picture * FIXME either our parser or ffmpeg is broken */ #if 0 if( p_sys->b_hurry_up ) p_context->skip_frame = __MAX( p_context->skip_frame, AVDISCARD_NONREF ); #endif } /* * Do the actual decoding now */ /* Don't forget that libavcodec requires a little more bytes * that the real frame size */ if( p_block && p_block->i_buffer > 0 ) { p_sys->b_flush = ( p_block->i_flags & BLOCK_FLAG_END_OF_SEQUENCE ) != 0; p_block = block_Realloc( p_block, 0, p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE ); if( !p_block ) return NULL; p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE; *pp_block = p_block; memset( p_block->p_buffer + p_block->i_buffer, 0, FF_INPUT_BUFFER_PADDING_SIZE ); } while( !p_block || p_block->i_buffer > 0 || p_sys->b_flush ) { int i_used, b_gotpicture; picture_t *p_pic; AVPacket pkt; post_mt( p_sys ); av_init_packet( &pkt ); if( p_block ) { pkt.data = p_block->p_buffer; pkt.size = p_block->i_buffer; pkt.pts = p_block->i_pts; pkt.dts = p_block->i_dts; } else { /* Return delayed frames if codec has CODEC_CAP_DELAY */ pkt.data = NULL; pkt.size = 0; } if( !p_sys->palette_sent ) { uint8_t *pal = av_packet_new_side_data(&pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE); if (pal) { memcpy(pal, p_dec->fmt_in.video.p_palette->palette, AVPALETTE_SIZE); p_sys->palette_sent = true; } } /* Make sure we don't reuse the same timestamps twice */ if( p_block ) { p_block->i_pts = p_block->i_dts = VLC_TS_INVALID; } i_used = avcodec_decode_video2( p_context, p_sys->p_ff_pic, &b_gotpicture, &pkt ); wait_mt( p_sys ); if( p_sys->b_flush ) p_sys->b_first_frame = true; if( p_block ) { if( p_block->i_buffer <= 0 ) p_sys->b_flush = false; if( i_used < 0 ) { if( b_drawpicture ) msg_Warn( p_dec, "cannot decode one frame (%zu bytes)", p_block->i_buffer ); block_Release( p_block ); return NULL; } else if( (unsigned)i_used > p_block->i_buffer || p_context->thread_count > 1 ) { i_used = p_block->i_buffer; } /* Consumed bytes */ p_block->i_buffer -= i_used; p_block->p_buffer += i_used; } /* Nothing to display */ if( !b_gotpicture ) { if( i_used == 0 ) break; continue; } /* Sanity check (seems to be needed for some streams) */ if( p_sys->p_ff_pic->pict_type == AV_PICTURE_TYPE_B) { p_sys->b_has_b_frames = true; } /* Compute the PTS */ mtime_t i_pts = p_sys->p_ff_pic->pkt_pts; if (i_pts <= VLC_TS_INVALID) i_pts = p_sys->p_ff_pic->pkt_dts; if( i_pts <= VLC_TS_INVALID ) i_pts = p_sys->i_pts; /* Interpolate the next PTS */ if( i_pts > VLC_TS_INVALID ) p_sys->i_pts = i_pts; if( p_sys->i_pts > VLC_TS_INVALID ) { /* interpolate the next PTS */ if( p_dec->fmt_in.video.i_frame_rate > 0 && p_dec->fmt_in.video.i_frame_rate_base > 0 ) { p_sys->i_pts += CLOCK_FREQ * (2 + p_sys->p_ff_pic->repeat_pict) * p_dec->fmt_in.video.i_frame_rate_base / (2 * p_dec->fmt_in.video.i_frame_rate); } else if( p_context->time_base.den > 0 ) { int i_tick = p_context->ticks_per_frame; if( i_tick <= 0 ) i_tick = 1; p_sys->i_pts += CLOCK_FREQ * (2 + p_sys->p_ff_pic->repeat_pict) * i_tick * p_context->time_base.num / (2 * p_context->time_base.den); } } /* Update frame late count (except when doing preroll) */ mtime_t i_display_date = 0; if( !p_block || !(p_block->i_flags & BLOCK_FLAG_PREROLL) ) i_display_date = decoder_GetDisplayDate( p_dec, i_pts ); if( i_display_date > 0 && i_display_date <= mdate() ) { p_sys->i_late_frames++; if( p_sys->i_late_frames == 1 ) p_sys->i_late_frames_start = mdate(); } else { p_sys->i_late_frames = 0; } if( !b_drawpicture || ( !p_sys->p_va && !p_sys->p_ff_pic->linesize[0] ) ) continue; if( p_sys->p_va != NULL || p_sys->p_ff_pic->opaque == NULL ) { /* Get a new picture */ p_pic = ffmpeg_NewPictBuf( p_dec, p_context ); if( !p_pic ) { if( p_block ) block_Release( p_block ); return NULL; } /* Fill p_picture_t from AVVideoFrame and do chroma conversion * if needed */ ffmpeg_CopyPicture( p_dec, p_pic, p_sys->p_ff_pic ); } else { p_pic = (picture_t *)p_sys->p_ff_pic->opaque; decoder_LinkPicture( p_dec, p_pic ); } if( !p_dec->fmt_in.video.i_sar_num || !p_dec->fmt_in.video.i_sar_den ) { /* Fetch again the aspect ratio in case it changed */ p_dec->fmt_out.video.i_sar_num = p_context->sample_aspect_ratio.num; p_dec->fmt_out.video.i_sar_den = p_context->sample_aspect_ratio.den; if( !p_dec->fmt_out.video.i_sar_num || !p_dec->fmt_out.video.i_sar_den ) { p_dec->fmt_out.video.i_sar_num = 1; p_dec->fmt_out.video.i_sar_den = 1; } } /* Send decoded frame to vout */ if( i_pts > VLC_TS_INVALID) { p_pic->date = i_pts; if( p_sys->b_first_frame ) { /* Hack to force display of still pictures */ p_sys->b_first_frame = false; p_pic->b_force = true; } p_pic->i_nb_fields = 2 + p_sys->p_ff_pic->repeat_pict; p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame; p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first; return p_pic; } else { decoder_DeletePicture( p_dec, p_pic ); } } if( p_block ) block_Release( p_block ); return NULL; }
/***************************************************************************** * Render: place string in picture ***************************************************************************** * This function merges the previously rendered freetype glyphs into a picture *****************************************************************************/ static void Render( filter_t *p_filter, subpicture_t *p_spu, subpicture_data_t *p_string ) { filter_sys_t *p_sys = p_filter->p_sys; line_desc_t *p_line; uint8_t *p_y, *p_u, *p_v, *p_a; video_format_t fmt; int i, x, y, i_pitch; /* Create a new subpicture region */ memset( &fmt, 0, sizeof(video_format_t) ); fmt.i_chroma = VLC_FOURCC('Y','U','V','A'); fmt.i_aspect = VOUT_ASPECT_FACTOR; fmt.i_width = fmt.i_visible_width = p_string->i_width + 2; fmt.i_height = fmt.i_visible_height = p_string->i_height + 2; fmt.i_x_offset = fmt.i_y_offset = 0; p_spu->p_region = p_spu->pf_create_region( VLC_OBJECT(p_filter), &fmt ); if( !p_spu->p_region ) { msg_Err( p_filter, "cannot allocate SPU region" ); return; } p_spu->p_region->i_x = p_spu->p_region->i_y = 0; p_y = p_spu->p_region->picture.Y_PIXELS; p_u = p_spu->p_region->picture.U_PIXELS; p_v = p_spu->p_region->picture.V_PIXELS; p_a = p_spu->p_region->picture.A_PIXELS; i_pitch = p_spu->p_region->picture.Y_PITCH; /* Initialize the region pixels (only the alpha will be changed later) */ memset( p_y, 0x00, i_pitch * p_spu->p_region->fmt.i_height ); memset( p_u, 0x80, i_pitch * p_spu->p_region->fmt.i_height ); memset( p_v, 0x80, i_pitch * p_spu->p_region->fmt.i_height ); memset( p_a, 0x00, i_pitch * p_spu->p_region->fmt.i_height ); #define pi_gamma p_sys->pi_gamma for( p_line = p_string->p_lines; p_line != NULL; p_line = p_line->p_next ) { int i_glyph_tmax = 0; int i_bitmap_offset, i_offset; for( i = 0; p_line->pp_glyphs[i] != NULL; i++ ) { FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ]; i_glyph_tmax = __MAX( i_glyph_tmax, p_glyph->top ); } for( i = 0; p_line->pp_glyphs[i] != NULL; i++ ) { FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ]; i_offset = ( p_line->p_glyph_pos[ i ].y + i_glyph_tmax - p_glyph->top + 1 ) * i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 1; for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ ) { for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ ) { if( !pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]] ) continue; i_offset -= i_pitch; p_a[i_offset + x] = ((uint16_t)p_a[i_offset + x] + pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]])/2; i_offset += i_pitch; x--; p_a[i_offset + x] = ((uint16_t)p_a[i_offset + x] + pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]])/2; x += 2; p_a[i_offset + x] = ((uint16_t)p_a[i_offset + x] + pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]])/2; i_offset += i_pitch; x--; p_a[i_offset + x] = ((uint16_t)p_a[i_offset + x] + pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]])/2; i_offset -= i_pitch; } i_offset += i_pitch; } i_offset = ( p_line->p_glyph_pos[ i ].y + i_glyph_tmax - p_glyph->top + 1 ) * i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 1; for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ ) { for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ ) { p_y[i_offset + x] = pi_gamma[p_glyph->bitmap.buffer[i_bitmap_offset]]; } i_offset += i_pitch; } #undef pi_gamma } } }
/***************************************************************************** * aout_InputNew : allocate a new input and rework the filter pipeline *****************************************************************************/ int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input, const aout_request_vout_t *p_request_vout ) { audio_sample_format_t chain_input_format; audio_sample_format_t chain_output_format; vlc_value_t val, text; char *psz_filters, *psz_visual, *psz_scaletempo; int i_visual; aout_FormatPrint( p_aout, "input", &p_input->input ); p_input->i_nb_resamplers = p_input->i_nb_filters = 0; /* Prepare FIFO. */ aout_FifoInit( p_aout, &p_input->mixer.fifo, p_aout->mixer_format.i_rate ); p_input->mixer.begin = NULL; /* */ if( p_request_vout ) { p_input->request_vout = *p_request_vout; } else { p_input->request_vout.pf_request_vout = RequestVout; p_input->request_vout.p_private = p_aout; } /* Prepare format structure */ chain_input_format = p_input->input; chain_output_format = p_aout->mixer_format; chain_output_format.i_rate = p_input->input.i_rate; aout_FormatPrepare( &chain_output_format ); /* Now add user filters */ if( var_Type( p_aout, "visual" ) == 0 ) { var_Create( p_aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE ); text.psz_string = _("Visualizations"); var_Change( p_aout, "visual", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; text.psz_string = _("Disable"); var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); val.psz_string = (char*)"spectrometer"; text.psz_string = _("Spectrometer"); var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); val.psz_string = (char*)"scope"; text.psz_string = _("Scope"); var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); val.psz_string = (char*)"spectrum"; text.psz_string = _("Spectrum"); var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); val.psz_string = (char*)"vuMeter"; text.psz_string = _("Vu meter"); var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); /* Look for goom plugin */ if( module_exists( "goom" ) ) { val.psz_string = (char*)"goom"; text.psz_string = (char*)"Goom"; var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); } /* Look for libprojectM plugin */ if( module_exists( "projectm" ) ) { val.psz_string = (char*)"projectm"; text.psz_string = (char*)"projectM"; var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text ); } if( var_Get( p_aout, "effect-list", &val ) == VLC_SUCCESS ) { var_SetString( p_aout, "visual", val.psz_string ); free( val.psz_string ); } var_AddCallback( p_aout, "visual", VisualizationCallback, NULL ); } if( var_Type( p_aout, "equalizer" ) == 0 ) { module_config_t *p_config; int i; p_config = config_FindConfig( VLC_OBJECT(p_aout), "equalizer-preset" ); if( p_config && p_config->i_list ) { var_Create( p_aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE ); text.psz_string = _("Equalizer"); var_Change( p_aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; text.psz_string = _("Disable"); var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text ); for( i = 0; i < p_config->i_list; i++ ) { val.psz_string = (char *)p_config->ppsz_list[i]; text.psz_string = (char *)p_config->ppsz_list_text[i]; var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text ); } var_AddCallback( p_aout, "equalizer", EqualizerCallback, NULL ); } } if( var_Type( p_aout, "audio-filter" ) == 0 ) { var_Create( p_aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); text.psz_string = _("Audio filters"); var_Change( p_aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL ); } if( var_Type( p_aout, "audio-visual" ) == 0 ) { var_Create( p_aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); text.psz_string = _("Audio visualizations"); var_Change( p_aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL ); } if( var_Type( p_aout, "audio-replay-gain-mode" ) == 0 ) { module_config_t *p_config; int i; p_config = config_FindConfig( VLC_OBJECT(p_aout), "audio-replay-gain-mode" ); if( p_config && p_config->i_list ) { var_Create( p_aout, "audio-replay-gain-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); text.psz_string = _("Replay gain"); var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL ); for( i = 0; i < p_config->i_list; i++ ) { val.psz_string = (char *)p_config->ppsz_list[i]; text.psz_string = (char *)p_config->ppsz_list_text[i]; var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE, &val, &text ); } var_AddCallback( p_aout, "audio-replay-gain-mode", ReplayGainCallback, NULL ); } } if( var_Type( p_aout, "audio-replay-gain-preamp" ) == 0 ) { var_Create( p_aout, "audio-replay-gain-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); } if( var_Type( p_aout, "audio-replay-gain-default" ) == 0 ) { var_Create( p_aout, "audio-replay-gain-default", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); } if( var_Type( p_aout, "audio-replay-gain-peak-protection" ) == 0 ) { var_Create( p_aout, "audio-replay-gain-peak-protection", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); } if( var_Type( p_aout, "audio-time-stretch" ) == 0 ) { var_Create( p_aout, "audio-time-stretch", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); } psz_filters = var_GetString( p_aout, "audio-filter" ); psz_visual = var_GetString( p_aout, "audio-visual"); psz_scaletempo = var_GetBool( p_aout, "audio-time-stretch" ) ? strdup( "scaletempo" ) : NULL; p_input->b_recycle_vout = psz_visual && *psz_visual; /* parse user filter lists */ char *const ppsz_array[] = { psz_scaletempo, psz_filters, psz_visual }; p_input->p_playback_rate_filter = NULL; for( i_visual = 0; i_visual < 3 && !AOUT_FMT_NON_LINEAR(&chain_output_format); i_visual++ ) { char *psz_next = NULL; char *psz_parser = ppsz_array[i_visual]; if( psz_parser == NULL || !*psz_parser ) continue; while( psz_parser && *psz_parser ) { filter_t * p_filter = NULL; if( p_input->i_nb_filters >= AOUT_MAX_FILTERS ) { msg_Dbg( p_aout, "max filters reached (%d)", AOUT_MAX_FILTERS ); break; } while( *psz_parser == ' ' && *psz_parser == ':' ) { psz_parser++; } if( ( psz_next = strchr( psz_parser , ':' ) ) ) { *psz_next++ = '\0'; } if( *psz_parser =='\0' ) { break; } /* Create a VLC object */ static const char typename[] = "audio filter"; p_filter = vlc_custom_create( p_aout, sizeof(*p_filter), VLC_OBJECT_GENERIC, typename ); if( p_filter == NULL ) { msg_Err( p_aout, "cannot add user filter %s (skipped)", psz_parser ); psz_parser = psz_next; continue; } vlc_object_attach( p_filter , p_aout ); p_filter->p_owner = malloc( sizeof(*p_filter->p_owner) ); p_filter->p_owner->p_aout = p_aout; p_filter->p_owner->p_input = p_input; /* request format */ memcpy( &p_filter->fmt_in.audio, &chain_output_format, sizeof(audio_sample_format_t) ); p_filter->fmt_in.i_codec = chain_output_format.i_format; memcpy( &p_filter->fmt_out.audio, &chain_output_format, sizeof(audio_sample_format_t) ); p_filter->fmt_out.i_codec = chain_output_format.i_format; p_filter->pf_audio_buffer_new = aout_FilterBufferNew; /* try to find the requested filter */ if( i_visual == 2 ) /* this can only be a visualization module */ { p_filter->p_module = module_need( p_filter, "visualization2", psz_parser, true ); } else /* this can be a audio filter module as well as a visualization module */ { p_filter->p_module = module_need( p_filter, "audio filter", psz_parser, true ); if ( p_filter->p_module == NULL ) { /* if the filter requested a special format, retry */ if ( !( AOUT_FMTS_IDENTICAL( &p_filter->fmt_in.audio, &chain_input_format ) && AOUT_FMTS_IDENTICAL( &p_filter->fmt_out.audio, &chain_output_format ) ) ) { aout_FormatPrepare( &p_filter->fmt_in.audio ); aout_FormatPrepare( &p_filter->fmt_out.audio ); p_filter->p_module = module_need( p_filter, "audio filter", psz_parser, true ); } /* try visual filters */ else { memcpy( &p_filter->fmt_in.audio, &chain_output_format, sizeof(audio_sample_format_t) ); memcpy( &p_filter->fmt_out.audio, &chain_output_format, sizeof(audio_sample_format_t) ); p_filter->p_module = module_need( p_filter, "visualization2", psz_parser, true ); } } } /* failure */ if ( p_filter->p_module == NULL ) { msg_Err( p_aout, "cannot add user filter %s (skipped)", psz_parser ); free( p_filter->p_owner ); vlc_object_release( p_filter ); psz_parser = psz_next; continue; } /* complete the filter chain if necessary */ if ( !AOUT_FMTS_IDENTICAL( &chain_input_format, &p_filter->fmt_in.audio ) ) { if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters, &p_input->i_nb_filters, &chain_input_format, &p_filter->fmt_in.audio ) < 0 ) { msg_Err( p_aout, "cannot add user filter %s (skipped)", psz_parser ); module_unneed( p_filter, p_filter->p_module ); free( p_filter->p_owner ); vlc_object_release( p_filter ); psz_parser = psz_next; continue; } } /* success */ p_input->pp_filters[p_input->i_nb_filters++] = p_filter; memcpy( &chain_input_format, &p_filter->fmt_out.audio, sizeof( audio_sample_format_t ) ); if( i_visual == 0 ) /* scaletempo */ p_input->p_playback_rate_filter = p_filter; /* next filter if any */ psz_parser = psz_next; } } free( psz_visual ); free( psz_filters ); free( psz_scaletempo ); /* complete the filter chain if necessary */ if ( !AOUT_FMTS_IDENTICAL( &chain_input_format, &chain_output_format ) ) { if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters, &p_input->i_nb_filters, &chain_input_format, &chain_output_format ) < 0 ) { inputFailure( p_aout, p_input, "couldn't set an input pipeline" ); return -1; } } /* Prepare hints for the buffer allocator. */ p_input->input_alloc.b_alloc = true; p_input->input_alloc.i_bytes_per_sec = -1; /* Create resamplers. */ if ( !AOUT_FMT_NON_LINEAR( &p_aout->mixer_format ) ) { chain_output_format.i_rate = (__MAX(p_input->input.i_rate, p_aout->mixer_format.i_rate) * (100 + AOUT_MAX_RESAMPLING)) / 100; if ( chain_output_format.i_rate == p_aout->mixer_format.i_rate ) { /* Just in case... */ chain_output_format.i_rate++; } if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_resamplers, &p_input->i_nb_resamplers, &chain_output_format, &p_aout->mixer_format ) < 0 ) { inputFailure( p_aout, p_input, "couldn't set a resampler pipeline"); return -1; } aout_FiltersHintBuffers( p_aout, p_input->pp_resamplers, p_input->i_nb_resamplers, &p_input->input_alloc ); p_input->input_alloc.b_alloc = true; /* Setup the initial rate of the resampler */ p_input->pp_resamplers[0]->fmt_in.audio.i_rate = p_input->input.i_rate; } p_input->i_resampling_type = AOUT_RESAMPLING_NONE; if( ! p_input->p_playback_rate_filter && p_input->i_nb_resamplers > 0 ) { p_input->p_playback_rate_filter = p_input->pp_resamplers[0]; } aout_FiltersHintBuffers( p_aout, p_input->pp_filters, p_input->i_nb_filters, &p_input->input_alloc ); p_input->input_alloc.b_alloc = true; /* i_bytes_per_sec is still == -1 if no filters */ p_input->input_alloc.i_bytes_per_sec = __MAX( p_input->input_alloc.i_bytes_per_sec, (int)(p_input->input.i_bytes_per_frame * p_input->input.i_rate / p_input->input.i_frame_length) ); ReplayGainSelect( p_aout, p_input ); /* Success */ p_input->b_error = false; p_input->i_last_input_rate = INPUT_RATE_DEFAULT; return 0; }
static int CdTextParse( vlc_meta_t ***ppp_tracks, int *pi_tracks, const uint8_t *p_buffer, int i_buffer ) { char *pppsz_info[128][0x10]; int i_track_last = -1; if( i_buffer < 4 ) return -1; memset( pppsz_info, 0, sizeof(pppsz_info) ); for( int i = 0; i < (i_buffer-4)/18; i++ ) { const uint8_t *p_block = &p_buffer[4 + 18*i]; char psz_text[12+1]; const int i_pack_type = p_block[0]; if( i_pack_type < 0x80 || i_pack_type > 0x8f ) continue; const int i_track_number = (p_block[1] >> 0)&0x7f; const int i_extension_flag = ( p_block[1] >> 7)& 0x01; if( i_extension_flag ) continue; //const int i_sequence_number = p_block[2]; //const int i_charater_position = (p_block[3] >> 0) &0x0f; //const int i_block_number = (p_block[3] >> 4) &0x07; /* TODO unicode support * I need a sample */ //const int i_unicode = ( p_block[3] >> 7)&0x01; //const int i_crc = (p_block[4+12] << 8) | (p_block[4+13] << 0); /* */ memcpy( psz_text, &p_block[4], 12 ); psz_text[12] = '\0'; /* */ int i_track = i_track_number; char *psz_track = &psz_text[0]; while( i_track <= 127 && psz_track < &psz_text[12] ) { //fprintf( stderr, "t=%d psz_track=%p end=%p", i_track, psz_track, &psz_text[12] ); if( *psz_track ) { astrcat( &pppsz_info[i_track][i_pack_type-0x80], psz_track ); i_track_last = __MAX( i_track_last, i_track ); } i_track++; psz_track += 1 + strlen(psz_track); } } if( i_track_last < 0 ) return -1; vlc_meta_t **pp_tracks = calloc( i_track_last+1, sizeof(*pp_tracks) ); if( !pp_tracks ) goto exit; for( int j = 0; j < 0x10; j++ ) { for( int i = 0; i <= i_track_last; i++ ) { /* */ if( pppsz_info[i][j] ) EnsureUTF8( pppsz_info[i][j] ); /* */ const char *psz_default = pppsz_info[0][j]; const char *psz_value = pppsz_info[i][j]; if( !psz_value && !psz_default ) continue; vlc_meta_t *p_track = pp_tracks[i]; if( !p_track ) { p_track = pp_tracks[i] = vlc_meta_New(); if( !p_track ) continue; } switch( j ) { case 0x00: /* Album/Title */ if( i == 0 ) { vlc_meta_SetAlbum( p_track, psz_value ); } else { if( psz_value ) vlc_meta_SetTitle( p_track, psz_value ); if( psz_default ) vlc_meta_SetAlbum( p_track, psz_default ); } break; case 0x01: /* Performer */ vlc_meta_SetArtist( p_track, psz_value ? psz_value : psz_default ); break; case 0x05: /* Messages */ vlc_meta_SetDescription( p_track, psz_value ? psz_value : psz_default ); break; case 0x07: /* Genre */ vlc_meta_SetGenre( p_track, psz_value ? psz_value : psz_default ); break; /* FIXME unsupported: * 0x02: songwriter * 0x03: composer * 0x04: arrenger * 0x06: disc id */ } } } /* */ exit: for( int j = 0; j < 0x10; j++ ) for( int i = 0; i <= i_track_last; i++ ) free( pppsz_info[i][j] ); *ppp_tracks = pp_tracks; *pi_tracks = i_track_last+1; return pp_tracks ? 0 : -1; }
static bool r_overlap( const rectangle_t *a, const rectangle_t *b, int i_dx, int i_dy ) { return __MAX(a->x0-i_dx, b->x0) < __MIN( a->x1+i_dx, b->x1 ) && __MAX(a->y0-i_dy, b->y0) < __MIN( a->y1+i_dy, b->y1 ); }
/**************************************************************************** * Seek command parsing handling ****************************************************************************/ void HandleSeek( intf_thread_t *p_intf, char *p_value ) { intf_sys_t *p_sys = p_intf->p_sys; vlc_value_t val; int i_stock = 0; uint64_t i_length; int i_value = 0; int i_relative = 0; #define POSITION_ABSOLUTE 12 #define POSITION_REL_FOR 13 #define POSITION_REL_BACK 11 #define VL_TIME_ABSOLUTE 0 #define VL_TIME_REL_FOR 1 #define VL_TIME_REL_BACK -1 if( p_sys->p_input ) { var_Get( p_sys->p_input, "length", &val ); i_length = val.i_time; while( p_value[0] != '\0' ) { switch(p_value[0]) { case '+': { i_relative = VL_TIME_REL_FOR; p_value++; break; } case '-': { i_relative = VL_TIME_REL_BACK; p_value++; break; } case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { i_stock = strtol( p_value , &p_value , 10 ); break; } case '%': /* for percentage ie position */ { i_relative += POSITION_ABSOLUTE; i_value = i_stock; i_stock = 0; p_value[0] = '\0'; break; } case ':': { i_value = 60 * (i_value + i_stock) ; i_stock = 0; p_value++; break; } case 'h': case 'H': /* hours */ { i_value += 3600 * i_stock; i_stock = 0; /* other characters which are not numbers are not * important */ while( ((p_value[0] < '0') || (p_value[0] > '9')) && (p_value[0] != '\0') ) { p_value++; } break; } case 'm': case 'M': case '\'': /* minutes */ { i_value += 60 * i_stock; i_stock = 0; p_value++; while( ((p_value[0] < '0') || (p_value[0] > '9')) && (p_value[0] != '\0') ) { p_value++; } break; } case 's': case 'S': case '"': /* seconds */ { i_value += i_stock; i_stock = 0; while( ((p_value[0] < '0') || (p_value[0] > '9')) && (p_value[0] != '\0') ) { p_value++; } break; } default: { p_value++; break; } } } /* if there is no known symbol, I consider it as seconds. * Otherwise, i_stock = 0 */ i_value += i_stock; switch(i_relative) { case VL_TIME_ABSOLUTE: { if( (uint64_t)( i_value ) * 1000000 <= i_length ) val.i_time = (uint64_t)( i_value ) * 1000000; else val.i_time = i_length; var_Set( p_sys->p_input, "time", val ); msg_Dbg( p_intf, "requested seek position: %dsec", i_value ); break; } case VL_TIME_REL_FOR: { var_Get( p_sys->p_input, "time", &val ); if( (uint64_t)( i_value ) * 1000000 + val.i_time <= i_length ) { val.i_time = ((uint64_t)( i_value ) * 1000000) + val.i_time; } else { val.i_time = i_length; } var_Set( p_sys->p_input, "time", val ); msg_Dbg( p_intf, "requested seek position forward: %dsec", i_value ); break; } case VL_TIME_REL_BACK: { var_Get( p_sys->p_input, "time", &val ); if( (int64_t)( i_value ) * 1000000 > val.i_time ) { val.i_time = 0; } else { val.i_time = val.i_time - ((uint64_t)( i_value ) * 1000000); } var_Set( p_sys->p_input, "time", val ); msg_Dbg( p_intf, "requested seek position backward: %dsec", i_value ); break; } case POSITION_ABSOLUTE: { val.f_float = __MIN( __MAX( ((float) i_value ) / 100.0 , 0.0 ), 100.0 ); var_Set( p_sys->p_input, "position", val ); msg_Dbg( p_intf, "requested seek percent: %d%%", i_value ); break; } case POSITION_REL_FOR: { var_Get( p_sys->p_input, "position", &val ); val.f_float += __MIN( __MAX( ((float) i_value ) / 100.0, 0.0 ) , 100.0 ); var_Set( p_sys->p_input, "position", val ); msg_Dbg( p_intf, "requested seek percent forward: %d%%", i_value ); break; } case POSITION_REL_BACK: { var_Get( p_sys->p_input, "position", &val ); val.f_float -= __MIN( __MAX( ((float) i_value ) / 100.0, 0.0 ) , 100.0 ); var_Set( p_sys->p_input, "position", val ); msg_Dbg( p_intf, "requested seek percent backward: %d%%", i_value ); break; } default: { msg_Dbg( p_intf, "invalid seek request" ); break; } } } #undef POSITION_ABSOLUTE #undef POSITION_REL_FOR #undef POSITION_REL_BACK #undef VL_TIME_ABSOLUTE #undef VL_TIME_REL_FOR #undef VL_TIME_REL_BACK }
/***************************************************************************** * Callback to update params on the fly *****************************************************************************/ static int MosaicCallback( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { VLC_UNUSED(oldval); filter_sys_t *p_sys = (filter_sys_t *) p_data; #define VAR_IS( a ) !strcmp( psz_var, CFG_PREFIX a ) if( VAR_IS( "alpha" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing alpha from %d/255 to %d/255", p_sys->i_alpha, (int)newval.i_int); p_sys->i_alpha = VLC_CLIP( newval.i_int, 0, 255 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "height" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing height from %dpx to %dpx", p_sys->i_height, (int)newval.i_int ); p_sys->i_height = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "width" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing width from %dpx to %dpx", p_sys->i_width, (int)newval.i_int ); p_sys->i_width = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "xoffset" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing x offset from %dpx to %dpx", p_sys->i_xoffset, (int)newval.i_int ); p_sys->i_xoffset = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "yoffset" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing y offset from %dpx to %dpx", p_sys->i_yoffset, (int)newval.i_int ); p_sys->i_yoffset = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "align" ) ) { int i_old = 0, i_new = 0; vlc_mutex_lock( &p_sys->lock ); newval.i_int = VLC_CLIP( newval.i_int, 0, 10 ); if( newval.i_int == 3 || newval.i_int == 7 ) newval.i_int = 5; while( pi_align_values[i_old] != p_sys->i_align ) i_old++; while( pi_align_values[i_new] != newval.i_int ) i_new++; msg_Dbg( p_this, "changing alignment from %d (%s) to %d (%s)", p_sys->i_align, ppsz_align_descriptions[i_old], (int)newval.i_int, ppsz_align_descriptions[i_new] ); p_sys->i_align = newval.i_int; vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "borderw" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing border width from %dpx to %dpx", p_sys->i_borderw, (int)newval.i_int ); p_sys->i_borderw = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "borderh" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing border height from %dpx to %dpx", p_sys->i_borderh, (int)newval.i_int ); p_sys->i_borderh = __MAX( newval.i_int, 0 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "position" ) ) { if( newval.i_int > 2 || newval.i_int < 0 ) { msg_Err( p_this, "Position is either 0 (%s), 1 (%s) or 2 (%s)", ppsz_pos_descriptions[0], ppsz_pos_descriptions[1], ppsz_pos_descriptions[2] ); } else { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing position method from %d (%s) to %d (%s)", p_sys->i_position, ppsz_pos_descriptions[p_sys->i_position], (int)newval.i_int, ppsz_pos_descriptions[newval.i_int]); p_sys->i_position = newval.i_int; vlc_mutex_unlock( &p_sys->lock ); } } else if( VAR_IS( "rows" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing number of rows from %d to %d", p_sys->i_rows, (int)newval.i_int ); p_sys->i_rows = __MAX( newval.i_int, 1 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "cols" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "changing number of columns from %d to %d", p_sys->i_cols, (int)newval.i_int ); p_sys->i_cols = __MAX( newval.i_int, 1 ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "order" ) ) { char *psz_order; int i_index; vlc_mutex_lock( &p_sys->lock ); msg_Dbg( p_this, "Changing mosaic order to %s", newval.psz_string ); psz_order = newval.psz_string; while( p_sys->i_order_length-- ) { free( p_sys->ppsz_order[p_sys->i_order_length] ); } free( p_sys->ppsz_order ); p_sys->ppsz_order = NULL; if( *psz_order ) { char *psz_end = NULL; i_index = 0; do { psz_end = strchr( psz_order, ',' ); i_index++; p_sys->ppsz_order = (char **)xrealloc( p_sys->ppsz_order, i_index * sizeof(char *) ); // sunqueen modify p_sys->ppsz_order[i_index - 1] = strndup( psz_order, psz_end - psz_order ); psz_order = psz_end+1; } while( psz_end ); p_sys->i_order_length = i_index; } vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "offsets" ) ) { vlc_mutex_lock( &p_sys->lock ); msg_Info( p_this, "Changing mosaic-offsets to %s", newval.psz_string ); if( p_sys->i_offsets_length != 0 ) { p_sys->i_offsets_length = 0; free( p_sys->pi_x_offsets ); free( p_sys->pi_y_offsets ); p_sys->pi_x_offsets = NULL; p_sys->pi_y_offsets = NULL; } mosaic_ParseSetOffsets( p_this, p_sys, newval.psz_string ); vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "keep-aspect-ratio" ) ) { vlc_mutex_lock( &p_sys->lock ); if( newval.i_int ) { msg_Dbg( p_this, "keeping aspect ratio" ); p_sys->b_ar = 1; } else { msg_Dbg( p_this, "won't keep aspect ratio" ); p_sys->b_ar = 0; } vlc_mutex_unlock( &p_sys->lock ); } else if( VAR_IS( "keep-picture" ) ) { vlc_mutex_lock( &p_sys->lock ); p_sys->b_keep = newval.b_bool; if ( !p_sys->b_keep && !p_sys->p_image ) { p_sys->p_image = image_HandlerCreate( p_this ); } vlc_mutex_unlock( &p_sys->lock ); } return VLC_SUCCESS; }
GenericBitmap *FT2Font::drawString( const UString &rString, uint32_t color, int maxWidth ) const { uint32_t code; int n; int penX = 0; int width1 = 0, width2 = 0; int yMin = 0, yMax = 0; uint32_t *pString = (uint32_t*)rString.u_str(); // Check if freetype has been initialized if( !m_face ) { return NULL; } // Get the length of the string int len = rString.length(); // Use fribidi if available #ifdef HAVE_FRIBIDI uint32_t *pFribidiString = NULL; if( len > 0 ) { pFribidiString = new uint32_t[len+1]; FriBidiCharType baseDir = FRIBIDI_TYPE_ON; fribidi_log2vis( (FriBidiChar*)pString, len, &baseDir, (FriBidiChar*)pFribidiString, 0, 0, 0 ); pString = pFribidiString; } #endif // Array of glyph bitmaps and position FT_BitmapGlyphRec **glyphs = new FT_BitmapGlyphRec*[len]; int *pos = new int[len]; // Does the font support kerning ? FT_Bool useKerning = FT_HAS_KERNING( m_face ); int previous = 0; // Index of the last glyph when the text is truncated with trailing ... int maxIndex = 0; // Position of the first trailing dot int firstDotX = 0; /// Get the dot glyph Glyph_t &dotGlyph = getGlyph( '.' ); // First, render all the glyphs for( n = 0; n < len; n++ ) { code = *(pString++); // Get the glyph for this character Glyph_t &glyph = getGlyph( code ); glyphs[n] = (FT_BitmapGlyphRec*)(glyph.m_glyph); // Retrieve kerning distance and move pen position if( useKerning && previous && glyph.m_index ) { FT_Vector delta; FT_Get_Kerning( m_face, previous, glyph.m_index, ft_kerning_default, &delta ); penX += delta.x >> 6; } pos[n] = penX; width1 = penX + glyph.m_size.xMax - glyph.m_size.xMin; yMin = __MIN( yMin, glyph.m_size.yMin ); yMax = __MAX( yMax, glyph.m_size.yMax ); // Next position penX += glyph.m_advance; // Save glyph index previous = glyph.m_index; if( maxWidth != -1 ) { // Check if the truncated text with the '...' fit in the maxWidth int curX = penX; if( useKerning ) { FT_Vector delta; FT_Get_Kerning( m_face, glyph.m_index, dotGlyph.m_index, ft_kerning_default, &delta ); curX += delta.x >> 6; } int dotWidth = 2 * dotGlyph.m_advance + dotGlyph.m_size.xMax - dotGlyph.m_size.xMin; if( curX + dotWidth < maxWidth ) { width2 = curX + dotWidth; maxIndex++; firstDotX = curX; } }
void PlListViewItemDelegate::paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const { QString title = VLCModel::getMeta( index, COLUMN_TITLE ); QString duration = VLCModel::getMeta( index, COLUMN_DURATION ); if( !duration.isEmpty() ) title += QString(" [%1]").arg( duration ); QString artist = VLCModel::getMeta( index, COLUMN_ARTIST ); QString album = VLCModel::getMeta( index, COLUMN_ALBUM ); QString trackNum = VLCModel::getMeta( index, COLUMN_TRACK_NUMBER ); QString artistAlbum = artist; if( !album.isEmpty() ) { if( !artist.isEmpty() ) artistAlbum += ": "; artistAlbum += album; if( !trackNum.isEmpty() ) artistAlbum += QString( " [#%1]" ).arg( trackNum ); } QPixmap artPix = VLCModel::getArtPixmap( index, QSize( LISTVIEW_ART_SIZE, LISTVIEW_ART_SIZE ) ); //Draw selection rectangle and current playing item indication paintBackground( painter, option, index ); QRect artRect( artPix.rect() ); artRect.moveCenter( QPoint( artRect.center().x() + 3, option.rect.center().y() ) ); //Draw album art painter->drawPixmap( artRect, artPix ); //Start drawing text painter->save(); if( option.state & QStyle::State_Selected ) painter->setPen( option.palette.color( QPalette::HighlightedText ) ); QTextOption textOpt( Qt::AlignVCenter | Qt::AlignLeft ); textOpt.setWrapMode( QTextOption::NoWrap ); QFont f( index.data( Qt::FontRole ).value<QFont>() ); //Draw title info f.setItalic( true ); f.setPointSize( __MAX( f.pointSize() + i_zoom, 4 ) ); f.setBold( index.data( PLModel::IsCurrentRole ).toBool() ); painter->setFont( f ); QFontMetrics fm( painter->fontMetrics() ); QRect textRect = option.rect.adjusted( LISTVIEW_ART_SIZE + 10, 0, -10, 0 ); if( !artistAlbum.isEmpty() ) { textRect.setHeight( fm.height() ); textRect.moveBottom( option.rect.center().y() - 2 ); } //Draw children indicator if( !index.data( PLModel::IsLeafNodeRole ).toBool() ) { QPixmap dirPix = QPixmap( ":/type/node" ); painter->drawPixmap( QPoint( textRect.x(), textRect.center().y() - dirPix.height() / 2 ), dirPix ); textRect.setLeft( textRect.x() + dirPix.width() + 5 ); } painter->drawText( textRect, fm.elidedText( title, Qt::ElideRight, textRect.width() ), textOpt ); // Draw artist and album info if( !artistAlbum.isEmpty() ) { f.setItalic( false ); painter->setFont( f ); fm = painter->fontMetrics(); textRect.moveTop( textRect.bottom() + 4 ); textRect.setLeft( textRect.x() + 20 ); painter->drawText( textRect, fm.elidedText( artistAlbum, Qt::ElideRight, textRect.width() ), textOpt ); } painter->restore(); }
static int AVI_ChunkRead_strf( stream_t *s, avi_chunk_t *p_chk ) { avi_chunk_t *p_strh; AVI_READCHUNK_ENTER; if( p_chk->common.p_father == NULL ) { msg_Err( (vlc_object_t*)s, "malformed avi file" ); AVI_READCHUNK_EXIT( VLC_EGENERIC ); } if( !( p_strh = AVI_ChunkFind( p_chk->common.p_father, AVIFOURCC_strh, 0 ) ) ) { msg_Err( (vlc_object_t*)s, "malformed avi file" ); AVI_READCHUNK_EXIT( VLC_EGENERIC ); } switch( p_strh->strh.i_type ) { case( AVIFOURCC_auds ): p_chk->strf.auds.i_cat = AUDIO_ES; p_chk->strf.auds.p_wf = xmalloc( __MAX( p_chk->common.i_chunk_size, sizeof( WAVEFORMATEX ) ) ); if ( !p_chk->strf.auds.p_wf ) { AVI_READCHUNK_EXIT( VLC_ENOMEM ); } AVI_READ2BYTES( p_chk->strf.auds.p_wf->wFormatTag ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->nChannels ); AVI_READ4BYTES( p_chk->strf.auds.p_wf->nSamplesPerSec ); AVI_READ4BYTES( p_chk->strf.auds.p_wf->nAvgBytesPerSec ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->nBlockAlign ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->wBitsPerSample ); if( p_chk->strf.auds.p_wf->wFormatTag != WAVE_FORMAT_PCM && p_chk->common.i_chunk_size > sizeof( WAVEFORMATEX ) ) { AVI_READ2BYTES( p_chk->strf.auds.p_wf->cbSize ); /* prevent segfault */ if( p_chk->strf.auds.p_wf->cbSize > p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX ) ) { p_chk->strf.auds.p_wf->cbSize = p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX ); } if( p_chk->strf.auds.p_wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE ) { msg_Dbg( s, "Extended header found" ); } } else { p_chk->strf.auds.p_wf->cbSize = 0; } if( p_chk->strf.auds.p_wf->cbSize > 0 ) { memcpy( &p_chk->strf.auds.p_wf[1] , p_buff + 8 + sizeof( WAVEFORMATEX ), /* 8=fourcc+size */ p_chk->strf.auds.p_wf->cbSize ); } #ifdef AVI_DEBUG msg_Dbg( (vlc_object_t*)s, "strf: audio:0x%4.4x channels:%d %dHz %dbits/sample %dkb/s", p_chk->strf.auds.p_wf->wFormatTag, p_chk->strf.auds.p_wf->nChannels, p_chk->strf.auds.p_wf->nSamplesPerSec, p_chk->strf.auds.p_wf->wBitsPerSample, p_chk->strf.auds.p_wf->nAvgBytesPerSec * 8 / 1024 ); #endif break; case( AVIFOURCC_vids ): p_strh->strh.i_samplesize = 0; /* XXX for ffmpeg avi file */ p_chk->strf.vids.i_cat = VIDEO_ES; p_chk->strf.vids.p_bih = xmalloc( __MAX( p_chk->common.i_chunk_size, sizeof( *p_chk->strf.vids.p_bih ) ) ); if ( !p_chk->strf.vids.p_bih ) { AVI_READCHUNK_EXIT( VLC_ENOMEM ); } AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSize ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biWidth ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biHeight ); AVI_READ2BYTES( p_chk->strf.vids.p_bih->biPlanes ); AVI_READ2BYTES( p_chk->strf.vids.p_bih->biBitCount ); AVI_READFOURCC( p_chk->strf.vids.p_bih->biCompression ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSizeImage ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biXPelsPerMeter ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biYPelsPerMeter ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrUsed ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrImportant ); if( p_chk->strf.vids.p_bih->biSize > p_chk->common.i_chunk_size ) { p_chk->strf.vids.p_bih->biSize = p_chk->common.i_chunk_size; } if ( p_chk->common.i_chunk_size > sizeof(VLC_BITMAPINFOHEADER) ) { uint64_t i_extrasize = p_chk->common.i_chunk_size - sizeof(VLC_BITMAPINFOHEADER); /* There's a color palette appended, set up VLC_BITMAPINFO */ memcpy( &p_chk->strf.vids.p_bih[1], p_buff + 8 + sizeof(VLC_BITMAPINFOHEADER), /* 8=fourrc+size */ i_extrasize ); if ( !p_chk->strf.vids.p_bih->biClrUsed ) p_chk->strf.vids.p_bih->biClrUsed = (1 << p_chk->strf.vids.p_bih->biBitCount); if( i_extrasize / sizeof(uint32_t) > UINT32_MAX ) p_chk->strf.vids.p_bih->biClrUsed = UINT32_MAX; else { p_chk->strf.vids.p_bih->biClrUsed = __MIN( i_extrasize / sizeof(uint32_t), p_chk->strf.vids.p_bih->biClrUsed ); } /* stay within VLC's limits */ p_chk->strf.vids.p_bih->biClrUsed = __MIN( VIDEO_PALETTE_COLORS_MAX, p_chk->strf.vids.p_bih->biClrUsed ); } else p_chk->strf.vids.p_bih->biClrUsed = 0; #ifdef AVI_DEBUG msg_Dbg( (vlc_object_t*)s, "strf: video:%4.4s %"PRIu32"x%"PRIu32" planes:%d %dbpp", (char*)&p_chk->strf.vids.p_bih->biCompression, (uint32_t)p_chk->strf.vids.p_bih->biWidth, (uint32_t)p_chk->strf.vids.p_bih->biHeight, p_chk->strf.vids.p_bih->biPlanes, p_chk->strf.vids.p_bih->biBitCount ); #endif break; case AVIFOURCC_iavs: case AVIFOURCC_ivas: p_chk->strf.common.i_cat = UNKNOWN_ES; break; case( AVIFOURCC_txts ): p_chk->strf.common.i_cat = SPU_ES; break; default: msg_Warn( (vlc_object_t*)s, "unknown stream type: %4.4s", (char*)&p_strh->strh.i_type ); p_chk->strf.common.i_cat = UNKNOWN_ES; break; } AVI_READCHUNK_EXIT( VLC_SUCCESS ); }
QFrame *AbstractController::telexFrame() { /** * Telextext QFrame **/ QFrame *telexFrame = new QFrame( this ); QHBoxLayout *telexLayout = new QHBoxLayout( telexFrame ); telexLayout->setSpacing( 0 ); telexLayout->setMargin( 0 ); CONNECT( THEMIM->getIM(), teletextPossible( bool ), telexFrame, setVisible( bool ) ); /* On/Off button */ QToolButton *telexOn = new QToolButton; setupButton( telexOn ); BUTTON_SET_BAR2( telexOn, toolbar/tv, qtr( "Teletext Activation" ) ); telexOn->setEnabled( false ); telexOn->setCheckable( true ); telexLayout->addWidget( telexOn ); /* Teletext Activation and set */ CONNECT( telexOn, clicked( bool ), THEMIM->getIM(), activateTeletext( bool ) ); CONNECT( THEMIM->getIM(), teletextPossible( bool ), telexOn, setEnabled( bool ) ); /* Transparency button */ QToolButton *telexTransparent = new QToolButton; setupButton( telexTransparent ); BUTTON_SET_BAR2( telexTransparent, toolbar/tvtelx, qtr( "Toggle Transparency " ) ); telexTransparent->setEnabled( false ); telexTransparent->setCheckable( true ); telexLayout->addWidget( telexTransparent ); /* Transparency change and set */ CONNECT( telexTransparent, clicked( bool ), THEMIM->getIM(), telexSetTransparency( bool ) ); CONNECT( THEMIM->getIM(), teletextTransparencyActivated( bool ), telexTransparent, setChecked( bool ) ); /* Page setting */ QSpinBox *telexPage = new QSpinBox( telexFrame ); telexPage->setRange( 100, 899 ); telexPage->setValue( 100 ); telexPage->setAccelerated( true ); telexPage->setWrapping( true ); telexPage->setAlignment( Qt::AlignRight ); telexPage->setSizePolicy( QSizePolicy::Preferred, QSizePolicy::Minimum ); telexPage->setEnabled( false ); telexLayout->addWidget( telexPage ); /* Contextual & Index Buttons */ QSignalMapper *contextButtonMapper = new QSignalMapper( this ); QToolButton *contextButton = NULL; int i_iconminsize = __MAX( 16, telexOn->minimumHeight() ); QPixmap iconPixmap( i_iconminsize, i_iconminsize ); iconPixmap.fill( Qt::transparent ); QPainter iconPixmapPainter( &iconPixmap ); QLinearGradient iconPixmapPainterGradient( iconPixmap.rect().center() / 2, iconPixmap.rect().center() ); #define CREATE_CONTEXT_BUTTON(color, key) \ iconPixmapPainterGradient.setColorAt( 0, QColor( color ).lighter(150) );\ iconPixmapPainterGradient.setColorAt( 1.0, QColor( color ) );\ iconPixmapPainter.setBrush( iconPixmapPainterGradient );\ iconPixmapPainter.drawEllipse( iconPixmap.rect().adjusted( 4, 4, -5, -5 ) );\ contextButton = new QToolButton();\ setupButton( contextButton );\ contextButton->setIcon( iconPixmap );\ contextButton->setEnabled( false );\ contextButtonMapper->setMapping( contextButton, key << 16 );\ CONNECT( contextButton, clicked(), contextButtonMapper, map() );\ CONNECT( contextButtonMapper, mapped( int ),\ THEMIM->getIM(), telexSetPage( int ) );\ CONNECT( THEMIM->getIM(), teletextActivated( bool ), contextButton, setEnabled( bool ) );\ telexLayout->addWidget( contextButton ) CREATE_CONTEXT_BUTTON("grey", 'i'); /* index */ CREATE_CONTEXT_BUTTON("red", 'r'); CREATE_CONTEXT_BUTTON("green", 'g'); CREATE_CONTEXT_BUTTON("yellow", 'y'); CREATE_CONTEXT_BUTTON("blue", 'b'); #undef CREATE_CONTEXT_BUTTON /* Page change and set */ CONNECT( telexPage, valueChanged( int ), THEMIM->getIM(), telexSetPage( int ) ); CONNECT( THEMIM->getIM(), newTelexPageSet( int ), telexPage, setValue( int ) ); CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexPage, setEnabled( bool ) ); CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexTransparent, setEnabled( bool ) ); CONNECT( THEMIM->getIM(), teletextActivated( bool ), telexOn, setChecked( bool ) ); return telexFrame; }
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic ) { picture_t *p_outpic; filter_sys_t *p_sys = p_filter->p_sys; const int i_dim = p_sys->i_dim; type_t *pt_buffer; type_t *pt_scale; const type_t *pt_distribution = p_sys->pt_distribution; if( !p_pic ) return NULL; p_outpic = filter_NewPicture( p_filter ); if( !p_outpic ) { picture_Release( p_pic ); return NULL; } if( !p_sys->pt_buffer ) { p_sys->pt_buffer = realloc_or_free( p_sys->pt_buffer, p_pic->p[Y_PLANE].i_visible_lines * p_pic->p[Y_PLANE].i_pitch * sizeof( type_t ) ); } pt_buffer = p_sys->pt_buffer; if( !p_sys->pt_scale ) { const int i_visible_lines = p_pic->p[Y_PLANE].i_visible_lines; const int i_visible_pitch = p_pic->p[Y_PLANE].i_visible_pitch; const int i_pitch = p_pic->p[Y_PLANE].i_pitch; p_sys->pt_scale = xmalloc( i_visible_lines * i_pitch * sizeof( type_t ) ); pt_scale = p_sys->pt_scale; for( int i_line = 0; i_line < i_visible_lines; i_line++ ) { for( int i_col = 0; i_col < i_visible_pitch; i_col++ ) { type_t t_value = 0; for( int y = __MAX( -i_dim, -i_line ); y <= __MIN( i_dim, i_visible_lines - i_line - 1 ); y++ ) { for( int x = __MAX( -i_dim, -i_col ); x <= __MIN( i_dim, i_visible_pitch - i_col + 1 ); x++ ) { t_value += pt_distribution[y+i_dim] * pt_distribution[x+i_dim]; } } pt_scale[i_line*i_pitch+i_col] = t_value; } } } pt_scale = p_sys->pt_scale; for( int i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ ) { uint8_t *p_in = p_pic->p[i_plane].p_pixels; uint8_t *p_out = p_outpic->p[i_plane].p_pixels; const int i_visible_lines = p_pic->p[i_plane].i_visible_lines; const int i_visible_pitch = p_pic->p[i_plane].i_visible_pitch; const int i_in_pitch = p_pic->p[i_plane].i_pitch; const int x_factor = p_pic->p[Y_PLANE].i_visible_pitch/i_visible_pitch-1; const int y_factor = p_pic->p[Y_PLANE].i_visible_lines/i_visible_lines-1; for( int i_line = 0; i_line < i_visible_lines; i_line++ ) { for( int i_col = 0; i_col < i_visible_pitch; i_col++ ) { type_t t_value = 0; const int c = i_line*i_in_pitch+i_col; for( int x = __MAX( -i_dim, -i_col*(x_factor+1) ); x <= __MIN( i_dim, (i_visible_pitch - i_col)*(x_factor+1) + 1 ); x++ ) { t_value += pt_distribution[x+i_dim] * p_in[c+(x>>x_factor)]; } pt_buffer[c] = t_value; } } for( int i_line = 0; i_line < i_visible_lines; i_line++ ) { for( int i_col = 0; i_col < i_visible_pitch; i_col++ ) { type_t t_value = 0; const int c = i_line*i_in_pitch+i_col; for( int y = __MAX( -i_dim, (-i_line)*(y_factor+1) ); y <= __MIN( i_dim, (i_visible_lines - i_line)*(y_factor+1) - 1 ); y++ ) { t_value += pt_distribution[y+i_dim] * pt_buffer[c+(y>>y_factor)*i_in_pitch]; } const type_t t_scale = pt_scale[(i_line<<y_factor)*(i_in_pitch<<x_factor)+(i_col<<x_factor)]; p_out[i_line * p_outpic->p[i_plane].i_pitch + i_col] = (uint8_t)(t_value / t_scale); // FIXME wouldn't it be better to round instead of trunc ? } } } return CopyInfoAndRelease( p_outpic, p_pic ); }
/***************************************************************************** * 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 = malloc( sizeof( filter_sys_t ) ); 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 = malloc( p_sys->i_length + 1 ); 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; }
static int64_t ControlGetTime( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; return __MAX(p_sys->i_pts, p_sys->i_pts_start) + p_sys->i_time_offset; }
static void transcode_video_encoder_init( sout_stream_t *p_stream, sout_stream_id_t *id ) { sout_stream_sys_t *p_sys = p_stream->p_sys; /* Calculate scaling * width/height of source */ int i_src_width = id->p_decoder->fmt_out.video.i_width; int i_src_height = id->p_decoder->fmt_out.video.i_height; /* with/height scaling */ float f_scale_width = 1; float f_scale_height = 1; /* width/height of output stream */ int i_dst_width; int i_dst_height; /* aspect ratio */ float f_aspect = (double)id->p_decoder->fmt_out.video.i_sar_num * id->p_decoder->fmt_out.video.i_width / id->p_decoder->fmt_out.video.i_sar_den / id->p_decoder->fmt_out.video.i_height; msg_Dbg( p_stream, "decoder aspect is %f:1", f_aspect ); /* Change f_aspect from source frame to source pixel */ f_aspect = f_aspect * i_src_height / i_src_width; msg_Dbg( p_stream, "source pixel aspect is %f:1", f_aspect ); /* Calculate scaling factor for specified parameters */ if( id->p_encoder->fmt_out.video.i_width <= 0 && id->p_encoder->fmt_out.video.i_height <= 0 && p_sys->f_scale ) { /* Global scaling. Make sure width will remain a factor of 16 */ float f_real_scale; int i_new_height; int i_new_width = i_src_width * p_sys->f_scale; if( i_new_width % 16 <= 7 && i_new_width >= 16 ) i_new_width -= i_new_width % 16; else i_new_width += 16 - i_new_width % 16; f_real_scale = (float)( i_new_width ) / (float) i_src_width; i_new_height = __MAX( 16, i_src_height * (float)f_real_scale ); f_scale_width = f_real_scale; f_scale_height = (float) i_new_height / (float) i_src_height; } else if( id->p_encoder->fmt_out.video.i_width > 0 && id->p_encoder->fmt_out.video.i_height <= 0 ) { /* Only width specified */ f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width; f_scale_height = f_scale_width; } else if( id->p_encoder->fmt_out.video.i_width <= 0 && id->p_encoder->fmt_out.video.i_height > 0 ) { /* Only height specified */ f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height; f_scale_width = f_scale_height; } else if( id->p_encoder->fmt_out.video.i_width > 0 && id->p_encoder->fmt_out.video.i_height > 0 ) { /* Width and height specified */ f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width; f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height; } /* check maxwidth and maxheight */ if( p_sys->i_maxwidth && f_scale_width > (float)p_sys->i_maxwidth / i_src_width ) { f_scale_width = (float)p_sys->i_maxwidth / i_src_width; } if( p_sys->i_maxheight && f_scale_height > (float)p_sys->i_maxheight / i_src_height ) { f_scale_height = (float)p_sys->i_maxheight / i_src_height; } /* Change aspect ratio from source pixel to scaled pixel */ f_aspect = f_aspect * f_scale_height / f_scale_width; msg_Dbg( p_stream, "scaled pixel aspect is %f:1", f_aspect ); /* f_scale_width and f_scale_height are now final */ /* Calculate width, height from scaling * Make sure its multiple of 2 */ i_dst_width = 2 * (int)(f_scale_width*i_src_width/2+0.5); i_dst_height = 2 * (int)(f_scale_height*i_src_height/2+0.5); /* Change aspect ratio from scaled pixel to output frame */ f_aspect = f_aspect * i_dst_width / i_dst_height; /* Store calculated values */ id->p_encoder->fmt_out.video.i_width = id->p_encoder->fmt_out.video.i_visible_width = i_dst_width; id->p_encoder->fmt_out.video.i_height = id->p_encoder->fmt_out.video.i_visible_height = i_dst_height; id->p_encoder->fmt_in.video.i_width = id->p_encoder->fmt_in.video.i_visible_width = i_dst_width; id->p_encoder->fmt_in.video.i_height = id->p_encoder->fmt_in.video.i_visible_height = i_dst_height; msg_Dbg( p_stream, "source %ix%i, destination %ix%i", i_src_width, i_src_height, i_dst_width, i_dst_height ); /* Handle frame rate conversion */ if( !id->p_encoder->fmt_out.video.i_frame_rate || !id->p_encoder->fmt_out.video.i_frame_rate_base ) { if( id->p_decoder->fmt_out.video.i_frame_rate && id->p_decoder->fmt_out.video.i_frame_rate_base ) { id->p_encoder->fmt_out.video.i_frame_rate = id->p_decoder->fmt_out.video.i_frame_rate; id->p_encoder->fmt_out.video.i_frame_rate_base = id->p_decoder->fmt_out.video.i_frame_rate_base; } else { /* Pick a sensible default value */ id->p_encoder->fmt_out.video.i_frame_rate = ENC_FRAMERATE; id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE; } } id->p_encoder->fmt_in.video.i_frame_rate = id->p_encoder->fmt_out.video.i_frame_rate; id->p_encoder->fmt_in.video.i_frame_rate_base = id->p_encoder->fmt_out.video.i_frame_rate_base; date_Init( &id->interpolated_pts, id->p_encoder->fmt_out.video.i_frame_rate, id->p_encoder->fmt_out.video.i_frame_rate_base ); /* Check whether a particular aspect ratio was requested */ if( id->p_encoder->fmt_out.video.i_sar_num <= 0 || id->p_encoder->fmt_out.video.i_sar_den <= 0 ) { vlc_ureduce( &id->p_encoder->fmt_out.video.i_sar_num, &id->p_encoder->fmt_out.video.i_sar_den, (uint64_t)id->p_decoder->fmt_out.video.i_sar_num * i_src_width * i_dst_height, (uint64_t)id->p_decoder->fmt_out.video.i_sar_den * i_src_height * i_dst_width, 0 ); } else { vlc_ureduce( &id->p_encoder->fmt_out.video.i_sar_num, &id->p_encoder->fmt_out.video.i_sar_den, id->p_encoder->fmt_out.video.i_sar_num, id->p_encoder->fmt_out.video.i_sar_den, 0 ); } id->p_encoder->fmt_in.video.i_sar_num = id->p_encoder->fmt_out.video.i_sar_num; id->p_encoder->fmt_in.video.i_sar_den = id->p_encoder->fmt_out.video.i_sar_den; msg_Dbg( p_stream, "encoder aspect is %i:%i", id->p_encoder->fmt_out.video.i_sar_num * id->p_encoder->fmt_out.video.i_width, id->p_encoder->fmt_out.video.i_sar_den * id->p_encoder->fmt_out.video.i_height ); id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec; }
void PlIconViewItemDelegate::paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const { QString title = VLCModel::getMeta( index, COLUMN_TITLE ); QString artist = VLCModel::getMeta( index, COLUMN_ARTIST ); QFont font( index.data( Qt::FontRole ).value<QFont>() ); font.setPointSize( __MAX( font.pointSize() + i_zoom, 4 ) ); font.setBold( index.data( PLModel::IsCurrentRole ).toBool() ); painter->setFont( font ); QFontMetrics fm = painter->fontMetrics(); int averagewidth = fm.averageCharWidth(); QSize rectSize = option.rect.size(); int art_width = averagewidth * ICON_SCALER; int art_height = averagewidth * ICON_SCALER; QPixmap artPix = VLCModel::getArtPixmap( index, QSize( art_width, art_height) ); paintBackground( painter, option, index ); painter->save(); QRect artRect( option.rect.x() + ( rectSize.width() - artPix.width() ) / 2, option.rect.y() - averagewidth*3 + ( rectSize.height() - artPix.height() ) / 2, artPix.width(), artPix.height() ); // Draw the drop shadow painter->save(); painter->setOpacity( 0.7 ); painter->setBrush( QBrush( Qt::darkGray ) ); painter->setPen( Qt::NoPen ); painter->drawRoundedRect( artRect.adjusted( 0, 0, 2, 2 ), ART_RADIUS, ART_RADIUS ); painter->restore(); // Draw the art pixmap QPainterPath artRectPath; artRectPath.addRoundedRect( artRect, ART_RADIUS, ART_RADIUS ); painter->setClipPath( artRectPath ); painter->drawPixmap( artRect, artPix ); painter->setClipping( false ); if( option.state & QStyle::State_Selected ) painter->setPen( option.palette.color( QPalette::HighlightedText ) ); //Draw children indicator if( !index.data( PLModel::IsLeafNodeRole ).toBool() ) { QRect r( option.rect ); r.setSize( QSize( 25, 25 ) ); r.translate( 5, 5 ); if( index.data( PLModel::IsCurrentsParentNodeRole ).toBool() ) { painter->setOpacity( 0.75 ); QPainterPath nodeRectPath; nodeRectPath.addRoundedRect( r, 4, 4 ); painter->fillPath( nodeRectPath, option.palette.color( QPalette::Highlight ) ); painter->setOpacity( 1.0 ); } QPixmap dirPix( ":/type/node" ); QRect r2( dirPix.rect() ); r2.moveCenter( r.center() ); painter->drawPixmap( r2, dirPix ); } // Draw title font.setItalic( true ); QRect textRect; textRect.setRect( option.rect.x() , artRect.bottom() + fm.height()/2, option.rect.width(), fm.height() ); painter->drawText( textRect, fm.elidedText( title, Qt::ElideRight, textRect.width() ), QTextOption( Qt::AlignCenter ) ); // Draw artist painter->setPen( painter->pen().color().lighter( 150 ) ); font.setItalic( false ); painter->setFont( font ); fm = painter->fontMetrics(); textRect.moveTop( textRect.bottom() + 1 ); painter->drawText( textRect, fm.elidedText( artist, Qt::ElideRight, textRect.width() ), QTextOption( Qt::AlignCenter ) ); painter->restore(); }
static int LayoutLine( filter_t *p_filter, paragraph_t *p_paragraph, int i_start_offset, int i_end_offset, line_desc_t **pp_line ) { if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0 || i_start_offset >= i_end_offset || i_start_offset < 0 || i_start_offset >= p_paragraph->i_size || i_end_offset <= 0 || i_end_offset > p_paragraph->i_size ) { msg_Err( p_filter, "LayoutLine() invalid parameters. " "Paragraph size: %d. Runs count: %d. " "Start offset: %d. End offset: %d", p_paragraph->i_size, p_paragraph->i_runs_count, i_start_offset, i_end_offset ); return VLC_EGENERIC; } line_desc_t *p_line = NewLine( i_end_offset - i_start_offset ); if( !p_line ) return VLC_ENOMEM; filter_sys_t *p_sys = p_filter->p_sys; int i_last_run = -1; run_desc_t *p_run = 0; text_style_t *p_style = 0; FT_Face p_face = 0; FT_Vector pen = { .x = 0, .y = 0 }; int i_line_index = 0; int i_font_width = 0; int i_ul_offset = 0; int i_ul_thickness = 0; #ifdef HAVE_FRIBIDI fribidi_reorder_line( 0, p_paragraph->p_types + i_start_offset, i_end_offset - i_start_offset, 0, p_paragraph->paragraph_type, p_paragraph->p_levels + i_start_offset, 0, p_paragraph->pi_reordered_indices + i_start_offset ); #endif for( int i = i_start_offset; i < i_end_offset; ++i, ++i_line_index ) { int i_paragraph_index; #ifdef HAVE_FRIBIDI i_paragraph_index = p_paragraph->pi_reordered_indices[ i ]; #else i_paragraph_index = i; #endif line_character_t *p_ch = p_line->p_character + i_line_index; glyph_bitmaps_t *p_bitmaps = p_paragraph->p_glyph_bitmaps + i_paragraph_index; if( !p_bitmaps->p_glyph ) { --i_line_index; continue; } if( i_last_run != p_paragraph->pi_run_ids[ i_paragraph_index ] ) { i_last_run = p_paragraph->pi_run_ids[ i_paragraph_index ]; p_run = p_paragraph->p_runs + i_last_run; p_style = p_run->p_style; p_face = p_run->p_face; i_font_width = p_style->i_style_flags & STYLE_HALFWIDTH ? p_style->i_font_size / 2 : p_style->i_font_size; } FT_Vector pen_new = { .x = pen.x + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_x_offset, .y = pen.y + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_y_offset }; FT_Vector pen_shadow = { .x = pen_new.x + p_sys->f_shadow_vector_x * ( i_font_width << 6 ), .y = pen_new.y + p_sys->f_shadow_vector_y * ( p_style->i_font_size << 6 ) }; if( p_bitmaps->p_shadow ) { if( FT_Glyph_To_Bitmap( &p_bitmaps->p_shadow, FT_RENDER_MODE_NORMAL, &pen_shadow, 0 ) ) p_bitmaps->p_shadow = 0; else FT_Glyph_Get_CBox( p_bitmaps->p_shadow, ft_glyph_bbox_pixels, &p_bitmaps->shadow_bbox ); } if( p_bitmaps->p_glyph ) { if( FT_Glyph_To_Bitmap( &p_bitmaps->p_glyph, FT_RENDER_MODE_NORMAL, &pen_new, 1 ) ) { FT_Done_Glyph( p_bitmaps->p_glyph ); if( p_bitmaps->p_outline ) FT_Done_Glyph( p_bitmaps->p_outline ); if( p_bitmaps->p_shadow ) FT_Done_Glyph( p_bitmaps->p_shadow ); --i_line_index; continue; } else FT_Glyph_Get_CBox( p_bitmaps->p_glyph, ft_glyph_bbox_pixels, &p_bitmaps->glyph_bbox ); } if( p_bitmaps->p_outline ) { if( FT_Glyph_To_Bitmap( &p_bitmaps->p_outline, FT_RENDER_MODE_NORMAL, &pen_new, 1 ) ) { FT_Done_Glyph( p_bitmaps->p_outline ); p_bitmaps->p_outline = 0; } else FT_Glyph_Get_CBox( p_bitmaps->p_outline, ft_glyph_bbox_pixels, &p_bitmaps->outline_bbox ); } FixGlyph( p_bitmaps->p_glyph, &p_bitmaps->glyph_bbox, p_bitmaps->i_x_advance, p_bitmaps->i_y_advance, &pen_new ); if( p_bitmaps->p_outline ) FixGlyph( p_bitmaps->p_outline, &p_bitmaps->outline_bbox, p_bitmaps->i_x_advance, p_bitmaps->i_y_advance, &pen_new ); if( p_bitmaps->p_shadow ) FixGlyph( p_bitmaps->p_shadow, &p_bitmaps->shadow_bbox, p_bitmaps->i_x_advance, p_bitmaps->i_y_advance, &pen_shadow ); int i_line_offset = 0; int i_line_thickness = 0; text_style_t *p_glyph_style = p_paragraph->pp_styles[ i_paragraph_index ]; if( p_glyph_style->i_style_flags & (STYLE_UNDERLINE | STYLE_STRIKEOUT) ) { i_line_offset = abs( FT_FLOOR( FT_MulFix( p_face->underline_position, p_face->size->metrics.y_scale ) ) ); i_line_thickness = abs( FT_CEIL( FT_MulFix( p_face->underline_thickness, p_face->size->metrics.y_scale ) ) ); if( p_glyph_style->i_style_flags & STYLE_STRIKEOUT ) { /* Move the baseline to make it strikethrough instead of * underline. That means that strikethrough takes precedence */ i_line_offset -= abs( FT_FLOOR( FT_MulFix( p_face->descender * 2, p_face->size->metrics.y_scale ) ) ); } else if( i_line_thickness > 0 ) { p_bitmaps->glyph_bbox.yMin = __MIN( p_bitmaps->glyph_bbox.yMin, - i_line_offset - i_line_thickness ); /* The real underline thickness and position are * updated once the whole line has been parsed */ i_ul_offset = __MAX( i_ul_offset, i_line_offset ); i_ul_thickness = __MAX( i_ul_thickness, i_line_thickness ); i_line_thickness = -1; } } p_ch->p_glyph = ( FT_BitmapGlyph ) p_bitmaps->p_glyph; p_ch->p_outline = ( FT_BitmapGlyph ) p_bitmaps->p_outline; p_ch->p_shadow = ( FT_BitmapGlyph ) p_bitmaps->p_shadow; bool b_karaoke = p_paragraph->pi_karaoke_bar[ i_paragraph_index ] != 0; p_ch->i_color = b_karaoke ? ( uint32_t ) p_glyph_style->i_karaoke_background_color | p_glyph_style->i_karaoke_background_alpha << 24 : ( uint32_t ) p_glyph_style->i_font_color | p_glyph_style->i_font_alpha << 24; p_ch->i_line_thickness = i_line_thickness; p_ch->i_line_offset = i_line_offset; BBoxEnlarge( &p_line->bbox, &p_bitmaps->glyph_bbox ); if( p_bitmaps->p_outline ) BBoxEnlarge( &p_line->bbox, &p_bitmaps->outline_bbox ); if( p_bitmaps->p_shadow ) BBoxEnlarge( &p_line->bbox, &p_bitmaps->shadow_bbox ); pen.x += p_bitmaps->i_x_advance; pen.y += p_bitmaps->i_y_advance; } p_line->i_width = __MAX( 0, p_line->bbox.xMax - p_line->bbox.xMin ); p_line->i_height = __MAX( 0, p_line->bbox.yMax - p_line->bbox.yMin ); p_line->i_character_count = i_line_index; if( i_ul_thickness > 0 ) { for( int i = 0; i < p_line->i_character_count; i++ ) { line_character_t *ch = &p_line->p_character[i]; if( ch->i_line_thickness < 0 ) { ch->i_line_offset = i_ul_offset; ch->i_line_thickness = i_ul_thickness; } } } *pp_line = p_line; return VLC_SUCCESS; } static int LayoutParagraph( filter_t *p_filter, paragraph_t *p_paragraph, int i_max_pixel_width, line_desc_t **pp_lines ) { if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0 ) { msg_Err( p_filter, "LayoutParagraph() invalid parameters. " "Paragraph size: %d. Runs count %d", p_paragraph->i_size, p_paragraph->i_runs_count ); return VLC_EGENERIC; } int i_line_start = 0; FT_Pos i_width = 0; FT_Pos i_max_width = i_max_pixel_width << 6; FT_Pos i_preferred_width = 0; FT_Pos i_total_width = 0; FT_Pos i_last_space_width = 0; int i_last_space = -1; line_desc_t *p_first_line = 0; line_desc_t **pp_line = &p_first_line; for( int i = 0; i < p_paragraph->i_size; ++i ) { #ifdef HAVE_FRIBIDI p_paragraph->pi_reordered_indices[ i ] = i; #endif i_total_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance; } int i_line_count = i_total_width / i_max_width + 1; i_preferred_width = i_total_width / i_line_count; for( int i = 0; i <= p_paragraph->i_size; ++i ) { if( i == p_paragraph->i_size ) { if( i_line_start < i ) if( LayoutLine( p_filter, p_paragraph, i_line_start, i, pp_line ) ) goto error; break; } if( p_paragraph->p_code_points[ i ] == ' ' #ifdef HAVE_FRIBIDI || p_paragraph->p_types[ i ] == FRIBIDI_TYPE_WS #endif ) { if( i_line_start == i ) { /* * Free orphaned white space glyphs not belonging to any lines. * At this point p_shadow points to either p_glyph or p_outline, * so we should not free it explicitly. */ if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph ) FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph ); if( p_paragraph->p_glyph_bitmaps[ i ].p_outline ) FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline ); i_line_start = i + 1; continue; } if( i_last_space == i - 1 ) { p_paragraph->p_glyph_bitmaps[ i - 1 ].i_x_advance = 0; i_last_space = i; continue; } i_last_space = i; i_last_space_width = i_width; } i_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance; if( i_last_space_width >= i_preferred_width || i_width >= i_max_width ) { if( i_line_start == i ) { msg_Err( p_filter, "LayoutParagraph(): Width of single glyph exceeds maximum" ); goto error; } int i_end_offset; if( i_last_space > i_line_start ) i_end_offset = i_last_space; else i_end_offset = i; if( LayoutLine( p_filter, p_paragraph, i_line_start, i_end_offset, pp_line ) ) goto error; pp_line = &( *pp_line )->p_next; i_line_start = i_end_offset; i = i_line_start - 1; i_width = 0; i_last_space_width = 0; } } *pp_lines = p_first_line; return VLC_SUCCESS; error: for( int i = i_line_start; i < p_paragraph->i_size; ++i ) { if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph ) FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph ); if( p_paragraph->p_glyph_bitmaps[ i ].p_outline ) FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline ); } if( p_first_line ) FreeLines( p_first_line ); return VLC_EGENERIC; } int LayoutText( filter_t *p_filter, line_desc_t **pp_lines, FT_BBox *p_bbox, int *pi_max_face_height, uni_char_t *psz_text, text_style_t **pp_styles, uint32_t *pi_k_dates, int i_len ) { line_desc_t *p_first_line = 0; line_desc_t **pp_line = &p_first_line; paragraph_t *p_paragraph = 0; int i_paragraph_start = 0; int i_max_height = 0; for( int i = 0; i <= i_len; ++i ) { if( i == i_len || psz_text[ i ] == '\n' ) { if( i_paragraph_start == i ) { i_paragraph_start = i + 1; continue; } p_paragraph = NewParagraph( p_filter, i - i_paragraph_start, psz_text + i_paragraph_start, pp_styles + i_paragraph_start, pi_k_dates ? pi_k_dates + i_paragraph_start : 0, 20 ); if( !p_paragraph ) { if( p_first_line ) FreeLines( p_first_line ); return VLC_ENOMEM; } #ifdef HAVE_FRIBIDI if( AnalyzeParagraph( p_paragraph ) ) goto error; #endif if( ItemizeParagraph( p_filter, p_paragraph ) ) goto error; #if defined HAVE_HARFBUZZ if( ShapeParagraphHarfBuzz( p_filter, &p_paragraph ) ) goto error; if( LoadGlyphs( p_filter, p_paragraph, true, false ) ) goto error; #elif defined HAVE_FRIBIDI if( ShapeParagraphFriBidi( p_filter, p_paragraph ) ) goto error; if( LoadGlyphs( p_filter, p_paragraph, false, true ) ) goto error; if( RemoveZeroWidthCharacters( p_paragraph ) ) goto error; if( ZeroNsmAdvance( p_paragraph ) ) goto error; #else if( LoadGlyphs( p_filter, p_paragraph, false, true ) ) goto error; #endif /* * Set max line width to allow for outline and shadow glyphs, * and any extra width caused by visual reordering */ int i_max_width = ( int ) p_filter->fmt_out.video.i_visible_width - 2 * p_filter->p_sys->style.i_font_size; if( LayoutParagraph( p_filter, p_paragraph, i_max_width, pp_line ) ) goto error; FreeParagraph( p_paragraph ); p_paragraph = 0; for( ; *pp_line; pp_line = &( *pp_line )->p_next ) i_max_height = __MAX( i_max_height, ( *pp_line )->i_height ); i_paragraph_start = i + 1; } } int i_base_line = 0; FT_BBox bbox = { .xMin = INT_MAX, .yMin = INT_MAX, .xMax = INT_MIN, .yMax = INT_MIN }; for( line_desc_t *p_line = p_first_line; p_line; p_line = p_line->p_next ) { p_line->i_base_line = i_base_line; p_line->bbox.yMin -= i_base_line; p_line->bbox.yMax -= i_base_line; BBoxEnlarge( &bbox, &p_line->bbox ); i_base_line += i_max_height; } *pp_lines = p_first_line; *p_bbox = bbox; *pi_max_face_height = i_max_height; return VLC_SUCCESS; error: if( p_first_line ) FreeLines( p_first_line ); if( p_paragraph ) FreeParagraph( p_paragraph ); return VLC_EGENERIC; }
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic ) { picture_t *p_outpic; filter_sys_t *p_sys = p_filter->p_sys; if( !p_pic ) return NULL; p_outpic = filter_NewPicture( p_filter ); if( !p_outpic ) { picture_Release( p_pic ); return NULL; } if( p_sys->p_motion != NULL ) { int i_angle = motion_get_angle( p_sys->p_motion ); store_trigo( p_sys, i_angle / 20.f ); } int i_sin, i_cos; fetch_trigo( p_sys, &i_sin, &i_cos ); for( int i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ ) { plane_t *p_srcp = &p_pic->p[i_plane]; plane_t *p_dstp = &p_outpic->p[i_plane]; const int i_visible_lines = p_srcp->i_visible_lines; const int i_visible_pitch = p_srcp->i_visible_pitch; const int i_aspect = __MAX( 1, ( i_visible_lines * p_pic->p[Y_PLANE].i_visible_pitch ) / ( p_pic->p[Y_PLANE].i_visible_lines * i_visible_pitch )); /* = 2 for U and V planes in YUV 4:2:2, = 1 otherwise */ const int i_line_center = i_visible_lines>>1; const int i_col_center = i_visible_pitch>>1; const uint8_t black_pixel = ( i_plane == Y_PLANE ) ? 0x00 : 0x80; const int i_line_next = i_cos / i_aspect -i_sin*i_visible_pitch; const int i_col_next = -i_sin / i_aspect -i_cos*i_visible_pitch; int i_line_orig0 = ( - i_cos * i_line_center / i_aspect - i_sin * i_col_center + (1<<11) ); int i_col_orig0 = i_sin * i_line_center / i_aspect - i_cos * i_col_center + (1<<11); for( int y = 0; y < i_visible_lines; y++) { uint8_t *p_out = &p_dstp->p_pixels[y * p_dstp->i_pitch]; for( int x = 0; x < i_visible_pitch; x++, p_out++ ) { const int i_line_orig = (i_line_orig0>>12)*i_aspect + i_line_center; const int i_col_orig = (i_col_orig0>>12) + i_col_center; const uint8_t *p_orig_offset = &p_srcp->p_pixels[i_line_orig * p_srcp->i_pitch + i_col_orig]; const uint8_t i_line_percent = (i_line_orig0>>4) & 255; const uint8_t i_col_percent = (i_col_orig0 >>4) & 255; if( -1 <= i_line_orig && i_line_orig < i_visible_lines && -1 <= i_col_orig && i_col_orig < i_visible_pitch ) { #define test 1 #undef test #ifdef test if( ( i_col_orig > i_visible_pitch/2 ) ) #endif { uint8_t i_curpix = black_pixel; uint8_t i_colpix = black_pixel; uint8_t i_linpix = black_pixel; uint8_t i_nexpix = black_pixel; if( ( 0 <= i_line_orig ) && ( 0 <= i_col_orig ) ) i_curpix = *p_orig_offset; p_orig_offset++; if( ( i_col_orig < i_visible_pitch - 1) && ( i_line_orig >= 0 ) ) i_colpix = *p_orig_offset; p_orig_offset += p_srcp->i_pitch; if( ( i_line_orig < i_visible_lines - 1) && ( i_col_orig < i_visible_pitch - 1) ) i_nexpix = *p_orig_offset; p_orig_offset--; if( ( i_line_orig < i_visible_lines - 1) && ( i_col_orig >= 0 ) ) i_linpix = *p_orig_offset; unsigned int temp = 0; temp+= i_curpix * (256 - i_line_percent) * ( 256 - i_col_percent ); temp+= i_linpix * i_line_percent * (256 - i_col_percent ); temp+= i_nexpix * ( i_col_percent) * ( i_line_percent); temp+= i_colpix * i_col_percent * (256 - i_line_percent ); *p_out = temp >> 16; } #ifdef test else if (i_col_orig == i_visible_pitch/2 ) { *p_out = black_pixel; } else *p_out = *p_orig_offset; #endif #undef test } else { *p_out = black_pixel; } i_line_orig0 += i_sin; i_col_orig0 += i_cos; }
static int AVI_ChunkRead_strf( stream_t *s, avi_chunk_t *p_chk ) { avi_chunk_t *p_strh; AVI_READCHUNK_ENTER; if( p_chk->common.p_father == NULL ) { msg_Err( (vlc_object_t*)s, "malformed avi file" ); AVI_READCHUNK_EXIT( VLC_EGENERIC ); } if( !( p_strh = AVI_ChunkFind( p_chk->common.p_father, AVIFOURCC_strh, 0 ) ) ) { msg_Err( (vlc_object_t*)s, "malformed avi file" ); AVI_READCHUNK_EXIT( VLC_EGENERIC ); } switch( p_strh->strh.i_type ) { case( AVIFOURCC_auds ): p_chk->strf.auds.i_cat = AUDIO_ES; p_chk->strf.auds.p_wf = malloc( __MAX( p_chk->common.i_chunk_size, sizeof( WAVEFORMATEX ) ) ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->wFormatTag ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->nChannels ); AVI_READ4BYTES( p_chk->strf.auds.p_wf->nSamplesPerSec ); AVI_READ4BYTES( p_chk->strf.auds.p_wf->nAvgBytesPerSec ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->nBlockAlign ); AVI_READ2BYTES( p_chk->strf.auds.p_wf->wBitsPerSample ); if( p_chk->strf.auds.p_wf->wFormatTag != WAVE_FORMAT_PCM && p_chk->common.i_chunk_size > sizeof( WAVEFORMATEX ) ) { AVI_READ2BYTES( p_chk->strf.auds.p_wf->cbSize ); /* prevent segfault */ if( p_chk->strf.auds.p_wf->cbSize > p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX ) ) { p_chk->strf.auds.p_wf->cbSize = p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX ); } if( p_chk->strf.auds.p_wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE ) { /* Found an extensible header atm almost nothing uses that. */ msg_Warn( (vlc_object_t*)s, "WAVE_FORMAT_EXTENSIBLE or " "vorbis audio dectected: not supported" ); } } else { p_chk->strf.auds.p_wf->cbSize = 0; } if( p_chk->strf.auds.p_wf->cbSize > 0 ) { memcpy( &p_chk->strf.auds.p_wf[1] , p_buff + 8 + sizeof( WAVEFORMATEX ), /* 8=fourrc+size */ p_chk->strf.auds.p_wf->cbSize ); } #ifdef AVI_DEBUG msg_Dbg( (vlc_object_t*)s, "strf: audio:0x%4.4x channels:%d %dHz %dbits/sample %dkb/s", p_chk->strf.auds.p_wf->wFormatTag, p_chk->strf.auds.p_wf->nChannels, p_chk->strf.auds.p_wf->nSamplesPerSec, p_chk->strf.auds.p_wf->wBitsPerSample, p_chk->strf.auds.p_wf->nAvgBytesPerSec * 8 / 1024 ); #endif break; case( AVIFOURCC_vids ): p_strh->strh.i_samplesize = 0; /* XXX for ffmpeg avi file */ p_chk->strf.vids.i_cat = VIDEO_ES; p_chk->strf.vids.p_bih = malloc( p_chk->common.i_chunk_size ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSize ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biWidth ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biHeight ); AVI_READ2BYTES( p_chk->strf.vids.p_bih->biPlanes ); AVI_READ2BYTES( p_chk->strf.vids.p_bih->biBitCount ); AVI_READFOURCC( p_chk->strf.vids.p_bih->biCompression ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSizeImage ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biXPelsPerMeter ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biYPelsPerMeter ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrUsed ); AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrImportant ); if( p_chk->strf.vids.p_bih->biSize > p_chk->common.i_chunk_size ) { p_chk->strf.vids.p_bih->biSize = p_chk->common.i_chunk_size; } if( p_chk->common.i_chunk_size - sizeof(BITMAPINFOHEADER) > 0 ) { memcpy( &p_chk->strf.vids.p_bih[1], p_buff + 8 + sizeof(BITMAPINFOHEADER), /* 8=fourrc+size */ p_chk->common.i_chunk_size -sizeof(BITMAPINFOHEADER) ); } #ifdef AVI_DEBUG msg_Dbg( (vlc_object_t*)s, "strf: video:%4.4s %"PRIu32"x%"PRIu32" planes:%d %dbpp", (char*)&p_chk->strf.vids.p_bih->biCompression, (uint32_t)p_chk->strf.vids.p_bih->biWidth, (uint32_t)p_chk->strf.vids.p_bih->biHeight, p_chk->strf.vids.p_bih->biPlanes, p_chk->strf.vids.p_bih->biBitCount ); #endif break; default: msg_Warn( (vlc_object_t*)s, "unknown stream type" ); p_chk->strf.common.i_cat = UNKNOWN_ES; break; } AVI_READCHUNK_EXIT( VLC_SUCCESS ); }
/***************************************************************************** * Run: main loop *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { intf_sys_t *p_sys = p_intf->p_sys; struct timeval timeout; char *psz_password; psz_password = config_GetPsz( p_intf, "telnet-password" ); while( !p_intf->b_die ) { fd_set fds_read, fds_write; int i_handle_max = 0; int i_ret, i_len, fd, i; /* if a new client wants to communicate */ fd = net_Accept( p_intf, p_sys->pi_fd, p_sys->i_clients > 0 ? 0 : -1 ); if( fd > 0 ) { telnet_client_t *cl; /* to be non blocking */ #if defined( WIN32 ) || defined( UNDER_CE ) { unsigned long i_dummy = 1; ioctlsocket( fd, FIONBIO, &i_dummy ); } #else fcntl( fd, F_SETFL, O_NONBLOCK ); #endif cl = malloc( sizeof( telnet_client_t )); cl->i_tel_cmd = 0; cl->fd = fd; cl->buffer_write = NULL; cl->p_buffer_write = cl->buffer_write; Write_message( cl, NULL, "Password: \xff\xfb\x01", WRITE_MODE_PWD ); TAB_APPEND( p_sys->i_clients, p_sys->clients, cl ); } /* to do a proper select */ FD_ZERO( &fds_read ); FD_ZERO( &fds_write ); for( i = 0 ; i < p_sys->i_clients ; i++ ) { telnet_client_t *cl = p_sys->clients[i]; if( cl->i_mode == WRITE_MODE_PWD || cl->i_mode == WRITE_MODE_CMD ) { FD_SET( cl->fd , &fds_write ); } else { FD_SET( cl->fd , &fds_read ); } i_handle_max = __MAX( i_handle_max, cl->fd ); } timeout.tv_sec = 0; timeout.tv_usec = 500*1000; i_ret = select( i_handle_max + 1, &fds_read, &fds_write, 0, &timeout ); if( i_ret == -1 && errno != EINTR ) { msg_Warn( p_intf, "cannot select sockets" ); msleep( 1000 ); continue; } else if( i_ret <= 0 ) { continue; } /* check if there is something to do with the socket */ for( i = 0 ; i < p_sys->i_clients ; i++ ) { telnet_client_t *cl = p_sys->clients[i]; if( FD_ISSET(cl->fd , &fds_write) && cl->i_buffer_write > 0 ) { i_len = send( cl->fd , cl->p_buffer_write , cl->i_buffer_write , 0 ); if( i_len > 0 ) { cl->p_buffer_write += i_len; cl->i_buffer_write -= i_len; } } else if( FD_ISSET( cl->fd, &fds_read) ) { int i_end = 0; int i_recv; while( (i_recv=recv( cl->fd, cl->p_buffer_read, 1, 0 )) > 0 && cl->p_buffer_read - cl->buffer_read < 999 ) { switch( cl->i_tel_cmd ) { case 0: switch( *(uint8_t *)cl->p_buffer_read ) { case '\r': break; case '\n': *cl->p_buffer_read = '\n'; i_end = 1; break; case TEL_IAC: // telnet specific command cl->i_tel_cmd = 1; cl->p_buffer_read++; break; default: cl->p_buffer_read++; break; } break; case 1: switch( *(uint8_t *)cl->p_buffer_read ) { case TEL_WILL: case TEL_WONT: case TEL_DO: case TEL_DONT: cl->i_tel_cmd++; cl->p_buffer_read++; break; default: cl->i_tel_cmd = 0; cl->p_buffer_read--; break; } break; case 2: cl->i_tel_cmd = 0; cl->p_buffer_read -= 2; break; } if( i_end != 0 ) break; } if( cl->p_buffer_read - cl->buffer_read == 999 ) { Write_message( cl, NULL, "Line too long\r\n", cl->i_mode + 2 ); } if( i_recv == 0 || ( i_recv == -1 && errno != EAGAIN && errno != 0 ) ) { net_Close( cl->fd ); TAB_REMOVE( p_intf->p_sys->i_clients , p_intf->p_sys->clients , cl ); free( cl ); } } } /* and now we should bidouille the data we received / send */ for( i = 0 ; i < p_sys->i_clients ; i++ ) { telnet_client_t *cl = p_sys->clients[i]; if( cl->i_mode >= WRITE_MODE_PWD && cl->i_buffer_write == 0 ) { // we have finished to send cl->i_mode -= 2; // corresponding READ MODE } else if( cl->i_mode == READ_MODE_PWD && *cl->p_buffer_read == '\n' ) { *cl->p_buffer_read = '\0'; if( strcmp( psz_password, cl->buffer_read ) == 0 ) { Write_message( cl, NULL, "\xff\xfc\x01\r\nWelcome, " "Master\r\n> ", WRITE_MODE_CMD ); } else { /* wrong password */ Write_message( cl, NULL, "\r\nWrong password.\r\nPassword: "******"logout", 6 ) || !strncmp( cl->buffer_read, "quit", 4 ) || !strncmp( cl->buffer_read, "exit", 4 ) ) { net_Close( cl->fd ); TAB_REMOVE( p_intf->p_sys->i_clients , p_intf->p_sys->clients , cl ); free( cl ); } else if( !strncmp( cl->buffer_read, "shutdown", 8 ) ) { msg_Err( p_intf, "shutdown requested" ); p_intf->p_vlc->b_die = VLC_TRUE; } else { vlm_message_t *message; /* create a standard string */ *cl->p_buffer_read = '\0'; vlm_ExecuteCommand( p_sys->mediatheque, cl->buffer_read, &message ); Write_message( cl, message, NULL, WRITE_MODE_CMD ); vlm_MessageDelete( message ); } } } } }
static void ParseSSAString( decoder_t *p_dec, char *psz_subtitle, subpicture_t *p_spu_in ) { /* We expect MKV formatted SSA: * ReadOrder, Layer, Style, CharacterName, MarginL, MarginR, * MarginV, Effect, Text */ decoder_sys_t *p_sys = p_dec->p_sys; subpicture_t *p_spu = p_spu_in; ssa_style_t *p_style = NULL; char *psz_new_subtitle = NULL; char *psz_buffer_sub = NULL; char *psz_style = NULL; char *psz_style_start = NULL; char *psz_style_end = NULL; int i_text = 0, i_comma = 0, i_strlen = 0, i; int i_margin_l = 0, i_margin_r = 0, i_margin_v = 0; psz_buffer_sub = psz_subtitle; i_comma = 0; while( i_comma < 8 && *psz_buffer_sub != '\0' ) { if( *psz_buffer_sub == ',' ) { i_comma++; if( i_comma == 2 ) psz_style_start = &psz_buffer_sub[1]; if( i_comma == 3 ) psz_style_end = &psz_buffer_sub[0]; if( i_comma == 4 ) i_margin_l = (int)strtol( psz_buffer_sub+1, NULL, 10 ); if( i_comma == 5 ) i_margin_r = (int)strtol( psz_buffer_sub+1, NULL, 10 ); if( i_comma == 6 ) i_margin_v = (int)strtol( psz_buffer_sub+1, NULL, 10 ); } psz_buffer_sub++; } if( *psz_buffer_sub == '\0' && i_comma == 8 ) { msg_Dbg( p_dec, "couldn't find all fields in this SSA line" ); return; } psz_new_subtitle = malloc( strlen( psz_buffer_sub ) + 1); i_text = 0; while( psz_buffer_sub[0] != '\0' ) { if( psz_buffer_sub[0] == '\\' && psz_buffer_sub[1] == 'n' ) { psz_new_subtitle[i_text] = ' '; i_text++; psz_buffer_sub += 2; } else if( psz_buffer_sub[0] == '\\' && psz_buffer_sub[1] == 'N' ) { psz_new_subtitle[i_text] = '\n'; i_text++; psz_buffer_sub += 2; } else if( psz_buffer_sub[0] == '{' && psz_buffer_sub[1] == '\\' ) { /* SSA control code */ while( psz_buffer_sub[0] != '\0' && psz_buffer_sub[0] != '}' ) { psz_buffer_sub++; } psz_buffer_sub++; } else { psz_new_subtitle[i_text] = psz_buffer_sub[0]; i_text++; psz_buffer_sub++; } } psz_new_subtitle[i_text] = '\0'; i_strlen = __MAX( psz_style_end - psz_style_start, 0); psz_style = (char *)malloc( i_strlen + 1); psz_style = memcpy( psz_style, psz_style_start, i_strlen ); psz_style[i_strlen] = '\0'; for( i = 0; i < p_sys->i_ssa_styles; i++ ) { if( !strcmp( p_sys->pp_ssa_styles[i]->psz_stylename, psz_style ) ) p_style = p_sys->pp_ssa_styles[i]; } if( psz_style ) free( psz_style ); p_spu->p_region->psz_text = psz_new_subtitle; if( p_style == NULL ) { p_spu->i_flags = SUBPICTURE_ALIGN_BOTTOM | p_sys->i_align; p_spu->i_x = p_sys->i_align ? 20 : 0; p_spu->i_y = 10; } else { msg_Dbg( p_dec, "style is: %s", p_style->psz_stylename); p_spu->p_region->p_style = &p_style->font_style; p_spu->i_flags = p_style->i_align; if( p_style->i_align & SUBPICTURE_ALIGN_LEFT ) { p_spu->i_x = (i_margin_l) ? i_margin_l : p_style->i_margin_h; } else if( p_style->i_align & SUBPICTURE_ALIGN_RIGHT ) { p_spu->i_x = (i_margin_r) ? i_margin_r : p_style->i_margin_h; } p_spu->i_y = (i_margin_v) ? i_margin_v : p_style->i_margin_v; } }
/** * 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; BarGraph_t *p_BarGraph; char* i_values = NULL; /* */ 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_BarGraph = &(p_sys->p_BarGraph); /* */ 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_BarGraph ); 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_CreateGetIntegerCommand( p_filter, "audiobargraph_v-position" ); p_sys->i_pos_x = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-x" ); p_sys->i_pos_y = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-y" ); p_BarGraph->i_alpha = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-transparency" ); p_BarGraph->i_alpha = __MAX( __MIN( p_BarGraph->i_alpha, 255 ), 0 ); i_values = var_CreateGetStringCommand( p_filter, "audiobargraph_v-i_values" ); //p_BarGraph->nbChannels = 0; //p_BarGraph->i_values = NULL; parse_i_values(p_BarGraph, i_values); p_BarGraph->alarm = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-alarm" ); p_BarGraph->barWidth = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-barWidth" ); p_BarGraph->scale = 400; /* Ignore aligment if a position is given for video filter */ if( !b_sub && p_sys->i_pos_x >= 0 && p_sys->i_pos_y >= 0 ) p_sys->i_pos = 0; vlc_mutex_init( &p_sys->lock ); LoadBarGraph( p_this, p_BarGraph ); p_sys->b_spu_update = true; for( int i = 0; ppsz_filter_callbacks[i]; i++ ) var_AddCallback( p_filter, ppsz_filter_callbacks[i], BarGraphCallback, p_sys ); /* Misc init */ if( b_sub ) { p_filter->pf_sub_filter = FilterSub; } else { p_filter->pf_video_filter = FilterVideo; } free( i_values ); return VLC_SUCCESS; }
void vout_InitInterlacingSupport(vout_thread_t *vout, bool is_interlaced) { vlc_value_t val, text; msg_Dbg(vout, "Deinterlacing available"); /* Create the configuration variables */ /* */ var_Create(vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE); int deinterlace_state = var_GetInteger(vout, "deinterlace"); deinterlace_state = __MAX(__MIN(deinterlace_state, 1), -1); text.psz_string = _("Deinterlace"); var_Change(vout, "deinterlace", VLC_VAR_SETTEXT, &text, NULL); const module_config_t *optd = config_FindConfig(VLC_OBJECT(vout), "deinterlace"); var_Change(vout, "deinterlace", VLC_VAR_CLEARCHOICES, NULL, NULL); for (int i = 0; optd && i < optd->i_list; i++) { val.i_int = optd->pi_list[i]; text.psz_string = (char*)vlc_gettext(optd->ppsz_list_text[i]); var_Change(vout, "deinterlace", VLC_VAR_ADDCHOICE, &val, &text); } var_AddCallback(vout, "deinterlace", DeinterlaceCallback, NULL); /* */ var_Create(vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE); char *deinterlace_mode = var_GetNonEmptyString(vout, "deinterlace-mode"); text.psz_string = _("Deinterlace mode"); var_Change(vout, "deinterlace-mode", VLC_VAR_SETTEXT, &text, NULL); const module_config_t *optm = config_FindConfig(VLC_OBJECT(vout), "deinterlace-mode"); var_Change(vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES, NULL, NULL); for (int i = 0; optm && i < optm->i_list; i++) { if (!DeinterlaceIsModeValid(optm->ppsz_list[i])) continue; val.psz_string = optm->ppsz_list[i]; text.psz_string = (char*)vlc_gettext(optm->ppsz_list_text[i]); var_Change(vout, "deinterlace-mode", VLC_VAR_ADDCHOICE, &val, &text); } var_AddCallback(vout, "deinterlace-mode", DeinterlaceCallback, NULL); /* */ var_Create(vout, "deinterlace-needed", VLC_VAR_BOOL); var_AddCallback(vout, "deinterlace-needed", DeinterlaceCallback, NULL); /* Override the initial value from filters if present */ char *filter_mode = NULL; if (DeinterlaceIsPresent(vout)) filter_mode = var_CreateGetNonEmptyString(vout, "sout-deinterlace-mode"); if (filter_mode) { deinterlace_state = 1; free(deinterlace_mode); deinterlace_mode = filter_mode; } /* */ val.psz_string = deinterlace_mode ? deinterlace_mode : optm->orig.psz; var_Change(vout, "deinterlace-mode", VLC_VAR_SETVALUE, &val, NULL); val.b_bool = is_interlaced; var_Change(vout, "deinterlace-needed", VLC_VAR_SETVALUE, &val, NULL); var_SetInteger(vout, "deinterlace", deinterlace_state); free(deinterlace_mode); }
/***************************************************************************** * Callback to update params on the fly *****************************************************************************/ static int BarGraphCallback( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { VLC_UNUSED(oldval); filter_sys_t *p_sys = (filter_sys_t *)p_data; BarGraph_t *p_BarGraph = &(p_sys->p_BarGraph); char* i_values; char* res = NULL; vlc_mutex_lock( &p_sys->lock ); if ( !strcmp( psz_var, "audiobargraph_v-x" ) ) { p_sys->i_pos_x = newval.i_int; } else if ( !strcmp( psz_var, "audiobargraph_v-y" ) ) { p_sys->i_pos_y = newval.i_int; } else if ( !strcmp( psz_var, "audiobargraph_v-position" ) ) { p_sys->i_pos = newval.i_int; } else if ( !strcmp( psz_var, "audiobargraph_v-transparency" ) ) { p_BarGraph->i_alpha = __MAX( __MIN( newval.i_int, 255 ), 0 ); } else if ( !strcmp( psz_var, "audiobargraph_v-i_values" ) ) { if( p_BarGraph->p_pic ) { picture_Release( p_BarGraph->p_pic ); p_BarGraph->p_pic = NULL; } i_values = strdup( newval.psz_string ); free(p_BarGraph->i_values); //p_BarGraph->i_values = NULL; //p_BarGraph->nbChannels = 0; // in case many answer are received at the same time, only keep one res = strchr(i_values, '@'); if (res) *res = 0; parse_i_values( p_BarGraph, i_values); LoadBarGraph(p_this,p_BarGraph); } else if ( !strcmp( psz_var, "audiobargraph_v-alarm" ) ) { if( p_BarGraph->p_pic ) { picture_Release( p_BarGraph->p_pic ); p_BarGraph->p_pic = NULL; } p_BarGraph->alarm = newval.i_int; LoadBarGraph(p_this,p_BarGraph); } else if ( !strcmp( psz_var, "audiobargraph_v-barWidth" ) ) { if( p_BarGraph->p_pic ) { picture_Release( p_BarGraph->p_pic ); p_BarGraph->p_pic = NULL; } p_BarGraph->barWidth = newval.i_int; LoadBarGraph(p_this,p_BarGraph); } p_sys->b_spu_update = true; vlc_mutex_unlock( &p_sys->lock ); return VLC_SUCCESS; }
static int BuildRegions( rectangle_t *p_region, int i_max_region, ASS_Image *p_img_list, int i_width, int i_height ) { ASS_Image *p_tmp; int i_count; #ifdef DEBUG_REGION int64_t i_ck_start = mdate(); #endif for( p_tmp = p_img_list, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->next ) if( p_tmp->w > 0 && p_tmp->h > 0 ) i_count++; if( i_count <= 0 ) return 0; ASS_Image **pp_img = calloc( i_count, sizeof(*pp_img) ); if( !pp_img ) return 0; for( p_tmp = p_img_list, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->next ) if( p_tmp->w > 0 && p_tmp->h > 0 ) pp_img[i_count++] = p_tmp; /* */ const int i_w_inc = __MAX( ( i_width + 49 ) / 50, 32 ); const int i_h_inc = __MAX( ( i_height + 99 ) / 100, 32 ); int i_maxh = i_w_inc; int i_maxw = i_h_inc; int i_region; // rectangle_t region[i_max_region+1]; rectangle_t *region = (rectangle_t *)malloc(sizeof(rectangle_t) * (i_max_region+1)); // sunqueen modify i_region = 0; for( int i_used = 0; i_used < i_count; ) { int n; for( n = 0; n < i_count; n++ ) { if( pp_img[n] ) break; } assert( i_region < i_max_region + 1 ); region[i_region++] = r_img( pp_img[n] ); pp_img[n] = NULL; i_used++; bool b_ok; do { b_ok = false; for( n = 0; n < i_count; n++ ) { ASS_Image *p_img = pp_img[n]; if( !p_img ) continue; rectangle_t r = r_img( p_img ); int k; int i_best = -1; int i_best_s = INT_MAX; for( k = 0; k < i_region; k++ ) { if( !r_overlap( ®ion[k], &r, i_maxw, i_maxh ) ) continue; int s = r_surface( &r ); if( s < i_best_s ) { i_best_s = s; i_best = k; } } if( i_best >= 0 ) { r_add( ®ion[i_best], &r ); pp_img[n] = NULL; i_used++; b_ok = true; } } } while( b_ok ); if( i_region > i_max_region ) { int i_best_i = -1; int i_best_j = -1; int i_best_ds = INT_MAX; /* merge best */ for( int i = 0; i < i_region; i++ ) { for( int j = i+1; j < i_region; j++ ) { rectangle_t n = region[i]; r_add( &n, ®ion[j] ); int ds = r_surface( &n ) - r_surface( ®ion[i] ) - r_surface( ®ion[j] ); if( ds < i_best_ds ) { i_best_i = i; i_best_j = j; i_best_ds = ds; } } } #ifdef DEBUG_REGION msg_Err( p_spu, "Merging %d and %d", i_best_i, i_best_j ); #endif if( i_best_j >= 0 && i_best_i >= 0 ) { r_add( ®ion[i_best_i], ®ion[i_best_j] ); if( i_best_j+1 < i_region ) memmove( ®ion[i_best_j], ®ion[i_best_j+1], sizeof(*region) * ( i_region - (i_best_j+1) ) ); i_region--; } } } /* */ for( int n = 0; n < i_region; n++ ) p_region[n] = region[n]; #ifdef DEBUG_REGION int64_t i_ck_time = mdate() - i_ck_start; msg_Err( p_spu, "ASS: %d objects merged into %d region in %d micros", i_count, i_region, (int)(i_ck_time) ); #endif free( pp_img ); free( region ); // sunqueen add return i_region; }
int avformat_OpenDemux( vlc_object_t *p_this ) { demux_t *p_demux = (demux_t*)p_this; demux_sys_t *p_sys; AVInputFormat *fmt = NULL; vlc_tick_t i_start_time = VLC_TICK_INVALID; bool b_can_seek; const char *psz_url; int error; if( p_demux->psz_filepath ) psz_url = p_demux->psz_filepath; else psz_url = p_demux->psz_url; if( avformat_ProbeDemux( p_this, &fmt, psz_url ) != VLC_SUCCESS ) return VLC_EGENERIC; vlc_stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_can_seek ); /* Fill p_demux fields */ p_demux->pf_demux = Demux; p_demux->pf_control = Control; p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->ic = 0; p_sys->fmt = fmt; p_sys->tracks = NULL; p_sys->i_ssa_order = 0; TAB_INIT( p_sys->i_attachments, p_sys->attachments); p_sys->p_title = NULL; p_sys->i_seekpoint = 0; p_sys->i_update = 0; /* Create I/O wrapper */ unsigned char * p_io_buffer = av_malloc( AVFORMAT_IOBUFFER_SIZE ); if( !p_io_buffer ) { avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->ic = avformat_alloc_context(); if( !p_sys->ic ) { av_free( p_io_buffer ); avformat_CloseDemux( p_this ); return VLC_ENOMEM; } AVIOContext *pb = p_sys->ic->pb = avio_alloc_context( p_io_buffer, AVFORMAT_IOBUFFER_SIZE, 0, p_demux, IORead, NULL, IOSeek ); if( !pb ) { av_free( p_io_buffer ); avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->ic->pb->seekable = b_can_seek ? AVIO_SEEKABLE_NORMAL : 0; error = avformat_open_input(&p_sys->ic, psz_url, p_sys->fmt, NULL); if( error < 0 ) { msg_Err( p_demux, "Could not open %s: %s", psz_url, vlc_strerror_c(AVUNERROR(error)) ); av_free( pb->buffer ); av_free( pb ); p_sys->ic = NULL; avformat_CloseDemux( p_this ); return VLC_EGENERIC; } char *psz_opts = var_InheritString( p_demux, "avformat-options" ); unsigned nb_streams = p_sys->ic->nb_streams; AVDictionary *options[nb_streams ? nb_streams : 1]; options[0] = NULL; for (unsigned i = 1; i < nb_streams; i++) options[i] = NULL; if (psz_opts) { vlc_av_get_options(psz_opts, &options[0]); for (unsigned i = 1; i < nb_streams; i++) { av_dict_copy(&options[i], options[0], 0); } free(psz_opts); } vlc_avcodec_lock(); /* avformat calls avcodec behind our back!!! */ error = avformat_find_stream_info( p_sys->ic, options ); vlc_avcodec_unlock(); AVDictionaryEntry *t = NULL; while ((t = av_dict_get(options[0], "", t, AV_DICT_IGNORE_SUFFIX))) { msg_Err( p_demux, "Unknown option \"%s\"", t->key ); } av_dict_free(&options[0]); for (unsigned i = 1; i < nb_streams; i++) { av_dict_free(&options[i]); } nb_streams = p_sys->ic->nb_streams; /* it may have changed */ if( !nb_streams ) { msg_Err( p_demux, "No streams found"); avformat_CloseDemux( p_this ); return VLC_EGENERIC; } p_sys->tracks = calloc( nb_streams, sizeof(*p_sys->tracks) ); if( !p_sys->tracks ) { avformat_CloseDemux( p_this ); return VLC_ENOMEM; } p_sys->i_tracks = nb_streams; if( error < 0 ) { msg_Warn( p_demux, "Could not find stream info: %s", vlc_strerror_c(AVUNERROR(error)) ); } for( unsigned i = 0; i < nb_streams; i++ ) { struct avformat_track_s *p_track = &p_sys->tracks[i]; AVStream *s = p_sys->ic->streams[i]; const AVCodecParameters *cp = s->codecpar; es_format_t es_fmt; const char *psz_type = "unknown"; /* Do not use the cover art as a stream */ if( s->disposition == AV_DISPOSITION_ATTACHED_PIC ) continue; vlc_fourcc_t fcc = GetVlcFourcc( cp->codec_id ); switch( cp->codec_type ) { case AVMEDIA_TYPE_AUDIO: es_format_Init( &es_fmt, AUDIO_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); es_fmt.i_bitrate = cp->bit_rate; es_fmt.audio.i_channels = cp->channels; es_fmt.audio.i_rate = cp->sample_rate; es_fmt.audio.i_bitspersample = cp->bits_per_coded_sample; es_fmt.audio.i_blockalign = cp->block_align; psz_type = "audio"; if(cp->codec_id == AV_CODEC_ID_AAC_LATM) { es_fmt.i_original_fourcc = VLC_FOURCC('L','A','T','M'); es_fmt.b_packetized = false; } else if(cp->codec_id == AV_CODEC_ID_AAC && p_sys->fmt->long_name && strstr(p_sys->fmt->long_name, "raw ADTS AAC")) { es_fmt.i_original_fourcc = VLC_FOURCC('A','D','T','S'); es_fmt.b_packetized = false; } break; case AVMEDIA_TYPE_VIDEO: es_format_Init( &es_fmt, VIDEO_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); es_fmt.video.i_bits_per_pixel = cp->bits_per_coded_sample; /* Special case for raw video data */ if( cp->codec_id == AV_CODEC_ID_RAWVIDEO ) { msg_Dbg( p_demux, "raw video, pixel format: %i", cp->format ); if( GetVlcChroma( &es_fmt.video, cp->format ) != VLC_SUCCESS) { msg_Err( p_demux, "was unable to find a FourCC match for raw video" ); } else es_fmt.i_codec = es_fmt.video.i_chroma; } /* We need this for the h264 packetizer */ else if( cp->codec_id == AV_CODEC_ID_H264 && ( p_sys->fmt == av_find_input_format("flv") || p_sys->fmt == av_find_input_format("matroska") || p_sys->fmt == av_find_input_format("mp4") ) ) es_fmt.i_original_fourcc = VLC_FOURCC( 'a', 'v', 'c', '1' ); es_fmt.video.i_width = cp->width; es_fmt.video.i_height = cp->height; es_fmt.video.i_visible_width = es_fmt.video.i_width; es_fmt.video.i_visible_height = es_fmt.video.i_height; get_rotation(&es_fmt, s); # warning FIXME: implement palette transmission psz_type = "video"; AVRational rate; #if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */ # if (LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(55, 20, 0)) rate.num = s->time_base.num; rate.den = s->time_base.den; # else rate.num = s->codec->time_base.num; rate.den = s->codec->time_base.den; # endif rate.den *= __MAX( s->codec->ticks_per_frame, 1 ); #else /* ffmpeg */ rate = av_guess_frame_rate( p_sys->ic, s, NULL ); #endif if( rate.den && rate.num ) { es_fmt.video.i_frame_rate = rate.num; es_fmt.video.i_frame_rate_base = rate.den; } AVRational ar; #if (LIBAVUTIL_VERSION_MICRO < 100) /* libav */ ar.num = s->sample_aspect_ratio.num; ar.den = s->sample_aspect_ratio.den; #else ar = av_guess_sample_aspect_ratio( p_sys->ic, s, NULL ); #endif if( ar.num && ar.den ) { es_fmt.video.i_sar_den = ar.den; es_fmt.video.i_sar_num = ar.num; } break; case AVMEDIA_TYPE_SUBTITLE: es_format_Init( &es_fmt, SPU_ES, fcc ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); if( strncmp( p_sys->ic->iformat->name, "matroska", 8 ) == 0 && cp->codec_id == AV_CODEC_ID_DVD_SUBTITLE && cp->extradata != NULL && cp->extradata_size > 0 ) { char *psz_start; char *psz_buf = malloc( cp->extradata_size + 1); if( psz_buf != NULL ) { memcpy( psz_buf, cp->extradata , cp->extradata_size ); psz_buf[cp->extradata_size] = '\0'; psz_start = strstr( psz_buf, "size:" ); if( psz_start && vobsub_size_parse( psz_start, &es_fmt.subs.spu.i_original_frame_width, &es_fmt.subs.spu.i_original_frame_height ) == VLC_SUCCESS ) { msg_Dbg( p_demux, "original frame size: %dx%d", es_fmt.subs.spu.i_original_frame_width, es_fmt.subs.spu.i_original_frame_height ); } else { msg_Warn( p_demux, "reading original frame size failed" ); } psz_start = strstr( psz_buf, "palette:" ); if( psz_start && vobsub_palette_parse( psz_start, &es_fmt.subs.spu.palette[1] ) == VLC_SUCCESS ) { es_fmt.subs.spu.palette[0] = SPU_PALETTE_DEFINED; msg_Dbg( p_demux, "vobsub palette read" ); } else { msg_Warn( p_demux, "reading original palette failed" ); } free( psz_buf ); } } else if( cp->codec_id == AV_CODEC_ID_DVB_SUBTITLE && cp->extradata_size > 3 ) { es_fmt.subs.dvb.i_id = GetWBE( cp->extradata ) | (GetWBE( cp->extradata + 2 ) << 16); } else if( cp->codec_id == AV_CODEC_ID_MOV_TEXT ) { if( cp->extradata_size && (es_fmt.p_extra = malloc(cp->extradata_size)) ) { memcpy( es_fmt.p_extra, cp->extradata, cp->extradata_size ); es_fmt.i_extra = cp->extradata_size; } } psz_type = "subtitle"; break; default: es_format_Init( &es_fmt, UNKNOWN_ES, 0 ); es_fmt.i_original_fourcc = CodecTagToFourcc( cp->codec_tag ); #ifdef HAVE_AVUTIL_CODEC_ATTACHMENT if( cp->codec_type == AVMEDIA_TYPE_ATTACHMENT ) { input_attachment_t *p_attachment; psz_type = "attachment"; if( cp->codec_id == AV_CODEC_ID_TTF ) { AVDictionaryEntry *filename = av_dict_get( s->metadata, "filename", NULL, 0 ); if( filename && filename->value ) { p_attachment = vlc_input_attachment_New( filename->value, "application/x-truetype-font", NULL, cp->extradata, (int)cp->extradata_size ); if( p_attachment ) TAB_APPEND( p_sys->i_attachments, p_sys->attachments, p_attachment ); } } else msg_Warn( p_demux, "unsupported attachment type (%u) in avformat demux", cp->codec_id ); } else #endif { if( cp->codec_type == AVMEDIA_TYPE_DATA ) psz_type = "data"; msg_Warn( p_demux, "unsupported track type (%u:%u) in avformat demux", cp->codec_type, cp->codec_id ); } break; } AVDictionaryEntry *language = av_dict_get( s->metadata, "language", NULL, 0 ); if ( language && language->value ) es_fmt.psz_language = strdup( language->value ); if( s->disposition & AV_DISPOSITION_DEFAULT ) es_fmt.i_priority = ES_PRIORITY_SELECTABLE_MIN + 1000; #ifdef HAVE_AVUTIL_CODEC_ATTACHMENT if( cp->codec_type != AVMEDIA_TYPE_ATTACHMENT ) #endif if( cp->codec_type != AVMEDIA_TYPE_DATA ) { const bool b_ogg = !strcmp( p_sys->fmt->name, "ogg" ); const uint8_t *p_extra = cp->extradata; unsigned i_extra = cp->extradata_size; if( cp->codec_id == AV_CODEC_ID_THEORA && b_ogg ) { unsigned pi_size[3]; const void *pp_data[3]; unsigned i_count; for( i_count = 0; i_count < 3; i_count++ ) { if( i_extra < 2 ) break; pi_size[i_count] = GetWBE( p_extra ); pp_data[i_count] = &p_extra[2]; if( i_extra < pi_size[i_count] + 2 ) break; p_extra += 2 + pi_size[i_count]; i_extra -= 2 + pi_size[i_count]; } if( i_count > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, i_count ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->codec_id == AV_CODEC_ID_SPEEX && b_ogg ) { const uint8_t p_dummy_comment[] = { 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned pi_size[2]; const void *pp_data[2]; pi_size[0] = i_extra; pp_data[0] = p_extra; pi_size[1] = sizeof(p_dummy_comment); pp_data[1] = p_dummy_comment; if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, 2 ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->codec_id == AV_CODEC_ID_OPUS ) { const uint8_t p_dummy_comment[] = { 'O', 'p', 'u', 's', 'T', 'a', 'g', 's', 0, 0, 0, 0, /* Vendor String length */ /* Vendor String */ 0, 0, 0, 0, /* User Comment List Length */ }; unsigned pi_size[2]; const void *pp_data[2]; pi_size[0] = i_extra; pp_data[0] = p_extra; pi_size[1] = sizeof(p_dummy_comment); pp_data[1] = p_dummy_comment; if( pi_size[0] > 0 && xiph_PackHeaders( &es_fmt.i_extra, &es_fmt.p_extra, pi_size, pp_data, 2 ) ) { es_fmt.i_extra = 0; es_fmt.p_extra = NULL; } } else if( cp->extradata_size > 0 && !es_fmt.i_extra ) { es_fmt.p_extra = malloc( i_extra ); if( es_fmt.p_extra ) { es_fmt.i_extra = i_extra; memcpy( es_fmt.p_extra, p_extra, i_extra ); } } p_track->p_es = es_out_Add( p_demux->out, &es_fmt ); if( p_track->p_es && (s->disposition & AV_DISPOSITION_DEFAULT) ) es_out_Control( p_demux->out, ES_OUT_SET_ES_DEFAULT, p_track->p_es ); msg_Dbg( p_demux, "adding es: %s codec = %4.4s (%d)", psz_type, (char*)&fcc, cp->codec_id ); } es_format_Clean( &es_fmt ); } if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE ) i_start_time = FROM_AV_TS(p_sys->ic->start_time); msg_Dbg( p_demux, "AVFormat(%s %s) supported stream", AVPROVIDER(LIBAVFORMAT), LIBAVFORMAT_IDENT ); msg_Dbg( p_demux, " - format = %s (%s)", p_sys->fmt->name, p_sys->fmt->long_name ); msg_Dbg( p_demux, " - start time = %"PRId64, i_start_time ); msg_Dbg( p_demux, " - duration = %"PRId64, ( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ? FROM_AV_TS(p_sys->ic->duration) : -1 ); if( p_sys->ic->nb_chapters > 0 ) { p_sys->p_title = vlc_input_title_New(); p_sys->p_title->i_length = FROM_AV_TS(p_sys->ic->duration); } for( unsigned i = 0; i < p_sys->ic->nb_chapters; i++ ) { seekpoint_t *s = vlc_seekpoint_New(); AVDictionaryEntry *title = av_dict_get( p_sys->ic->metadata, "title", NULL, 0); if( title && title->value ) { s->psz_name = strdup( title->value ); EnsureUTF8( s->psz_name ); msg_Dbg( p_demux, " - chapter %d: %s", i, s->psz_name ); } s->i_time_offset = vlc_tick_from_samples( p_sys->ic->chapters[i]->start * p_sys->ic->chapters[i]->time_base.num, p_sys->ic->chapters[i]->time_base.den ) - (i_start_time != VLC_TICK_INVALID ? i_start_time : 0 ); TAB_APPEND( p_sys->p_title->i_seekpoint, p_sys->p_title->seekpoint, s ); } ResetTime( p_demux, 0 ); return VLC_SUCCESS; }
/** * This function receives a string and creates a subpicture for it. It * also calculates the size needed for this string, and renders the * needed glyphs into memory. It is used as pf_add_string callback in * the vout method by this module */ static subpicture_t *RenderText( filter_t *p_filter, block_t *p_block ) { filter_sys_t *p_sys = p_filter->p_sys; subpicture_t *p_subpic = 0; subpicture_data_t *p_string = 0; line_desc_t *p_line = 0, *p_next = 0, *p_prev = 0; int i, i_pen_y, i_pen_x, i_error, i_glyph_index, i_previous; uint32_t *psz_unicode, *psz_unicode_orig = 0, i_char, *psz_line_start; int i_string_length; char *psz_string; vlc_iconv_t iconv_handle = (vlc_iconv_t)(-1); FT_BBox line; FT_BBox glyph_size; FT_Vector result; FT_Glyph tmp_glyph; /* Sanity check */ if( !p_block ) return NULL; psz_string = p_block->p_buffer; if( !psz_string || !*psz_string ) goto error; result.x = 0; result.y = 0; line.xMin = 0; line.xMax = 0; line.yMin = 0; line.yMax = 0; /* Create and initialize a subpicture */ p_subpic = p_filter->pf_sub_buffer_new( p_filter ); if( !p_subpic ) goto error; p_subpic->i_start = p_block->i_pts; p_subpic->i_stop = p_block->i_pts + p_block->i_length; p_subpic->b_ephemer = (p_block->i_length == 0); p_subpic->b_absolute = VLC_FALSE; /* Create and initialize private data for the subpicture */ p_string = malloc( sizeof(subpicture_data_t) ); if( !p_string ) { msg_Err( p_filter, "out of memory" ); goto error; } p_string->p_lines = 0; p_string->psz_text = strdup( psz_string ); psz_unicode = psz_unicode_orig = malloc( ( strlen(psz_string) + 1 ) * sizeof(uint32_t) ); if( psz_unicode == NULL ) { msg_Err( p_filter, "out of memory" ); goto error; } #if defined(WORDS_BIGENDIAN) iconv_handle = vlc_iconv_open( "UCS-4BE", "UTF-8" ); #else iconv_handle = vlc_iconv_open( "UCS-4LE", "UTF-8" ); #endif if( iconv_handle == (vlc_iconv_t)-1 ) { msg_Warn( p_filter, "unable to do convertion" ); goto error; } { char *p_in_buffer, *p_out_buffer; size_t i_in_bytes, i_out_bytes, i_out_bytes_left, i_ret; i_in_bytes = strlen( psz_string ); i_out_bytes = i_in_bytes * sizeof( uint32_t ); i_out_bytes_left = i_out_bytes; p_in_buffer = psz_string; p_out_buffer = (char *)psz_unicode; i_ret = vlc_iconv( iconv_handle, &p_in_buffer, &i_in_bytes, &p_out_buffer, &i_out_bytes_left ); vlc_iconv_close( iconv_handle ); if( i_in_bytes ) { msg_Warn( p_filter, "failed to convert string to unicode (%s), " "bytes left %d", strerror(errno), i_in_bytes ); goto error; } *(uint32_t*)p_out_buffer = 0; i_string_length = (i_out_bytes - i_out_bytes_left) / sizeof(uint32_t); } #if defined(HAVE_FRIBIDI) { uint32_t *p_fribidi_string; FriBidiCharType base_dir = FRIBIDI_TYPE_ON; p_fribidi_string = malloc( (i_string_length + 1) * sizeof(uint32_t) ); fribidi_log2vis( (FriBidiChar*)psz_unicode, i_string_length, &base_dir, (FriBidiChar*)p_fribidi_string, 0, 0, 0 ); free( psz_unicode_orig ); psz_unicode = psz_unicode_orig = p_fribidi_string; p_fribidi_string[ i_string_length ] = 0; } #endif /* Calculate relative glyph positions and a bounding box for the * entire string */ p_line = NewLine( psz_string ); if( p_line == NULL ) { msg_Err( p_filter, "out of memory" ); goto error; } p_string->p_lines = p_line; i_pen_x = 0; i_pen_y = 0; i_previous = 0; i = 0; psz_line_start = psz_unicode; #define face p_sys->p_face #define glyph face->glyph while( *psz_unicode ) { i_char = *psz_unicode++; if( i_char == '\r' ) /* ignore CR chars wherever they may be */ { continue; } if( i_char == '\n' ) { psz_line_start = psz_unicode; p_next = NewLine( psz_string ); if( p_next == NULL ) { msg_Err( p_filter, "out of memory" ); goto error; } p_line->p_next = p_next; p_line->i_width = line.xMax; p_line->i_height = face->size->metrics.height >> 6; p_line->pp_glyphs[ i ] = NULL; p_prev = p_line; p_line = p_next; result.x = __MAX( result.x, line.xMax ); result.y += face->size->metrics.height >> 6; i_pen_x = 0; i_previous = 0; line.xMin = 0; line.xMax = 0; line.yMin = 0; line.yMax = 0; i_pen_y += face->size->metrics.height >> 6; #if 0 msg_Dbg( p_filter, "Creating new line, i is %d", i ); #endif i = 0; continue; } i_glyph_index = FT_Get_Char_Index( face, i_char ); if( p_sys->i_use_kerning && i_glyph_index && i_previous ) { FT_Vector delta; FT_Get_Kerning( face, i_previous, i_glyph_index, ft_kerning_default, &delta ); i_pen_x += delta.x >> 6; }
/***************************************************************************** * Demux: *****************************************************************************/ static int Demux( demux_t *p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; AVPacket pkt; block_t *p_frame; vlc_tick_t i_start_time; /* Read a frame */ int i_av_ret = av_read_frame( p_sys->ic, &pkt ); if( i_av_ret ) { /* Avoid EOF if av_read_frame returns AVERROR(EAGAIN) */ if( i_av_ret == AVERROR(EAGAIN) ) return 1; return 0; } if( pkt.stream_index < 0 || (unsigned) pkt.stream_index >= p_sys->i_tracks ) { av_packet_unref( &pkt ); return 1; } struct avformat_track_s *p_track = &p_sys->tracks[pkt.stream_index]; const AVStream *p_stream = p_sys->ic->streams[pkt.stream_index]; if( p_stream->time_base.den <= 0 ) { msg_Warn( p_demux, "Invalid time base for the stream %d", pkt.stream_index ); av_packet_unref( &pkt ); return 1; } if( p_stream->codecpar->codec_id == AV_CODEC_ID_SSA ) { p_frame = BuildSsaFrame( &pkt, p_sys->i_ssa_order++ ); if( !p_frame ) { av_packet_unref( &pkt ); return 1; } } else if( p_stream->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE ) { if( ( p_frame = block_Alloc( pkt.size + 3 ) ) == NULL ) { av_packet_unref( &pkt ); return 0; } p_frame->p_buffer[0] = 0x20; p_frame->p_buffer[1] = 0x00; memcpy( &p_frame->p_buffer[2], pkt.data, pkt.size ); p_frame->p_buffer[p_frame->i_buffer - 1] = 0x3f; } else { if( ( p_frame = block_Alloc( pkt.size ) ) == NULL ) { av_packet_unref( &pkt ); return 0; } memcpy( p_frame->p_buffer, pkt.data, pkt.size ); } if( pkt.flags & AV_PKT_FLAG_KEY ) p_frame->i_flags |= BLOCK_FLAG_TYPE_I; /* Used to avoid timestamps overlow */ if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE ) { i_start_time = vlc_tick_from_frac(p_sys->ic->start_time, AV_TIME_BASE); } else i_start_time = 0; if( pkt.dts == (int64_t)AV_NOPTS_VALUE ) p_frame->i_dts = VLC_TICK_INVALID; else { p_frame->i_dts = vlc_tick_from_frac( pkt.dts * p_stream->time_base.num, p_stream->time_base.den ) - i_start_time + VLC_TICK_0; } if( pkt.pts == (int64_t)AV_NOPTS_VALUE ) p_frame->i_pts = VLC_TICK_INVALID; else { p_frame->i_pts = vlc_tick_from_frac( pkt.pts * p_stream->time_base.num, p_stream->time_base.den ) - i_start_time + VLC_TICK_0; } if( pkt.duration > 0 && p_frame->i_length <= 0 ) p_frame->i_length = vlc_tick_from_samples(pkt.duration * p_stream->time_base.num, p_stream->time_base.den ); /* Add here notoriously bugged file formats/samples */ if( !strcmp( p_sys->fmt->name, "flv" ) ) { /* FLV and video PTS */ if( p_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt.dts != (int64_t)AV_NOPTS_VALUE && pkt.dts == pkt.pts ) p_frame->i_pts = VLC_TICK_INVALID; /* Handle broken dts/pts increase with AAC. Duration is correct. * sky_the80s_aacplus.flv #8195 */ if( p_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && p_stream->codecpar->codec_id == AV_CODEC_ID_AAC ) { if( p_track->i_pcr != VLC_TICK_INVALID && p_track->i_pcr + p_frame->i_length > p_frame->i_dts ) { p_frame->i_dts = p_frame->i_pts = p_track->i_pcr + p_frame->i_length; } } } #ifdef AVFORMAT_DEBUG msg_Dbg( p_demux, "tk[%d] dts=%"PRId64" pts=%"PRId64, pkt.stream_index, p_frame->i_dts, p_frame->i_pts ); #endif if( p_frame->i_dts != VLC_TICK_INVALID && p_track->p_es != NULL ) p_track->i_pcr = p_frame->i_dts; vlc_tick_t i_ts_max = INT64_MIN; for( unsigned i = 0; i < p_sys->i_tracks; i++ ) { if( p_sys->tracks[i].p_es != NULL ) i_ts_max = __MAX( i_ts_max, p_sys->tracks[i].i_pcr ); } vlc_tick_t i_ts_min = INT64_MAX; for( unsigned i = 0; i < p_sys->i_tracks; i++ ) { if( p_sys->tracks[i].p_es != NULL && p_sys->tracks[i].i_pcr != VLC_TICK_INVALID && p_sys->tracks[i].i_pcr + VLC_TICK_FROM_SEC(10)>= i_ts_max ) i_ts_min = __MIN( i_ts_min, p_sys->tracks[i].i_pcr ); } if( i_ts_min >= p_sys->i_pcr && likely(i_ts_min != INT64_MAX) ) { p_sys->i_pcr = i_ts_min; es_out_SetPCR( p_demux->out, p_sys->i_pcr ); UpdateSeekPoint( p_demux, p_sys->i_pcr ); } if( p_track->p_es != NULL ) es_out_Send( p_demux->out, p_track->p_es, p_frame ); else block_Release( p_frame ); av_packet_unref( &pkt ); return 1; }
/**************************************************************************** * DecodeBlock: ****************************************************************************/ static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block ) { decoder_sys_t *p_sys = p_dec->p_sys; subpicture_t *p_spu = NULL; block_t *p_block; if( !pp_block || *pp_block == NULL ) return NULL; p_block = *pp_block; *pp_block = NULL; if( p_block->i_flags & BLOCK_FLAG_CORRUPTED ) { Flush( p_dec ); block_Release( p_block ); return NULL; } if( p_block->i_buffer == 0 || p_block->p_buffer[0] == '\0' ) { block_Release( p_block ); return NULL; } subpicture_updater_sys_t *p_spu_sys = malloc( sizeof(*p_spu_sys) ); if( !p_spu_sys ) { block_Release( p_block ); return NULL; } subpicture_updater_t updater = { .pf_validate = SubpictureValidate, .pf_update = SubpictureUpdate, .pf_destroy = SubpictureDestroy, .p_sys = p_spu_sys, }; p_spu = decoder_NewSubpicture( p_dec, &updater ); if( !p_spu ) { msg_Warn( p_dec, "can't get spu buffer" ); free( p_spu_sys ); block_Release( p_block ); return NULL; } p_spu_sys->p_img = NULL; p_spu_sys->p_dec_sys = p_sys; p_spu_sys->i_subs_len = p_block->i_buffer; p_spu_sys->p_subs_data = malloc( p_block->i_buffer ); p_spu_sys->i_pts = p_block->i_pts; if( !p_spu_sys->p_subs_data ) { subpicture_Delete( p_spu ); block_Release( p_block ); return NULL; } memcpy( p_spu_sys->p_subs_data, p_block->p_buffer, p_block->i_buffer ); p_spu->i_start = p_block->i_pts; p_spu->i_stop = __MAX( p_sys->i_max_stop, p_block->i_pts + p_block->i_length ); p_spu->b_ephemer = true; p_spu->b_absolute = true; p_sys->i_max_stop = p_spu->i_stop; vlc_mutex_lock( &p_sys->lock ); if( p_sys->p_track ) { ass_process_chunk( p_sys->p_track, p_spu_sys->p_subs_data, p_spu_sys->i_subs_len, p_block->i_pts / 1000, p_block->i_length / 1000 ); } vlc_mutex_unlock( &p_sys->lock ); DecSysHold( p_sys ); /* Keep a reference for the returned subpicture */ block_Release( p_block ); return p_spu; }
/* 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; int width = p_context->coded_width; int height = p_context->coded_height; if( p_sys->p_va == NULL ) { int aligns[AV_NUM_DATA_POINTERS]; avcodec_align_dimensions2(p_context, &width, &height, aligns); } if( width == 0 || height == 0 || width > 8192 || height > 8192 ) { msg_Err( p_dec, "Invalid frame size %dx%d.", width, height ); return NULL; /* invalid display size */ } p_dec->fmt_out.video.i_width = width; p_dec->fmt_out.video.i_height = height; if( width != p_context->width || height != p_context->height ) { p_dec->fmt_out.video.i_visible_width = p_context->width; p_dec->fmt_out.video.i_visible_height = p_context->height; } else { p_dec->fmt_out.video.i_visible_width = width; p_dec->fmt_out.video.i_visible_height = height; } if( !p_sys->p_va && GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) ) { /* we are doomed, but not really, because most codecs set their pix_fmt * much later * FIXME does it make sense here ? */ p_dec->fmt_out.video.i_chroma = VLC_CODEC_I420; } p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma; /* If an aspect-ratio was specified in the input format then force it */ if( p_dec->fmt_in.video.i_sar_num > 0 && p_dec->fmt_in.video.i_sar_den > 0 ) { p_dec->fmt_out.video.i_sar_num = p_dec->fmt_in.video.i_sar_num; p_dec->fmt_out.video.i_sar_den = p_dec->fmt_in.video.i_sar_den; } else { p_dec->fmt_out.video.i_sar_num = p_context->sample_aspect_ratio.num; p_dec->fmt_out.video.i_sar_den = p_context->sample_aspect_ratio.den; if( !p_dec->fmt_out.video.i_sar_num || !p_dec->fmt_out.video.i_sar_den ) { p_dec->fmt_out.video.i_sar_num = 1; p_dec->fmt_out.video.i_sar_den = 1; } } if( p_dec->fmt_in.video.i_frame_rate > 0 && p_dec->fmt_in.video.i_frame_rate_base > 0 ) { p_dec->fmt_out.video.i_frame_rate = p_dec->fmt_in.video.i_frame_rate; p_dec->fmt_out.video.i_frame_rate_base = p_dec->fmt_in.video.i_frame_rate_base; } else if( p_context->time_base.num > 0 && p_context->time_base.den > 0 ) { p_dec->fmt_out.video.i_frame_rate = p_context->time_base.den; p_dec->fmt_out.video.i_frame_rate_base = p_context->time_base.num * __MAX( p_context->ticks_per_frame, 1 ); } return decoder_NewPicture( p_dec ); }