void add_current_pts(struct ccx_common_timing_ctx *ctx, LLONG pts)
{
set_current_pts(ctx, ctx->current_pts + pts);
}
LLONG get_data(struct lib_ccx_ctx *ctx, struct wtv_chunked_buffer *cb, struct demuxer_data *data)
{
static int video_streams[32];
static int alt_stream; //Stream to use for timestamps if the cc stream has broken timestamps
static int use_alt_stream = 0;
static int num_streams = 0;
struct lib_cc_decode *dec_ctx = update_decoder_list(ctx);
while(1)
{
int bytesread = 0;
// Read the 32 bytes containing the GUID and length and stream_id info
get_sized_buffer(ctx->demux_ctx, cb, 32);
if(cb->buffer == NULL)
return CCX_EOF;
uint8_t guid[16];
memcpy(&guid, cb->buffer, 16); // Read the GUID
int x;
for(x=0; x<16; x++)
dbg_print(CCX_DMT_PARSE, "%02X ", guid[x]);
dbg_print(CCX_DMT_PARSE, "\n");
uint32_t len;
memcpy(&len, cb->buffer+16, 4); // Read the length
len-=32;
dbg_print(CCX_DMT_PARSE, "len %X\n", len);
uint32_t pad;
pad = len%8==0 ? 0 : 8- (len % 8); // Calculate the padding to add to the length
// to get to the next GUID
dbg_print(CCX_DMT_PARSE, "pad %X\n", pad);
uint32_t stream_id;
memcpy(&stream_id, cb->buffer+20, 4);
stream_id = stream_id & 0x7f; // Read and calculate the stream_id
dbg_print(CCX_DMT_PARSE, "stream_id: 0x%X\n", stream_id);
for(x=0; x<num_streams; x++)
dbg_print(CCX_DMT_PARSE, "video stream_id: %X\n", video_streams[x]);
if( !memcmp(guid, WTV_EOF, 16 ))
{
// This is the end of the data in this file
// read the padding at the end of the file
// and return one more byte
dbg_print(CCX_DMT_PARSE, "WTV EOF\n");
uint8_t *parsebuf;
parsebuf = (uint8_t*)malloc(1024);
do {
buffered_read(ctx->demux_ctx, parsebuf, 1024);
ctx->demux_ctx->past+=1024;
} while (result==1024);
ctx->demux_ctx->past+=result;
free(parsebuf);
free(cb->buffer);
cb->buffer=NULL;
//return one more byte so the final percentage is shown correctly
*(data->buffer+data->len)=0x00;
data->len++;
return CCX_EOF;
}
if( !memcmp(guid, WTV_STREAM2, 16 ) )
{
// The WTV_STREAM2 GUID appares near the start of the data dir
// It maps stream_ids to the type of stream
dbg_print(CCX_DMT_PARSE, "WTV STREAM2\n");
get_sized_buffer(ctx->demux_ctx, cb, 0xc+16);
if(cb->buffer==NULL)
return CCX_EOF;
static unsigned char stream_type[16];
memcpy(&stream_type, cb->buffer+0xc, 16); //Read the stream type GUID
const void *stream_guid;
if(ccx_options.wtvmpeg2)
stream_guid = WTV_STREAM_VIDEO; // We want mpeg2 data if the user set -wtvmpeg2
else
stream_guid = WTV_STREAM_MSTVCAPTION; // Otherwise we want the MSTV captions stream
if(!memcmp(stream_type, stream_guid, 16 ) )
{
video_streams[num_streams]=stream_id; // We keep a list of stream ids
num_streams++; // Even though there should only be 1
}
if (memcmp(stream_type, WTV_STREAM_AUDIO, 16))
alt_stream = stream_id;
len-=28;
}
if (!memcmp(guid, WTV_TIMING, 16) && ((use_alt_stream < WTV_CC_TIMESTAMP_MAGIC_THRESH && check_stream_id(stream_id, video_streams, num_streams))
|| (use_alt_stream == WTV_CC_TIMESTAMP_MAGIC_THRESH && stream_id == alt_stream)))
{
// The WTV_TIMING GUID contains a timestamp for the given stream_id
dbg_print(CCX_DMT_PARSE, "WTV TIMING\n");
get_sized_buffer(ctx->demux_ctx, cb, 0x8+0x8);
if(cb->buffer==NULL)
return CCX_EOF;
int64_t time;
memcpy(&time, cb->buffer+0x8, 8); // Read the timestamp
dbg_print(CCX_DMT_PARSE, "TIME: %ld\n", time);
if (time != -1 && time != WTV_CC_TIMESTAMP_MAGIC) { // Ignore -1 timestamps
set_current_pts(dec_ctx->timing, time_to_pes_time(time));
frames_since_ref_time = 0;
set_fts(dec_ctx->timing);
}
else if (time == WTV_CC_TIMESTAMP_MAGIC && stream_id != alt_stream) {
use_alt_stream++;
mprint("WARNING: %i WTV_CC_TIMESTAMP_MAGIC detected in cc timestamps. \n", use_alt_stream);
if (use_alt_stream == WTV_CC_TIMESTAMP_MAGIC_THRESH)
mprint("WARNING: WTV_CC_TIMESTAMP_MAGIC_THRESH reached. Switching to alt timestamps!\n");
}
len-=16;
}
if( !memcmp(guid, WTV_DATA, 16 )
&& check_stream_id(stream_id, video_streams, num_streams) && dec_ctx->timing->current_pts != 0
&& (ccx_options.wtvmpeg2 || (!ccx_options.wtvmpeg2 && len==2)))
{
// This is the data for a stream we want to process
dbg_print(CCX_DMT_PARSE, "\nWTV DATA\n");
get_sized_buffer(ctx->demux_ctx, cb, len);
if(cb->buffer==NULL)
return CCX_EOF;
memcpy(data->buffer+data->len, cb->buffer, len);
data->len+=result;
bytesread+=(int) len;
frames_since_ref_time++;
set_fts(dec_ctx->timing);
if(pad>0)
{ //Make sure we skip any padding too, since we are returning here
skip_sized_buffer(ctx->demux_ctx, cb, pad);
}
return bytesread;
}
if(len+pad>0)
{
// skip any remaining data
// For any unhandled GUIDs this will be len+pad
// For others it will just be pad
skip_sized_buffer(ctx->demux_ctx, cb, len+pad);
}
}
}
// Return TRUE if the data parsing finished, FALSE otherwise.
// estream->pos is advanced. Data is only processed if esstream->error
// is FALSE, parsing can set esstream->error to TRUE.
static int gop_header(struct lib_cc_decode *ctx, struct bitstream *esstream, struct cc_subtitle *sub)
{
debug("GOP header\n");
if (esstream->error || esstream->bitsleft <= 0)
return 0;
// We only get here after seeing that start code
if (read_u32(esstream) != 0xB8010000) // LSB first (0x000001B8)
fatal(CCX_COMMON_EXIT_BUG_BUG, "gop_header: read_u32(esstream) != 0xB8010000. Please file a bug report in GitHub.\n");
unsigned drop_frame_flag = (unsigned) read_bits(esstream,1);
struct gop_time_code gtc;
gtc.time_code_hours = (int) read_bits(esstream,5);
gtc.time_code_minutes = (int) read_bits(esstream,6);
skip_bits(esstream,1); // Marker bit
gtc.time_code_seconds = (int) read_bits(esstream,6);
gtc.time_code_pictures = (int) read_bits(esstream,6);
gtc.inited = 1;
calculate_ms_gop_time(>c);
if (esstream->bitsleft < 0)
return 0;
if (gop_accepted(>c))
{
// Do GOP padding during GOP header. The previous GOP and all
// included captions are written. Use the current GOP time to
// do the padding.
// Flush buffered cc blocks before doing the housekeeping
if (ctx->has_ccdata_buffered)
{
process_hdcc(ctx, sub);
}
// Last GOPs pulldown frames
if ((ctx->current_pulldownfields>0) != (ctx->pulldownfields>0))
{
ctx->current_pulldownfields = ctx->pulldownfields;
debug("Pulldown: %s", (ctx->pulldownfields ? "on" : "off"));
if (ctx->pulldownfields)
debug(" - %u fields in last GOP", ctx->pulldownfields);
debug("\n");
}
ctx->pulldownfields = 0;
// Report synchronization jumps between GOPs. Warn if there
// are 20% or more deviation.
if ( (ccx_options.debug_mask & CCX_DMT_TIME)
&& ((gtc.ms - gop_time.ms // more than 20% longer
> ctx->frames_since_last_gop*1000.0/current_fps*1.2)
||
(gtc.ms - gop_time.ms // or 20% shorter
< ctx->frames_since_last_gop*1000.0/current_fps*0.8))
&& first_gop_time.inited )
{
mprint("\rWarning: Jump in GOP timing.\n");
mprint(" (old) %s",
print_mstime_static(gop_time.ms));
mprint(" + %s (%uF)",
print_mstime_static((LLONG) (ctx->frames_since_last_gop
*1000.0/current_fps)),
ctx->frames_since_last_gop);
mprint(" != (new) %s\n",
print_mstime_static(gtc.ms));
}
if (first_gop_time.inited == 0)
{
first_gop_time = gtc;
// It needs to be "+1" because the frame count starts at 0 and we
// need the length of all frames.
if ( total_frames_count == 0 )
{ // If this is the first frame there cannot be an offset
ctx->timing->fts_fc_offset = 0;
// first_gop_time.ms stays unchanged
}
else
{
ctx->timing->fts_fc_offset = (LLONG) ((total_frames_count+1)
*1000.0/current_fps);
// Compensate for those written before
first_gop_time.ms -= ctx->timing->fts_fc_offset;
}
dbg_print(CCX_DMT_TIME, "\nFirst GOP time: %02u:%02u:%02u:%03u %+lldms\n",
gtc.time_code_hours,
gtc.time_code_minutes, gtc.time_code_seconds,
(unsigned) (1000.0*gtc.time_code_pictures/current_fps),
ctx->timing->fts_fc_offset);
}
gop_time = gtc;
ctx->frames_since_last_gop=0;
// Indicate that we read a gop header (since last frame number 0)
ctx->saw_gop_header = 1;
// If we use GOP timing, reconstruct the PTS from the GOP
if (ccx_options.use_gop_as_pts==1)
{
set_current_pts(ctx->timing, gtc.ms*(MPEG_CLOCK_FREQ/1000));
ctx->timing->current_tref = 0;
frames_since_ref_time = 0;
set_fts(ctx->timing);
fts_at_gop_start = get_fts_max(ctx->timing);
}
else
{
// FIXME: Wrong when PTS are not increasing but are identical
// troughout the GOP and then jump to the next time for the
// next GOP.
// This effect will also lead to captions being one GOP early
// for DVD captions.
fts_at_gop_start = get_fts_max(ctx->timing) + (LLONG) (1000.0/current_fps);
}
if (ccx_options.debug_mask & CCX_DMT_TIME)
{
dbg_print(CCX_DMT_TIME, "\nNew GOP:\n");
dbg_print(CCX_DMT_TIME, "\nDrop frame flag: %u:\n", drop_frame_flag);
print_debug_timing(ctx->timing);
}
}
return 1;
}
