/// Open an mpg physical stream
static demuxer_t* demux_mpg_open(demuxer_t* demuxer) {
stream_t *s = demuxer->stream;
mpg_demuxer_t* mpg_d = calloc(1,sizeof(*mpg_d));
if (!mpg_d)
return NULL;
demuxer->priv = mpg_d;
while (demuxer->video->packs + demuxer->audio->packs < 2)
if (!demux_fill_buffer(demuxer, demuxer->video)) return 0;
mpg_d->last_pts = -1.0;
mpg_d->first_pts = -1.0;
//if seeking is allowed set has_valid_timestamps if appropriate
if(demuxer->seekable
&& (demuxer->stream->type == STREAMTYPE_FILE
|| demuxer->stream->type == STREAMTYPE_VCD)
&& demuxer->movi_start != demuxer-> movi_end
)
{
//We seek to the beginning of the stream, to somewhere in the
//middle, and to the end of the stream, while remembering the pts
//at each of the three positions. With these pts, we check whether
//or not the pts are "linear enough" to justify seeking by the pts
//of the stream
//The position where the stream is now
off_t pos = stream_tell(s);
float first_pts = read_first_mpeg_pts_at_position(demuxer, demuxer->movi_start);
if(first_pts != -1.0)
{
float middle_pts = read_first_mpeg_pts_at_position(demuxer, (demuxer->movi_end + demuxer->movi_start)/2);
if(middle_pts != -1.0)
{
float final_pts = read_first_mpeg_pts_at_position(demuxer, demuxer->movi_end - TIMESTAMP_PROBE_LEN);
if(final_pts != -1.0)
{
// found proper first, middle, and final pts.
float proportion = (middle_pts-first_pts==0) ? -1 : (final_pts-middle_pts)/(middle_pts-first_pts);
// if they are linear enough set has_valid_timestamps
if((0.5 < proportion) && (proportion < 2))
{
mpg_d->first_pts = first_pts;
mpg_d->first_to_final_pts_len = final_pts - first_pts;
mpg_d->has_valid_timestamps = 1;
}
}
}
}
//Cleaning up from seeking in stream
reset_eof(demuxer);
stream_seek(s,pos);
ds_fill_buffer(demuxer->video);
} // if ( demuxer->seekable )
return demuxer;
}
/* Implement the 'r' (add files to end of archive), and 'u' (add files
to end of archive if they aren't there, or are more up to date than
the version in the archive) commands. */
void
update_archive (void)
{
enum read_header previous_status = HEADER_STILL_UNREAD;
bool found_end = false;
name_gather ();
open_archive (ACCESS_UPDATE);
xheader_write_global ();
while (!found_end)
{
enum read_header status = read_header (false);
switch (status)
{
case HEADER_STILL_UNREAD:
case HEADER_SUCCESS_EXTENDED:
abort ();
case HEADER_SUCCESS:
{
struct name *name;
decode_header (current_header, ¤t_stat_info,
¤t_format, 0);
archive_format = current_format;
if (subcommand_option == UPDATE_SUBCOMMAND
&& (name = name_scan (current_stat_info.file_name)) != NULL)
{
struct stat s;
chdir_do (name->change_dir);
if (deref_stat (dereference_option,
current_stat_info.file_name, &s) == 0
&& s.st_mtime <= current_stat_info.stat.st_mtime)
add_avoided_name (current_stat_info.file_name);
}
skip_member ();
break;
}
case HEADER_ZERO_BLOCK:
current_block = current_header;
found_end = true;
break;
case HEADER_END_OF_FILE:
found_end = true;
break;
case HEADER_FAILURE:
set_next_block_after (current_header);
switch (previous_status)
{
case HEADER_STILL_UNREAD:
WARN ((0, 0, _("This does not look like a tar archive")));
/* Fall through. */
case HEADER_SUCCESS:
case HEADER_ZERO_BLOCK:
ERROR ((0, 0, _("Skipping to next header")));
/* Fall through. */
case HEADER_FAILURE:
break;
case HEADER_END_OF_FILE:
case HEADER_SUCCESS_EXTENDED:
abort ();
}
break;
}
tar_stat_destroy (¤t_stat_info);
xheader_destroy (&extended_header);
previous_status = status;
}
reset_eof ();
time_to_start_writing = true;
output_start = current_block->buffer;
{
char *file_name;
while ((file_name = name_from_list ()) != NULL)
{
if (excluded_name (file_name))
continue;
if (interactive_option && !confirm ("add", file_name))
continue;
if (subcommand_option == CAT_SUBCOMMAND)
append_file (file_name);
else
dump_file (file_name, 1, (dev_t) 0);
}
}
write_eot ();
close_archive ();
names_notfound ();
}
/* Implement the 'r' (add files to end of archive), and 'u' (add files to
end of archive if they arent there, or are more up to date than the
version in the archive.) commands.*/
void
update_archive ()
{
int found_end = 0;
int status = 3;
int prev_status;
char *p;
struct name *name;
extern void dump_file ();
name_gather ();
if (cmd_mode == CMD_UPDATE)
name_expand ();
open_archive (2); /* Open for updating */
do
{
prev_status = status;
status = read_header ();
switch (status)
{
case EOF:
found_end = 1;
break;
case 0: /* A bad record */
userec (head);
switch (prev_status)
{
case 3:
msg ("This doesn't look like a tar archive.");
/* FALL THROUGH */
case 2:
case 1:
msg ("Skipping to next header");
case 0:
break;
}
break;
/* A good record */
case 1:
/* printf("File %s\n",head->header.name); */
/* head->header.name[NAMSIZ-1]='\0'; */
if (cmd_mode == CMD_UPDATE && (name = name_scan (current_file_name)))
{
/* struct stat hstat; */
struct stat nstat;
int head_standard;
decode_header (head, &hstat, &head_standard, 0);
if (stat (current_file_name, &nstat) < 0)
{
msg_perror ("can't stat %s:", current_file_name);
}
else
{
if (hstat.st_mtime >= nstat.st_mtime)
name->found++;
}
}
userec (head);
if (head->header.isextended)
skip_extended_headers ();
skip_file ((long) hstat.st_size);
break;
case 2:
ar_record = head;
found_end = 1;
break;
}
}
while (!found_end);
reset_eof ();
time_to_start_writing = 1;
output_start = ar_record->charptr;
while (p = name_from_list ())
{
if (f_confirm && !confirm ("add", p))
continue;
if (cmd_mode == CMD_CAT)
append_file (p);
else
dump_file (p, -1, 1);
}
write_eot ();
close_archive ();
names_notfound ();
}