/**************************************************************************
* Get codec description from media elementary stream
**************************************************************************/
const char *
libvlc_media_get_codec_description( libvlc_track_type_t i_type,
uint32_t i_codec )
{
switch( i_type )
{
case libvlc_track_audio:
return vlc_fourcc_GetDescription( AUDIO_ES, i_codec );
case libvlc_track_video:
return vlc_fourcc_GetDescription( VIDEO_ES, i_codec );
case libvlc_track_text:
return vlc_fourcc_GetDescription( SPU_ES, i_codec );
case libvlc_track_unknown:
default:
return vlc_fourcc_GetDescription( UNKNOWN_ES, i_codec );
}
}
int GetVlcChromaFormat( OMX_COLOR_FORMATTYPE i_omx_codec,
vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
{
unsigned int i;
for( i = 0; chroma_format_table[i].i_codec != 0; i++ )
if( chroma_format_table[i].i_codec == i_omx_codec ) break;
if( pi_fourcc ) *pi_fourcc = chroma_format_table[i].i_fourcc;
if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES,
chroma_format_table[i].i_fourcc );
return !!chroma_format_table[i].i_fourcc;
}
int OmxToVlcAudioFormat( OMX_AUDIO_CODINGTYPE i_omx_codec,
vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
{
unsigned int i;
for( i = 0; audio_format_table[i].i_codec != 0; i++ )
if( audio_format_table[i].i_codec == i_omx_codec ) break;
if( pi_fourcc ) *pi_fourcc = audio_format_table[i].i_fourcc;
if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( AUDIO_ES,
audio_format_table[i].i_fourcc );
return !!audio_format_table[i].i_fourcc;
}
int GetVlcVideoFormat( OMX_VIDEO_CODINGTYPE i_omx_codec,
vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
{
unsigned int i;
for( i = 0; video_format_table[i].i_codec != 0; i++ )
if( video_format_table[i].i_codec == i_omx_codec ) break;
if( pi_fourcc ) *pi_fourcc = video_format_table[i].i_fourcc;
if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES,
video_format_table[i].i_fourcc );
return !!video_format_table[i].i_fourcc;
}
int GetVlcFourcc( unsigned i_ffmpeg_codec, int *pi_cat,
vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
{
for( unsigned i = 0; i < codecs_count; i++ )
{
if( codecs_table[i].i_codec == i_ffmpeg_codec )
{
if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
if( pi_fourcc ) *pi_fourcc = codecs_table[i].i_fourcc;
if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( codecs_table[i].i_cat, codecs_table[i].i_fourcc );
return true;
}
}
return false;
}
int GetFfmpegCodec( vlc_fourcc_t i_fourcc, int *pi_cat,
unsigned *pi_ffmpeg_codec, const char **ppsz_name )
{
i_fourcc = vlc_fourcc_GetCodec( UNKNOWN_ES, i_fourcc );
for( unsigned i = 0; i < codecs_count; i++ )
{
if( codecs_table[i].i_fourcc == i_fourcc )
{
if( pi_cat ) *pi_cat = codecs_table[i].i_cat;
if( pi_ffmpeg_codec ) *pi_ffmpeg_codec = codecs_table[i].i_codec;
if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( UNKNOWN_ES, i_fourcc );//char *)codecs_table[i].psz_name;
return true;
}
}
return false;
}
jobjectArray read_track_info_internal(JNIEnv *env, jobject thiz, libvlc_media_t* p_m)
{
/* get java class */
jclass cls = (*env)->FindClass( env, "org/videolan/libvlc/TrackInfo" );
if ( !cls )
{
LOGE("Failed to load class (org/videolan/libvlc/TrackInfo)" );
return NULL;
}
/* get java class contructor */
jmethodID clsCtor = (*env)->GetMethodID( env, cls, "<init>", "()V" );
if ( !clsCtor )
{
LOGE("Failed to find class constructor (org/videolan/libvlc/TrackInfo)" );
return NULL;
}
/* Get the tracks information of the media. */
libvlc_media_track_t **p_tracks;
int i_nbTracks = libvlc_media_tracks_get(p_m, &p_tracks);
jobjectArray array = (*env)->NewObjectArray(env, i_nbTracks + 1, cls, NULL);
unsigned i;
if (array != NULL)
{
for (i = 0; i <= i_nbTracks; ++i)
{
jobject item = (*env)->NewObject(env, cls, clsCtor);
if (item == NULL)
continue;
(*env)->SetObjectArrayElement(env, array, i, item);
// use last track for metadata
if (i == i_nbTracks)
{
setInt(env, item, "Type", 3 /* TYPE_META */);
setLong(env, item, "Length", libvlc_media_get_duration(p_m));
setString(env, item, "Title", libvlc_media_get_meta(p_m, libvlc_meta_Title));
setString(env, item, "Artist", libvlc_media_get_meta(p_m, libvlc_meta_Artist));
setString(env, item, "Album", libvlc_media_get_meta(p_m, libvlc_meta_Album));
setString(env, item, "Genre", libvlc_media_get_meta(p_m, libvlc_meta_Genre));
setString(env, item, "ArtworkURL", libvlc_media_get_meta(p_m, libvlc_meta_ArtworkURL));
continue;
}
setInt(env, item, "Id", p_tracks[i]->i_id);
setInt(env, item, "Type", p_tracks[i]->i_type);
setString(env, item, "Codec", (const char*)vlc_fourcc_GetDescription(0,p_tracks[i]->i_codec));
setString(env, item, "Language", p_tracks[i]->psz_language);
setInt(env, item, "Bitrate", p_tracks[i]->i_bitrate);
if (p_tracks[i]->i_type == libvlc_track_video)
{
setInt(env, item, "Height", p_tracks[i]->video->i_height);
setInt(env, item, "Width", p_tracks[i]->video->i_width);
setFloat(env, item, "Framerate", (float)p_tracks[i]->video->i_frame_rate_num / p_tracks[i]->video->i_frame_rate_den);
}
if (p_tracks[i]->i_type == libvlc_track_audio)
{
setInt(env, item, "Channels", p_tracks[i]->audio->i_channels);
setInt(env, item, "Samplerate", p_tracks[i]->audio->i_rate);
}
}
}
libvlc_media_tracks_release(p_tracks, i_nbTracks);
return array;
}
static int Open(vlc_object_t *object)
{
demux_t *demux = (demux_t*)object;
/* Detect the image type */
const image_format_t *img;
const uint8_t *peek;
int peek_size = 0;
for (int i = 0; ; i++) {
img = &formats[i];
if (!img->codec)
return VLC_EGENERIC;
if (img->detect) {
if (img->detect(demux->s))
break;
} else {
if (peek_size < img->marker_size)
peek_size = stream_Peek(demux->s, &peek, img->marker_size);
if (peek_size >= img->marker_size &&
!memcmp(peek, img->marker, img->marker_size))
break;
}
}
msg_Dbg(demux, "Detected image: %s",
vlc_fourcc_GetDescription(VIDEO_ES, img->codec));
if( img->codec == VLC_CODEC_MXPEG )
{
return VLC_EGENERIC; //let avformat demux this file
}
/* Load and if selected decode */
es_format_t fmt;
es_format_Init(&fmt, VIDEO_ES, img->codec);
fmt.video.i_chroma = fmt.i_codec;
block_t *data = Load(demux);
if (data && var_InheritBool(demux, "image-decode")) {
char *string = var_InheritString(demux, "image-chroma");
vlc_fourcc_t chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, string);
free(string);
data = Decode(demux, &fmt.video, chroma, data);
fmt.i_codec = fmt.video.i_chroma;
}
fmt.i_id = var_InheritInteger(demux, "image-id");
fmt.i_group = var_InheritInteger(demux, "image-group");
if (var_InheritURational(demux,
&fmt.video.i_frame_rate,
&fmt.video.i_frame_rate_base,
"image-fps") ||
fmt.video.i_frame_rate <= 0 || fmt.video.i_frame_rate_base <= 0) {
msg_Err(demux, "Invalid frame rate, using 10/1 instead");
fmt.video.i_frame_rate = 10;
fmt.video.i_frame_rate_base = 1;
}
/* If loadind failed, we still continue to avoid mis-detection
* by other demuxers. */
if (!data)
msg_Err(demux, "Failed to load the image");
/* */
demux_sys_t *sys = malloc(sizeof(*sys));
if (!sys) {
if (data)
block_Release(data);
es_format_Clean(&fmt);
return VLC_ENOMEM;
}
sys->data = data;
sys->es = es_out_Add(demux->out, &fmt);
sys->duration = CLOCK_FREQ * var_InheritFloat(demux, "image-duration");
sys->is_realtime = var_InheritBool(demux, "image-realtime");
sys->pts_origin = sys->is_realtime ? mdate() : 0;
sys->pts_next = VLC_TS_INVALID;
date_Init(&sys->pts, fmt.video.i_frame_rate, fmt.video.i_frame_rate_base);
date_Set(&sys->pts, 0);
es_format_Clean(&fmt);
demux->pf_demux = Demux;
demux->pf_control = Control;
demux->p_sys = sys;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
if (p_demux->out == NULL)
return VLC_EGENERIC;
p_sys = vlc_obj_calloc( p_this, 1, sizeof(demux_sys_t) );
if( !p_sys ) return VLC_ENOMEM;
p_sys->f_fps = var_InheritFloat( p_demux, CFG_PREFIX "fps" );
if ( p_sys->f_fps <= 0 ) p_sys->f_fps = 1.0;
p_sys->i_frame_interval = vlc_tick_rate_duration( p_sys->f_fps );
char *psz_chroma = var_InheritString( p_demux, CFG_PREFIX "chroma" );
vlc_fourcc_t i_chroma = vlc_fourcc_GetCodecFromString( VIDEO_ES, psz_chroma );
free( psz_chroma );
if ( !i_chroma || vlc_fourcc_IsYUV( i_chroma ) )
{
msg_Err( p_demux, "Only RGB chroma are supported" );
return VLC_EGENERIC;
}
const vlc_chroma_description_t *p_chroma_desc = vlc_fourcc_GetChromaDescription( i_chroma );
if ( !p_chroma_desc )
{
msg_Err( p_demux, "Unable to get RGB chroma description" );
return VLC_EGENERIC;
}
#ifdef NDEBUG
rfbEnableClientLogging = FALSE;
#endif
p_sys->p_client = rfbGetClient( p_chroma_desc->pixel_bits / 3, // bitsPerSample
3, // samplesPerPixel
p_chroma_desc->pixel_size ); // bytesPerPixel
if ( ! p_sys->p_client )
{
msg_Dbg( p_demux, "Unable to set up client for %s",
vlc_fourcc_GetDescription( VIDEO_ES, i_chroma ) );
return VLC_EGENERIC;
}
msg_Dbg( p_demux, "set up client for %s %d %d %d",
vlc_fourcc_GetDescription( VIDEO_ES, i_chroma ),
p_chroma_desc->pixel_bits / 3, 3, p_chroma_desc->pixel_size );
p_sys->p_client->MallocFrameBuffer = mallocFrameBufferHandler;
p_sys->p_client->canHandleNewFBSize = TRUE;
p_sys->p_client->GetCredential = getCredentialHandler;
p_sys->p_client->GetPassword = getPasswordHandler; /* VNC simple auth */
/* Set compression and quality levels */
p_sys->p_client->appData.compressLevel =
var_InheritInteger( p_demux, CFG_PREFIX "compress-level" );
p_sys->p_client->appData.qualityLevel =
var_InheritInteger( p_demux, CFG_PREFIX "quality-level" );
/* Parse uri params */
vlc_url_t url;
vlc_UrlParse( &url, p_demux->psz_location );
if ( !EMPTY_STR(url.psz_host) )
p_sys->p_client->serverHost = strdup( url.psz_host );
else
p_sys->p_client->serverHost = strdup( "localhost" );
p_sys->p_client->appData.viewOnly = TRUE;
p_sys->p_client->serverPort = ( url.i_port > 0 ) ? url.i_port : 5900;
msg_Dbg( p_demux, "VNC init %s host=%s port=%d",
p_demux->psz_location,
p_sys->p_client->serverHost,
p_sys->p_client->serverPort );
vlc_UrlClean( &url );
/* make demux available for callback handlers */
rfbClientSetClientData( p_sys->p_client, DemuxThread, p_demux );
p_demux->p_sys = p_sys;
if( !rfbInitClient( p_sys->p_client, NULL, NULL ) )
{
msg_Err( p_demux, "can't connect to RFB server" );
return VLC_EGENERIC;
}
p_sys->i_starttime = vlc_tick_now();
if ( vlc_clone( &p_sys->thread, DemuxThread, p_demux, VLC_THREAD_PRIORITY_INPUT ) != VLC_SUCCESS )
{
msg_Err( p_demux, "can't spawn thread" );
return VLC_EGENERIC;
}
p_demux->pf_demux = NULL;
p_demux->pf_control = Control;
return VLC_SUCCESS;
}
/**
* @brief Write y4m header based on filter in_fmt, or failing that, picture
* @return number of bytes written or < 0 on error
*/
static int writeY4mHeader(const filter_t* intf, const picture_t* pic, int fd)
{
const video_format_t* fmt = &intf->fmt_in.video;
const char* y4mChroma = NULL;
int i = 0;
while (sChromaTable[i].name)
{
if (sChromaTable[i].fourcc == fmt->i_chroma)
{
y4mChroma = sChromaTable[i].name;
break;
}
i++;
}
if (!y4mChroma)
{
msg_Err(intf, "writeY4mHeader: unsupported chroma: %s",
vlc_fourcc_GetDescription(VIDEO_ES, fmt->i_chroma));
return -1;
}
msg_Info(intf, "writeY4mHeader: infps=%.4f outfps=%.4f, frameFps=%.4f",
(float)fmt->i_frame_rate / fmt->i_frame_rate_base,
(float)intf->fmt_out.video.i_frame_rate / intf->fmt_out.video.i_frame_rate_base,
(float)pic->format.i_frame_rate / pic->format.i_frame_rate_base);
int fpsNum = fmt->i_frame_rate;
int fpsDen = fmt->i_frame_rate_base;
if (fpsNum == 0 || fpsDen == 0)
{
fpsNum = pic->format.i_frame_rate;
fpsDen = pic->format.i_frame_rate_base;
}
if (fpsNum == 0 || fpsDen == 0)
{
// some wmv's don't supply a frame rate via VLC asf demuxer
msg_Err(intf, "writeY4mHeader: vlc didn't supply an input frame rate");
return -2;
}
// if (100 < (fpsNum / fpsDen))
// {
// // the ffmpeg asf demuxer might return a bogus frame rate
// msg_Err(intf, "writeY4mHeader: vlc says fps > 100, probably bullshit");
// return -3;
// }
char header[256];
sprintf(header,
"YUV4MPEG2 W%d H%d F%d:%d Ip A%d:%d C%s XVLCPIPE\x0a",
fmt->i_visible_width,
fmt->i_visible_height,
fpsNum,
fpsDen,
fmt->i_sar_num,
fmt->i_sar_den,
y4mChroma);
msg_Info(intf, "y4m header: %s", header);
return write(fd, header, strlen(header));
}
