// Buffer caption blocks for later sorting/flushing.
void store_hdcc(unsigned char *cc_data, int cc_count, int sequence_number, LLONG current_fts_now)
{
// Uninitialized?
if (anchor_seq_number < 0)
{
anchor_hdcc( sequence_number);
}
int seq_index = sequence_number - anchor_seq_number + MAXBFRAMES;
if (seq_index < 0 || seq_index > 2*MAXBFRAMES)
{
// Maybe missing an anchor frame - try to recover
dbg_print(CCX_DMT_VERBOSE, "Too many B-frames, or missing anchor frame. Trying to recover ..\n");
process_hdcc();
anchor_hdcc( sequence_number);
seq_index = sequence_number - anchor_seq_number + MAXBFRAMES;
}
has_ccdata_buffered = 1;
// In GOP mode the fts is set only once for the whole GOP. Recreate
// the right time according to the sequence number.
if (ccx_options.use_gop_as_pts==1)
{
current_fts_now += (LLONG) (sequence_number*1000.0/current_fps);
}
if (cc_count)
{
if (cc_data)
{
// Changed by CFS to concat, i.e. don't assume there's no data already for this seq_index.
// Needed at least for MP4 samples. // TODO: make sure we don't overflow
cc_fts[seq_index] = current_fts_now; // CFS: Maybe do even if there's no data?
if (stream_mode!=CCX_SM_MP4) // CFS: Very ugly hack, but looks like overwriting is needed for at least some ES
cc_data_count[seq_index] = 0;
memcpy(cc_data_pkts[seq_index]+cc_data_count[seq_index]*3, cc_data, cc_count*3+1);
}
cc_data_count[seq_index] += cc_count;
}
// DEBUG STUFF
/*
printf("\nCC blocks, channel 0:\n");
for ( int i=0; i < cc_count*3; i+=3)
{
printf("%s", debug_608toASC( cc_data+i, 0) );
}
printf("\n");
*/
}
// Buffer caption blocks for later sorting/flushing.
void store_hdcc(unsigned char *cc_data, int cc_count, int sequence_number, LLONG current_fts_now)
{
// Uninitialized?
if (anchor_seq_number < 0)
{
anchor_hdcc( sequence_number);
}
int seq_index = sequence_number - anchor_seq_number + MAXBFRAMES;
if (seq_index < 0 || seq_index > 2*MAXBFRAMES)
{
// Maybe missing an anchor frame - try to recover
if(debug_verbose)
printf("Too many B-frames, or missing anchor frame. Trying to recover ..\n");
process_hdcc();
anchor_hdcc( sequence_number);
seq_index = sequence_number - anchor_seq_number + MAXBFRAMES;
}
has_ccdata_buffered = 1;
cc_data_count[seq_index] = cc_count;
// In GOP mode the fts is set only once for the whole GOP. Recreate
// the right time according to the sequence number.
if (use_gop_as_pts)
{
current_fts_now += LLONG(sequence_number*1000.0/current_fps);
}
cc_fts[seq_index] = current_fts_now;
memcpy(cc_data_pkts[seq_index], cc_data, cc_count*3+1);
// DEBUG STUFF
/*
printf("\nCC blocks, channel 0:\n");
for ( int i=0; i < cc_count*3; i+=3)
{
printf("%s", debug_608toASC( cc_data+i, 0) );
}
printf("\n");
*/
}
void prepare_for_new_file (struct lib_ccx_ctx *ctx)
{
// struct lib_cc_decode *dec_ctx = NULL;
// dec_ctx = ctx->dec_ctx;
// Init per file variables
// inputsize=0; Now responsibility of switch_to_next_file()
ctx->last_reported_progress=-1;
ctx->stat_numuserheaders = 0;
ctx->stat_dvdccheaders = 0;
ctx->stat_scte20ccheaders = 0;
ctx->stat_replay5000headers = 0;
ctx->stat_replay4000headers = 0;
ctx->stat_dishheaders = 0;
ctx->stat_hdtv = 0;
ctx->stat_divicom = 0;
total_frames_count = 0;
// ctx->total_pulldownfields = 0;
// ctx->total_pulldownframes = 0;
// dec_ctx->cc_stats[0]=0; dec_ctx->cc_stats[1]=0; dec_ctx->cc_stats[2]=0; dec_ctx->cc_stats[3]=0;
ctx->false_pict_header=0;
// ctx->frames_since_last_gop=0;
frames_since_ref_time=0;
gop_time.inited=0;
first_gop_time.inited=0;
gop_rollover=0;
printed_gop.inited=0;
// dec_ctx->saw_caption_block=0;
pts_big_change=0;
anchor_hdcc(-1);
firstcall = 1;
for(int x=0; x<0xfff; x++)
{
ctx->epg_buffers[x].buffer=NULL;
ctx->epg_buffers[x].ccounter=0;
}
for (int i = 0; i < TS_PMT_MAP_SIZE; i++)
{
ctx->eit_programs[i].array_len=0;
ctx->eit_current_events[i]=-1;
}
ctx->epg_last_output=-1;
ctx->epg_last_live_output=-1;
}
// Return TRUE if all was read. FALSE if a problem occured:
// If a bitstream syntax problem occured the bitstream will
// point to after the problem, in case we run out of data the bitstream
// will point to where we want to restart after getting more.
static int read_pic_info(struct bitstream *esstream)
{
dbg_print(DMT_VERBOSE, "Read PIC Info\n");
// We only get here after seeing that start code
if (next_u32(esstream) != 0x00010000) // LSB first (0x00000100)
fatal(EXIT_BUG_BUG, "Impossible!");
// If we get here esstream points to the start of a group_start_code
// should we run out of data in esstream this is where we want to restart
// after getting more.
unsigned char *pic_info_start = esstream->pos;
pic_header(esstream);
pic_coding_ext(esstream);
if (esstream->error)
return 0;
if (esstream->bitsleft < 0)
{
init_bitstream(esstream, pic_info_start, esstream->end);
return 0;
}
// Analyse/use the picture information
static int maxtref; // Use to remember the temporal reference number
// A new anchor frame - flush buffered caption data. Might be flushed
// in GOP header already.
if (picture_coding_type==I_FRAME || picture_coding_type==P_FRAME)
{
// if (((picture_structure != 0x1) && (picture_structure != 0x2)) ||
// (temporal_reference != current_tref))
// {
// NOTE: process_hdcc() needs to be called before set_fts() as it
// uses fts_now to re-create the timeline !!!!!
if (has_ccdata_buffered)
{
process_hdcc();
}
anchor_hdcc(temporal_reference);
// }
}
current_tref = temporal_reference;
current_picture_coding_type = picture_coding_type;
// We mostly use PTS, but when the GOP mode is enabled do not set
// the FTS time here.
if (!use_gop_as_pts)
{
set_fts(); // Initialize fts
}
dbg_print(DMT_VIDES, "PTS: %s (%8u) - tref: %2d - %s since tref0/GOP: %2u/%2u",
print_mstime(current_pts/(MPEG_CLOCK_FREQ/1000)),
unsigned(current_pts), temporal_reference,
pict_types[picture_coding_type],
unsigned(frames_since_ref_time),
unsigned(frames_since_last_gop));
dbg_print(DMT_VIDES, " t:%d r:%d p:%d", top_field_first,
repeat_first_field, progressive_frame);
dbg_print(DMT_VIDES, " FTS: %s\n", print_mstime(get_fts()));
// Set min_pts/sync_pts according to the current time stamp.
// Use fts_at_gop_start as reference when a GOP header was seen
// since the last frame 0. If not this is most probably a
// TS without GOP headers but with USER DATA after each picture
// header. Use the current FTS values as reference.
// Note: If a GOP header was present the reference time is from
// the beginning of the GOP, otherwise it is now.
if(temporal_reference == 0)
{
last_gop_length = maxtref + 1;
maxtref = temporal_reference;
// frames_since_ref_time is used in set_fts()
if( saw_gop_header )
{
// This time (fts_at_gop_start) that was set in the
// GOP header and it might be off by one GOP. See the comment there.
frames_since_ref_time = frames_since_last_gop; // Should this be 0?
}
else
{
// No GOP header, use the current values
fts_at_gop_start=get_fts();
frames_since_ref_time = 0;
}
if (debug_mask & DMT_TIME)
{
dbg_print(DMT_TIME, "\nNew temporal reference:\n");
print_debug_timing();
}
saw_gop_header = 0; // Reset the value
}
if ( !saw_gop_header && picture_coding_type==I_FRAME )
{
// A new GOP beginns with an I-frame. Lets hope there are
// never more than one per GOP
frames_since_last_gop = 0;
}
// Set maxtref
if( temporal_reference > maxtref ) {
maxtref = temporal_reference;
if (maxtref+1 > max_gop_length)
max_gop_length = maxtref+1;
}
unsigned extraframe = 0;
if (repeat_first_field)
{
pulldownfields++;
total_pulldownfields++;
if ( current_progressive_sequence || !(total_pulldownfields%2) )
extraframe = 1;
if ( current_progressive_sequence && top_field_first )
extraframe = 2;
dbg_print(DMT_VIDES, "Pulldown: total pd fields: %d - %d extra frames\n",
total_pulldownfields, extraframe);
}
total_pulldownframes += extraframe;
total_frames_count += 1+extraframe;
frames_since_last_gop += 1+extraframe;
frames_since_ref_time += 1+extraframe;
dbg_print(DMT_VERBOSE, "Read PIC Info - processed\n\n");
return 1;
}
// Return TRUE if all was read. FALSE if a problem occured:
// If a bitstream syntax problem occured the bitstream will
// point to after the problem, in case we run out of data the bitstream
// will point to where we want to restart after getting more.
static int read_pic_info(struct lib_cc_decode *ctx, struct bitstream *esstream, struct cc_subtitle *sub)
{
debug("Read PIC Info\n");
// We only get here after seeing that start code
if (next_u32(esstream) != 0x00010000) // LSB first (0x00000100)
fatal(CCX_COMMON_EXIT_BUG_BUG, "In read_pic_info: next_u32(esstream) != 0x00010000. Please file a bug report in GitHub.\n");
// If we get here esstream points to the start of a group_start_code
// should we run out of data in esstream this is where we want to restart
// after getting more.
unsigned char *pic_info_start = esstream->pos;
pic_header(ctx, esstream);
pic_coding_ext(ctx, esstream);
if (esstream->error)
return 0;
if (esstream->bitsleft < 0)
{
init_bitstream(esstream, pic_info_start, esstream->end);
return 0;
}
// A new anchor frame - flush buffered caption data. Might be flushed
// in GOP header already.
if (ctx->picture_coding_type==CCX_FRAME_TYPE_I_FRAME || ctx->picture_coding_type==CCX_FRAME_TYPE_P_FRAME)
{
if (((ctx->picture_structure != 0x1) && (ctx->picture_structure != 0x2)) ||
(ctx->temporal_reference != ctx->timing->current_tref))
{
// NOTE: process_hdcc() needs to be called before set_fts() as it
// uses fts_now to re-create the timeline !!!!!
if (ctx->has_ccdata_buffered)
{
process_hdcc(ctx, sub);
}
anchor_hdcc(ctx, ctx->temporal_reference);
}
}
ctx->timing->current_tref = ctx->temporal_reference;
ctx->timing->current_picture_coding_type = ctx->picture_coding_type;
// We mostly use PTS, but when the GOP mode is enabled do not set
// the FTS time here.
if (ccx_options.use_gop_as_pts!=1)
{
set_fts(ctx->timing); // Initialize fts
}
dbg_print(CCX_DMT_VIDES, " t:%d r:%d p:%d", ctx->top_field_first,
ctx->repeat_first_field, ctx->progressive_frame);
dbg_print(CCX_DMT_VIDES, " FTS: %s\n", print_mstime_static(get_fts(ctx->timing, ctx->current_field)));
// Set min_pts/sync_pts according to the current time stamp.
// Use fts_at_gop_start as reference when a GOP header was seen
// since the last frame 0. If not this is most probably a
// TS without GOP headers but with USER DATA after each picture
// header. Use the current FTS values as reference.
// Note: If a GOP header was present the reference time is from
// the beginning of the GOP, otherwise it is now.
if(ctx->temporal_reference == 0)
{
ctx->last_gop_length = ctx->maxtref + 1;
ctx->maxtref = ctx->temporal_reference;
// frames_since_ref_time is used in set_fts()
if( ctx->saw_gop_header )
{
// This time (fts_at_gop_start) that was set in the
// GOP header and it might be off by one GOP. See the comment there.
frames_since_ref_time = ctx->frames_since_last_gop; // Should this be 0?
}
else
{
// No GOP header, use the current values
fts_at_gop_start = get_fts(ctx->timing, ctx->current_field);
frames_since_ref_time = 0;
}
if (ccx_options.debug_mask & CCX_DMT_TIME)
{
dbg_print(CCX_DMT_TIME, "\nNew temporal reference:\n");
print_debug_timing(ctx->timing);
}
ctx->saw_gop_header = 0; // Reset the value
}
if ( !ctx->saw_gop_header && ctx->picture_coding_type==CCX_FRAME_TYPE_I_FRAME )
{
// A new GOP beginns with an I-frame. Lets hope there are
// never more than one per GOP
ctx->frames_since_last_gop = 0;
}
// Set maxtref
if( ctx->temporal_reference > ctx->maxtref ) {
ctx->maxtref = ctx->temporal_reference;
if (ctx->maxtref + 1 > ctx->max_gop_length)
ctx->max_gop_length = ctx->maxtref + 1;
}
unsigned extraframe = 0;
if (ctx->repeat_first_field)
{
ctx->pulldownfields++;
ctx->total_pulldownfields++;
if ( ctx->current_progressive_sequence || !(ctx->total_pulldownfields%2) )
extraframe = 1;
if ( ctx->current_progressive_sequence && ctx->top_field_first )
extraframe = 2;
dbg_print(CCX_DMT_VIDES, "Pulldown: total pd fields: %d - %d extra frames\n",
ctx->total_pulldownfields, extraframe);
}
ctx->total_pulldownframes += extraframe;
total_frames_count += 1+extraframe;
ctx->frames_since_last_gop += 1+extraframe;
frames_since_ref_time += 1+extraframe;
debug("Read PIC Info - processed\n\n");
return 1;
}