static void
gss_level_from_track (GssAdaptive * adaptive, GssIsomTrack * track,
GssIsomMovie * movie, const char *filename, gboolean is_video)
{
GssAdaptiveLevel *level;
int i;
g_return_if_fail (adaptive != NULL);
g_return_if_fail (track != NULL);
g_return_if_fail (movie != NULL);
g_return_if_fail (filename != NULL);
if (is_video) {
adaptive->video_levels = g_realloc (adaptive->video_levels,
(adaptive->n_video_levels + 1) * sizeof (GssAdaptiveLevel));
level = adaptive->video_levels + adaptive->n_video_levels;
adaptive->n_video_levels++;
} else {
adaptive->audio_levels = g_realloc (adaptive->audio_levels,
(adaptive->n_audio_levels + 1) * sizeof (GssAdaptiveLevel));
level = adaptive->audio_levels + adaptive->n_audio_levels;
adaptive->n_audio_levels++;
}
memset (level, 0, sizeof (GssAdaptiveLevel));
level->track = track;
if (is_video) {
adaptive->max_width = MAX (adaptive->max_width, track->mp4v.width);
adaptive->max_height = MAX (adaptive->max_height, track->mp4v.height);
}
if (adaptive->drm_type != GSS_DRM_CLEAR) {
generate_iv (level, filename, track->tkhd.track_id);
for (i = 0; i < track->n_fragments; i++) {
GssIsomFragment *fragment = track->fragments[i];
gss_playready_setup_iv (adaptive->server->playready, adaptive, level,
fragment);
/* Hack to prevent serialization of sample encryption UUID and
* enable saiz/saio serialization */
if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
fragment->sample_encryption.present = FALSE;
fragment->saiz.present = TRUE;
fragment->saio.present = TRUE;
fragment->tfdt.present = TRUE;
}
}
}
if (adaptive->drm_type == GSS_DRM_PLAYREADY) {
/* FIXME move */
if (adaptive->drm_info.data == NULL) {
adaptive->drm_info.drm_type = GSS_DRM_PLAYREADY;
adaptive->drm_info.data_len =
gss_playready_get_protection_header (adaptive,
adaptive->server->playready->license_url, NULL,
&adaptive->drm_info.data);
}
}
if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
gss_adaptive_convert_isoff_ondemand (adaptive, movie, track,
adaptive->drm_type);
} else if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISM) {
gss_adaptive_convert_ism (adaptive, movie, track, adaptive->drm_type);
}
level->track_id = track->tkhd.track_id;
level->n_fragments = track->n_fragments;
level->filename = g_strdup (filename);
level->bitrate = estimate_bitrate (track);
level->video_width = track->mp4v.width;
level->video_height = track->mp4v.height;
//level->file = file;
level->codec_data = gss_hex_encode (track->esds.codec_data,
track->esds.codec_data_len);
if (is_video) {
level->codec = g_strdup_printf ("avc1.%02x%02x%02x",
track->esds.codec_data[1],
track->esds.codec_data[2], track->esds.codec_data[3]);
level->profile = track->esds.codec_data[1];
level->level = track->esds.codec_data[2];
} else {
/* FIXME hard-coded AAC LC */
level->codec = g_strdup ("mp4a.40.2");
level->profile = 2;
level->audio_rate = (track->mp4a.sample_rate >> 16);
}
}
static void
load_file (GssAdaptive * adaptive, const char *filename)
{
GssIsomParser *file;
GssIsomTrack *video_track;
GssIsomTrack *audio_track;
g_return_if_fail (adaptive != 0);
g_return_if_fail (filename != 0);
file = gss_isom_parser_new ();
adaptive->parsers[adaptive->n_parsers] = file;
adaptive->n_parsers++;
gss_isom_parser_parse_file (file, filename);
if (file->movie->tracks[0]->n_fragments == 0) {
gss_isom_parser_fragmentize (file,
adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND ||
adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_LIVE);
}
#if 0
if (adaptive->drm_type == GSS_DRM_PLAYREADY &&
adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
gss_playready_add_protection_header (file->movie, adaptive,
adaptive->server->playready->license_url, NULL);
}
#endif
if (adaptive->duration == 0) {
adaptive->duration = gss_isom_movie_get_duration (file->movie);
}
video_track = gss_isom_movie_get_video_track (file->movie);
if (video_track) {
gss_level_from_track (adaptive, video_track, file->movie, filename, TRUE);
}
audio_track = gss_isom_movie_get_audio_track (file->movie);
if (audio_track) {
gss_level_from_track (adaptive, audio_track, file->movie, filename, FALSE);
#if 0
GssAdaptiveLevel *level;
int i;
adaptive->audio_levels = g_realloc (adaptive->audio_levels,
(adaptive->n_audio_levels + 1) * sizeof (GssAdaptiveLevel));
level = adaptive->audio_levels + adaptive->n_audio_levels;
adaptive->n_audio_levels++;
memset (level, 0, sizeof (GssAdaptiveLevel));
generate_iv (level, filename, video_track->tkhd.track_id);
for (i = 0; i < audio_track->n_fragments; i++) {
GssIsomFragment *fragment = audio_track->fragments[i];
gss_playready_setup_iv (adaptive->server->playready, adaptive, level,
fragment);
}
gss_isom_track_prepare_streaming (file->movie, audio_track);
level->track_id = audio_track->tkhd.track_id;
level->track = audio_track;
level->n_fragments =
gss_isom_parser_get_n_fragments (file, level->track_id);
level->file = file;
level->filename = g_strdup (filename);
level->bitrate = audio_bitrate;
level->codec_data = gss_hex_encode (audio_track->esds.codec_data,
audio_track->esds.codec_data_len);
level->audio_rate = audio_track->mp4a.sample_rate >> 16;
/* FIXME hard-coded AAC LC */
level->codec = g_strdup ("mp4a.40.2");
#endif
}
}
int main(int argc, char **argv) {
int c;
bzero(CONFIG_PATH, PATH_MAX);
while ((c = getopt(argc,argv, "vf:")) != EOF) {
switch (c) {
case 'f':
snprintf(CONFIG_PATH, PATH_MAX, "%s", optarg);
break;
case 'v':
verbose = 1;
break;
case '?':
fprintf(stderr,"Invalid argument\n");
exit(1);
}
}
read_config();
#ifdef HAVE_LIBMAGIC
load_magic();
#endif
load_regexes();
pcre_callout = pcre_callout_spider;
umask(077);
compile_regexes();
if (Encrypt) {
// do we have a password?
if (!strlen(Password)) {
fprintf(stderr, "No password supplied\n");
exit(1);
}
// prep the log array
startlog = (struct logarray *)malloc(sizeof(struct logarray));
if (startlog == NULL) {
fprintf(stderr, "Malloc: %s\n", strerror(errno));
exit(1);
}
bzero(startlog -> entry, LOG_MAX);
currlog = startlog;
// prep our keying material
generate_iv();
generate_key();
}
if (Log2File && !LogStdout) {
// get our filehandle open
if (AppendLog) {
if (CustomLogPath[0]) {
logfp = fopen(CustomLogPath, "a+");
} else {
logfp = fopen(LogPath, "a+");
}
} else {
if (CustomLogPath[0]) {
logfp = fopen(CustomLogPath, "w");
} else {
logfp = fopen(LogPath, "w");
}
}
if (logfp == NULL) {
fprintf(stderr, "unable to open %s:%s\n",
LogPath,
strerror(errno));
exit(1);
}
}
if (LogSyslog) {
(void)openlog("spider", LOG_PID|LOG_NDELAY, LOG_FAC);
}
// normally, this would run as a child process
// we'd hold the child PID in pid_t worker
// when the Stop Spider button is clicked,
// we'll send a TERM signal to the child process
//
run_spider(START_PATH);
if (LogFooter[0]) {
write_footer();
}
if (Encrypt) {
// write out the encrypted log
if (!spider_encrypt()) {
fprintf(stderr, "failure to write encrypted log!\n");
exit(1);
}
}
if (logfp) { fclose(logfp); }
if (WhenDone == EXIT_WHEN_DONE) {
if (verbose) {
fprintf(stderr, "Normal exit.\n");
}
exit(0);
}
if (WhenDone == RESTORE_WHEN_DONE) {
// GTK fru-fru
}
if (WhenDone == VIEWLOG_WHEN_DONE) {
// launch the log viewer
}
exit(0);
}
