/*****************************************************************************
* OpenScaler: probe the filter and return score
*****************************************************************************/
static int OpenScaler( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys;
/* Allocate the memory needed to store the decoder's structure */
if( ( p_filter->p_sys = p_sys =
(filter_sys_t *)malloc(sizeof(filter_sys_t)) ) == NULL )
{
return VLC_ENOMEM;
}
/* Misc init */
p_sys->ctx = NULL;
p_filter->pf_video_filter = Filter;
es_format_Init( &p_sys->fmt_in, 0, 0 );
es_format_Init( &p_sys->fmt_out, 0, 0 );
if( Init( p_filter ) )
{
free( p_sys );
return VLC_EGENERIC;
}
msg_Dbg( p_filter, "%ix%i chroma: %4.4s -> %ix%i chroma: %4.4s",
p_filter->fmt_in.video.i_width, p_filter->fmt_in.video.i_height,
(char *)&p_filter->fmt_in.video.i_chroma,
p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height,
(char *)&p_filter->fmt_out.video.i_chroma );
return VLC_SUCCESS;
}
/**
* Filter chain initialisation
*/
filter_chain_t *filter_chain_New( vlc_object_t *p_this,
const char *psz_capability,
bool b_allow_fmt_out_change,
int (*pf_buffer_allocation_init)( filter_t *, void * ),
void (*pf_buffer_allocation_clean)( filter_t * ),
void *p_buffer_allocation_data )
{
assert( p_this );
assert( psz_capability );
size_t size = sizeof(filter_chain_t) + strlen(psz_capability);
filter_chain_t *p_chain = malloc( size );
if( !p_chain )
return NULL;
p_chain->p_this = p_this;
p_chain->last = p_chain->first = NULL;
p_chain->length = 0;
strcpy( p_chain->psz_capability, psz_capability );
es_format_Init( &p_chain->fmt_in, UNKNOWN_ES, 0 );
es_format_Init( &p_chain->fmt_out, UNKNOWN_ES, 0 );
p_chain->b_allow_fmt_out_change = b_allow_fmt_out_change;
p_chain->allocator.pf_init = pf_buffer_allocation_init;
p_chain->allocator.pf_clean = pf_buffer_allocation_clean;
p_chain->allocator.p_data = p_buffer_allocation_data;
return p_chain;
}
static decoder_t *CreateDecoder( vlc_object_t *p_this, video_format_t *fmt )
{
decoder_t *p_dec;
p_dec = vlc_custom_create( p_this, sizeof( *p_dec ), "image decoder" );
if( p_dec == NULL )
return NULL;
p_dec->p_module = NULL;
es_format_Init( &p_dec->fmt_in, VIDEO_ES, fmt->i_chroma );
es_format_Init( &p_dec->fmt_out, VIDEO_ES, 0 );
p_dec->fmt_in.video = *fmt;
p_dec->b_frame_drop_allowed = false;
p_dec->pf_vout_format_update = video_update_format;
p_dec->pf_vout_buffer_new = video_new_buffer;
/* Find a suitable decoder module */
p_dec->p_module = module_need( p_dec, "decoder", "$codec", false );
if( !p_dec->p_module )
{
msg_Err( p_dec, "no suitable decoder module for fourcc `%4.4s'. "
"VLC probably does not support this image format.",
(char*)&p_dec->fmt_in.i_codec );
DeleteDecoder( p_dec );
return NULL;
}
return p_dec;
}
filter_t *filter_NewBlend( vlc_object_t *p_this,
const video_format_t *p_dst_chroma )
{
filter_t *p_blend = vlc_custom_create( p_this, sizeof(*p_blend),
VLC_OBJECT_GENERIC, "blend" );
if( !p_blend )
return NULL;
es_format_Init( &p_blend->fmt_in, VIDEO_ES, 0 );
es_format_Init( &p_blend->fmt_out, VIDEO_ES, 0 );
p_blend->fmt_out.i_codec =
p_blend->fmt_out.video.i_chroma = p_dst_chroma->i_chroma;
p_blend->fmt_out.video.i_rmask = p_dst_chroma->i_rmask;
p_blend->fmt_out.video.i_gmask = p_dst_chroma->i_gmask;
p_blend->fmt_out.video.i_bmask = p_dst_chroma->i_bmask;
p_blend->fmt_out.video.i_rrshift= p_dst_chroma->i_rrshift;
p_blend->fmt_out.video.i_rgshift= p_dst_chroma->i_rgshift;
p_blend->fmt_out.video.i_rbshift= p_dst_chroma->i_rbshift;
p_blend->fmt_out.video.i_lrshift= p_dst_chroma->i_lrshift;
p_blend->fmt_out.video.i_lgshift= p_dst_chroma->i_lgshift;
p_blend->fmt_out.video.i_lbshift= p_dst_chroma->i_lbshift;
/* The blend module will be loaded when needed with the real
* input format */
p_blend->p_module = NULL;
return p_blend;
}
/*****************************************************************************
* Open: initializes demux structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
uint8_t *p_peek;
vlc_value_t val;
if( stream_Peek( p_demux->s, &p_peek, 5 ) < 5 ) return VLC_EGENERIC;
if( p_peek[0] != 0x00 || p_peek[1] != 0x00 ||
p_peek[2] != 0x00 || p_peek[3] != 0x01 ||
(p_peek[4]&0x1F) != 7 ) /* SPS */
{
if( !p_demux->b_force )
{
msg_Warn( p_demux, "h264 module discarded (no startcode)" );
return VLC_EGENERIC;
}
msg_Err( p_demux, "this doesn't look like a H264 ES stream, "
"continuing anyway" );
}
p_demux->pf_demux = Demux;
p_demux->pf_control= Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
p_sys->p_es = NULL;
p_sys->i_dts = 1;
var_Create( p_demux, "h264-fps", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );
var_Get( p_demux, "h264-fps", &val );
p_sys->f_fps = val.f_float;
if( val.f_float < 0.001 ) p_sys->f_fps = 0.001;
msg_Dbg( p_demux, "using %.2f fps", p_sys->f_fps );
/*
* Load the mpegvideo packetizer
*/
p_sys->p_packetizer = vlc_object_create( p_demux, VLC_OBJECT_PACKETIZER );
p_sys->p_packetizer->pf_decode_audio = NULL;
p_sys->p_packetizer->pf_decode_video = NULL;
p_sys->p_packetizer->pf_decode_sub = NULL;
p_sys->p_packetizer->pf_packetize = NULL;
es_format_Init( &p_sys->p_packetizer->fmt_in, VIDEO_ES,
VLC_FOURCC( 'h', '2', '6', '4' ) );
es_format_Init( &p_sys->p_packetizer->fmt_out, UNKNOWN_ES, 0 );
p_sys->p_packetizer->p_module =
module_Need( p_sys->p_packetizer, "packetizer", NULL, 0 );
if( p_sys->p_packetizer->p_module == NULL)
{
vlc_object_destroy( p_sys->p_packetizer );
msg_Err( p_demux, "cannot find mp4v packetizer" );
free( p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initializes demux structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
bool b_forced = false;
const uint8_t *p_peek;
es_format_t fmt;
if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 )
{
msg_Err( p_demux, "cannot peek" );
return VLC_EGENERIC;
}
if( p_demux->b_force )
b_forced = true;
if( p_peek[0] != 0x00 || p_peek[1] != 0x00 || p_peek[2] != 0x01 )
{
if( !b_forced ) return VLC_EGENERIC;
msg_Err( p_demux, "this doesn't look like an MPEG ES stream, continuing" );
}
if( p_peek[3] > 0xb9 )
{
if( !b_forced ) return VLC_EGENERIC;
msg_Err( p_demux, "this seems to be a system stream (PS plug-in ?), but continuing" );
}
p_demux->pf_demux = Demux;
p_demux->pf_control= Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
p_sys->b_start = true;
p_sys->p_es = NULL;
/* Load the mpegvideo packetizer */
es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_MPGV );
p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "mpeg video" );
if( !p_sys->p_packetizer )
{
free( p_sys );
return VLC_EGENERIC;
}
/* create the output */
es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_MPGV );
p_sys->p_es = es_out_Add( p_demux->out, &fmt );
return VLC_SUCCESS;
}
/*****************************************************************************
* DecoderOpen: open/initialize the svcdsub decoder.
*****************************************************************************/
static int DecoderOpen( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
decoder_sys_t *p_sys;
if( p_dec->fmt_in.i_codec != VLC_CODEC_OGT )
return VLC_EGENERIC;
p_dec->p_sys = p_sys = calloc( 1, sizeof( decoder_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_sys->i_debug = var_InheritInteger( p_this, MODULE_STRING "-debug" );
p_sys->i_image = -1;
p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
p_sys->p_spu = NULL;
es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_CODEC_OGT );
p_dec->pf_decode_sub = Decode;
p_dec->pf_packetize = Packetize;
dbg_print( (DECODE_DBG_CALL) , "");
return VLC_SUCCESS;
}
static int OpenAudioDev( demux_t *p_demux, const char *psz_device )
{
demux_sys_t *p_sys = p_demux->p_sys;
if( OpenAudioDevAlsa( p_demux, psz_device ) != VLC_SUCCESS )
return VLC_EGENERIC;
msg_Dbg( p_demux, "opened adev=`%s' %s %dHz",
psz_device, p_sys->b_stereo ? "stereo" : "mono",
p_sys->i_sample_rate );
es_format_t fmt;
es_format_Init( &fmt, AUDIO_ES, VLC_FOURCC('a','r','a','w') );
fmt.audio.i_channels = p_sys->b_stereo ? 2 : 1;
fmt.audio.i_rate = p_sys->i_sample_rate;
fmt.audio.i_bitspersample = 16;
fmt.audio.i_blockalign = fmt.audio.i_channels * fmt.audio.i_bitspersample / 8;
fmt.i_bitrate = fmt.audio.i_channels * fmt.audio.i_rate * fmt.audio.i_bitspersample;
msg_Dbg( p_demux, "new audio es %d channels %dHz",
fmt.audio.i_channels, fmt.audio.i_rate );
p_sys->p_es = es_out_Add( p_demux->out, &fmt );
return VLC_SUCCESS;
}
static picture_t *ImageFilter( image_handler_t *p_image, picture_t *p_pic,
video_format_t *p_fmt, const char *psz_module )
{
/* Start a filter */
if( !p_image->p_filter )
{
es_format_t fmt;
es_format_Init( &fmt, VIDEO_ES, p_fmt->i_chroma );
fmt.video = *p_fmt;
p_image->p_filter =
CreateFilter( p_image->p_parent, &fmt, &fmt.video, psz_module );
if( !p_image->p_filter )
{
return NULL;
}
}
else
{
/* Filters should handle on-the-fly size changes */
p_image->p_filter->fmt_in.video = *p_fmt;
p_image->p_filter->fmt_out.video = *p_fmt;
}
picture_Hold( p_pic );
return p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
}
/*****************************************************************************
* Open: check file and initializes structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
/* Identify cdg file by extension, as there is no simple way to
* detect it */
if( !demux_IsPathExtension( p_demux, ".cdg" ) && !demux_IsForced( p_demux, "cdg" ) )
return VLC_EGENERIC;
/* CDG file size has to be multiple of CDG_FRAME_SIZE (it works even
* if size is unknown ie 0) */
// if( (stream_Size( p_demux->s ) % CDG_FRAME_SIZE) != 0 )
// {
// msg_Err( p_demux, "Reject CDG file based on its size" );
// return VLC_EGENERIC;
// }
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
/* */
es_format_Init( &p_sys->fmt, VIDEO_ES, VLC_CODEC_CDG );
p_sys->fmt.video.i_width = 300-2*6;
p_sys->fmt.video.i_height = 216-2*12 ;
p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt );
/* There is CDG_FRAME_RATE frames per second */
date_Init( &p_sys->pts, CDG_FRAME_RATE, 1 );
date_Set( &p_sys->pts, 1 );
return VLC_SUCCESS;
}
static int Open (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = vlc_malloc(obj, sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
es_format_t fmt;
es_format_Init (&fmt, SPU_ES, VLC_CODEC_ITU_T140);
sys->es = es_out_Add (demux->out, &fmt);
unsigned num, den;
if (var_InheritURational (demux, &num, &den, "timecode-fps")
|| !num || !den)
{
msg_Err (demux, "invalid frame rate");
return VLC_EGENERIC;
}
date_Init (&sys->date, num, den);
date_Set (&sys->date, VLC_TS_0);
sys->next_time = VLC_TS_INVALID;
demux->p_sys = sys;
demux->pf_demux = Demux;
demux->pf_control = Control;
return VLC_SUCCESS;
}
/*****************************************************************************
* DecoderOpen: open/initialize the svcdsub decoder.
*****************************************************************************/
static int DecoderOpen( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
decoder_sys_t *p_sys;
if( p_dec->fmt_in.i_codec != VLC_CODEC_OGT )
return VLC_EGENERIC;
p_dec->p_sys = p_sys = calloc( 1, sizeof( decoder_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_sys->i_image = -1;
p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
p_sys->p_spu = NULL;
es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_CODEC_OGT );
p_dec->pf_decode_sub = Decode;
p_dec->pf_packetize = Packetize;
return VLC_SUCCESS;
}
/*
* OSD menu
*/
int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_sys_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
id->p_decoder->fmt_in.i_cat = SPU_ES;
id->p_encoder->fmt_out.psz_language = strdup( "osd" );
if( p_sys->i_osdcodec != 0 || p_sys->psz_osdenc )
{
msg_Dbg( p_stream, "creating osdmenu transcoding from fcc=`%4.4s' "
"to fcc=`%4.4s'", (char*)&id->p_encoder->fmt_out.i_codec,
(char*)&p_sys->i_osdcodec );
/* Complete destination format */
id->p_encoder->fmt_out.i_codec = p_sys->i_osdcodec;
/* Open encoder */
es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
VLC_CODEC_YUVA );
id->p_encoder->fmt_in.psz_language = strdup( "osd" );
id->p_encoder->p_cfg = p_sys->p_osd_cfg;
id->p_encoder->p_module =
module_need( id->p_encoder, "encoder", p_sys->psz_osdenc, true );
if( !id->p_encoder->p_module )
{
msg_Err( p_stream, "cannot find spu encoder (%s)", p_sys->psz_osdenc );
goto error;
}
/* open output stream */
id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_encoder->fmt_out );
id->b_transcode = true;
if( !id->id ) goto error;
}
else
{
msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')",
(char*)&id->p_decoder->fmt_out.i_codec );
id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_decoder->fmt_out );
id->b_transcode = false;
if( !id->id ) goto error;
}
if( !p_sys->p_spu )
p_sys->p_spu = spu_Create( p_stream );
return VLC_SUCCESS;
error:
msg_Err( p_stream, "starting osd encoding thread failed" );
if( id->p_encoder->p_module )
module_unneed( id->p_encoder, id->p_encoder->p_module );
p_sys->b_osd = false;
return VLC_EGENERIC;
}
static es_format_t GetModeSettings(demux_t *demux, IDeckLinkDisplayMode *m)
{
demux_sys_t *sys = demux->p_sys;
uint32_t flags = 0;
(void)GetFieldDominance(m->GetFieldDominance(), &flags);
BMDTimeValue frame_duration, time_scale;
if (m->GetFrameRate(&frame_duration, &time_scale) != S_OK) {
time_scale = 0;
frame_duration = 1;
}
es_format_t video_fmt;
vlc_fourcc_t chroma = sys->tenbits ? VLC_CODEC_I422_10L : VLC_CODEC_UYVY;
es_format_Init(&video_fmt, VIDEO_ES, chroma);
video_fmt.video.i_width = m->GetWidth();
video_fmt.video.i_height = m->GetHeight();
video_fmt.video.i_sar_num = 1;
video_fmt.video.i_sar_den = 1;
video_fmt.video.i_frame_rate = time_scale;
video_fmt.video.i_frame_rate_base = frame_duration;
video_fmt.i_bitrate = video_fmt.video.i_width * video_fmt.video.i_height * video_fmt.video.i_frame_rate * 2 * 8;
unsigned aspect_num, aspect_den;
if (!var_InheritURational(demux, &aspect_num, &aspect_den, "decklink-aspect-ratio") &&
aspect_num > 0 && aspect_den > 0) {
video_fmt.video.i_sar_num = aspect_num * video_fmt.video.i_height;
video_fmt.video.i_sar_den = aspect_den * video_fmt.video.i_width;
}
sys->dominance_flags = flags;
return video_fmt;
}
/* PT=32
* MPV: MPEG Video (RFC2250, §3.5)
*/
static void *mpv_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, VIDEO_ES, VLC_CODEC_MPGV);
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
static void *l16m_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_S16B);
fmt.audio.i_rate = 44100;
fmt.audio.i_channels = 1;
return codec_init (demux, &fmt);
}
/* PT=12
* QCELP
*/
static void *qcelp_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_QCELP);
fmt.audio.i_rate = 8000;
fmt.audio.i_channels = 1;
return codec_init (demux, &fmt);
}
/* PT=14
* MPA: MPEG Audio (RFC2250, §3.4)
*/
static void *mpa_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_MPGA);
fmt.audio.i_channels = 2;
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
/* PT=10,11
* L16: 16-bits (network byte order) PCM
*/
static void *l16s_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_S16B);
fmt.audio.i_rate = 44100;
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHANS_STEREO;
return codec_init (demux, &fmt);
}
/* PT=14
* MPA: MPEG Audio (RFC2250, §3.4)
*/
static void *mpa_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_MPGA);
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHANS_STEREO;
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
/* PT=12
* QCELP
*/
static void *qcelp_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_QCELP);
fmt.audio.i_rate = 8000;
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHAN_CENTER;
return codec_init (demux, &fmt);
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
decoder_sys_t *p_sys;
if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'm', 'p', 'g', '1' ) &&
p_dec->fmt_in.i_codec != VLC_FOURCC( 'm', 'p', 'g', '2' ) &&
p_dec->fmt_in.i_codec != VLC_FOURCC( 'm', 'p', 'g', 'v' ) )
{
return VLC_EGENERIC;
}
es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC('m','p','g','v') );
p_dec->pf_packetize = Packetize;
p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );
/* Misc init */
p_sys->i_state = STATE_NOSYNC;
p_sys->bytestream = block_BytestreamInit( p_dec );
p_sys->p_startcode[0] = 0;
p_sys->p_startcode[1] = 0;
p_sys->p_startcode[2] = 1;
p_sys->i_offset = 0;
p_sys->p_seq = NULL;
p_sys->p_ext = NULL;
p_sys->p_frame = NULL;
p_sys->pp_last = &p_sys->p_frame;
p_sys->b_frame_slice = VLC_FALSE;
p_sys->i_dts = p_sys->i_pts = 0;
p_sys->i_frame_rate = 1;
p_sys->i_frame_rate_base = 1;
p_sys->b_seq_progressive = VLC_TRUE;
p_sys->b_low_delay = VLC_TRUE;
p_sys->i_seq_old = 0;
p_sys->i_temporal_ref = 0;
p_sys->i_picture_type = 0;
p_sys->i_picture_structure = 0x03; /* frame */
p_sys->i_top_field_first = 0;
p_sys->i_repeat_first_field = 0;
p_sys->i_progressive_frame = 0;
p_sys->b_inited = 0;
p_sys->i_interpolated_dts = 0;
p_sys->i_old_duration = 0;
p_sys->i_last_ref_pts = 0;
return VLC_SUCCESS;
}
vlc_v4l2_vbi_t *OpenVBI (demux_t *demux, const char *psz_device)
{
vlc_v4l2_vbi_t *vbi = malloc (sizeof (*vbi));
if (unlikely(vbi == NULL))
return NULL;
int rawfd = vlc_open (psz_device, O_RDWR);
if (rawfd == -1)
{
msg_Err (demux, "cannot open device '%s': %m", psz_device);
goto err;
}
//Can put more in here. See osd.c in zvbi package.
unsigned int services = VBI_SLICED_CAPTION_525;
char *errstr = NULL;
vbi->cap = vbi_capture_v4l2k_new (psz_device, rawfd,
/* buffers */ 5,
&services,
/* strict */ 1,
&errstr,
/* verbose */ 1);
if (vbi->cap == NULL)
{
msg_Err (demux, "cannot capture VBI data: %s", errstr);
free (errstr);
goto err;
}
for (unsigned i = 0; i < VBI_NUM_CC_STREAMS; i++)
{
es_format_t fmt;
es_format_Init (&fmt, SPU_ES, VLC_FOURCC('c', 'c', '1' + i, ' '));
if (asprintf (&fmt.psz_description, "Closed captions %d", i + 1) >= 0)
{
msg_Dbg (demux, "new spu es %4.4s", (char *)&fmt.i_codec);
vbi->es[i] = es_out_Add (demux->out, &fmt);
}
}
/* Do a single read and throw away the results so that ZVBI calls
the STREAMON ioctl() */
GrabVBI(demux, vbi);
return vbi;
err:
free (vbi);
return NULL;
}
static filter_chain_t *filter_chain_NewInner( const filter_owner_t *callbacks,
const char *cap, bool fmt_out_change, const filter_owner_t *owner )
{
assert( callbacks != NULL && callbacks->sys != NULL );
assert( cap != NULL );
filter_chain_t *chain = malloc( sizeof(*chain) + strlen( cap ) );
if( unlikely(chain == NULL) )
return NULL;
chain->callbacks = *callbacks;
if( owner != NULL )
chain->owner = *owner;
chain->first = NULL;
chain->last = NULL;
es_format_Init( &chain->fmt_in, UNKNOWN_ES, 0 );
es_format_Init( &chain->fmt_out, UNKNOWN_ES, 0 );
chain->length = 0;
chain->b_allow_fmt_out_change = fmt_out_change;
strcpy( chain->psz_capability, cap );
return chain;
}
int transcode_spu_new( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
/*
* Open decoder
*/
/* Initialization of decoder structures */
id->p_decoder->pf_decode_sub = NULL;
id->p_decoder->pf_spu_buffer_new = spu_new_buffer;
id->p_decoder->pf_spu_buffer_del = spu_del_buffer;
id->p_decoder->p_owner = (decoder_owner_sys_t *)p_stream;
/* id->p_decoder->p_cfg = p_sys->p_spu_cfg; */
id->p_decoder->p_module =
module_need( id->p_decoder, "decoder", "$codec", false );
if( !id->p_decoder->p_module )
{
msg_Err( p_stream, "cannot find spu decoder" );
return VLC_EGENERIC;
}
if( !p_sys->b_soverlay )
{
/* Open encoder */
/* Initialization of encoder format structures */
es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
id->p_decoder->fmt_in.i_codec );
id->p_encoder->p_cfg = p_sys->p_spu_cfg;
id->p_encoder->p_module =
module_need( id->p_encoder, "encoder", p_sys->psz_senc, true );
if( !id->p_encoder->p_module )
{
module_unneed( id->p_decoder, id->p_decoder->p_module );
msg_Err( p_stream, "cannot find spu encoder (%s)", p_sys->psz_senc );
return VLC_EGENERIC;
}
}
if( !p_sys->p_spu )
p_sys->p_spu = spu_Create( p_stream );
return VLC_SUCCESS;
}
ts_pes_es_t * ts_pes_es_New( ts_pmt_t *p_program )
{
ts_pes_es_t *p_es = malloc( sizeof(*p_es) );
if( p_es )
{
p_es->p_program = p_program;
p_es->id = NULL;
p_es->i_sl_es_id = 0;
p_es->p_extraes = NULL;
p_es->p_next = NULL;
p_es->b_interlaced = false;
es_format_Init( &p_es->fmt, UNKNOWN_ES, 0 );
p_es->fmt.i_group = p_program->i_number;
}
return p_es;
}
static void desktopResizeHandler( rdpContext *p_context )
{
vlcrdp_context_t * p_vlccontext = (vlcrdp_context_t *) p_context;
demux_sys_t *p_sys = p_vlccontext->p_demux->p_sys;
rdpGdi *p_gdi = p_context->gdi;
if ( p_sys->es )
{
es_out_Del( p_vlccontext->p_demux->out, p_sys->es );
p_sys->es = NULL;
}
/* Now init and fill es format */
vlc_fourcc_t i_chroma;
switch( p_gdi->bytesPerPixel )
{
default:
case 16:
i_chroma = VLC_CODEC_RGB16;
break;
case 24:
i_chroma = VLC_CODEC_RGB24;
break;
case 32:
i_chroma = VLC_CODEC_RGB32;
break;
}
es_format_t fmt;
es_format_Init( &fmt, VIDEO_ES, i_chroma );
fmt.video.i_chroma = i_chroma;
fmt.video.i_visible_width =
fmt.video.i_width = p_gdi->width;
fmt.video.i_visible_height =
fmt.video.i_height = p_gdi->height;
fmt.video.i_frame_rate_base = 1000;
fmt.video.i_frame_rate = 1000 * p_sys->f_fps;
p_sys->i_framebuffersize = p_gdi->width * p_gdi->height * p_gdi->bytesPerPixel;
if ( p_sys->p_block )
p_sys->p_block = block_Realloc( p_sys->p_block, 0, p_sys->i_framebuffersize );
else
p_sys->p_block = block_Alloc( p_sys->i_framebuffersize );
p_sys->es = es_out_Add( p_vlccontext->p_demux->out, &fmt );
}
static void output_mode_cb(void *data, struct wl_output *output,
uint32_t flags, int32_t width, int32_t height,
int32_t refresh)
{
demux_t *demux = data;
demux_sys_t *sys = demux->p_sys;
msg_Dbg(demux, "output mode: 0x%08"PRIX32" %"PRId32"x%"PRId32
" %"PRId32"mHz%s", flags, width, height, refresh,
(flags & WL_OUTPUT_MODE_CURRENT) ? " (current)" : "");
if (!(flags & WL_OUTPUT_MODE_CURRENT))
return;
if (width <= sys->x || height <= sys->y)
return;
if (sys->es != NULL)
es_out_Del(demux->out, sys->es);
es_format_t fmt;
es_format_Init(&fmt, VIDEO_ES, VLC_CODEC_RGB32);
fmt.video.i_chroma = VLC_CODEC_RGB32;
fmt.video.i_bits_per_pixel = 32;
fmt.video.i_sar_num = fmt.video.i_sar_den = 1;
fmt.video.i_frame_rate = lroundf(1000.f * sys->rate);
fmt.video.i_frame_rate_base = 1000;
fmt.video.i_width = width;
if (sys->w != 0 && width > sys->w + sys->x)
fmt.video.i_visible_width = sys->w;
else
fmt.video.i_visible_width = width - sys->x;
if (sys->h != 0 && height > sys->h + sys->y)
fmt.video.i_visible_height = sys->h;
else
fmt.video.i_visible_height = height - sys->y;
fmt.video.i_height = fmt.video.i_visible_height;
sys->es = es_out_Add(demux->out, &fmt);
sys->width = width;
sys->height = height;
(void) output;
}
/*****************************************************************************
* Open: initializes demux structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
const uint8_t *p_peek;
es_format_t fmt;
if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
if( p_peek[0] != 0x00 || p_peek[1] != 0x00 ||
p_peek[2] != 0x01 || p_peek[3] != 0x0f ) /* Sequence header */
{
if( !p_demux->b_force )
{
msg_Warn( p_demux, "vc-1 module discarded (no startcode)" );
return VLC_EGENERIC;
}
msg_Err( p_demux, "this doesn't look like a VC-1 ES stream, "
"continuing anyway" );
}
p_sys = (demux_sys_t *)malloc( sizeof( demux_sys_t ) ); // sunqueen modify
if( unlikely(p_sys == NULL) )
return VLC_ENOMEM;
p_demux->pf_demux = Demux;
p_demux->pf_control= Control;
p_demux->p_sys = p_sys;
p_sys->p_es = NULL;
p_sys->i_dts = 0;
p_sys->f_fps = var_CreateGetFloat( p_demux, "vc1-fps" );
if( p_sys->f_fps < 0.001 )
p_sys->f_fps = 0.0;
/* Load the packetizer */
es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_VC1 );
p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "VC-1" );
if( !p_sys->p_packetizer )
{
free( p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initializes demux structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
const uint8_t *p_peek;
es_format_t fmt;
if( stream_Peek( p_demux->s, &p_peek, 5 ) < 5 ) return VLC_EGENERIC;
if( p_peek[0] != 0x00 || p_peek[1] != 0x00 ||
p_peek[2] != 0x00 || p_peek[3] != 0x01 ||
(p_peek[4]&0x1F) != 7 ) /* SPS */
{
if( !p_demux->b_force )
{
msg_Warn( p_demux, "h264 module discarded (no startcode)" );
return VLC_EGENERIC;
}
msg_Err( p_demux, "this doesn't look like a H264 ES stream, "
"continuing anyway" );
}
p_demux->pf_demux = Demux;
p_demux->pf_control= Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
p_sys->p_es = NULL;
p_sys->i_dts = 0;
p_sys->f_fps = var_CreateGetFloat( p_demux, "h264-fps" );
if( p_sys->f_fps < 0.001f )
p_sys->f_fps = 0.001f;
msg_Dbg( p_demux, "using %.2f fps", (double) p_sys->f_fps );
/* Load the mpegvideo packetizer */
es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_H264 );
p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "h264" );
if( !p_sys->p_packetizer )
{
free( p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}