}
sample.p_sample->GetPointer( &p_data );
- p_access->p_libvlc->pf_memcpy( p_block->p_buffer, p_data, i_data_size );
+ vlc_memcpy( p_block->p_buffer, p_data, i_data_size );
sample.p_sample->Release();
/* The caller got what he wanted */
#endif
p_block = block_New( p_demux, i_data_size );
- p_demux->p_libvlc->pf_memcpy( p_block->p_buffer, p_data, i_data_size );
+ vlc_memcpy( p_block->p_buffer, p_data, i_data_size );
p_block->i_pts = p_block->i_dts = i_pts;
sample.p_sample->Release();
/* Copy the S/PDIF headers. */
if( p_filter->output.i_format == VLC_FOURCC('s','p','d','b') )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_sync_be, 6 );
+ vlc_memcpy( p_out, p_sync_be, 6 );
p_out[4] = p_in[5] & 0x7; /* bsmod */
p_out[6] = (i_frame_size >> 4) & 0xff;
p_out[7] = (i_frame_size << 4) & 0xff;
- p_filter->p_libvlc->pf_memcpy( &p_out[8], p_in, i_frame_size * 2 );
+ vlc_memcpy( &p_out[8], p_in, i_frame_size * 2 );
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_sync_le, 6 );
+ vlc_memcpy( p_out, p_sync_le, 6 );
p_out[5] = p_in[5] & 0x7; /* bsmod */
p_out[6] = (i_frame_size << 4) & 0xff;
p_out[7] = (i_frame_size >> 4) & 0xff;
}
#endif
}
- p_filter->p_libvlc->pf_memset( p_out + 8 + i_frame_size * 2, 0,
- AOUT_SPDIF_SIZE - i_frame_size * 2 - 8 );
+ vlc_memset( p_out + 8 + i_frame_size * 2, 0,
+ AOUT_SPDIF_SIZE - i_frame_size * 2 - 8 );
p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
p_out_buf->i_nb_bytes = AOUT_SPDIF_SIZE;
}
/* Backup frame */
- p_filter->p_libvlc->pf_memcpy( p_filter->p_sys->p_buf + p_in_buf->i_nb_bytes *
- p_filter->p_sys->i_frames, p_in_buf->p_buffer,
- p_in_buf->i_nb_bytes );
+ vlc_memcpy( p_filter->p_sys->p_buf + p_in_buf->i_nb_bytes *
+ p_filter->p_sys->i_frames,
+ p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
p_filter->p_sys->i_frames++;
/* Copy the S/PDIF headers. */
if( p_filter->output.i_format == VLC_FOURCC('s','p','d','b') )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_sync_be, 6 );
+ vlc_memcpy( p_out, p_sync_be, 6 );
p_out[5] = i_ac5_spdif_type;
p_out[6] = (( i_length ) >> 5 ) & 0xFF;
p_out[7] = ( i_length << 3 ) & 0xFF;
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_sync_le, 6 );
+ vlc_memcpy( p_out, p_sync_le, 6 );
p_out[4] = i_ac5_spdif_type;
p_out[6] = ( i_length << 3 ) & 0xFF;
p_out[7] = (( i_length ) >> 5 ) & 0xFF;
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out + 8, p_in, i_length );
+ vlc_memcpy( p_out + 8, p_in, i_length );
}
if( i_fz > i_length + 8 )
{
- p_filter->p_libvlc->pf_memset( p_out + 8 + i_length_padded, 0,
- i_fz - i_length_padded - 8 );
+ vlc_memset( p_out + 8 + i_length_padded, 0,
+ i_fz - i_length_padded - 8 );
}
}
break;
case 1:
- p_filter->p_libvlc->pf_memcpy( p_samples, p_left,
- i_samples * sizeof(mad_fixed_t) );
+ vlc_memcpy( p_samples, p_left, i_samples * sizeof(mad_fixed_t) );
break;
default:
/* Copy all our samples in p_in */
if( p_filter->p_sys->i_old_wing )
{
- p_aout->p_libvlc->pf_memcpy( p_in, p_filter->p_sys->p_buf,
- p_filter->p_sys->i_old_wing * 2 *
- p_filter->input.i_bytes_per_frame );
+ vlc_memcpy( p_in, p_filter->p_sys->p_buf,
+ p_filter->p_sys->i_old_wing * 2 *
+ p_filter->input.i_bytes_per_frame );
}
- p_aout->p_libvlc->pf_memcpy( p_in + p_filter->p_sys->i_old_wing * 2 *
- i_nb_channels, p_in_buf->p_buffer,
- p_in_buf->i_nb_samples *
- p_filter->input.i_bytes_per_frame );
+ vlc_memcpy( p_in + p_filter->p_sys->i_old_wing * 2 * i_nb_channels,
+ p_in_buf->p_buffer,
+ p_in_buf->i_nb_samples * p_filter->input.i_bytes_per_frame );
/* Make sure the output buffer is reset */
memset( p_out, 0, p_out_buf->i_size );
return;
}
- p_aout->p_libvlc->pf_memcpy( p_in, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
+ vlc_memcpy( p_in, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
/* Take care of the previous input sample (if any) */
if( !p_filter->b_continuity )
{
/* For whatever reason the buffer allocator decided to allocate
* a new buffer. Currently, this never happens. */
- p_aout->p_libvlc->pf_memcpy( p_out_buf->p_buffer, p_in_buf->p_buffer,
- __MIN(i_out_nb, i_in_nb) * i_sample_bytes );
+ vlc_memcpy( p_out_buf->p_buffer, p_in_buf->p_buffer,
+ __MIN(i_out_nb, i_in_nb) * i_sample_bytes );
}
if ( i_out_nb > i_in_nb )
return;
}
- p_aout->p_libvlc->pf_memcpy( p_in, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
+ vlc_memcpy( p_in, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
for( i_out = i_out_nb ; i_out-- ; )
{
{
aout_buffer_t * p_old_buffer;
- if ( i_available_bytes > 0 )
- p_aout->p_libvlc->pf_memcpy( p_out, p_in, i_available_bytes );
+ vlc_memcpy( p_out, p_in, i_available_bytes );
i_nb_bytes -= i_available_bytes;
p_out += i_available_bytes;
}
else
{
- if ( i_nb_bytes > 0 )
- p_aout->p_libvlc->pf_memcpy( p_out, p_in, i_nb_bytes );
+ vlc_memcpy( p_out, p_in, i_nb_bytes );
p_input->p_first_byte_to_mix = p_in + i_nb_bytes;
break;
}
if( p_sys->i_total_bytes > 0 )
{
i_mData_bytes = __MIN( p_sys->i_total_bytes - p_sys->i_read_bytes, ioData->mBuffers[0].mDataByteSize );
- p_aout->p_libvlc->pf_memcpy( ioData->mBuffers[0].mData, &p_sys->p_remainder_buffer[p_sys->i_read_bytes], i_mData_bytes );
+ vlc_memcpy( ioData->mBuffers[0].mData,
+ &p_sys->p_remainder_buffer[p_sys->i_read_bytes],
+ i_mData_bytes );
p_sys->i_read_bytes += i_mData_bytes;
current_date += (mtime_t) ( (mtime_t) 1000000 / p_aout->output.output.i_rate ) *
( i_mData_bytes / 4 / aout_FormatNbChannels( &p_aout->output.output ) ); // 4 is fl32 specific
{
uint32_t i_second_mData_bytes = __MIN( p_buffer->i_nb_bytes, ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
- p_aout->p_libvlc->pf_memcpy( (uint8_t *)ioData->mBuffers[0].mData + i_mData_bytes, p_buffer->p_buffer, i_second_mData_bytes );
+ vlc_memcpy( (uint8_t *)ioData->mBuffers[0].mData + i_mData_bytes,
+ p_buffer->p_buffer, i_second_mData_bytes );
i_mData_bytes += i_second_mData_bytes;
if( i_mData_bytes >= ioData->mBuffers[0].mDataByteSize )
{
p_sys->i_total_bytes = p_buffer->i_nb_bytes - i_second_mData_bytes;
- p_aout->p_libvlc->pf_memcpy( p_sys->p_remainder_buffer, &p_buffer->p_buffer[i_second_mData_bytes], p_sys->i_total_bytes );
+ vlc_memcpy( p_sys->p_remainder_buffer,
+ &p_buffer->p_buffer[i_second_mData_bytes],
+ p_sys->i_total_bytes );
}
else
{
}
else
{
- p_aout->p_libvlc->pf_memset( (uint8_t *)ioData->mBuffers[0].mData +i_mData_bytes, 0, ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
+ vlc_memset( (uint8_t *)ioData->mBuffers[0].mData +i_mData_bytes,
+ 0,ioData->mBuffers[0].mDataByteSize - i_mData_bytes );
i_mData_bytes += ioData->mBuffers[0].mDataByteSize - i_mData_bytes;
}
}
msg_Warn( p_aout, "bytesize: %d nb_bytes: %d", (int)BUFFER.mDataByteSize, (int)p_buffer->i_nb_bytes );
/* move data into output data buffer */
- p_aout->p_libvlc->pf_memcpy( BUFFER.mData,
- p_buffer->p_buffer, p_buffer->i_nb_bytes );
+ vlc_memcpy( BUFFER.mData, p_buffer->p_buffer, p_buffer->i_nb_bytes );
aout_BufferFree( p_buffer );
}
else
{
- p_aout->p_libvlc->pf_memset( BUFFER.mData, 0, BUFFER.mDataByteSize );
+ vlc_memset( BUFFER.mData, 0, BUFFER.mDataByteSize );
}
#undef BUFFER
p_sys->i_bits_per_sample );
}
- p_aout->p_libvlc->pf_memcpy( p_write_position, p_buffer->p_buffer,
- l_bytes1 );
+ vlc_memcpy( p_write_position, p_buffer->p_buffer, l_bytes1 );
aout_BufferFree( p_buffer );
}
#define i p_sys->nNextBufferIndex
if( p_buffer == NULL )
{
- p_aout->p_libvlc->pf_memset( p_sys->ppBuffers[ i ], 0,
+ vlc_memset( p_aout, p_sys->ppBuffers[ i ], 0,
p_sys->nBufferSize );
}
else
p_sys->i_channels, p_sys->pi_chan_table,
p_sys->i_bits_per_sample );
}
- p_aout->p_libvlc->pf_memcpy( outputBuffer, p_buffer->p_buffer,
- framesPerBuffer * p_sys->i_sample_size );
+ vlc_memcpy( outputBuffer, p_buffer->p_buffer,
+ framesPerBuffer * p_sys->i_sample_size );
/* aout_BufferFree may be dangereous here, but then so is
* aout_OutputNextBuffer (calls aout_BufferFree internally).
* one solution would be to link the no longer useful buffers
else
/* Audio output buffer shortage -> stop the fill process and wait */
{
- p_aout->p_libvlc->pf_memset( outputBuffer, 0,
- framesPerBuffer * p_sys->i_sample_size );
+ vlc_memset( outputBuffer, 0, framesPerBuffer * p_sys->i_sample_size );
}
return 0;
}
if ( p_buffer != NULL )
{
- p_aout->p_libvlc->pf_memcpy( p_stream, p_buffer->p_buffer, i_len );
+ vlc_memcpy( p_stream, p_buffer->p_buffer, i_len );
aout_BufferFree( p_buffer );
}
else
{
- p_aout->p_libvlc->pf_memset( p_stream, 0, i_len );
+ vlc_memset( p_stream, 0, i_len );
}
}
*/
if(b_spdif)
{
- p_aout->p_libvlc->pf_memcpy( p_aout->output.p_sys->p_silence_buffer,
- p_buffer->p_buffer,
- p_aout->output.p_sys->i_buffer_size );
+ vlc_memcpy( p_aout->output.p_sys->p_silence_buffer,
+ p_buffer->p_buffer,
+ p_aout->output.p_sys->i_buffer_size );
p_aout->output.p_sys->i_repeat_counter = 2;
}
} else {
p_aout->output.p_sys->i_repeat_counter--;
if(!p_aout->output.p_sys->i_repeat_counter)
{
- p_aout->p_libvlc->pf_memset( p_aout->output.p_sys->p_silence_buffer,
- 0x00,
- p_aout->output.p_sys->i_buffer_size
- );
+ vlc_memset( p_aout->output.p_sys->p_silence_buffer,
+ 0x00, p_aout->output.p_sys->i_buffer_size );
}
}
p_waveheader->lpData = p_aout->output.p_sys->p_silence_buffer;
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
+ vlc_memcpy( p_dst, p_src, i_width );
p_src += i_width;
p_dst += i_dst_stride;
}
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_enc->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
+ vlc_memcpy( p_dst, p_src, i_width );
p_dst += i_width;
p_src += i_src_stride;
}
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
+ vlc_memcpy( p_dst, p_src, i_width );
p_src += i_width;
p_dst += i_dst_stride;
}
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
i_line++ )
{
- p_enc->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
+ vlc_memcpy( p_dst, p_src, i_width );
p_dst += i_width;
p_src += i_src_stride;
}
/* FIXME: multiple blocks per frame */
if( p_block->i_buffer > i_header_size )
{
- p_dec->p_libvlc->pf_memcpy( p_block->p_buffer,
- p_block->p_buffer + i_header_size,
- p_block->i_buffer - i_header_size );
+ vlc_memcpy( p_block->p_buffer,
+ p_block->p_buffer + i_header_size,
+ p_block->i_buffer - i_header_size );
p_block->i_buffer -= i_header_size;
}
}
if( p_block->i_buffer > 0 )
{
- p_dec->p_libvlc->pf_memcpy( &p_sys->p_buffer[p_sys->i_buffer],
- p_block->p_buffer, p_block->i_buffer );
+ vlc_memcpy(, &p_sys->p_buffer[p_sys->i_buffer],
+ p_block->p_buffer, p_block->i_buffer );
p_sys->i_buffer += p_block->i_buffer;
p_block->i_buffer = 0;
}
return VLC_EGENERIC;
}
- swscale_fast_memcpy = p_filter->p_libvlc->pf_memcpy;
+ swscale_fast_memcpy = vlc_memcpy;
/* Set CPU capabilities */
i_cpu = vlc_CPU();
}
p_sys->p_buffer = p_sys->p_buffer_orig;
p_sys->i_buffer = p_block->i_buffer;
- p_dec->p_libvlc->pf_memcpy( p_sys->p_buffer, p_block->p_buffer,
- p_block->i_buffer );
+ vlc_memcpy( p_sys->p_buffer, p_block->p_buffer, p_block->i_buffer );
memset( p_sys->p_buffer + p_block->i_buffer, 0,
FF_INPUT_BUFFER_PADDING_SIZE );
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_size );
+ vlc_memcpy( p_dst, p_src, i_size );
p_src += i_src_stride;
p_dst += i_dst_stride;
}
p_sys->p_decoder->sync();
p_sys->i_counter = 0;
p_frame = p_sys->p_decoder->frame();
- p_dec->p_libvlc->pf_memcpy( p_pic->p[0].p_pixels, p_frame, i_width*i_height );
+ vlc_memcpy( p_dec, p_pic->p[0].p_pixels, p_frame, i_width*i_height );
p_frame += i_width * i_height;
- p_dec->p_libvlc->pf_memcpy( p_pic->p[1].p_pixels, p_frame, i_width*i_height/4 );
+ vlc_memcpy( p_dec, p_pic->p[1].p_pixels, p_frame, i_width*i_height/4 );
p_frame += i_width * i_height/4;
- p_dec->p_libvlc->pf_memcpy( p_pic->p[2].p_pixels, p_frame, i_width*i_height/4 );
+ vlc_memcpy( p_dec, p_pic->p[2].p_pixels, p_frame, i_width*i_height/4 );
p_pic->date = p_sys->i_pts;
}
block_Release( p_block);
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_width );
+ vlc_memcpy( p_dst, p_src, i_width );
p_src += p_sys->b_invert ? -i_width : i_width;
p_dst += i_width;
}
for( j = 0; j < pic.p[i].i_visible_lines / 2; j++ )
{
- p_dec->p_libvlc->pf_memcpy( p_tmp, p_bottom,
- pic.p[i].i_visible_pitch );
- p_dec->p_libvlc->pf_memcpy( p_bottom, p_top,
- pic.p[i].i_visible_pitch );
- p_dec->p_libvlc->pf_memcpy( p_top, p_tmp,
- pic.p[i].i_visible_pitch );
+ vlc_memcpy( p_tmp, p_bottom, pic.p[i].i_visible_pitch );
+ vlc_memcpy( p_bottom, p_top, pic.p[i].i_visible_pitch );
+ vlc_memcpy( p_top, p_tmp, pic.p[i].i_visible_pitch );
p_top += i_pitch;
p_bottom -= i_pitch;
}
for ( i = 0; i < p_surface->h; i++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_pitch );
+ vlc_memcpy( p_dst, p_src, i_pitch );
p_src += p_surface->pitch;
p_dst += p_pic->p[0].i_pitch;
}
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src, i_src_stride );
+ vlc_memcpy( p_dst, p_src, i_src_stride );
p_src += i_src_stride;
p_dst += i_dst_stride;
for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
{
- p_dec->p_libvlc->pf_memcpy( p_dst, p_src + i_src_xoffset,
- i_plane ? yuv->uv_width : yuv->y_width );
+ vlc_memcpy( p_dst, p_src + i_src_xoffset,
+ i_plane ? yuv->uv_width : yuv->y_width );
p_src += i_src_stride;
p_dst += i_dst_stride;
}
p_sys->p_out_buffer, MAX_CODED_FRAME_SIZE );
p_sys->i_nb_samples = 0;
p_block = block_New( p_enc, i_used );
- p_enc->p_libvlc->pf_memcpy( p_block->p_buffer, p_sys->p_out_buffer,
- i_used );
+ vlc_memcpy( p_block->p_buffer, p_sys->p_out_buffer, i_used );
p_block->i_length = (mtime_t)1000000 *
(mtime_t)MPEG_FRAME_SIZE / (mtime_t)p_enc->fmt_out.audio.i_rate;
p_block->i_dts = p_block->i_pts = p_sys->i_pts;
if( p_aout_buffer != NULL )
{
- p_aout->p_libvlc->pf_memcpy( p_buffer, p_aout_buffer->p_buffer,
- MIN( i_size, p_aout_buffer->i_nb_bytes ) );
+ vlc_memcpy( p_buffer, p_aout_buffer->p_buffer,
+ MIN( i_size, p_aout_buffer->i_nb_bytes ) );
if( p_aout_buffer->i_nb_bytes < i_size )
{
- p_aout->p_libvlc->pf_memset( p_buffer + p_aout_buffer->i_nb_bytes,
- 0, i_size - p_aout_buffer->i_nb_bytes );
+ vlc_memset( p_buffer + p_aout_buffer->i_nb_bytes,
+ 0, i_size - p_aout_buffer->i_nb_bytes );
}
aout_BufferFree( p_aout_buffer );
}
else
{
- p_aout->p_libvlc->pf_memset( p_buffer, 0, i_size );
+ vlc_memset( p_buffer, 0, i_size );
}
}
msg_Err( p_intf, "out of memory" );
return VLC_ENOMEM;
}
- p_intf->p_libvlc->pf_memcpy( p_sys->p_style, &default_text_style,
- sizeof( text_style_t ) );
+ vlc_memcpy( p_sys->p_style, &default_text_style, sizeof( text_style_t ) );
p_intf->pf_run = Run;
for( i = 0; i < FBOSD_RENDER_MAX; i++ )
{
- p_intf->p_libvlc->pf_memcpy( &p_sys->render[i].text_style,
- &default_text_style,
- sizeof( text_style_t ) );
+ vlc_memcpy( &p_sys->render[i].text_style, &default_text_style,
+ sizeof( text_style_t ) );
}
p_sys->b_clear = var_CreateGetBoolCommand( p_intf, "fbosd-clear" );
if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch )
{
/* There are margins, but with the same width : perfect ! */
- p_intf->p_libvlc->pf_memcpy(
- p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
- p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
+ vlc_memcpy( p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
+ p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
}
else
{
p_out += ( i_y_offset * p_dest->p[i].i_pitch );
for( i_line = 0; i_line < ( p_src->p[i].i_visible_lines - i_y_clip ); i_line++ )
{
- p_intf->p_libvlc->pf_memcpy( p_out + i_x, p_in,
- p_src->p[i].i_visible_pitch - i_x_clip );
+ vlc_memcpy( p_out + i_x, p_in,
+ p_src->p[i].i_visible_pitch - i_x_clip );
p_in += p_src->p[i].i_pitch;
p_out += p_dest->p[i].i_pitch;
}
#else
fmt_out = p_region->fmt;
fmt_out.i_bits_per_pixel = 32;
- p_intf->p_libvlc->pf_memcpy( p_fmt, &fmt_out,
- sizeof(video_format_t) );
+ vlc_memcpy( p_fmt, &fmt_out, sizeof(video_format_t) );
p_dest = AllocatePicture( VLC_OBJECT(p_intf), &fmt_out );
if( !p_dest )
{
intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys;
- p_intf->p_libvlc->pf_memcpy( &render->text_style, &default_text_style,
- sizeof( text_style_t ) );
+ vlc_memcpy( &render->text_style, &default_text_style,
+ sizeof( text_style_t ) );
free( render->psz_string );
render->psz_string = NULL;
p_pes->i_length = 0;
if( i_pes_payload > 0 )
{
- p_sout->p_libvlc->pf_memcpy( p_pes->p_buffer + i_pes_header,
- p_data, i_pes_payload );
+ vlc_memcpy( p_pes->p_buffer + i_pes_header, p_data,
+ i_pes_payload );
}
i_pes_count++;
}
else if( i_size > STD_PES_PAYLOAD )
{
block_t *p_new = block_New( p_mux, STD_PES_PAYLOAD );
- p_mux->p_libvlc->pf_memcpy( p_new->p_buffer, p_data->p_buffer, STD_PES_PAYLOAD );
+ vlc_memcpy( p_new->p_buffer, p_data->p_buffer, STD_PES_PAYLOAD );
p_new->i_pts = p_data->i_pts;
p_new->i_dts = p_data->i_dts;
p_new->i_length = p_data->i_length * STD_PES_PAYLOAD
}
i_copy = __MIN( STD_PES_PAYLOAD - i_size, p_next->i_buffer );
- p_mux->p_libvlc->pf_memcpy( &p_data->p_buffer[i_size], p_next->p_buffer,
- i_copy );
+ vlc_memcpy( &p_data->p_buffer[i_size], p_next->p_buffer, i_copy );
p_next->i_pts += p_next->i_length * i_copy / p_next->i_buffer;
p_next->i_dts += p_next->i_length * i_copy / p_next->i_buffer;
p_next->i_length -= p_next->i_length * i_copy / p_next->i_buffer;
= id->ff_enc_c->coded_frame->motion_subsample_log2;
id->p_frame->mb_type = malloc( ((mb_width + 1) * (mb_height + 1) + 1)
* sizeof(uint32_t) );
- p_stream->p_libvlc->pf_memcpy( id->p_frame->mb_type,
- id->ff_enc_c->coded_frame->mb_type,
- (mb_width + 1) * mb_height
- * sizeof(id->p_frame->mb_type[0]));
+ vlc_memcpy( id->p_frame->mb_type, id->ff_enc_c->coded_frame->mb_type,
+ (mb_width + 1) * mb_height * sizeof(id->p_frame->mb_type[0]));
for ( i = 0; i < 2; i++ )
{
{
id->p_frame->motion_val[i] = malloc( 2 * stride * height
* sizeof(int16_t) );
- p_stream->p_libvlc->pf_memcpy( id->p_frame->motion_val[i],
- id->ff_enc_c->coded_frame->motion_val[i],
- 2 * stride * height * sizeof(int16_t) );
+ vlc_memcpy( id->p_frame->motion_val[i],
+ id->ff_enc_c->coded_frame->motion_val[i],
+ 2 * stride * height * sizeof(int16_t) );
}
if ( id->ff_enc_c->coded_frame->ref_index[i] )
{
id->p_frame->ref_index[i] = malloc( b8_stride * 2 * mb_height
* sizeof(int8_t) );
- p_stream->p_libvlc->pf_memcpy( id->p_frame->ref_index[i],
- id->ff_enc_c->coded_frame->ref_index[i],
- b8_stride * 2 * mb_height * sizeof(int8_t));
+ vlc_memcpy( id->p_frame->ref_index[i],
+ id->ff_enc_c->coded_frame->ref_index[i],
+ b8_stride * 2 * mb_height * sizeof(int8_t));
}
}
}
#endif
p_out = block_New( p_stream, i_out );
- p_stream->p_libvlc->pf_memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
+ vlc_memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
p_out->i_length = p_buffer->i_length;
p_out->i_pts = p_buffer->i_dts;
p_out->i_dts = p_buffer->i_dts;
return NULL;
p_out = block_New( p_stream, i_out );
- p_stream->p_libvlc->pf_memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
+ vlc_memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
p_out->i_length = p_buffer->i_length;
p_out->i_pts = p_buffer->i_dts;
p_out->i_dts = p_buffer->i_dts;
while( (i_scale_count -= p_vout->render.i_height) > 0 ) \
{ \
/* Height increment: copy previous picture line */ \
- p_vout->p_libvlc->pf_memcpy( p_pic, p_pic_start, \
- p_vout->output.i_width * BPP ); \
+ vlc_memcpy( p_pic, p_pic_start, p_vout->output.i_width * BPP ); \
p_pic = (void*)((uint8_t*)p_pic + p_dest->p->i_pitch ); \
} \
i_scale_count += p_vout->output.i_height; \
int i_x;
/* Copy the Y part */
- p_vout->p_libvlc->pf_memcpy( p_dest->Y_PIXELS, p_source->Y_PIXELS,
- p_dest->p[Y_PLANE].i_pitch * p_dest->p[Y_PLANE].i_visible_lines );
+ vlc_memcpy( p_dest->Y_PIXELS, p_source->Y_PIXELS,
+ p_dest->p[Y_PLANE].i_pitch * p_dest->p[Y_PLANE].i_visible_lines );
/* Copy the U:V part */
for( i_x = p_dest->p[U_PLANE].i_pitch * p_dest->p[U_PLANE].i_visible_lines / 64;
uint8_t *p_u = p_source->U_PIXELS + (i_y-1)*i_spuv;
uint8_t *p_dv = p_dest->V_PIXELS + (i_y/2-1)*i_dpuv;
uint8_t *p_v = p_source->V_PIXELS + (i_y-1)*i_spuv;
- void *(*pf_memcpy)(void *, const void *, size_t) = p_vout->p_libvlc->pf_memcpy;
i_y /= 2;
for ( ; i_y--; )
{
- pf_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
- pf_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
- pf_memcpy(p_du, p_u, i_width/2); p_du -= i_dpuv; p_u -= 2*i_spuv;
- pf_memcpy(p_dv, p_v, i_width/2); p_dv -= i_dpuv; p_v -= 2*i_spuv;
+ vlc_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
+ vlc_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
+ vlc_memcpy(p_du, p_u, i_width/2); p_du -= i_dpuv; p_u -= 2*i_spuv;
+ vlc_memcpy(p_dv, p_v, i_width/2); p_dv -= i_dpuv; p_v -= 2*i_spuv;
}
}
uint8_t *p_u = p_source->U_PIXELS + (i_y-1)*i_spuv;
uint8_t *p_dv = p_dest->U_PIXELS + (i_y/2-1)*i_dpuv; /* U and V are swapped */
uint8_t *p_v = p_source->V_PIXELS + (i_y-1)*i_spuv;
- void *(*pf_memcpy)(void *, const void *, size_t) = p_vout->p_libvlc->pf_memcpy;
i_y /= 2;
for ( ; i_y--; )
{
- pf_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
- pf_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
- pf_memcpy(p_du, p_u, i_width/2); p_du -= i_dpuv; p_u -= 2*i_spuv;
- pf_memcpy(p_dv, p_v, i_width/2); p_dv -= i_dpuv; p_v -= 2*i_spuv;
+ vlc_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
+ vlc_memcpy(p_dy, p_y, i_width); p_dy -= i_dpy; p_y -= i_spy;
+ vlc_memcpy(p_du, p_u, i_width/2); p_du -= i_dpuv; p_u -= 2*i_spuv;
+ vlc_memcpy(p_dv, p_v, i_width/2); p_dv -= i_dpuv; p_v -= 2*i_spuv;
}
}
picture_t *p_dest )
{
I422_I420( p_vout, p_source, p_dest );
- p_vout->p_libvlc->pf_memset( p_dest->p[A_PLANE].p_pixels, 0xff,
- p_dest->p[A_PLANE].i_lines
- * p_dest->p[A_PLANE].i_pitch );
+ vlc_memset( p_dest->p[A_PLANE].p_pixels, 0xff,
+ p_dest->p[A_PLANE].i_lines * p_dest->p[A_PLANE].i_pitch );
}
for( i_line = 0; i_line < i_lines; i_line++,
p_src += i_src_pitch, p_dst += i_dst_pitch )
{
- p_filter->p_libvlc->pf_memcpy(
- p_dst, p_src, i_visible_pitch );
+ vlc_memcpy( p_dst, p_src, i_visible_pitch );
}
}
else
{
/* plane sizes match */
- p_filter->p_libvlc->pf_memcpy(
- p_apic->p_pixels, p_mask->p_pixels,
- p_mask->i_pitch * p_mask->i_lines );
+ vlc_memcpy( p_apic->p_pixels, p_mask->p_pixels,
+ p_mask->i_pitch * p_mask->i_lines );
}
}
vlc_mutex_unlock( &p_sys->mask_lock );
p_src2_y += i_src2_pitch )
{
/* Completely opaque. Completely overwrite underlying pixel */
- p_filter->p_libvlc->pf_memcpy( p_dst_y, p_src2_y, i_width );
+ vlc_memcpy( p_dst_y, p_src2_y, i_width );
if( b_even_scanline )
{
p_dst_u += i_dst_pitch/2;
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_dst_u, p_src2_u, i_width/2 );
- p_filter->p_libvlc->pf_memcpy( p_dst_v, p_src2_v, i_width/2 );
+ vlc_memcpy( p_dst_u, p_src2_u, i_width/2 );
+ vlc_memcpy( p_dst_v, p_src2_v, i_width/2 );
}
b_even_scanline = !b_even_scanline;
if( i_y%2 == 1 )
}
}
/* Gaussian convolution to make it look cleaner */
- p_filter->p_libvlc->pf_memset( p_a, 0, 2 * i_pitch );
+ vlc_memset( p_a, 0, 2 * i_pitch );
for( i = 2; i < i_lines - 2; i++ )
{
p_a[i*i_pitch] = 0x00;
if( i_in_pitch == i_copy_pitch
&& i_out_pitch == i_copy_pitch )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_in_pitch
+ vlc_memcpy( p_out, p_in, i_in_pitch
* p_outpic->p[i_plane].i_visible_lines );
}
else
while( p_in < p_in_end )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch );
+ vlc_memcpy( p_out, p_in, i_copy_pitch );
p_in += i_in_pitch;
p_out += i_out_pitch;
}
p_out_v = p_outpic->p[V_PLANE].p_pixels;
/* Create grayscale version of input */
- p_filter->p_libvlc->
- pf_memcpy( p_out_y, p_in_y, p_pic->p[Y_PLANE].i_visible_lines
+ vlc_memcpy( p_out_y, p_in_y, p_pic->p[Y_PLANE].i_visible_lines
* p_pic->p[Y_PLANE].i_pitch - 8 );
- p_filter->p_libvlc->
- pf_memset( p_out_u, 0x80, p_pic->p[U_PLANE].i_visible_lines
+ vlc_memset( p_out_u, 0x80, p_pic->p[U_PLANE].i_visible_lines
* p_pic->p[U_PLANE].i_pitch - 8 );
- p_filter->p_libvlc->
- pf_memset( p_out_v, 0x80, p_pic->p[U_PLANE].i_visible_lines
+ vlc_memset( p_out_v, 0x80, p_pic->p[U_PLANE].i_visible_lines
* p_pic->p[U_PLANE].i_pitch - 8 );
/*
while( p_out < p_out_end )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch );
+ vlc_memcpy( p_out, p_in, i_copy_pitch );
p_in += i_in_pitch;
p_out += i_out_pitch;
}
p_in += i_ycrop * p_plane->i_pitch;
/* Padd on the top */
- p_filter->p_libvlc->pf_memset( p_out, i_padd_color,
- i_ypadd * p_outplane->i_pitch );
+ vlc_memset( p_out, i_padd_color, i_ypadd * p_outplane->i_pitch );
p_out += i_ypadd * p_outplane->i_pitch;
int i_line;
p_in += i_xcrop * i_pixel_pitch;
/* Padd on the left */
- p_filter->p_libvlc->pf_memset( p_out, i_padd_color,
- i_xpadd * i_pixel_pitch );
+ vlc_memset( p_out, i_padd_color, i_xpadd * i_pixel_pitch );
p_out += i_xpadd * i_pixel_pitch;
/* Copy the image and crop on the right */
- p_filter->p_libvlc->pf_memcpy( p_out, p_in,
- i_width * i_pixel_pitch );
+ vlc_memcpy( p_out, p_in, i_width * i_pixel_pitch );
p_out += i_width * i_pixel_pitch;
p_in += i_width * i_pixel_pitch;
/* Padd on the right */
- p_filter->p_libvlc->pf_memset( p_out, i_padd_color,
- ( i_outwidth - i_width ) * i_pixel_pitch );
+ vlc_memset( p_out, i_padd_color,
+ ( i_outwidth - i_width ) * i_pixel_pitch );
/* Got to begining of the next line */
p_in = p_in_next;
}
/* Padd on the bottom */
- p_filter->p_libvlc->pf_memset( p_out, i_padd_color,
+ vlc_memset( p_out, i_padd_color,
( i_outheight - i_ypadd - i_height ) * p_outplane->i_pitch );
}
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
p_in += 2 * p_pic->p[i_plane].i_pitch;
{
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
p_in += i_increment;
}
{
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
p_in += i_increment;
}
/* For BOTTOM field we need to add the first line */
if( i_field == 1 )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
}
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_in += 2 * p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
}
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
/* For TOP field we need to add the last line */
if( i_field == 0 )
{
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
}
break;
/* For BOTTOM field we need to add the first line */
if( i_field == 1 )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
}
{
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_in += 2 * p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
{
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
p_in += 2 * p_pic->p[i_plane].i_pitch;
}
}
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
/* For TOP field we need to add the last line */
if( i_field == 0 )
{
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
}
break;
}
/* For BOTTOM field we need to add the first line */
if( i_field == 1 )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
}
for( ; p_out < p_out_end ; )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
}
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
/* For TOP field we need to add the last line */
if( i_field == 0 )
{
p_in += p_pic->p[i_plane].i_pitch;
p_out += p_outpic->p[i_plane].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
}
}
EndMerge();
case VLC_FOURCC('I','Y','U','V'):
case VLC_FOURCC('Y','V','1','2'):
/* First line: simple copy */
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
/* Remaining lines: mean value */
case VLC_FOURCC('I','4','2','2'):
/* First line: simple copy */
- p_vout->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_plane].i_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
p_out += p_outpic->p[i_plane].i_pitch;
/* Remaining lines: mean value */
*pp_region = NULL;
break;
}
- p_filter->p_libvlc->pf_memcpy( (*pp_region)->p_style,
- &p_overlay->fontstyle,
- sizeof(struct text_style_t) );
+ vlc_memcpy( (*pp_region)->p_style, &p_overlay->fontstyle,
+ sizeof(struct text_style_t) );
}
else
{
i_line < (size_t)p_ovl->data.p_pic->p[i_plane].i_visible_lines;
++i_line )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in,
- p_ovl->data.p_pic->p[i_plane].i_visible_pitch );
+ vlc_memcpy( p_out, p_in,
+ p_ovl->data.p_pic->p[i_plane].i_visible_pitch );
p_out += p_ovl->data.p_pic->p[i_plane].i_pitch;
p_in += p_ovl->data.p_pic->p[i_plane].i_visible_pitch;
}
i_width = __MIN( i_visible_pitch - i_x, i_width );
/* Copy original pixel buffer */
- p_filter->p_libvlc->pf_memcpy( p_outpix, p_inpix, i_pitch * i_lines );
+ vlc_memcpy( p_outpix, p_inpix, i_pitch * i_lines );
/* Horizontal linear interpolation of masked areas */
p_outpix = p_outpic->p[i_plane].p_pixels + i_y*i_pitch + i_x;
if( p_filter->p_sys->b_cartoon )
{
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[U_PLANE].p_pixels,
p_inpic->p[U_PLANE].p_pixels,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[V_PLANE].p_pixels,
p_inpic->p[V_PLANE].p_pixels,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
}
else
{
- p_filter->p_libvlc->pf_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
}
if( p_filter->p_sys->b_cartoon )
{
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[U_PLANE].p_pixels,
p_inpic->p[U_PLANE].p_pixels,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[V_PLANE].p_pixels,
p_inpic->p[V_PLANE].p_pixels,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
}
else
{
- p_filter->p_libvlc->pf_memset( p_outpic->p[Y_PLANE].p_pixels, 0xff,
+ vlc_memset( p_outpic->p[Y_PLANE].p_pixels, 0xff,
p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
}
msg_Dbg(p_filter, "Precalculation done");
}
- p_filter->p_libvlc->pf_memset( p_hough, 0,
- i_diag * i_nb_steps * sizeof(int) );
+ vlc_memset( p_hough, 0, i_diag * i_nb_steps * sizeof(int) );
- p_filter->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_outpic->p[Y_PLANE].p_pixels, p_inpic->p[Y_PLANE].p_pixels,
p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_outpic->p[U_PLANE].p_pixels, p_inpic->p[U_PLANE].p_pixels,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_outpic->p[V_PLANE].p_pixels, p_inpic->p[V_PLANE].p_pixels,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
const int i_lines = p_pic->p[i_index].i_lines;
const int i_pitch = p_pic->p[i_index].i_pitch;
- p_filter->p_libvlc->pf_memcpy( p_out, p_in, i_lines * i_pitch );
+ vlc_memcpy( p_out, p_in, i_lines * i_pitch );
}
{
/* We don't want to invert the alpha plane */
i_planes = p_pic->i_planes - 1;
- p_filter->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_outpic->p[A_PLANE].p_pixels, p_pic->p[A_PLANE].p_pixels,
p_pic->p[A_PLANE].i_pitch * p_pic->p[A_PLANE].i_lines );
}
{
for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
{
- p_vout->p_libvlc->
- pf_memcpy( p_outpic->p[i_plane].p_pixels, p_pic->p[i_plane].p_pixels,
+ vlc_memcpy( p_outpic->p[i_plane].p_pixels, p_pic->p[i_plane].p_pixels,
p_outpic->p[i_plane].i_lines * p_outpic->p[i_plane].i_pitch );
}
}
{
for( y=0; y<p_converted->p[i_plane].i_visible_lines; y++)
{
- p_vout->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_outpic->p[i_plane].p_pixels+y*p_outpic->p[i_plane].i_pitch,
p_converted->p[i_plane].p_pixels+y*p_converted->p[i_plane].i_pitch,
p_converted->p[i_plane].i_visible_pitch );
v_w = p_oyp->i_pitch*ZOOM_FACTOR/(VIS_ZOOM*o_zoom);
v_h = (o_y+p_oyp->i_lines*ZOOM_FACTOR/o_zoom)/VIS_ZOOM;
/* top line */
- p_vout->p_libvlc->pf_memset( p_oyp->p_pixels
+ vlc_memset( p_oyp->p_pixels
+ o_y/VIS_ZOOM*p_oyp->i_pitch
+ o_x/VIS_ZOOM, 0xff, v_w+1 );
] = 0xff;
}
/* bottom line */
- p_vout->p_libvlc->pf_memset( p_oyp->p_pixels
+ vlc_memset( p_oyp->p_pixels
+ v_h*p_oyp->i_pitch
+ o_x/VIS_ZOOM, 0xff, v_w+1 );
if( p_vout->p_sys->b_visible )
{
/* zoom gauge */
- p_vout->p_libvlc->pf_memset( p_oyp->p_pixels
- + (v_h+9)*p_oyp->i_pitch,
- 0xff, 41 );
+ vlc_memset( p_oyp->p_pixels + (v_h+9)*p_oyp->i_pitch, 0xff, 41 );
for( y = v_h + 10; y < v_h + 90; y++ )
{
int width = v_h + 90 - y;
width = (width*width)/160;
if( (80 - y + v_h)*10 < o_zoom )
{
- p_vout->p_libvlc->pf_memset( p_oyp->p_pixels
- + y*p_oyp->i_pitch,
- 0xff, width );
+ vlc_memset( p_oyp->p_pixels + y*p_oyp->i_pitch, 0xff, width );
}
else
{
int i_plane;
for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
{
- p_filter->p_libvlc->pf_memcpy(
+ vlc_memcpy(
p_filter->p_sys->pp_planes[i_plane], p_pic->p[i_plane].p_pixels,
p_pic->p[i_plane].i_pitch * p_pic->p[i_plane].i_visible_lines );
}
}
p_outpix = p_outpic->p[Y_PLANE].p_pixels;
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
- p_inpic->p[U_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[U_PLANE].p_pixels, p_inpic->p[U_PLANE].p_pixels,
p_inpic->p[U_PLANE].i_pitch * p_inpic->p[U_PLANE].i_visible_lines );
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
- p_inpic->p[V_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[V_PLANE].p_pixels, p_inpic->p[V_PLANE].p_pixels,
p_inpic->p[V_PLANE].i_pitch * p_inpic->p[V_PLANE].i_visible_lines );
if( !p_sys->p_oldpix || !p_sys->p_buf )
/**
* We're done. Lets keep a copy of the picture
*/
- p_filter->p_libvlc->pf_memcpy( p_oldpix, p_inpix,
- i_src_pitch * i_num_lines );
- p_filter->p_libvlc->pf_memcpy( p_oldpix_u, p_inpix_u,
- i_src_pitch_u * i_num_lines_u );
- p_filter->p_libvlc->pf_memcpy( p_oldpix_v, p_inpix_v,
- i_src_pitch_u * i_num_lines_u );
+ vlc_memcpy( p_oldpix, p_inpix, i_src_pitch * i_num_lines );
+ vlc_memcpy( p_oldpix_u, p_inpix_u, i_src_pitch_u * i_num_lines_u );
+ vlc_memcpy( p_oldpix_v, p_inpix_v, i_src_pitch_u * i_num_lines_u );
vlc_mutex_unlock( &p_filter->p_sys->lock );
if( rand()%8 )
{
/* line isn't noisy */
- p_filter->p_libvlc->pf_memcpy( p_out+i_line*i_pitch,
- p_in+i_line*i_pitch,
- i_num_cols );
+ vlc_memcpy( p_out+i_line*i_pitch, p_in+i_line*i_pitch,
+ i_num_cols );
}
else
{
while( p_in < p_in_end )
{
#ifndef OVERLAP
- p_vout->p_libvlc->pf_memcpy( p_out , p_in, i_copy_pitch);
+ vlc_memcpy( p_out, p_in, i_copy_pitch);
#else
if (p_vout->p_sys->i_col > 2)
{
length /= 2;
if (i_col == 0)
- p_vout->p_libvlc->pf_memcpy( p_out + length , p_in, i_copy_pitch - length);
+ vlc_memcpy( p_out + length , p_in, i_copy_pitch - length);
else if (i_col + 1 == p_vout->p_sys->i_col)
- p_vout->p_libvlc->pf_memcpy( p_out, p_in - length, i_copy_pitch - length);
- else
- p_vout->p_libvlc->pf_memcpy( p_out, p_in - length, i_copy_pitch);
+ vlc_memcpy( p_out, p_in - length, i_copy_pitch - length);
+ else
+ vlc_memcpy( p_out, p_in - length, i_copy_pitch);
if ((i_col == 0))
// black bar
length *= 2;
}
else
- p_vout->p_libvlc->pf_memcpy( p_out , p_in, i_copy_pitch);
+ vlc_memcpy( p_out , p_in, i_copy_pitch);
if (p_vout->p_sys->b_attenuate)
{
while( p_in < p_in_end )
{
#ifndef OVERLAP
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch);
+ vlc_memcpy( p_out, p_in, i_copy_pitch );
#else
if (p_vout->p_sys->i_col > 2)
{
// vertical blend
length /= 2;
if (i_col == 0)
- p_vout->p_libvlc->pf_memcpy( p_out + length, p_in, i_copy_pitch - length);
+ vlc_memcpy( p_out + length, p_in, i_copy_pitch - length);
else if (i_col + 1 == p_vout->p_sys->i_col)
- p_vout->p_libvlc->pf_memcpy( p_out, p_in - length, i_copy_pitch - length);
- else
- p_vout->p_libvlc->pf_memcpy( p_out, p_in - length, i_copy_pitch);
+ vlc_memcpy( p_out, p_in - length, i_copy_pitch - length);
+ else
+ vlc_memcpy( p_out, p_in - length, i_copy_pitch);
if ((i_col == 0))
// black bar
length *= 2;
}
else
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch);
+ vlc_memcpy( p_out, p_in, i_copy_pitch);
// vertical blend
// first blended zone
while( p_in < p_in_end )
{
#ifndef OVERLAP
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch);
+ vlc_memcpy( p_out, p_in, i_copy_pitch);
#else
- p_vout->p_libvlc->pf_memcpy( p_out + i_col * length, p_in + i_col * length, i_copy_pitch - length);
+ vlc_memcpy( p_out + i_col * length, p_in + i_col * length, i_copy_pitch - length);
p_out += LeftOffset;
p_in += LeftOffset;
#ifndef GAMMA
v = p_filter->p_sys->v;
for( y = 0; y<p_outpic->p[U_PLANE].i_lines; y++)
{
- p_filter->p_libvlc->pf_memset(
+ vlc_memset(
p_outpic->p[U_PLANE].p_pixels+y*p_outpic->p[U_PLANE].i_pitch,
u, p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memset(
+ vlc_memset(
p_outpic->p[V_PLANE].p_pixels+y*p_outpic->p[V_PLANE].i_pitch,
v, p_outpic->p[V_PLANE].i_pitch );
if( v == 0 && u != 0 )
}
/* luminance */
- p_filter->p_libvlc->pf_memcpy(
- p_outpic->p[Y_PLANE].p_pixels, p_pic->p[Y_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[Y_PLANE].p_pixels, p_pic->p[Y_PLANE].p_pixels,
p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
/* image visualization */
uint8_t color = ( i_plane == Y_PLANE ? 0x0 : 0x80 );
for( ; i_row < i_last_row; i_row++, i_orow++ )
{
- p_vout->p_libvlc->
- pf_memset( p_out->p_pixels + i_row * i_pitch
+ vlc_memset( p_out->p_pixels + i_row * i_pitch
+ i_col * i_pitch / i_cols,
color, i_pitch / i_cols );
}
{
for( ; i_row < i_last_row; i_row++, i_orow++ )
{
- p_vout->p_libvlc->
- pf_memcpy( p_out->p_pixels + i_row * i_pitch
+ vlc_memcpy( p_out->p_pixels + i_row * i_pitch
+ i_col * i_pitch / i_cols,
p_in->p_pixels + i_orow * i_pitch
+ i_ocol * i_pitch / i_cols,
int i_last_row = i_row + 1;
i_row *= p_in->i_lines / i_rows;
i_last_row *= p_in->i_lines / i_rows;
- p_vout->p_libvlc->
- pf_memset( p_out->p_pixels + i_row * i_pitch
+ vlc_memset( p_out->p_pixels + i_row * i_pitch
+ i_col * i_pitch / i_cols,
0xff, i_pitch / i_cols );
for( ; i_row < i_last_row; i_row++ )
+ (i_col+1) * i_pitch / i_cols - 1 ] = 0xff;
}
i_row--;
- p_vout->p_libvlc->
- pf_memset( p_out->p_pixels + i_row * i_pitch
+ vlc_memset( p_out->p_pixels + i_row * i_pitch
+ i_col * i_pitch / i_cols,
0xff, i_pitch / i_cols );
}
for( i_line = 0 ; i_line < i_first_line ; i_line++ )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_index].i_visible_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_index].i_visible_pitch );
p_in += p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
{
if( i_offset < 0 )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in - i_offset,
- p_pic->p[i_index].i_visible_pitch + i_offset );
+ vlc_memcpy( p_out, p_in - i_offset,
+ p_pic->p[i_index].i_visible_pitch + i_offset );
p_in -= p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
- p_filter->p_libvlc->pf_memset( p_out + i_offset,
- black_pixel, -i_offset );
+ vlc_memset( p_out + i_offset, black_pixel, -i_offset );
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out + i_offset, p_in,
- p_pic->p[i_index].i_visible_pitch - i_offset );
- p_filter->p_libvlc->pf_memset( p_out, black_pixel,
- i_offset );
+ vlc_memcpy( p_out + i_offset, p_in,
+ p_pic->p[i_index].i_visible_pitch - i_offset );
+ vlc_memset( p_out, black_pixel, i_offset );
p_in -= p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in,
- p_pic->p[i_index].i_visible_pitch );
+ vlc_memcpy( p_out, p_in, p_pic->p[i_index].i_visible_pitch );
p_in -= p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
p_filter->p_sys->p_grad = (int*)malloc(i_src_pitch * i_num_lines * sizeof(int));
//#if defined( DRAW_GRADIENT ) || defined( DRAW_ENERGY ) || defined( DRAW_SEAM )
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[Y_PLANE].p_pixels,
- p_inpic->p[Y_PLANE].p_pixels,
+ vlc_memcpy( p_outpic->p[Y_PLANE].p_pixels, p_inpic->p[Y_PLANE].p_pixels,
p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
//#else
-// p_filter->p_libvlc->pf_memset( p_outpix, 0x80,
+// vlc_memset( p_outpix, 0x80,
// p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
//#endif
- p_filter->p_libvlc->pf_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
+ vlc_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
#if defined( DRAW_GRADIENT ) || defined( DRAW_ENERGY ) || defined( DRAW_SEAM )
i_src_visible = RemoveVerticalSeam( p_filter, p_outpic, p_outpic, i_src_visible );
int y;
for( y = 0; y < p_outpic->p[Y_PLANE].i_lines; y++ )
- p_filter->p_libvlc->pf_memset( p_outpic->p[Y_PLANE].p_pixels + y*p_outpic->p[Y_PLANE].i_pitch + i_src_visible, 0x00, p_outpic->p[Y_PLANE].i_pitch - i_src_visible );
+ vlc_memset( p_outpic->p[Y_PLANE].p_pixels + y*p_outpic->p[Y_PLANE].i_pitch + i_src_visible, 0x00, p_outpic->p[Y_PLANE].i_pitch - i_src_visible );
j += k;
if( j == 100 ) k = -1;
if( j == 1 ) k = 1;
}
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
- p_pic->p[U_PLANE].p_pixels,
- p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
+ vlc_memcpy( p_outpic->p[U_PLANE].p_pixels, p_pic->p[U_PLANE].p_pixels,
+ p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
- p_filter->p_libvlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
- p_pic->p[V_PLANE].p_pixels,
- p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
+ vlc_memcpy( p_outpic->p[V_PLANE].p_pixels, p_pic->p[V_PLANE].p_pixels,
+ p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
p_outpic->date = p_pic->date;
for( ; p_in < p_in_end ; )
{
p_in_end -= p_pic->p[i_index].i_pitch;
- p_vout->p_libvlc->pf_memcpy( p_out, p_in_end,
- p_pic->p[i_index].i_visible_pitch );
+ vlc_memcpy( p_out, p_in_end,
+ p_pic->p[i_index].i_visible_pitch );
p_out += p_pic->p[i_index].i_pitch;
}
}
while( p_in < p_in_end )
{
- p_vout->p_libvlc->pf_memcpy( p_out, p_in, i_copy_pitch );
+ vlc_memcpy( p_out, p_in, i_copy_pitch );
p_in += i_in_pitch;
p_out += i_out_pitch;
}
{
if( i_offset < 0 )
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in - i_offset,
- i_visible_pitch + i_offset );
+ vlc_memcpy( p_out, p_in - i_offset,
+ i_visible_pitch + i_offset );
p_in += p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
- p_filter->p_libvlc->pf_memset( p_out + i_offset,
- black_pixel, -i_offset );
+ vlc_memset( p_out + i_offset, black_pixel, -i_offset );
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out + i_offset, p_in,
- i_visible_pitch - i_offset );
- p_filter->p_libvlc->pf_memset( p_out, black_pixel,
- i_offset );
+ vlc_memcpy( p_out + i_offset, p_in,
+ i_visible_pitch - i_offset );
+ vlc_memset( p_out, black_pixel, i_offset );
p_in += p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
else
{
- p_filter->p_libvlc->pf_memcpy( p_out, p_in,
- i_visible_pitch );
+ vlc_memcpy( p_out, p_in, i_visible_pitch );
p_in += p_pic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
if( !p_vout->p_sys->b_hw_accel )
{
- p_vout->p_libvlc->pf_memcpy( p_vout->p_sys->p_video, p_pic->p->p_pixels,
- p_vout->p_sys->i_page_size );
+ vlc_memcpy( p_vout->p_sys->p_video, p_pic->p->p_pixels,
+ p_vout->p_sys->i_page_size );
}
}
i_index = p_vout->p_sys->i_index;
- p_vout->p_libvlc->pf_memcpy( p_vout->p_sys->p_list[i_index]->p_data,
- p_pic->p->p_pixels,
- p_vout->p_sys->i_datasize );
+ vlc_memcpy( p_vout->p_sys->p_list[i_index]->p_data, p_pic->p->p_pixels,
+ p_vout->p_sys->i_datasize );
i_date = snapshot_GetMovietime( p_vout );
/ p_input->input.i_rate;
aout_BufferAlloc( &p_input->input_alloc, duration, NULL, p_new_buffer );
- p_aout->p_libvlc->pf_memcpy( p_new_buffer->p_buffer, p_buffer->p_buffer,
- p_buffer->i_nb_bytes );
+ vlc_memcpy( p_new_buffer->p_buffer, p_buffer->p_buffer,
+ p_buffer->i_nb_bytes );
p_new_buffer->i_nb_samples = p_buffer->i_nb_samples;
p_new_buffer->i_nb_bytes = p_buffer->i_nb_bytes;
p_new_buffer->start_date = p_buffer->start_date;
if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch )
{
/* There are margins, but with the same width : perfect ! */
- p_this->p_libvlc->pf_memcpy(
- p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
- p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
+ vlc_memcpy( p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
+ p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
}
else
{
for( i_line = p_src->p[i].i_visible_lines; i_line--; )
{
- p_this->p_libvlc->pf_memcpy( p_out, p_in,
- p_src->p[i].i_visible_pitch );
+ vlc_memcpy( p_out, p_in, p_src->p[i].i_visible_pitch );
p_in += p_src->p[i].i_pitch;
p_out += p_dest->p[i].i_pitch;
}
projects / vlc / commitdiff