static int test_autoloop_to_fps(int frc)
{
int ret = 0, myfrc;
double fps;
ret = tc_frc_code_to_value(frc, &fps);
if (ret == TC_NULL_MATCH) {
tc_log_warn(PACKAGE, "to_fps: failed conversion_to for frc=%i",
frc);
return 1;
}
ret = tc_frc_code_from_value(&myfrc, fps);
if (ret == TC_NULL_MATCH) {
tc_log_warn(PACKAGE, "to_fps: failed conversion_from for frc=%i",
frc);
return 2;
}
if (frc == myfrc) {
tc_log_msg(PACKAGE, "to_fps: test for frc=%i -> OK", frc);
} else {
tc_log_warn(PACKAGE, "to_fps: test for frc=%i -> FAILED (%i)",
frc, myfrc);
ret = -1;
}
return ret;
}
static int test_autoloop_from_fps(double fps)
{
int ret = 0, frc;
double myfps;
ret = tc_frc_code_from_value(&frc, fps);
if (ret == TC_NULL_MATCH) {
tc_log_warn(PACKAGE, "from_fps: failed conversion_from for fps=%f",
fps);
return 1;
}
ret = tc_frc_code_to_value(frc, &myfps);
if (ret == TC_NULL_MATCH) {
tc_log_warn(PACKAGE, "from_fps: failed conversion_to for fps=%f",
fps);
return 2;
}
if (myfps - DELTA < fps && fps < myfps + DELTA) {
tc_log_msg(PACKAGE, "from_fps: test for fps=%f -> OK",
fps);
} else {
tc_log_warn(PACKAGE, "from_fps: test for fps=%f -> FAILED (%f)",
fps, myfps);
ret = -1;
}
return ret;
}
static void translate_info(const AVFormatContext *ctx, ProbeInfo *info)
{
AVStream *st = NULL;
int i = 0, j = 0;
if (ctx == NULL || info == NULL) {
return;
}
/* first of all, video */
for (i = 0; i < ctx->nb_streams; i++) {
st = ctx->streams[i];
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
info->bitrate = st->codec->bit_rate / 1000;
info->width = st->codec->width;
info->height = st->codec->height;
if (st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0) {
info->fps = av_q2d(st->r_frame_rate);
} else {
/* watch out here */
info->fps = 1.0/av_q2d(st->codec->time_base);
}
tc_frc_code_from_value(&info->frc, info->fps);
break;
}
}
/* then audio track(s) */
for (i = 0; i < ctx->nb_streams; i++) {
st = ctx->streams[i];
if (st->codec->codec_type == CODEC_TYPE_AUDIO
&& j < TC_MAX_AUD_TRACKS) {
info->track[j].format = 0x1; /* known wrong */
info->track[j].chan = st->codec->channels;
info->track[j].samplerate = st->codec->sample_rate;
info->track[j].bitrate = st->codec->bit_rate / 1000;
/* XXX: known wrong for PCM */
info->track[j].bits = BITS;
/*
* XXX where libavcodec/libaformat provide this?
* Should be inferred by CODEC_ID used?
* */
info->track[j].pts_start = 0; /* XXX: ?!? */
j++;
}
}
info->num_tracks = j;
}
int tc_x11source_probe(TCX11Source *handle, ProbeInfo *info)
{
if (handle != NULL && info != NULL) {
info->width = handle->width;
info->height = handle->height;
info->codec = handle->out_fmt;
info->magic = TC_MAGIC_X11; /* enforce */
info->asr = 1; /* force 1:1 ASR (XXX) */
/* FPS/FRC MUST BE choosed by user; that's only a kind suggestion */
info->fps = 10.0;
tc_frc_code_from_value(&info->frc, info->fps);
info->num_tracks = 0; /* no audio, here */
return 0;
}
return 1;
}
void probe_ogg(info_t *ipipe)
{
ogg_sync_state sync;
ogg_page page;
ogg_packet pack;
char *buf;
int nread, np, sno, nvtracks = 0, natracks = 0, i, idx;
//int endofstream = 0, k, n;
struct demux_t streams[MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS];
int fdin = -1;
char vid_codec[5];
ogm_stream_header *sth;
fdin = ipipe->fd_in;
if (fdin == -1) {
tc_log_error(__FILE__, "Could not open file.");
goto ogg_out;
}
ipipe->probe_info->magic=TC_MAGIC_OGG;
memset(streams, 0, sizeof(streams));
for (i = 0; i < (MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS); i++)
streams[i].serial = -1;
ogg_sync_init(&sync);
while (1) {
np = ogg_sync_pageseek(&sync, &page);
if (np < 0) {
tc_log_error(__FILE__, "ogg_sync_pageseek failed");
goto ogg_out;
}
if (np == 0) {
buf = ogg_sync_buffer(&sync, BLOCK_SIZE);
if (!buf) {
tc_log_error(__FILE__, "ogg_sync_buffer failed");
goto ogg_out;
}
if ((nread = read(fdin, buf, BLOCK_SIZE)) <= 0) {
}
ogg_sync_wrote(&sync, nread);
continue;
}
if (!ogg_page_bos(&page)) {
break;
} else {
ogg_stream_state sstate;
vorbis_info *inf = tc_malloc (sizeof(vorbis_info));
vorbis_comment *com = tc_malloc (sizeof(vorbis_comment));
if (!inf || !com) {
tc_log_error(__FILE__, "Out of Memory at %d", __LINE__);
goto ogg_out;
}
sno = ogg_page_serialno(&page);
if (ogg_stream_init(&sstate, sno)) {
tc_log_error(__FILE__, "ogg_stream_init failed");
goto ogg_out;
}
ogg_stream_pagein(&sstate, &page);
ogg_stream_packetout(&sstate, &pack);
switch (ogm_packet_type(pack))
{
case Vorbis:
vorbis_info_init(inf);
vorbis_comment_init(com);
if(vorbis_synthesis_headerin(inf, com, &pack) < 0) {
tc_log_warn(__FILE__, "Could not decode vorbis header "
"packet - invalid vorbis stream ()");
} else {
#ifdef OGM_DEBUG
tc_log_msg(__FILE__, "(a%d/%d) Vorbis audio; "
"rate: %ldHz, channels: %d, bitrate %3.2f kb/s",
natracks + 1, natracks + nvtracks + 1, inf->rate,
inf->channels, (double)inf->bitrate_nominal/1000.0);
#endif
ipipe->probe_info->track[natracks].samplerate = inf->rate;
ipipe->probe_info->track[natracks].chan = inf->channels;
ipipe->probe_info->track[natracks].bits = 0; /* XXX --tibit*/
ipipe->probe_info->track[natracks].format = TC_CODEC_VORBIS;
ipipe->probe_info->track[natracks].bitrate = (double)inf->bitrate_nominal/1000.0;
ipipe->probe_info->track[natracks].tid=natracks;
if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks;
streams[natracks].serial = sno;
streams[natracks].vorbis = 1;
ac_memcpy(&streams[natracks].state, &sstate, sizeof(sstate));
natracks++;
}
break;
#ifdef HAVE_THEORA
case Theora:
{
theora_info ti;
theora_comment tc;
theora_decode_header(&ti, &tc, &pack);
ipipe->probe_info->width = ti.width;
ipipe->probe_info->height = ti.height;
ipipe->probe_info->fps = (double)ti.fps_numerator/ti.fps_denominator;
tc_frc_code_from_ratio(&(ipipe->probe_info->frc),
ti.fps_numerator, ti.fps_denominator);
ipipe->probe_info->codec=TC_CODEC_THEORA;
idx = natracks + MAX_AUDIO_TRACKS;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
nvtracks++;
break;
}
#endif
case DirectShow:
if ((*(int32_t*)(pack.packet+96) == 0x05589f80) &&
(pack.bytes >= 184)) {
tc_log_warn(__FILE__, "(v%d/%d) Found old video "
"header. Not supported.", nvtracks + 1,
natracks + nvtracks + 1);
} else if (*(int32_t*)pack.packet+96 == 0x05589F81) {
tc_log_warn(__FILE__, "(a%d/%d) Found old audio "
"header. Not supported.", natracks + 1,
natracks + nvtracks + 1);
}
break;
case StreamHeader:
sth = (ogm_stream_header *)(pack.packet + 1);
if (!strncmp(sth->streamtype, "video", 5)) {
#ifdef OGM_DEBUG
unsigned long codec;
codec = (sth->subtype[0] << 24) +
(sth->subtype[1] << 16) + (sth->subtype[2] << 8) + sth->subtype[3];
tc_log_msg(__FILE__, "(v%d/%d) video; fps: %.3f width height: %dx%d "
"codec: %p (%c%c%c%c)", nvtracks + 1,
natracks + nvtracks + 1,
(double)10000000 / (double)sth->time_unit,
sth->sh.video.width, sth->sh.video.height, (void *)codec,
sth->subtype[0], sth->subtype[1], sth->subtype[2],
sth->subtype[3]);
#endif
vid_codec[0] = sth->subtype[0];
vid_codec[1] = sth->subtype[1];
vid_codec[2] = sth->subtype[2];
vid_codec[3] = sth->subtype[3];
vid_codec[4] = '\0';
//ipipe->probe_info->frames = AVI_video_frames(avifile);
ipipe->probe_info->width = sth->sh.video.width;
ipipe->probe_info->height = sth->sh.video.height;
ipipe->probe_info->fps = (double)10000000 / (double)sth->time_unit;
tc_frc_code_from_value(&(ipipe->probe_info->frc),
ipipe->probe_info->fps);
ipipe->probe_info->codec=TC_CODEC_UNKNOWN; // gets rewritten
if(strlen(vid_codec)==0) {
ipipe->probe_info->codec=TC_CODEC_RGB24;
} else {
if(strcasecmp(vid_codec,"dvsd")==0)
ipipe->probe_info->codec=TC_CODEC_DV;
if(strcasecmp(vid_codec,"DIV3")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX3;
if(strcasecmp(vid_codec,"DIVX")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX4;
if(strcasecmp(vid_codec,"DX50")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX5;
if(strcasecmp(vid_codec,"XVID")==0)
ipipe->probe_info->codec=TC_CODEC_XVID;
if(strcasecmp(vid_codec,"MJPG")==0)
ipipe->probe_info->codec=TC_CODEC_MJPEG;
}
idx = natracks + MAX_AUDIO_TRACKS;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
nvtracks++;
} else if (!strncmp(sth->streamtype, "audio", 5)) {
int codec;
char buf[5];
ac_memcpy(buf, sth->subtype, 4);
buf[4] = 0;
codec = strtoul(buf, NULL, 16);
#ifdef OGM_DEBUG
tc_log_msg(__FILE__, "(a%d/%d) codec: %d (0x%04x) (%s) bits per "
"sample: %d channels: %hd samples per second: %ld "
"avgbytespersec: %hd blockalign: %d",
natracks + 1, natracks + nvtracks + 1,
codec, codec,
codec == 0x1 ? "PCM" : codec == 55 ? "MP3" :
codec == 0x55 ? "MP3" :
codec == 0x2000 ? "AC3" : "unknown",
sth->bits_per_sample, sth->sh.audio.channels,
(long)sth->samples_per_unit,
sth->sh.audio.avgbytespersec,
sth->sh.audio.blockalign);
#endif
idx = natracks;
ipipe->probe_info->track[natracks].samplerate = sth->samples_per_unit;
ipipe->probe_info->track[natracks].chan = sth->sh.audio.channels;
ipipe->probe_info->track[natracks].bits =
(sth->bits_per_sample<4)?sth->bits_per_sample*8:sth->bits_per_sample;
ipipe->probe_info->track[natracks].format = codec;
ipipe->probe_info->track[natracks].bitrate = 0;
ipipe->probe_info->track[natracks].tid=natracks;
if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
natracks++;
} else {
tc_log_warn(__FILE__, "(%d) found new header of unknown/"
"unsupported type\n", nvtracks + natracks + 1);
}
break;
case none:
tc_log_warn(__FILE__, "OGG stream %d is of an unknown type "
"(bad header?)", nvtracks + natracks + 1);
break;
} /* switch type */
free(inf);
free(com);
ogg_stream_clear(&sstate);
} /* beginning of page */
} /* while (1) */
ogg_out:
//close(fdin);
return;
}
void probe_mov(info_t *ipipe)
{
quicktime_t *qt_file=NULL;
char *codec=NULL;
int j, tracks;
/* open movie for video probe */
if(qt_file==NULL)
if(NULL == (qt_file = quicktime_open((char *)ipipe->name,1,0))){
tc_log_error(__FILE__,"can't open quicktime!");
ipipe->error=1;
return;
}
// extract audio parameters
tracks=quicktime_audio_tracks(qt_file);
if(tracks>TC_MAX_AUD_TRACKS) {
tc_log_warn(__FILE__, "only %d of %d audio tracks scanned",
TC_MAX_AUD_TRACKS, tracks);
tracks=TC_MAX_AUD_TRACKS;
}
for(j=0; j<tracks; ++j) {
ipipe->probe_info->track[j].samplerate = quicktime_sample_rate(qt_file, j);
ipipe->probe_info->track[j].chan = quicktime_track_channels(qt_file, j);
ipipe->probe_info->track[j].bits = quicktime_audio_bits(qt_file, j);
codec = quicktime_audio_compressor(qt_file, j);
if(strcasecmp(codec,QUICKTIME_RAW)==0 || strcasecmp(codec,QUICKTIME_TWOS)==0)
ipipe->probe_info->track[j].format = CODEC_PCM;
else if(strcasecmp(codec,QUICKTIME_IMA4)==0)
ipipe->probe_info->track[j].format = CODEC_IMA4;
else
/* XXX not right but works */
ipipe->probe_info->track[j].format = CODEC_PCM;
if (! binary_dump)
tc_log_info(__FILE__, "audio codec=%s", codec);
if(ipipe->probe_info->track[j].chan>0) ++ipipe->probe_info->num_tracks;
}
// read all video parameter from input file
ipipe->probe_info->width = quicktime_video_width(qt_file, 0);
ipipe->probe_info->height = quicktime_video_height(qt_file, 0);
ipipe->probe_info->fps = quicktime_frame_rate(qt_file, 0);
ipipe->probe_info->frames = quicktime_video_length(qt_file, 0);
codec = quicktime_video_compressor(qt_file, 0);
//check for supported codecs
if(codec!=NULL) {
if(strlen(codec)==0) {
ipipe->probe_info->codec=TC_CODEC_RGB;
} else {
if(strcasecmp(codec,QUICKTIME_DV)==0)
ipipe->probe_info->codec=TC_CODEC_DV;
if(strcasecmp(codec,"dvsd")==0)
ipipe->probe_info->codec=TC_CODEC_DV;
if(strcasecmp(codec,"DIV3")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX3;
if(strcasecmp(codec,"DIVX")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX4;
if(strcasecmp(codec,"DX50")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX5;
if(strcasecmp(codec,"MJPG")==0 || strcasecmp(codec,"JPEG")==0)
ipipe->probe_info->codec=TC_CODEC_MJPEG;
if(strcasecmp(codec,"YUV2")==0)
ipipe->probe_info->codec=TC_CODEC_YUV2;
if(strcasecmp(codec,"SVQ1")==0)
ipipe->probe_info->codec=TC_CODEC_SVQ1;
if(strcasecmp(codec,"SVQ3")==0)
ipipe->probe_info->codec=TC_CODEC_SVQ3;
}
} else
ipipe->probe_info->codec=TC_CODEC_UNKNOWN;
if (! binary_dump)
tc_log_info(__FILE__, "video codec=%s", codec);
ipipe->probe_info->magic=TC_MAGIC_MOV;
tc_frc_code_from_value(&(ipipe->probe_info->frc),
ipipe->probe_info->fps);
return;
}
