/*****************************************************************************
* vcd_Open: Opens a VCD device or file initializes, a list of
tracks, segements and entry lsns and sizes and returns an opaque handle.
*****************************************************************************/
static vcdinfo_obj_t *
vcd_Open( vlc_object_t *p_this, const char *psz_dev )
{
access_t *p_access = (access_t *)p_this;
vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
vcdinfo_obj_t *p_vcdobj;
char *actual_dev;
unsigned int i;
dbg_print(INPUT_DBG_CALL, "called with %s", psz_dev);
if( !psz_dev ) return NULL;
actual_dev= ToLocaleDup(psz_dev);
if( vcdinfo_open(&p_vcdobj, &actual_dev, DRIVER_UNKNOWN, NULL) !=
VCDINFO_OPEN_VCD)
{
free(actual_dev);
return NULL;
}
free(actual_dev);
/*
Save summary info on tracks, segments and entries...
*/
if ( 0 < (p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdobj)) )
{
p_vcdplayer->track = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_tracks, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_tracks; i++)
{
unsigned int track_num=i+1;
p_vcdplayer->track[i].size =
vcdinfo_get_track_sect_count(p_vcdobj, track_num);
p_vcdplayer->track[i].start_LSN =
vcdinfo_get_track_lsn(p_vcdobj, track_num);
}
} else
p_vcdplayer->track = NULL;
if( 0 < (p_vcdplayer->i_entries = vcdinfo_get_num_entries(p_vcdobj)) )
{
p_vcdplayer->entry = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_entries, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_entries; i++)
{
p_vcdplayer->entry[i].size =
vcdinfo_get_entry_sect_count(p_vcdobj, i);
p_vcdplayer->entry[i].start_LSN =
vcdinfo_get_entry_lsn(p_vcdobj, i);
}
} else
p_vcdplayer->entry = NULL;
if ( 0 < (p_vcdplayer->i_segments = vcdinfo_get_num_segments(p_vcdobj)) )
{
p_vcdplayer->segment = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_segments, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_segments; i++)
{
p_vcdplayer->segment[i].size =
vcdinfo_get_seg_sector_count(p_vcdobj, i);
p_vcdplayer->segment[i].start_LSN =
vcdinfo_get_seg_lsn(p_vcdobj, i);
}
} else
p_vcdplayer->segment = NULL;
return p_vcdobj;
}
/**
* Once we're inside of idleproc_run(), we are executing in the context of the
* first process-- a real context, so we can finally begin running
* meaningful code.
*
* This is the body of process 0. It should initialize all that we didn't
* already initialize in kmain(), launch the init process (initproc_run),
* wait for the init process to exit, then halt the machine.
*
* @param arg1 the first argument (unused)
* @param arg2 the second argument (unused)
*/
static void *
idleproc_run(int arg1, void *arg2)
{
int status;
pid_t child;
/* create init proc */
kthread_t *initthr = initproc_create();
init_call_all();
GDB_CALL_HOOK(initialized);
/* Create other kernel threads (in order) */
#ifdef __VFS__
/* Once you have VFS remember to set the current working directory
* of the idle and init processes */
NOT_YET_IMPLEMENTED("VFS: idleproc_run");
/* Here you need to make the null, zero, and tty devices using mknod */
/* You can't do this until you have VFS, check the include/drivers/dev.h
* file for macros with the device ID's you will need to pass to mknod */
NOT_YET_IMPLEMENTED("VFS: idleproc_run");
#endif
/* Finally, enable interrupts (we want to make sure interrupts
* are enabled AFTER all drivers are initialized) */
intr_enable();
/* Run initproc */
sched_make_runnable(initthr);
/* Now wait for it */
child = do_waitpid(-1, 0, &status);
KASSERT(PID_INIT == child);
#ifdef __MTP__
kthread_reapd_shutdown();
#endif
#ifdef __SHADOWD__
/* wait for shadowd to shutdown */
shadowd_shutdown();
#endif
#ifdef __VFS__
/* Shutdown the vfs: */
dbg_print("weenix: vfs shutdown...\n");
vput(curproc->p_cwd);
if (vfs_shutdown())
panic("vfs shutdown FAILED!!\n");
#endif
/* Shutdown the pframe system */
#ifdef __S5FS__
pframe_shutdown();
#endif
dbg_print("\nweenix: halted cleanly!\n");
GDB_CALL_HOOK(shutdown);
hard_shutdown();
return NULL;
}
/****************************************************************************
* VCDSeek
****************************************************************************/
int
VCDSeek( access_t * p_access, uint64_t i_pos )
{
if (!p_access || !p_access->p_sys) return VLC_EGENERIC;
{
vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_vcd_access->p_sys;
unsigned int i_entry = VCDINFO_INVALID_ENTRY;
/* Next sector to read */
p_vcdplayer->i_lsn = (i_pos / (uint64_t) M2F2_SECTOR_SIZE) +
p_vcdplayer->origin_lsn;
switch (p_vcdplayer->play_item.type)
{
case VCDINFO_ITEM_TYPE_TRACK:
case VCDINFO_ITEM_TYPE_ENTRY:
break;
default:
p_vcdplayer->b_valid_ep = false;
break;
}
/* Find entry */
if( p_vcdplayer->b_valid_ep )
{
for( i_entry = 0 ; i_entry < p_vcdplayer->i_entries ; i_entry ++ )
{
if( p_vcdplayer->i_lsn < p_vcdplayer->p_entries[i_entry] )
{
VCDUpdateVar( p_access, i_entry, VLC_VAR_SETVALUE,
"chapter", _("Entry"), "Setting entry" );
break;
}
}
{
vcdinfo_itemid_t itemid;
itemid.num = i_entry;
itemid.type = VCDINFO_ITEM_TYPE_ENTRY;
VCDSetOrigin(p_access, p_vcdplayer->i_lsn,
p_vcdplayer->i_track, &itemid);
}
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK),
"orig %lu, cur: %lu, offset: %"PRIi64", entry %d",
(long unsigned int) p_vcdplayer->origin_lsn,
(long unsigned int) p_vcdplayer->i_lsn, i_pos,
i_entry );
#if 0
/* Find seekpoint */
const input_title_t *t = p_vcdplayer->p_title[p_vcdplayer->i_cur_title];
int i_seekpoint;
for( i_seekpoint = 0; i_seekpoint < t->i_seekpoint; i_seekpoint++ )
{
if( i_seekpoint + 1 >= t->i_seekpoint ) break;
if( i_pos < t->seekpoint[i_seekpoint + 1]->i_byte_offset ) break;
}
/* Update current seekpoint */
if( p_vcdplayer->i_cur_chapter != i_seekpoint )
dbg_print( (INPUT_DBG_SEEK), "seekpoint change %d",
i_seekpoint );
p_vcdplayer->i_cur_chapter = i_seekpoint;
#endif
}
p_access->info.b_eof = false;
return VLC_SUCCESS;
}
extern void mate_analyze_frame(packet_info *pinfo, proto_tree* tree) {
mate_cfg_pdu* cfg;
GPtrArray* protos;
field_info* proto;
guint i,j;
AVPL* criterium_match;
mate_pdu* pdu = NULL;
mate_pdu* last = NULL;
rd->now = (float) nstime_to_sec(&pinfo->fd->rel_ts);
if ( proto_tracking_interesting_fields(tree)
&& rd->highest_analyzed_frame < pinfo->fd->num ) {
for ( i = 0; i < mc->pducfglist->len; i++ ) {
cfg = (mate_cfg_pdu *)g_ptr_array_index(mc->pducfglist,i);
dbg_print (dbg_pdu,4,dbg_facility,"mate_analyze_frame: trying to extract: %s",cfg->name);
protos = proto_get_finfo_ptr_array(tree, cfg->hfid_proto);
if (protos) {
pdu = NULL;
for (j = 0; j < protos->len; j++) {
dbg_print (dbg_pdu,3,dbg_facility,"mate_analyze_frame: found matching proto, extracting: %s",cfg->name);
proto = (field_info*) g_ptr_array_index(protos,j);
pdu = new_pdu(cfg, pinfo->fd->num, proto, tree);
if (cfg->criterium) {
criterium_match = new_avpl_from_match(cfg->criterium_match_mode,"",pdu->avpl,cfg->criterium,FALSE);
if (criterium_match) {
delete_avpl(criterium_match,FALSE);
}
if ( (criterium_match && cfg->criterium_accept_mode == REJECT_MODE )
|| ( ! criterium_match && cfg->criterium_accept_mode == ACCEPT_MODE )) {
delete_avpl(pdu->avpl,TRUE);
g_slice_free(mate_max_size,(mate_max_size*)pdu);
pdu = NULL;
continue;
}
}
analyze_pdu(pdu);
if ( ! pdu->gop && cfg->drop_unassigned) {
delete_avpl(pdu->avpl,TRUE);
g_slice_free(mate_max_size,(mate_max_size*)pdu);
pdu = NULL;
continue;
}
if ( cfg->discard ) {
delete_avpl(pdu->avpl,TRUE);
pdu->avpl = NULL;
}
if (!last) {
g_hash_table_insert(rd->frames,GINT_TO_POINTER(pinfo->fd->num),pdu);
last = pdu;
} else {
last->next_in_frame = pdu;
last = pdu;
}
}
if ( pdu && cfg->last_extracted ) break;
}
}
rd->highest_analyzed_frame = pinfo->fd->num;
}
}
H264_DPB_entry* open_api_h264_get_empty_dpb(void)
{
kal_uint32 index, i, Ind;
kal_int32 minPOC;
H264_DPB_entry *p_DPB = NULL, *dpbe;
/*Scott, Check if there is any free dpb be marked as un-used for ref. in the ref marking process */
open_api_h264_check_free_dpb();
// check fullness
if (g_open_api_h264_DPB_list.num_used == (g_open_api_h264_dec_info_ptr->dec_param.max_DPB_number+1))
{
//Needs to do bumping process here!!
// Find the removable entry with minimal POC
minPOC = (kal_int32)maxINT;
Ind = 0;
dpbe = g_open_api_h264_DPB_list.dpbe;
for (i=0; i < (g_open_api_h264_dec_info_ptr->dec_param.max_DPB_number+1); i++)// find the one with smallest POC
{
p_DPB = dpbe++;
if ( (p_DPB->isOutputed == 1) && (p_DPB->status_marked == H264_unused_ref) )
{
if (p_DPB->POC < minPOC)
{
minPOC = p_DPB->POC;
Ind = i;
}
}
}
if (minPOC != maxINT)
{
p_DPB = &g_open_api_h264_DPB_list.dpbe[Ind];
//clear_rpe_by_ind(dpbe->statusMarked, Ind);
open_api_h264_free_dpb(p_DPB);
g_open_api_h264_DPB_list.num_used--;
//return p_DPB; // Move to the final
goto GET_EMPTY_END;
}
// In the non-display-ordering mode, if goes here there must be something wrong...
//
if (fgDisplayOrderMode == KAL_FALSE)
{
//ASSERT(0);
return NULL;
}
// Find non-outputed one with smallest POC and do bumping process.
while (1)
{
minPOC = get_ind_dpbe_with_smallest_poc(&Ind);
if (minPOC == maxINT)
{
video_dbg_trace(H264_DEC_FIND_SMALLEST_POC_FAIL, 0);
dbg_print("[DRV H264]get_ind_dpbe_with_smallest_poc fails\n\r");
return NULL;
}
p_DPB = &g_open_api_h264_DPB_list.dpbe[Ind];
if (p_DPB->isOutputed == 0)
{
p_DPB->isOutputed = 1;
if (output_a_pic_normal(p_DPB) != 1)
{
video_dbg_trace(H264_DEC_OUTPUT_PIC_FAIL, p_DPB->frame_no);
dbg_print("[DRV H264]output_a_pic_normal() fails, frames_no = %d\n\r", p_DPB->frame_no);
return NULL;
}
}
video_dbg_trace(H264_DEC_BUMPING_PROCESS, p_DPB->frame_no);
dbg_print("[DRV H264]open_api_h264_get_empty_dpb() DPB Full, Bumping process remove frame: %d\n\r", p_DPB->frame_no);
if (p_DPB->status_marked == H264_unused_ref)
{
open_api_h264_free_dpb(p_DPB);
g_open_api_h264_DPB_list.num_used--;
//return p_DPB; // Move to the final
break;
}
}
}
GET_EMPTY_END:
for (index=0; index < (g_open_api_h264_dec_info_ptr->dec_param.max_DPB_number+1); index++)
{
if (g_open_api_h264_DPB_list.dpbe[index].b_used == KAL_FALSE)
{
g_open_api_h264_DPB_list.dpbe[index].b_used = KAL_TRUE;
p_DPB = &g_open_api_h264_DPB_list.dpbe[index];
g_open_api_h264_DPB_list.num_used++;
break;
}
}
return p_DPB;
}
static void reanalyze_gop(mate_gop* gop) {
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
mate_cfg_gop* gop_cfg = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
mate_gog* gog = gop->gog;
gogkey* gog_key;
if ( ! gog ) return;
gog->last_time = rd->now;
dbg_print (dbg_gog,1,dbg_facility,"reanalyze_gop: %s:%d",gop->cfg->name,gop->id);
apply_extras(gop->avpl,gog->avpl,gog->cfg->extra);
/* XXX: Instead of using the length of the avpl to check if an avpl has changed,
which is not accurate at all, we should have apply_extras,
apply_transformations and other functions that can modify the avpl
to flag the avpl if it has changed, then we'll check for the flag
and clear it after analysis */
if (gog->last_n != gog->avpl->len) {
dbg_print (dbg_gog,2,dbg_facility,"reanalyze_gop: gog has new attributes let's look for new keys");
gog_keys = gog->cfg->keys;
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
gop_cfg = (mate_cfg_gop *)g_hash_table_lookup(mc->gopcfgs,curr_gogkey->name);
if (( gogkey_match = new_avpl_exact_match(gop_cfg->name,gog->avpl,curr_gogkey,FALSE) )) {
gog_key = (gogkey *)g_malloc(sizeof(gogkey));
gog_key->key = avpl_to_str(gogkey_match);
delete_avpl(gogkey_match,FALSE);
gog_key->cfg = gop_cfg;
if (g_hash_table_lookup(gop_cfg->gog_index,gog_key->key)) {
g_free(gog_key->key);
g_free(gog_key);
gog_key = NULL;
}
if (! gog_key ) {
/* XXX: since these gogs actually share key info
we should try to merge (non released) gogs
that happen to have equal keys */
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: new key for gog=%s:%d : %s",gog->cfg->name,gog->id,gog_key->key);
g_ptr_array_add(gog->gog_keys,gog_key);
g_hash_table_insert(gog_key->cfg->gog_index,gog_key->key,gog);
}
}
}
gog->last_n = gog->avpl->len;
}
if (gog->num_of_released_gops == gog->num_of_counting_gops) {
gog->released = TRUE;
gog->expiration = gog->cfg->expiration + rd->now;
} else {
gog->released = FALSE;
}
}
static void analyze_pdu(mate_pdu* pdu) {
/* TODO:
return a g_boolean to tell we've destroyed the pdu when the pdu is unnassigned
destroy the unassigned pdu
*/
mate_cfg_gop* cfg = NULL;
mate_gop* gop = NULL;
gchar* gop_key;
gchar* orig_gop_key = NULL;
AVPL* candidate_start = NULL;
AVPL* candidate_stop = NULL;
AVPL* is_start = NULL;
AVPL* is_stop = NULL;
AVPL* gopkey_match = NULL;
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
gchar* gogkey_str = NULL;
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: %s",pdu->cfg->name);
if (! (cfg = (mate_cfg_gop *)g_hash_table_lookup(mc->gops_by_pduname,pdu->cfg->name)) )
return;
if ((gopkey_match = new_avpl_exact_match("gop_key_match",pdu->avpl,cfg->key, TRUE))) {
gop_key = avpl_to_str(gopkey_match);
g_hash_table_lookup_extended(cfg->gop_index,(gconstpointer)gop_key,(gpointer *)&orig_gop_key,(gpointer *)&gop);
if ( gop ) {
g_free(gop_key);
/* is the gop dead ? */
if ( ! gop->released &&
( ( gop->cfg->lifetime > 0.0 && gop->time_to_die >= rd->now) ||
( gop->cfg->idle_timeout > 0.0 && gop->time_to_timeout >= rd->now) ) ) {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: expiring released gop");
gop->released = TRUE;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
/* TODO: is the gop expired? */
gop_key = orig_gop_key;
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got gop: %s",gop_key);
if (( candidate_start = cfg->start )) {
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got candidate start");
if (( is_start = new_avpl_exact_match("",pdu->avpl, candidate_start, FALSE) )) {
delete_avpl(is_start,FALSE);
if ( gop->released ) {
dbg_print (dbg_gop,3,dbg_facility,"analyze_pdu: start on released gop, let's create a new gop");
g_hash_table_remove(cfg->gop_index,gop_key);
gop->gop_key = NULL;
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: duplicate start on gop");
}
}
}
pdu->gop = gop;
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
if (gop->released) pdu->after_release = TRUE;
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: no gop already");
if ( ! cfg->start ) {
/* there is no GopStart, we'll check for matching GogKeys
if we have one we'll create the Gop */
apply_extras(pdu->avpl,gopkey_match,cfg->extra);
gog_keys = (LoAL *)g_hash_table_lookup(mc->gogs_by_gopname,cfg->name);
if (gog_keys) {
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
if (( gogkey_match = new_avpl_exact_match(cfg->name,gopkey_match,curr_gogkey,FALSE) )) {
gogkey_str = avpl_to_str(gogkey_match);
if (g_hash_table_lookup(cfg->gog_index,gogkey_str)) {
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
break;
} else {
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
}
}
}
if ( ! gop ) {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
candidate_start = cfg->start;
if (( is_start = new_avpl_exact_match("",pdu->avpl, candidate_start, FALSE) )) {
delete_avpl(is_start,FALSE);
gop = new_gop(cfg,pdu,gop_key);
} else {
g_free(gop_key);
return;
}
pdu->gop = gop;
}
}
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
gop->num_of_pdus++;
gop->time_to_timeout = cfg->idle_timeout > 0.0 ? cfg->idle_timeout + rd->now : (float) -1.0 ;
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: merge with key");
merge_avpl(gop->avpl,gopkey_match,TRUE);
delete_avpl(gopkey_match,TRUE);
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: apply extras");
apply_extras(pdu->avpl,gop->avpl,gop->cfg->extra);
gop->last_time = pdu->rel_time;
if ( ! gop->released) {
candidate_stop = cfg->stop;
if (candidate_stop) {
is_stop = new_avpl_exact_match("",pdu->avpl, candidate_stop,FALSE);
} else {
is_stop = new_avpl("");
}
if(is_stop) {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: is a `stop");
delete_avpl(is_stop,FALSE);
if (! gop->released) {
gop->released = TRUE;
gop->release_time = pdu->rel_time;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
pdu->is_stop = TRUE;
}
}
if (gop->last_n != gop->avpl->len) apply_transforms(gop->cfg->transforms,gop->avpl);
gop->last_n = gop->avpl->len;
if (gop->gog) {
reanalyze_gop(gop);
} else {
analyze_gop(gop);
}
} else {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: no match for this pdu");
pdu->gop = NULL;
}
}
/**
* new_avpl_loose_match:
* @name: the name of the resulting avpl
* @src: avpl to be matched agains an "op" avpl
* @op: the "op" avpl that will be matched against the src avpl
* @copy_avps: whether the avps in the resulting avpl should be copied
*
* creates an avp list containing any avps in src matching any avps in op
* it will eventually create an empty list in none match
*
* Return value: a pointer to the newly created avpl containing the
* matching avps.
**/
extern AVPL* new_avpl_loose_match(const gchar* name,
AVPL* src,
AVPL* op,
gboolean copy_avps) {
AVPL* newavpl = new_avpl(scs_subscribe(avp_strings, name));
AVPN* co = NULL;
AVPN* cs = NULL;
ptrdiff_t c;
AVP* m;
AVP* copy;
#ifdef _AVP_DEBUGGING
dbg_print(dbg_avpl_op,3,dbg_fp,"new_avpl_loose_match: %X src=%X op=%X name='%s'",newavpl,src,op,name);
#endif
cs = src->null.next;
co = op->null.next;
while(1) {
if (!co->avp) {
return newavpl;
}
if (!cs->avp) {
return newavpl;
}
c = ADDRDIFF(co->avp->n, cs->avp->n);
if ( c > 0 ) {
if (co->avp) co = co->next;
} else if (c < 0) {
if (cs->avp) cs = cs->next;
} else {
m = match_avp(cs->avp,co->avp);
if(m) {
if (copy_avps) {
copy = avp_copy(m);
if ( ! insert_avp(newavpl,copy) ) {
delete_avp(copy);
}
} else {
insert_avp(newavpl,m);
}
}
if (cs->avp) cs = cs->next;
}
}
#ifdef _AVP_DEBUGGING
dbg_print(dbg_avpl_op,6,dbg_fp,"new_avpl_loose_match: done!");
#endif
return NULL;
}
void write_cc_line_as_transcript2(struct eia608_screen *data, struct encoder_ctx *context, int line_number)
{
unsigned h1,m1,s1,ms1;
unsigned h2,m2,s2,ms2;
LLONG start_time = data->start_time;
LLONG end_time = data->end_time;
if (ccx_options.sentence_cap)
{
capitalize (line_number,data);
correct_case(line_number,data);
}
int length = get_decoder_line_basic (subline, line_number, data,ccx_options.trim_subs,ccx_options.encoding);
if (ccx_options.encoding!=CCX_ENC_UNICODE)
{
dbg_print(CCX_DMT_DECODER_608, "\r");
dbg_print(CCX_DMT_DECODER_608, "%s\n",subline);
}
if (length>0)
{
if (data->start_time == -1)
{
// CFS: Means that the line has characters but we don't have a timestamp for the first one. Since the timestamp
// is set for example by the write_char function, it possible that we don't have one in empty lines (unclear)
// For now, let's not consider this a bug as before and just return.
// fatal (EXIT_BUG_BUG, "Bug in timedtranscript (ts_start_of_current_line==-1). Please report.");
return;
}
if (ccx_options.transcript_settings.showStartTime){
char buf1[80];
if (ccx_options.transcript_settings.relativeTimestamp){
millis_to_date(start_time + context->subs_delay, buf1);
fdprintf(context->out->fh, "%s|", buf1);
}
else {
mstotime(start_time + context->subs_delay, &h1, &m1, &s1, &ms1);
time_t start_time_int = (start_time + context->subs_delay) / 1000;
int start_time_dec = (start_time + context->subs_delay) % 1000;
struct tm *start_time_struct = gmtime(&start_time_int);
strftime(buf1, sizeof(buf1), "%Y%m%d%H%M%S", start_time_struct);
fdprintf(context->out->fh, "%s%c%03d|", buf1,ccx_options.millis_separator,start_time_dec);
}
}
if (ccx_options.transcript_settings.showEndTime){
char buf2[80];
if (ccx_options.transcript_settings.relativeTimestamp){
millis_to_date(end_time, buf2);
fdprintf(context->out->fh, "%s|", buf2);
}
else {
mstotime(get_fts() + context->subs_delay, &h2, &m2, &s2, &ms2);
time_t end_time_int = (end_time + context->subs_delay) / 1000;
int end_time_dec = (end_time + context->subs_delay) % 1000;
struct tm *end_time_struct = gmtime(&end_time_int);
strftime(buf2, sizeof(buf2), "%Y%m%d%H%M%S", end_time_struct);
fdprintf(context->out->fh, "%s%c%03d|", buf2,ccx_options.millis_separator,end_time_dec);
}
}
if (ccx_options.transcript_settings.showCC){
fdprintf(context->out->fh, "CC%d|", data->my_field == 1 ? data->channel : data->channel + 2); // Data from field 2 is CC3 or 4
}
if (ccx_options.transcript_settings.showMode){
const char *mode = "???";
switch (data->mode)
{
case MODE_POPON:
mode = "POP";
break;
case MODE_FAKE_ROLLUP_1:
mode = "RU1";
break;
case MODE_ROLLUP_2:
mode = "RU2";
break;
case MODE_ROLLUP_3:
mode = "RU3";
break;
case MODE_ROLLUP_4:
mode = "RU4";
break;
case MODE_TEXT:
mode = "TXT";
break;
case MODE_PAINTON:
mode = "PAI";
break;
}
fdprintf(context->out->fh, "%s|", mode);
}
write(context->out->fh, subline, length);
write(context->out->fh, encoded_crlf, encoded_crlf_length);
}
// fprintf (wb->fh,encoded_crlf);
}
/**
* new_avpl_exact_match:
* @name: the name of the resulting avpl
* @src: avpl to be matched agains an "op" avpl
* @op: the "op" avpl that will be matched against the src avpl
* @copy_avps: whether the avps in the resulting avpl should be copied
*
* creates an avp list containing every avp in src matching every avp in op
* it will not create a list unless every avp in op is matched only once
* to every avp in op.
*
* Return value: a pointer to the newly created avpl containing the
* matching avps.
**/
extern AVPL* new_avpl_exact_match(const gchar* name,AVPL* src, AVPL* op, gboolean copy_avps) {
AVPL* newavpl = new_avpl(name);
AVPN* co = NULL;
AVPN* cs = NULL;
ptrdiff_t c;
AVP* m;
AVP* copy;
#ifdef _AVP_DEBUGGING
dbg_print(dbg_avpl_op,3,dbg_fp,"new_avpl_every_match: %X src=%X op=%X name='%s'",newavpl,src,op,name);
#endif
if (op->len == 0)
return newavpl;
if (src->len == 0) {
delete_avpl(newavpl,FALSE);
return NULL;
}
cs = src->null.next;
co = op->null.next;
while(1) {
c = ADDRDIFF(co->avp->n,cs->avp->n);
if ( c > 0 ) {
delete_avpl(newavpl,TRUE);
return NULL;
} else if (c < 0) {
cs = cs->next;
if (! cs->avp ) {
delete_avpl(newavpl,TRUE);
return NULL;
}
} else {
m = match_avp(cs->avp,co->avp);
if(m) {
cs = cs->next;
co = co->next;
if (copy_avps) {
copy = avp_copy(m);
if ( ! insert_avp(newavpl,copy) ) {
delete_avp(copy);
}
} else {
insert_avp(newavpl,m);
}
if (!co->avp) {
return newavpl;
}
if (!cs->avp) {
delete_avpl(newavpl,TRUE);
return NULL;
}
} else {
delete_avpl(newavpl,TRUE);
return NULL;
}
}
}
/* should never be reached */
return NULL;
}
/**
* match_avp:
* @src: an src to be compared agains an "op" avp
* @op: the "op" avp that will be matched against the src avp
*
* Checks whether or not two avp's match.
*
* Return value: a pointer to the src avp if there's a match.
*
**/
extern AVP* match_avp(AVP* src, AVP* op) {
gchar** splited;
int i;
gchar* p;
guint ls;
guint lo;
float fs = 0.0f;
float fo = 0.0f;
gboolean lower = FALSE;
#ifdef _AVP_DEBUGGING
dbg_print(dbg_avpl_op,3,dbg_fp,"match_avp: %s%c%s; vs. %s%c%s;",src->n,src->o,src->v,op->n,op->o,op->v);
#endif
if ( src->n != op->n ) {
return NULL;
}
switch (op->o) {
case AVP_OP_EXISTS:
return src;
case AVP_OP_EQUAL:
return src->v == op->v ? src : NULL;
case AVP_OP_NOTEQUAL:
return !( src->v == op->v) ? src : NULL;
case AVP_OP_STARTS:
return strncmp(src->v,op->v,strlen(op->v)) == 0 ? src : NULL;
case AVP_OP_ONEOFF:
splited = g_strsplit(op->v,"|",0);
if (splited) {
for (i=0;splited[i];i++) {
if(g_str_equal(splited[i],src->v)) {
g_strfreev(splited);
return src;
}
}
g_strfreev(splited);
}
return NULL;
case AVP_OP_LOWER:
lower = TRUE;
/* FALLTHRU */
case AVP_OP_HIGHER:
fs = (float) g_ascii_strtod(src->v, NULL);
fo = (float) g_ascii_strtod(op->v, NULL);
if (lower) {
if (fs<fo) return src;
else return NULL;
} else {
if (fs>fo) return src;
else return NULL;
}
case AVP_OP_ENDS:
/* does this work? */
ls = (guint) strlen(src->v);
lo = (guint) strlen(op->v);
if ( ls < lo ) {
return NULL;
} else {
p = src->v + ( ls - lo );
return g_str_equal(p,op->v) ? src : NULL;
}
/* case AVP_OP_TRANSF: */
/* return do_transform(src,op); */
case AVP_OP_CONTAINS:
/* TODO */
return NULL;
}
/* will never get here */
return NULL;
}
/**
* new_avpl_every_match:
* @name: the name of the resulting avpl
* @src: avpl to be matched agains an "op" avpl
* @op: the "op" avpl that will be matched against the src avpl
* @copy_avps: whether the avps in the resulting avpl should be copied
*
* creates an avp list containing any avps in src matching every avp in op
* it will not create a list if there is not a match for every attribute in op
*
* Return value: a pointer to the newly created avpl containing the
* matching avps.
**/
extern AVPL* new_avpl_every_match(const gchar* name, AVPL* src, AVPL* op, gboolean copy_avps) {
AVPL* newavpl;
AVPN* co = NULL;
AVPN* cs = NULL;
ptrdiff_t c;
AVP* m;
AVP* copy;
gboolean matches;
#ifdef _AVP_DEBUGGING
dbg_print(dbg_avpl_op,3,dbg_fp,"new_avpl_every_match: %X src=%X op=%X name='%s'",newavpl,src,op,name);
#endif
if (src->len == 0) return NULL;
newavpl = new_avpl(scs_subscribe(avp_strings, name));
if (op->len == 0)
return newavpl;
matches = TRUE;
cs = src->null.next;
co = op->null.next;
while(1) {
if (!co->avp) {
break;
}
if (!cs->avp) {
break;
}
c = ADDRDIFF(co->avp->n,cs->avp->n);
if ( c > 0 ) {
delete_avpl(newavpl,TRUE);
return NULL;
} else if (c < 0) {
cs = cs->next;
if (! cs->avp ) {
break;
}
} else {
m = match_avp(cs->avp,co->avp);
if(m) {
matches++;
cs = cs->next;
co = co->next;
if (copy_avps) {
copy = avp_copy(m);
if ( ! insert_avp(newavpl,copy) ) {
delete_avp(copy);
}
} else {
insert_avp(newavpl,m);
}
} else {
cs = cs->next;
}
}
}
if (matches) {
return newavpl;
} else {
delete_avpl(newavpl,TRUE);
return NULL;
}
}
static block_t *Reassemble( decoder_t *p_dec, block_t *p_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
uint8_t *p_buffer;
uint16_t i_expected_image;
uint8_t i_packet, i_expected_packet;
if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
{
block_Release( p_block );
return NULL;
}
if( p_block->i_buffer < SPU_HEADER_LEN )
{
msg_Dbg( p_dec, "invalid packet header (size %zu < %u)" ,
p_block->i_buffer, SPU_HEADER_LEN );
block_Release( p_block );
return NULL;
}
p_buffer = p_block->p_buffer;
if( p_sys->i_state == SUBTITLE_BLOCK_EMPTY )
{
i_expected_image = p_sys->i_image + 1;
i_expected_packet = 0;
}
else
{
i_expected_image = p_sys->i_image;
i_expected_packet = p_sys->i_packet + 1;
}
/* The dummy ES that the menu selection uses has an 0x70 at
the head which we need to strip off. */
p_buffer += 2;
if( *p_buffer & 0x80 )
{
p_sys->i_state = SUBTITLE_BLOCK_COMPLETE;
i_packet = *p_buffer++ & 0x7F;
}
else
{
p_sys->i_state = SUBTITLE_BLOCK_PARTIAL;
i_packet = *p_buffer++;
}
p_sys->i_image = GETINT16(p_buffer);
if( p_sys->i_image != i_expected_image )
{
msg_Warn( p_dec, "expected subtitle image %u but found %u",
i_expected_image, p_sys->i_image );
}
if( i_packet != i_expected_packet )
{
msg_Warn( p_dec, "expected subtitle image packet %u but found %u",
i_expected_packet, i_packet );
}
p_block->p_buffer += SPU_HEADER_LEN;
p_block->i_buffer -= SPU_HEADER_LEN;
p_sys->i_packet = i_packet;
/* First packet in the subtitle block */
if( !p_sys->i_packet ) ParseHeader( p_dec, p_block );
block_ChainAppend( &p_sys->p_spu, p_block );
if( p_sys->i_state == SUBTITLE_BLOCK_COMPLETE )
{
block_t *p_spu = block_ChainGather( p_sys->p_spu );
if( p_spu->i_buffer != p_sys->i_spu_size )
{
msg_Warn( p_dec, "subtitle packets size=%zu should be %zu",
p_spu->i_buffer, p_sys->i_spu_size );
}
dbg_print( (DECODE_DBG_PACKET),
"subtitle packet complete, size=%zu", p_spu->i_buffer );
p_sys->i_state = SUBTITLE_BLOCK_EMPTY;
p_sys->p_spu = 0;
return p_spu;
}
return NULL;
}
/*****************************************************************************
VCDOpen: open VCD.
read in meta-information about VCD: the number of tracks, segments,
entries, size and starting information. Then set up state variables so
that we read/seek starting at the location specified.
On success we return VLC_SUCCESS, on memory exhausted VLC_ENOMEM,
and VLC_EGENERIC for some other error.
*****************************************************************************/
int
VCDOpen ( vlc_object_t *p_this )
{
access_t *p_access = (access_t *)p_this;
vcdplayer_t *p_vcdplayer;
char *psz_source;
vcdinfo_itemid_t itemid;
bool play_single_item = false;
p_access->pf_read = NULL;
p_access->pf_block = VCDReadBlock;
p_access->pf_control = VCDControl;
p_access->pf_seek = VCDSeek;
p_access->info.i_pos = 0;
p_access->info.b_eof = false;
p_vcdplayer = malloc( sizeof(vcdplayer_t) );
if( p_vcdplayer == NULL )
return VLC_ENOMEM;
p_vcdplayer->i_debug = var_InheritInteger( p_this, MODULE_STRING "-debug" );
p_access->p_sys = (access_sys_t *) p_vcdplayer;
p_vcdplayer->size = 0;
/* Set where to log errors messages from libcdio. */
p_vcd_access = p_access;
cdio_log_set_handler ( cdio_log_handler );
vcd_log_set_handler ( vcd_log_handler );
psz_source = VCDParse( p_access, &itemid, &play_single_item );
if ( NULL == psz_source )
{
free( p_vcdplayer );
return( VLC_EGENERIC );
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "source: %s: mrl: %s",
psz_source, p_access->psz_location );
p_vcdplayer->psz_source = strdup(psz_source);
p_vcdplayer->i_blocks_per_read = var_InheritInteger( p_this, MODULE_STRING
"-blocks-per-read" );
p_vcdplayer->b_track_length = var_InheritInteger( p_this, MODULE_STRING
"-track-length" );
p_vcdplayer->in_still = false;
p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_NOTFOUND;
p_vcdplayer->p_input = p_access->p_input;
// p_vcdplayer->p_meta = vlc_meta_New();
p_vcdplayer->p_segments = NULL;
p_vcdplayer->p_entries = NULL;
p_vcdplayer->i_cur_title = 0;
p_vcdplayer->i_cur_chapter = 0;
/* set up input */
if( !(p_vcdplayer->vcd = vcd_Open( p_this, psz_source )) )
{
goto err_exit;
}
p_vcdplayer->b_svd = vcdinfo_get_tracksSVD(p_vcdplayer->vcd);
/* Get track information. */
p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdplayer->vcd);
if( p_vcdplayer->i_tracks<1 || CDIO_INVALID_TRACK==p_vcdplayer->i_tracks )
{
vcdinfo_close( p_vcdplayer->vcd );
LOG_ERR ("no movie tracks found" );
goto err_exit;
}
/* Build Navigation Title table for the tracks. */
VCDTitles( p_access );
/* Add into the above entry points as "Chapters". */
if( ! VCDEntryPoints( p_access ) )
{
msg_Warn( p_access, "could not read entry points, will not use them" );
p_vcdplayer->b_valid_ep = false;
}
/* Initialize LID info and add that as a menu item */
if( ! VCDLIDs( p_access ) )
{
msg_Warn( p_access, "could not read entry LIDs" );
}
/* Do we set PBC (via LID) on? */
p_vcdplayer->i_lid =
( VCDINFO_ITEM_TYPE_LID == itemid.type
&& p_vcdplayer->i_lids > itemid.num )
? itemid.num
: VCDINFO_INVALID_ENTRY;
/* Initialize segment information and add that a "Track". */
VCDSegments( p_access );
vcdplayer_play( p_access, itemid );
#ifdef FIXED
if( play_single_item )
VCDFixupPlayList(p_access,p_vcd,psz_source,&itemid,play_single_item);
#endif
p_vcdplayer->p_access = p_access;
free( psz_source );
return VLC_SUCCESS;
err_exit:
free( psz_source );
free( p_vcdplayer->psz_source );
free( p_vcdplayer );
return VLC_EGENERIC;
}
void
handler_expose(XEvent *ev)
{
(void)ev;
dbg_print(__func__);
}
// Read ts packets until a complete video PES element can be returned.
// The data is read into capbuf and the function returns the number of
// bytes read.
long ts_readstream(void)
{
static int prev_ccounter = 0;
static int prev_packet = 0;
int gotpes = 0;
long pespcount=0; // count packets in PES with captions
long pcount=0; // count all packets until PES is complete
int saw_pesstart = 0;
capbuflen = 0;
do
{
pcount++;
if( !prev_packet )
{
// Exit the loop at EOF
if ( !ts_readpacket() )
break;
}
else
prev_packet = 0;
// Skip damaged packets, they could do more harm than good
if (payload.transport_error)
{
dbg_print(DMT_VERBOSE, "Packet (pid %u) skipped - transport error.\n",
payload.pid);
continue;
}
// Skip packets with no payload. This also fixes the problems
// with the continuity counter not being incremented in empty
// packets.
if ( !payload.length )
{
dbg_print(DMT_VERBOSE, "Packet (pid %u) skipped - no payload.\n",
payload.pid);
continue;
}
if (cappid == 0)
{
if (!payload.pesstart)
// Not the first entry. Ignore it, it should not be here.
continue;
}
// Check for PAT
if( payload.pid == 0 && telext_mode!=TXT_IN_USE) // If teletext is in use, then we don't need to process PAT
{
if (!payload.pesstart)
// Not the first entry. Ignore it, it should not be here.
continue;
unsigned pointer_field = *(payload.start);
unsigned char *payload_start = payload.start + pointer_field + 1;
unsigned payload_length = tspacket+188-payload_start;
unsigned table_id = payload_start[0];
unsigned section_length = (((payload_start[1] & 0x0F) << 8)
| payload_start[2]);
unsigned transport_stream_id = ((payload_start[3] << 8)
| payload_start[4]);
unsigned version_number = (payload_start[5] & 0x3E) >> 1;
unsigned current_next_indicator = payload_start[5] & 0x01;
unsigned section_number = payload_start[6];
unsigned last_section_number = payload_start[7];
if ( last_section_number > 0 )
{
fatal(EXIT_BUG_BUG,
"Sorry, long PATs not yet supported!\n");
}
if (!current_next_indicator)
// This table is not active, no need to evaluate
continue;
payload_start += 8;
payload_length = tspacket+188-payload_start;
unsigned programm_data = section_length - 5 - 4; // prev. bytes and CRC
dbg_print(DMT_PARSE, "Read PAT packet (id: %u) ts-id: 0x%04x\n",
table_id, transport_stream_id);
dbg_print(DMT_PARSE, " section length: %u number: %u last: %u\n",
section_length, section_number, last_section_number);
dbg_print(DMT_PARSE, " version_number: %u current_next_indicator: %u\n",
version_number, current_next_indicator);
if ( programm_data+4 > payload_length )
{
fatal(EXIT_BUG_BUG,
"Sorry, PAT too long!\n");
}
unsigned ts_prog_num = 0;
unsigned ts_prog_map_pid = 0;
dbg_print(DMT_VERBOSE, "\nProgram association section (PAT)\n");
for( unsigned i=0; i < programm_data; i+=4)
{
unsigned program_number = ((payload_start[i] << 8)
| payload_start[i+1]);
unsigned prog_map_pid = ((payload_start[i+2] << 8)
| payload_start[i+3]) & 0x1FFF;
dbg_print(DMT_VERBOSE, " Program number: %u -> PMTPID: %u\n",
program_number, prog_map_pid);
if( program_number != 0 )
{
if ( ts_prog_num && ts_prog_num!=program_number && !ts_forced_program_selected)
{
// We can only work with "simple" ts files
mprint ("\nThis TS file has more than one program. These are the program numbers found: \n");
for( unsigned j=0; j < programm_data; j+=4)
{
unsigned pn = ((payload_start[j] << 8)
| payload_start[j+1]);
if (pn)
mprint ("%u\n",pn);
activity_program_number (pn);
}
fatal(EXIT_BUG_BUG, "Run ccextractor again with --program-number specifying which program to process.");
}
else
{
if (!ts_forced_program_selected || program_number == ts_forced_program)
{
// Otherwise ignore
ts_prog_num = program_number;
ts_prog_map_pid = prog_map_pid;
}
}
}
}
// If we found a new PAT reset all TS stream variables
if( ts_prog_num != TS_program_number )
{
TS_program_number = ts_prog_num;
pmtpid = ts_prog_map_pid;
cappid = 0; // Reset caption stream pid
// If we have data flush it
if( capbuflen > 0 )
{
gotpes = 1;
break;
}
}
continue;
}
// PID != 0 but no PMT defined yet, ignore the rest of the current
// package and continue searching.
if ( !pmtpid && telext_mode!=TXT_IN_USE)
{
dbg_print(DMT_PARSE, "Packet (pid %u) skipped - no PMT pid identified yet.\n",
payload.pid);
continue;
}
// Check for PMT (ISO13818-1 / table 2-28)
if( payload.pid == pmtpid && telext_mode!=TXT_IN_USE)
{
if (!payload.pesstart)
// Not the first entry. Ignore it, it should not be here.
continue;
unsigned pointer_field = *(payload.start);
unsigned char *payload_start = payload.start + pointer_field + 1;
unsigned payload_length = tspacket+188-payload_start;
unsigned table_id = payload_start[0];
unsigned section_length = (((payload_start[1] & 0x0F) << 8)
| payload_start[2]);
unsigned program_number = ((payload_start[3] << 8)
| payload_start[4]);
if (program_number != TS_program_number)
{
// Only use PMTs with matching program number
dbg_print(DMT_PARSE,"Reject this PMT packet (pid: %u) program number: %u\n",
pmtpid, program_number);
continue;
}
unsigned version_number = (payload_start[5] & 0x3E) >> 1;
unsigned current_next_indicator = payload_start[5] & 0x01;
if (!current_next_indicator)
// This table is not active, no need to evaluate
continue;
unsigned section_number = payload_start[6];
unsigned last_section_number = payload_start[7];
if ( last_section_number > 0 )
{
mprint("Long PMTs are not supported - reject!\n");
continue;
}
unsigned PCR_PID = (((payload_start[8] & 0x1F) << 8)
| payload_start[9]);
unsigned pi_length = (((payload_start[10] & 0x0F) << 8)
| payload_start[11]);
if( 12 + pi_length > payload_length )
{
// If we would support long PMTs, this would be wrong.
mprint("program_info_length cannot be longer than the payload_length - reject!\n");
continue;
}
payload_start += 12 + pi_length;
payload_length = tspacket+188-payload_start;
unsigned stream_data = section_length - 9 - pi_length - 4; // prev. bytes and CRC
dbg_print(DMT_PARSE, "Read PMT packet (id: %u) program number: %u\n",
table_id, program_number);
dbg_print(DMT_PARSE, " section length: %u number: %u last: %u\n",
section_length, section_number, last_section_number);
dbg_print(DMT_PARSE, " version_number: %u current_next_indicator: %u\n",
version_number, current_next_indicator);
dbg_print(DMT_PARSE, " PCR_PID: %u data length: %u payload_length: %u\n",
PCR_PID, stream_data, payload_length);
if ( stream_data+4 > payload_length )
{
fatal(EXIT_BUG_BUG,
"Sorry, PMT to long!\n");
}
unsigned newcappid = 0;
unsigned newcap_stream_type = 0;
dbg_print(DMT_VERBOSE, "\nProgram map section (PMT)\n");
for( unsigned i=0; i < stream_data; i+=5)
{
unsigned stream_type = payload_start[i];
unsigned elementary_PID = (((payload_start[i+1] & 0x1F) << 8)
| payload_start[i+2]);
unsigned ES_info_length = (((payload_start[i+3] & 0x0F) << 8)
| payload_start[i+4]);
if (telext_mode==TXT_AUTO_NOT_YET_FOUND && stream_type == PRIVATE_MPEG2) // MPEG-2 Packetized Elementary Stream packets containing private data
{
// descriptor_tag: 0x45 = VBI_data_descriptor, 0x46 = VBI_teletext_descriptor, 0x56 = teletext_descriptor
unsigned descriptor_tag = payload_start[i + 5];
if ((descriptor_tag == 0x45) || (descriptor_tag == 0x46) || (descriptor_tag == 0x56))
{
telxcc_init();
cappid = newcappid = elementary_PID;
cap_stream_type = newcap_stream_type = stream_type;
telext_mode =TXT_IN_USE;
mprint ("VBI/teletext stream ID %u (0x%x) for SID %u (0x%x)\n",
elementary_PID, elementary_PID, program_number, program_number);
}
}
// For the print command below
unsigned tmp_stream_type = stream_type;
switch (stream_type)
{
case VIDEO_MPEG2:
case VIDEO_H264:
// If telext has been detected/selected it has priority over video for subtitles
if (telext_mode != TXT_IN_USE)
{
newcappid = elementary_PID;
newcap_stream_type = stream_type;
}
break;
case PRIVATE_MPEG2:
case VIDEO_MPEG1:
case AUDIO_MPEG1:
case AUDIO_MPEG2:
case AUDIO_AAC:
case VIDEO_MPEG4:
case AUDIO_AC3:
case AUDIO_DTS:
case AUDIO_HDMV_DTS:
break;
default:
tmp_stream_type = UNKNOWNSTREAM;
break;
}
dbg_print(DMT_VERBOSE, " %s stream [0x%02x] - PID: %u\n",
desc[tmp_stream_type],
stream_type, elementary_PID);
i += ES_info_length;
}
if (!newcappid)
{
mprint("No supported stream with caption data found - reject!\n");
continue;
}
if (newcappid != cappid)
{
cappid = newcappid;
cap_stream_type = newcap_stream_type;
mprint ("Decode captions from %s stream [0x%02x] - PID: %u\n",
desc[cap_stream_type], cap_stream_type, cappid);
// If we have data flush it
if( capbuflen > 0 )
{
gotpes = 1;
break;
}
}
continue;
}
if (PIDs_seen[payload.pid] == 0)
{
mprint ("\nNew PID found: %u\n", payload.pid);
PIDs_seen[payload.pid] = 1;
}
if (payload.pid==1003 && !hauppauge_warning_shown && !hauppauge_mode)
{
// TODO: Change this very weak test for something more decent such as size.
mprint ("\n\nNote: This TS could be a recording from a Hauppage card. If no captions are detected, try --hauppauge\n\n");
hauppauge_warning_shown=1;
}
// No caption stream PID defined yet, continue searching.
if ( !cappid )
{
dbg_print(DMT_PARSE, "Packet (pid %u) skipped - no stream with captions identified yet.\n",
payload.pid);
continue;
}
if (hauppauge_mode && payload.pid==HAUPPAGE_CCPID)
{
// Haup packets processed separately, because we can't mix payloads. So they go in their own buffer
// copy payload to capbuf
int haup_newcapbuflen = haup_capbuflen + payload.length;
if ( haup_newcapbuflen > haup_capbufsize) {
haup_capbuf = (unsigned char*)realloc(haup_capbuf, haup_newcapbuflen);
if (!haup_capbuf)
fatal(EXIT_NOT_ENOUGH_MEMORY, "Out of memory");
haup_capbufsize = haup_newcapbuflen;
}
memcpy(haup_capbuf+haup_capbuflen, payload.start, payload.length);
haup_capbuflen = haup_newcapbuflen;
}
// Check for PID with captions. Note that in Hauppauge mode we also process the video stream because
// we need the timing from its PES header, which isn't included in Hauppauge's packets
// CFS: Warning. Most likely mixing payloads.
if( payload.pid == cappid)
{ // Now we got a payload
// Video PES start
if (payload.pesstart)
{
// Pretend the previous was smaller
prev_ccounter=payload.counter-1;
saw_pesstart = 1;
}
// Discard packets when no pesstart was found.
if ( !saw_pesstart )
{
dbg_print(DMT_PARSE, "Packet (pid %u) skipped - Did not see pesstart.\n",
payload.pid);
continue;
}
// If the buffer is empty we just started this function
if (payload.pesstart && capbuflen > 0)
{
dbg_print(DMT_PARSE, "\nPES finished (%ld bytes/%ld PES packets/%ld total packets)\n",
capbuflen, pespcount, pcount);
// Keep the data in capbuf to be worked on
prev_packet = 1;
gotpes = 1;
break;
}
if ( (prev_ccounter==15 ? 0 : prev_ccounter+1) != payload.counter )
{
mprint("TS continuity counter not incremented prev/curr %u/%u\n",
prev_ccounter, payload.counter);
}
prev_ccounter = payload.counter;
pespcount++;
// copy payload to capbuf
int newcapbuflen = capbuflen + payload.length;
if ( newcapbuflen > capbufsize) {
capbuf = (unsigned char*)realloc(capbuf, newcapbuflen);
if (!capbuf)
fatal(EXIT_NOT_ENOUGH_MEMORY, "Out of memory");
capbufsize = newcapbuflen;
}
memcpy(capbuf+capbuflen, payload.start, payload.length);
capbuflen = newcapbuflen;
}
//else
// if(debug_verbose)
// printf("Packet (pid %u) skipped - unused.\n",
// payload.pid);
// Nothing suitable found, start over
}
while( !gotpes ); // gotpes==1 never arrives here because of the breaks
return capbuflen;
}
void
handler_mappingnotify(XEvent *ev)
{
(void)ev;
dbg_print(__func__);
}
// Return 1 for sucessfully read ts packet
int ts_readpacket(void)
{
buffered_read(tspacket,188);
past+=result;
if (result!=188)
{
if (result>0)
mprint("Premature end of file!\n");
end_of_file=1;
return 0;
}
int printtsprob = 1;
while (tspacket[0]!=0x47)
{
if (printtsprob)
{
mprint ("\nProblem: No TS header mark. Received bytes:\n");
dump (DMT_GENERIC_NOTICES, tspacket,4, 0, 0);
mprint ("Skip forward to the next TS header mark.\n");
printtsprob = 0;
}
unsigned char *tstemp;
// The amount of bytes read into tspacket
int tslen = 188;
// Check for 0x47 in the remaining bytes of tspacket
tstemp = (unsigned char *) memchr (tspacket+1, 0x47, tslen-1);
if (tstemp != NULL )
{
// Found it
int atpos = tstemp-tspacket;
memmove (tspacket,tstemp,(size_t)(tslen-atpos));
buffered_read(tspacket+(tslen-atpos),atpos);
past+=result;
if (result!=atpos)
{
mprint("Premature end of file!\n");
end_of_file=1;
return 0;
}
}
else
{
// Read the next 188 bytes.
buffered_read(tspacket,tslen);
past+=result;
if (result!=tslen)
{
mprint("Premature end of file!\n");
end_of_file=1;
return 0;
}
}
}
unsigned char *payload_start = tspacket + 4;
unsigned payload_length = 188 - 4;
unsigned transport_error_indicator = (tspacket[1]&0x80)>>7;
unsigned payload_start_indicator = (tspacket[1]&0x40)>>6;
// unsigned transport_priority = (tspacket[1]&0x20)>>5;
unsigned pid = (((tspacket[1] & 0x1F) << 8) | tspacket[2]) & 0x1FFF;
// unsigned transport_scrambling_control = (tspacket[3]&0xC0)>>6;
unsigned adaptation_field_control = (tspacket[3]&0x30)>>4;
unsigned ccounter = tspacket[3] & 0xF;
if (transport_error_indicator)
{
mprint ("Warning: Defective (error indicator on) TS packet:\n");
dump (DMT_GENERIC_NOTICES, tspacket, 188, 0, 0);
}
unsigned adaptation_field_length = 0;
if ( adaptation_field_control & 2 )
{
// TODO: If present, we should take the PCR (Program Clock Reference) from here, in case PTS is not
// available, as done in telxcc.
adaptation_field_length = tspacket[4];
payload_start = payload_start + adaptation_field_length + 1;
payload_length = tspacket+188-payload_start;
}
dbg_print(DMT_PARSE, "TS pid: %d PES start: %d counter: %u payload length: %u adapt length: %d\n",
pid, payload_start_indicator, ccounter, payload_length,
int(adaptation_field_length));
// Catch bad packages with adaptation_field_length > 184 and
// the unsigned nature of payload_length leading to huge numbers.
if (payload_length > 184)
{
// This renders the package invalid
payload_length = 0;
dbg_print(DMT_PARSE, " Reject package - set length to zero.\n");
}
// Save data in global struct
payload.start = payload_start;
payload.length = payload_length;
payload.pesstart = payload_start_indicator;
payload.pid = pid;
payload.counter = ccounter;
payload.transport_error = transport_error_indicator;
if (payload_length == 0)
{
dbg_print(DMT_PARSE, " No payload in package.\n");
}
// Store packet information
return 1;
}
static void analyze_gop(mate_gop* gop) {
mate_cfg_gog* cfg = NULL;
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
mate_gog* gog = NULL;
gchar* key = NULL;
if ( ! gop->gog ) {
/* no gog, let's either find one or create it if due */
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gog");
gog_keys = (LoAL *)g_hash_table_lookup(mc->gogs_by_gopname,gop->cfg->name);
if ( ! gog_keys ) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gog_keys for this gop");
return;
}
/* We have gog_keys! look for matching gogkeys */
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got gog_keys: %s",gog_keys->name) ;
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
if (( gogkey_match = new_avpl_exact_match(gop->cfg->name,gop->avpl,curr_gogkey,TRUE) )) {
key = avpl_to_str(gogkey_match);
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got gogkey_match: %s",key);
if (( gog = (mate_gog *)g_hash_table_lookup(gop->cfg->gog_index,key) )) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: got already a matching gog");
if (gog->num_of_counting_gops == gog->num_of_released_gops && gog->expiration < rd->now) {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: this is a new gog, not the old one, let's create it");
gog_remove_keys(gog);
new_gog(gog->cfg,gop);
break;
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: this is our gog");
if (! gop->gog ) adopt_gop(gog,gop);
break;
}
} else {
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no such gog in hash, let's create a new %s",curr_gogkey->name);
cfg = (mate_cfg_gog *)g_hash_table_lookup(mc->gogcfgs,curr_gogkey->name);
if (cfg) {
gog = new_gog(cfg,gop);
gog->num_of_gops = 1;
if (gop->cfg->start) {
gog->num_of_counting_gops = 1;
}
} else {
dbg_print (dbg_gog,0,dbg_facility,"analyze_gop: no such gog_cfg: %s",curr_gogkey->name);
}
break;
}
/** Can't get here because of "breaks" above */
g_assert_not_reached();
}
dbg_print (dbg_gog,1,dbg_facility,"analyze_gop: no gogkey_match: %s",key);
} /* while */
g_free(key);
key = NULL;
if (gogkey_match) delete_avpl(gogkey_match,TRUE);
reanalyze_gop(gop);
}
}
// TS specific data grabber
LLONG ts_getmoredata(void)
{
long payload_read = 0;
const char *tstr; // Temporary string to describe the stream type
do
{
if( !ts_readstream() )
{ // If we didn't get data, try again
mprint("empty\n");
continue;
}
// Separate MPEG-2 and H.264 video streams
if( cap_stream_type == VIDEO_MPEG2)
{
bufferdatatype = PES;
tstr = "MPG";
}
else if( cap_stream_type == VIDEO_H264 )
{
bufferdatatype = H264;
tstr = "H.264";
}
else if ( cap_stream_type == UNKNOWNSTREAM && hauppauge_mode)
{
bufferdatatype = HAUPPAGE;
tstr = "Hauppage";
}
else if ( cap_stream_type == PRIVATE_MPEG2 && telext_mode==TXT_IN_USE)
{
bufferdatatype = TELETEXT;
tstr = "Teletext";
}
else
fatal(EXIT_BUG_BUG,
"Not reachable!");
// We read a video PES
if (capbuf[0]!=0x00 || capbuf[1]!=0x00 ||
capbuf[2]!=0x01)
{
// ??? Shouldn't happen. Complain and try again.
mprint("Missing PES header!\n");
dump(DMT_GENERIC_NOTICES, capbuf,256, 0, 0);
continue;
}
unsigned stream_id = capbuf[3];
if (telext_mode == TXT_IN_USE)
{
if (cappid==0)
{ // If here, the user forced teletext mode but didn't supply a PID, and we haven't found it yet.
continue;
}
memcpy(buffer+inbuf, capbuf, capbuflen);
payload_read = capbuflen;
inbuf += capbuflen;
break;
}
if (hauppauge_mode)
{
if (haup_capbuflen%12 != 0)
mprint ("Warning: Inconsistent Hauppage's buffer length\n");
if (!haup_capbuflen)
{
// Do this so that we always return something until EOF. This will be skipped.
buffer[inbuf++]=0xFA;
buffer[inbuf++]=0x80;
buffer[inbuf++]=0x80;
payload_read+=3;
}
for (int i=0; i<haup_capbuflen; i+=12)
{
unsigned haup_stream_id = haup_capbuf[i+3];
if (haup_stream_id==0xbd && haup_capbuf[i+4]==0 && haup_capbuf[i+5]==6 )
{
// Because I (CFS) don't have a lot of samples for this, for now I make sure everything is like the one I have:
// 12 bytes total length, stream id = 0xbd (Private non-video and non-audio), etc
if (2 > BUFSIZE - inbuf)
{
fatal(EXIT_BUG_BUG,
"Remaining buffer (%lld) not enough to hold the 3 Hauppage bytes.\n"
"Please send bug report!",
BUFSIZE - inbuf);
}
if (haup_capbuf[i+9]==1 || haup_capbuf[i+9]==2) // Field match. // TODO: If extract==12 this won't work!
{
if (haup_capbuf[i+9]==1)
buffer[inbuf++]=4; // Field 1 + cc_valid=1
else
buffer[inbuf++]=5; // Field 2 + cc_valid=1
buffer[inbuf++]=haup_capbuf[i+10];
buffer[inbuf++]=haup_capbuf[i+11];
payload_read+=3;
}
/*
if (inbuf>1024) // Just a way to send the bytes to the decoder from time to time, otherwise the buffer will fill up.
break;
else
continue; */
}
}
haup_capbuflen=0;
}
if( !((stream_id&0xf0)==0xe0)) // 0xBD = private stream
{
// ??? Shouldn't happen. Complain and try again.
mprint("Not a video PES header!\n");
continue;
}
dbg_print(DMT_VERBOSE, "TS payload start video PES id: %d len: %ld\n",
stream_id, capbuflen);
int pesheaderlen;
int vpesdatalen = read_video_pes_header(capbuf, &pesheaderlen, capbuflen);
if (vpesdatalen < 0)
{ // Seems to be a broken PES
end_of_file=1;
break;
}
unsigned char *databuf = capbuf + pesheaderlen;
long databuflen = capbuflen - pesheaderlen;
// If the package length is unknown vpesdatalen is zero.
// If we know he package length, use it to quit
dbg_print(DMT_VERBOSE, "Read PES-%s (databuffer %ld/PES data %d) ",
tstr, databuflen, vpesdatalen);
// We got the whole PES in buffer
if( vpesdatalen && (databuflen >= vpesdatalen) )
dbg_print(DMT_VERBOSE, " - complete");
dbg_print(DMT_VERBOSE, "\n");
if (databuflen > BUFSIZE - inbuf)
{
fatal(EXIT_BUG_BUG,
"PES data packet (%ld) larger than remaining buffer (%lld).\n"
"Please send bug report!",
databuflen, BUFSIZE - inbuf);
}
if (!hauppauge_mode) // in Haup mode the buffer is filled somewhere else
{
memcpy(buffer+inbuf, databuf, databuflen);
payload_read = databuflen;
inbuf += databuflen;
}
break;
}
while ( !end_of_file );
return payload_read;
}
static mate_pdu* new_pdu(mate_cfg_pdu* cfg, guint32 framenum, field_info* proto, proto_tree* tree) {
mate_pdu* pdu = (mate_pdu*)g_slice_new(mate_max_size);
field_info* cfi;
GPtrArray* ptrs;
mate_range* range;
mate_range* proto_range;
tmp_pdu_data data;
guint i,j;
gint min_dist;
field_info* range_fi;
gint32 last_start;
gint32 first_end;
gint32 curr_end;
int hfid;
dbg_print (dbg_pdu,1,dbg_facility,"new_pdu: type=%s framenum=%i",cfg->name,framenum);
pdu->id = ++(cfg->last_id);
pdu->cfg = cfg;
pdu->avpl = new_avpl(cfg->name);
pdu->frame = framenum;
pdu->next_in_frame = NULL;
pdu->rel_time = rd->now;
pdu->gop = NULL;
pdu->next = NULL;
pdu->time_in_gop = -1.0f;
pdu->first = FALSE;
pdu->is_start = FALSE;
pdu->is_stop = FALSE;
pdu->after_release = FALSE;
data.ranges = g_ptr_array_new();
data.pdu = pdu;
data.tree = tree;
/* first we create the proto range */
proto_range = (mate_range *)g_malloc(sizeof(mate_range));
proto_range->start = proto->start;
proto_range->end = proto->start + proto->length;
g_ptr_array_add(data.ranges,proto_range);
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: proto range %u-%u",proto_range->start,proto_range->end);
last_start = proto_range->start;
/* we move forward in the tranport */
for (i = cfg->transport_ranges->len; i--; ) {
hfid = *((int*)g_ptr_array_index(cfg->transport_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
if (cfi->start < last_start && min_dist >= (last_start - cfi->start) ) {
range_fi = cfi;
min_dist = last_start - cfi->start;
}
}
if ( range_fi ) {
range = (mate_range *)g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
last_start = range_fi->start;
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: transport(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,6,dbg_facility,"new_pdu: transport(%i) missed",hfid);
}
}
}
if (cfg->payload_ranges) {
first_end = proto_range->end;
for (i = 0 ; i < cfg->payload_ranges->len; i++) {
hfid = *((int*)g_ptr_array_index(cfg->payload_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
curr_end = cfi->start + cfi->length;
if (curr_end > first_end && min_dist >= (curr_end - first_end) ) {
range_fi = cfi;
min_dist = curr_end - first_end;
}
}
if ( range_fi ) {
range = (mate_range *)g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
last_start = range_fi->start;
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: payload(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,5,dbg_facility,"new_pdu: payload(%i) missed",hfid);
}
}
}
}
g_hash_table_foreach(cfg->hfids_attr,get_pdu_fields,&data);
apply_transforms(pdu->cfg->transforms,pdu->avpl);
g_ptr_array_free(data.ranges,TRUE);
return pdu;
}
DWORD WINAPI Get_ServerStatusThread2(LPVOID lpParam)
{
GAME_INFO *pGI = (GAME_INFO *)lpParam;
SERVER_INFO *pSI=NULL;
DWORD idx=0;
DWORD size = pGI->vRefScanSI.size();
char szScanStatus[256]; //cache local language status text
strcpy(szScanStatus,g_lang.GetString("ScanStatus"));
while(pGI->dwScanIdx<size)
{
if(SCANNER_bCloseApp)
{
dbg_print("Stop scanning SIGNALED!");
break;
}
pSI=NULL;
EnterCriticalSection(&SCANNER_cs);
if(pGI->dwScanIdx<size)
{
SetStatusText(pGI->iIconIndex,szScanStatus,pGI->dwScanIdx,size);
pSI = pGI->vRefScanSI.at(pGI->dwScanIdx).pServerInfo; //pGI->vSI.at(pGI->vRefScanSI.at(pGI->dwScanIdx).dwIndex);
pGI->dwScanIdx++;
}
LeaveCriticalSection(&SCANNER_cs);
//Is there any more server to scan?
if(pSI==NULL) //if(pSI->usPort==0) //if the port is zero then no equal empty SERVER_INFO structure, (Ugly hack but it works :))
{
//OutputDebugString(">>>>ERROR? Breaked scanning thread\n");
break;
}
//Do non-filtered scan of all servers
Get_ServerStatus(pSI,NULL,NULL);
UpdateServerItem(size-pGI->dwScanIdx);
if(g_hwndProgressBar!=NULL)
SendMessage(g_hwndProgressBar, PBM_STEPIT, (WPARAM) 0, 0);
Sleep(AppCFG.dwSleep);
}
SetStatusText(pGI->iIconIndex, g_lang.GetString("ScanWaitingForThreads") );
//This ensures that all threads has been created properly and thread count critical sections works correctly
//dbg_print("Waiting for all threads to finish the loop!\n");
DWORD dwWaitResult = WaitForSingleObject(SCAN_hContinueEvent,INFINITE); // infinite wait
switch (dwWaitResult)
{
// Both event objects were signaled.
case WAIT_OBJECT_0:
// dbg_print("WAIT_OBJECT_0:\n");
break;
case WAIT_ABANDONED:
dbg_print("WAIT_ABANDONED: \n");
break;
case WAIT_TIMEOUT:
dbg_print("WAIT_TIMEOUT:\n");
break;
case WAIT_FAILED:
dbg_print("WAIT_FAILED:\n");
break;
// An error occurred.
default:
dbg_print("WaitForSingleObject error: \n");
}
DWORD id=0;
//Decrease thread counter....
EnterCriticalSection( &SCANNER_CSthreadcounter );
id = SCANNER_dwThreadCounter;
SCANNER_dwThreadCounter--;
LeaveCriticalSection( &SCANNER_CSthreadcounter );
// ExitThread(id);
return id;
}
kal_bool open_api_h264_add_dpb_info(kal_uint32 frame_addr, kal_uint32 frame_length)
{
kal_uint32 index;
kal_bool b_found = KAL_FALSE;
H264_dpb_frame_entry *p_frame_entry = g_open_api_h264_dpb_frame_info.frame_list;
dbg_print("[DRV H264]open_api_h264_add_dpb_info(), frame_no:%d\n\r", g_open_api_h264_dec_info_ptr->hdr_add_frames_no);
video_dbg_trace(H264_DEC_ADD_FRAME, g_open_api_h264_dec_info_ptr->hdr_add_frames_no);
//Pre Check If the frame_no is exists
for(index = 0; index < (g_open_api_h264_dpb_frame_info.max_queue_num*2); index++)
{
if((p_frame_entry->b_used == KAL_TRUE) &&
(p_frame_entry->frame_no==g_open_api_h264_dec_info_ptr->hdr_add_frames_no))
{
//if previous decode fail is due to dpb full
video_dbg_trace(H264_DEC_ADD_EXIST_FRAME,g_open_api_h264_dec_info_ptr->hdr_add_frames_no);
dbg_print("[DRV H264]open_api_h264_add_dpb_info(), frame_no:%d\n\r", g_open_api_h264_dec_info_ptr->hdr_add_frames_no);
b_found = KAL_TRUE;
if(p_frame_entry->p_dpb != 0)
{
video_dbg_trace(H264_DEC_ASSERT,__LINE__);
VIDEO_ASSERT(0);
}
p_frame_entry->addr = frame_addr;
p_frame_entry->length = frame_length;
if(g_open_api_h264_dpb_frame_info.p_next_parse == NULL)
g_open_api_h264_dpb_frame_info.p_next_parse = p_frame_entry;
return KAL_TRUE;
}
p_frame_entry++;
}
p_frame_entry = g_open_api_h264_dpb_frame_info.frame_list;
// find empty slot from list
for(index = 0; index < (g_open_api_h264_dpb_frame_info.max_queue_num*2); index++)
{
if(p_frame_entry->b_used == KAL_FALSE)
{
b_found = KAL_TRUE;
break;
}
p_frame_entry++;
}
//if(b_found == KAL_FALSE)
//EXT_ASSERT(0, g_open_api_h264_dpb_frame_info.max_queue_num, 0, 0);
if(b_found == KAL_FALSE)
{
video_dbg_trace(H264_DEC_DPB_FRAME_ENTRY_FULL,video_get_current_time());
dbg_print("[DRV H264]open_api_h264_add_dpb_info()\n\r");
return KAL_FALSE;
}
// store the information into the found slot
p_frame_entry->addr = frame_addr;
p_frame_entry->length = frame_length;
p_frame_entry->frame_no=g_open_api_h264_dec_info_ptr->hdr_add_frames_no;
//p_frame_entry->b_dec_done = KAL_FALSE;
p_frame_entry->b_used = KAL_TRUE;
p_frame_entry->p_next_dpb = NULL;
p_frame_entry->p_prev_dpb = NULL;
p_frame_entry->p_dpb = NULL;
//reconstruct the list
if(g_open_api_h264_dpb_frame_info.p_start == NULL)
{
g_open_api_h264_dpb_frame_info.p_start = p_frame_entry;
g_open_api_h264_dpb_frame_info.p_end = p_frame_entry;
g_open_api_h264_dpb_frame_info.p_next_parse = p_frame_entry;
}
else
{
g_open_api_h264_dpb_frame_info.p_end->p_next_dpb = p_frame_entry;
p_frame_entry->p_prev_dpb = g_open_api_h264_dpb_frame_info.p_end;
g_open_api_h264_dpb_frame_info.p_end = p_frame_entry;
if(g_open_api_h264_dpb_frame_info.p_next_parse == NULL)
g_open_api_h264_dpb_frame_info.p_next_parse = p_frame_entry;
}
return KAL_TRUE;
}
//Create scanning threads
void Initialize_Rescan2(GAME_INFO *pGI, bool (*filterServerItem)(SERVER_INFO *lp,GAME_INFO *pGI, vFILTER_SETS *vFilterSets))
{
g_log.AddLogInfo(GS_LOG_DEBUG,"Entering Initialize_Rescan2 function.");
//SCAN_FilterServerItem = filterServerItem;
vFILTER_SETS vFS;
vFS = pGI->vFilterSets;
vFS.insert(vFS.end(),gm.GetFilterSet(GLOBAL_FILTER).begin(),gm.GetFilterSet(GLOBAL_FILTER).end());
sort(vFS.begin(),vFS.end(),Sort_Filter_By_GroupName);
vSRV_INF::iterator iLst;
pGI->vRefScanSI.clear();
pGI->dwViewFlags |= SCAN_SERVERLIST;
for ( iLst = pGI->vSI.begin( ); iLst != pGI->vSI.end( ); iLst++ )
{
SERVER_INFO *pSI = *iLst;
REF_SERVER_INFO refSI;
refSI.pServerInfo = pSI;
if(filterServerItem!=NULL)
{
if(filterServerItem(pSI,pGI,&vFS))
{
pGI->vRefScanSI.push_back(refSI);
}
}
else
{
pGI->vRefScanSI.push_back(refSI);
}
}
if(pGI->dwViewFlags & SCAN_SERVERLIST)
pGI->dwViewFlags ^= SCAN_SERVERLIST;
g_log.AddLogInfo(GS_LOG_INFO,"Preparing to scan %d servers of a total %d.",pGI->vRefScanSI.size(),pGI->vSI.size());
if(pGI->dwViewFlags & FORCE_SCAN_FILTERED)
pGI->dwViewFlags = 0;
if(g_hwndProgressBar!=NULL)
{
//Initililze Progressbar
SendMessage(g_hwndProgressBar, PBM_SETSTEP, (WPARAM) 1, 0);
SendMessage(g_hwndProgressBar, PBM_SETRANGE, (WPARAM) 0,MAKELPARAM(0,pGI->vRefScanSI.size()));
SendMessage(g_hwndProgressBar, PBM_SETPOS, (WPARAM) 0, 0);
}
HANDLE hThreadIndex[MAX_THREADS];
DWORD dwThreadId[MAX_THREADS];
for(DWORD i=0; i<AppCFG.dwThreads; i++)
hThreadIndex[i]=NULL;
SCANNER_dwThreadCounter=0;
pGI->dwScanIdx = 0;
//Create and setup Continue Event, this is important! Otherwise ETSV can crash.
SCAN_hContinueEvent = CreateEvent(NULL,TRUE,TRUE,"ScanContinueEvent");
if (SCAN_hContinueEvent == NULL)
g_log.AddLogInfo(GS_LOG_DEBUG,"CreateEvent failed (%d)\n", GetLastError());
if (! ResetEvent(SCAN_hContinueEvent) )
g_log.AddLogInfo(GS_LOG_DEBUG,"ResetEvent failed (%d)\n", GetLastError());
DWORD dwMaxThreads = (AppCFG.dwThreads>pGI->vRefScanSI.size())?pGI->vRefScanSI.size():AppCFG.dwThreads;
//---------------------------------
//Multi thread scanning code
//---------------------------------
//Startup the threads!!!
for (DWORD i=0; i<dwMaxThreads; i++)
{
hThreadIndex[SCANNER_dwThreadCounter] = CreateThread( NULL, 0, &Get_ServerStatusThread2, (LPVOID) pGI ,0, &dwThreadId[SCANNER_dwThreadCounter]);
if (hThreadIndex[SCANNER_dwThreadCounter] == NULL)
{
dbg_print("Error creating thread!\n");
}
else
{
//g_log.AddLogInfo(GS_LOG_INFO,"Thread created! %d",i);
EnterCriticalSection( &SCANNER_CSthreadcounter );
SCANNER_dwThreadCounter++;
LeaveCriticalSection( &SCANNER_CSthreadcounter );
//SetThreadName(dwThreadId[SCANNER_dwThreadCounter], "Get_ServerStatusThread2");
}
}
//All threads created in graceful way and counter increased properly
if (! SetEvent(SCAN_hContinueEvent) )
dbg_print("SetEvent failed\n");
//After this this the thread counter can decrease properly with a noncorrupted handle
DWORD dwStartTick = GetTickCount();
DWORD iWaitIndex = 0;
DWORD i=0;
//Wait for all threads to finish...
//g_log.AddLogInfo(GS_LOG_DEBUG,"AppCFG.dwThreads %d",AppCFG.dwThreads);
while(iWaitIndex<dwMaxThreads)
{
DWORD max = ((dwMaxThreads-iWaitIndex)<MAXIMUM_WAIT_OBJECTS)?(dwMaxThreads-iWaitIndex):MAXIMUM_WAIT_OBJECTS;
// g_log.AddLogInfo(GS_LOG_DEBUG,"iWaitIndex: %d, iWaitIndex+max: %d, dwMaxThreads: %d, max:%d",iWaitIndex,iWaitIndex+max,dwMaxThreads,max);
DWORD dwEvent = WaitForMultipleObjects(max, &hThreadIndex[iWaitIndex], TRUE, INFINITE);
//g_log.AddLogInfo(GS_LOG_DEBUG,">iWaitIndex: %d, iWaitIndex+max: %d, dwMaxThreads: %d, nThreads: %d, max:%d",iWaitIndex,iWaitIndex+max,dwMaxThreads, nThreads,max);
switch (dwEvent)
{
case WAIT_OBJECT_0:
//dbg_print("First event was signaled.\n");
break;
case WAIT_TIMEOUT:
g_log.AddLogInfo(GS_LOG_DEBUG,"Wait timed out. @ %s",__FUNCTION__);
break;
// Return value is invalid.
default:
{
g_log.AddLogInfo(GS_LOG_DEBUG,"Error at waiting threads! %s",__FUNCTION__);
}
}
// Close all thread handles upon completion.
for(i=iWaitIndex; i<iWaitIndex+max; i++)
{
if(hThreadIndex[i]!=NULL)
{
CloseHandle(hThreadIndex[i]);
hThreadIndex[i]=NULL;
}
}
iWaitIndex+=MAXIMUM_WAIT_OBJECTS;
}
DWORD dwEndTick = GetTickCount();
g_log.AddLogInfo(0,"All servers is now scanned...%d sec",(dwEndTick-dwStartTick)/1000);
pGI->vRefScanSI.clear();
CloseHandle(SCAN_hContinueEvent);
}
void data_chain_testbench()
{
int i = 0;
dbg(char buff[100]);
struct data_chain chain;
struct data_chain_node* temp;
dbg_print("Creating data_chain\n");
data_chain_init(&chain, BLOCK_SIZE);
// Prepend test
dbg_print("Prepending in data_chain\n");
for(i = 0; i < OP_NB; i++)
{
dbg_print1(buff, "Inserting node %d...\t", i);
data_chain_insert(&chain, NULL, NULL);
dbg_print("Filling node...");
data_chain_node_fill(chain.next, BLOCK_SIZE, i);
dbg_print("Done.\n");
data_chain_state_print(&chain);
}
data_chain_print(&chain);
// Append test
dbg_print("Appending in data_chain\n");
for(i = 0; i < OP_NB; i++)
{
dbg_print1(buff, "Inserting node %d...\t", i);
data_chain_append(&chain, NULL);
dbg_print("Filling node...");
data_chain_node_fill(chain.prev, BLOCK_SIZE, i);
dbg_print("Done.\n");
data_chain_state_print(&chain);
}
data_chain_print(&chain);
// Insert test
dbg_print("Inserting in data_chain\n");
for(i = 0, temp = chain.next; i < OP_NB; i++, temp = temp->next->next)
{
dbg_print1(buff, "Inserting node %d...\t", i);
data_chain_insert(&chain, temp, NULL);
dbg_print("Filling node...");
data_chain_node_fill(temp->next, BLOCK_SIZE, i);
dbg_print("Done.\n");
}
data_chain_print(&chain);
// Deleting ref test
dbg_print("Deleting in data_chain\n");
for(i = 0, temp = chain.next; i < OP_NB; i++, temp = temp->next)
{
dbg_print1(buff, "Deleting node %d...", i);
data_chain_del(&chain, temp);
dbg_print("Done.\n");
}
data_chain_print(&chain);
// Append after ref test
dbg_print("Reinserting in data_chain\n");
for(i = 0, temp = chain.next; i < OP_NB; i++, temp = temp->next->next)
{
dbg_print1(buff, "Inserting node %d...\t", i);
data_chain_insert(&chain, temp, NULL);
dbg_print("Filling node...");
data_chain_node_fill(temp->next, BLOCK_SIZE, i);
dbg_print("Done.\n");
}
data_chain_print(&chain);
// Freeing chain
dbg_print("Destroying data_chain...");
data_chain_destroy(&chain);
dbg_print("Done.\n");
}
/**
* Once we're inside of idleproc_run(), we are executing in the context of the
* first process-- a real context, so we can finally begin running
* meaningful code.
*
* This is the body of process 0. It should initialize all that we didn't
* already initialize in kmain(), launch the init process (initproc_run),
* wait for the init process to exit, then halt the machine.
*
* @param arg1 the first argument (unused)
* @param arg2 the second argument (unused)
*/
static void *
idleproc_run(int arg1, void *arg2)
{
int status;
pid_t child;
/* create init proc */
kthread_t *initthr = initproc_create();
init_call_all();
GDB_CALL_HOOK(initialized);
/* Create other kernel threads (in order) */
/* PROCS BLANK {{{ */
#ifdef __SHADOWD__
/* TODO port this - alvin */
#endif
/* PROCS BLANK }}} */
#ifdef __VFS__
/* Once you have VFS remember to set the current working directory
* of the idle and init processes */
/* PROCS BLANK {{{ */
proc_t *idle = proc_lookup(PID_IDLE);
proc_t *init = proc_lookup(PID_INIT);
KASSERT(NULL != idle);
KASSERT(NULL != init);
idle->p_cwd = vfs_root_vn;
init->p_cwd = vfs_root_vn;
vref(vfs_root_vn);
vref(vfs_root_vn);
/* PROCS BLANK }}} */
/* Here you need to make the null, zero, and tty devices using mknod */
/* You can't do this until you have VFS, check the include/drivers/dev.h
* file for macros with the device ID's you will need to pass to mknod */
/* PROCS BLANK {{{ */
int fd, ii;
char path[32];
struct stat statbuf;
if (do_stat("/dev", &statbuf) < 0) {
KASSERT(!(status = do_mkdir("/dev")));
}
if ((fd = do_open("/dev/null", O_RDONLY)) < 0) {
KASSERT(!(status = do_mknod("/dev/null", S_IFCHR, MEM_NULL_DEVID)));
} else {
do_close(fd);
}
if ((fd = do_open("/dev/zero", O_RDONLY)) < 0) {
KASSERT(!(status = do_mknod("/dev/zero", S_IFCHR, MEM_ZERO_DEVID)));
} else {
do_close(fd);
}
memset(path, '\0', 32);
for (ii = 0; ii < __NTERMS__; ii++) {
sprintf(path, "/dev/tty%d", ii);
dbg(DBG_INIT, "Creating tty mknod with path %s\n", path);
if ((fd = do_open(path, O_RDONLY)) < 0) {
KASSERT(!do_mknod(path, S_IFCHR, MKDEVID(2, ii)));
} else {
do_close(fd);
}
}
for (ii = 0; ii < __NDISKS__; ii++) {
sprintf(path, "/dev/hda%d", ii);
dbg(DBG_INIT, "Creating disk mknod with path %s\n", path);
if ((fd = do_open(path, O_RDONLY)) < 0) {
KASSERT(!do_mknod(path, S_IFBLK, MKDEVID(1, ii)));
} else {
do_close(fd);
}
}
/* PROCS BLANK }}} */
#endif
/* Finally, enable interrupts (we want to make sure interrupts
* are enabled AFTER all drivers are initialized) */
intr_enable();
/* Run initproc */
sched_make_runnable(initthr);
/* Now wait for it */
child = do_waitpid(-1, 0, &status);
KASSERT(PID_INIT == child);
#ifdef __MTP__
kthread_reapd_shutdown();
#endif
#ifdef __SHADOWD__
/* wait for shadowd to shutdown */
shadowd_shutdown();
#endif
#ifdef __VFS__
/* Shutdown the vfs: */
dbg_print("weenix: vfs shutdown...\n");
vput(curproc->p_cwd);
if (vfs_shutdown())
panic("vfs shutdown FAILED!!\n");
#endif
/* Shutdown the pframe system */
#ifdef __S5FS__
pframe_shutdown();
#endif
dbg_print("\nweenix: halted cleanly!\n");
GDB_CALL_HOOK(shutdown);
hard_shutdown();
return NULL;
}
/*****************************************************************************
VCDRead: reads VCD_BLOCKS_ONCE from the VCD and returns that.
NULL is returned if something went wrong.
*****************************************************************************/
static block_t *
VCDReadBlock( access_t * p_access )
{
vcdplayer_t *p_vcdplayer= (vcdplayer_t *)p_access->p_sys;
const int i_blocks = p_vcdplayer->i_blocks_per_read;
block_t *p_block;
int i_read;
uint8_t *p_buf;
dbg_print( (INPUT_DBG_LSN), "lsn: %lu",
(long unsigned int) p_vcdplayer->i_lsn );
/* Allocate a block for the reading */
if( !( p_block = block_Alloc( i_blocks * M2F2_SECTOR_SIZE ) ) )
{
msg_Err( p_access, "cannot get a new block of size: %i",
i_blocks * M2F2_SECTOR_SIZE );
block_Release( p_block );
return NULL;
}
p_buf = (uint8_t *) p_block->p_buffer;
for ( i_read = 0 ; i_read < i_blocks ; i_read++ )
{
vcdplayer_read_status_t read_status = vcdplayer_read(p_access, p_buf);
switch ( read_status ) {
case READ_END:
/* End reached. Return NULL to indicated this. */
/* We also set the postion to the end so the higher level
(demux?) doesn't try to keep reading. If everything works out
right this shouldn't have to happen.
*/
block_Release( p_block );
return NULL;
case READ_ERROR:
/* Some sort of error. Should we increment lsn? to skip block? */
block_Release( p_block );
return NULL;
case READ_STILL_FRAME:
/* FIXME The below should be done in an event thread.
Until then...
*/
#if 1
msleep( INT64_C(1000) * *p_buf );
VCDSetOrigin(p_access, p_vcdplayer->origin_lsn,
p_vcdplayer->i_track, &(p_vcdplayer->play_item));
// p_vcd->in_still = false;
dbg_print(INPUT_DBG_STILL, "still wait time done");
#endif
block_Release( p_block );
return NULL;
default:
case READ_BLOCK:
/* Read buffer */
break;
}
p_buf += M2F2_SECTOR_SIZE;
/* Update seekpoint */
if ( VCDINFO_ITEM_TYPE_ENTRY == p_vcdplayer->play_item.type )
{
size_t i_entry = p_vcdplayer->play_item.num+1;
lsn_t i_lsn = vcdinfo_get_entry_lsn(p_vcdplayer->vcd, i_entry);
if ( p_vcdplayer->i_lsn >= i_lsn && i_lsn != VCDINFO_NULL_LSN )
{
dbg_print( (INPUT_DBG_LSN|INPUT_DBG_PBC),
"entry change to %zu, current LSN %u >= end %u",
i_entry, p_vcdplayer->i_lsn, i_lsn);
p_vcdplayer->play_item.num = i_entry;
VCDSetOrigin( p_access, i_lsn, p_vcdplayer->i_track,
&(p_vcdplayer->play_item) );
}
}
}
return p_block;
}
static kal_bool uart_core_task_init(void)
{
dbg_print("=========>uartcore_task_init\r\n");
return KAL_TRUE;
}
/*****************************************************************************
* VCDParse: parse command line
*****************************************************************************/
static char *
VCDParse( access_t * p_access, /*out*/ vcdinfo_itemid_t * p_itemid,
/*out*/ bool *play_single_item )
{
vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_access->p_sys;
char *psz_parser;
char *psz_source;
char *psz_next;
if( var_InheritBool( p_access, MODULE_STRING "-PBC" ) ) {
p_itemid->type = VCDINFO_ITEM_TYPE_LID;
p_itemid->num = 1;
*play_single_item = false;
}
else
{
p_itemid->type = VCDINFO_ITEM_TYPE_ENTRY;
p_itemid->num = 0;
}
#ifdef _WIN32
/* On Win32 we want the VCD access plugin to be explicitly requested,
* we end up with lots of problems otherwise */
if( !p_access->psz_access || !*p_access->psz_access ) return NULL;
#endif
if( !p_access->psz_location )
{
return NULL;
}
psz_parser = psz_source = strdup( p_access->psz_location );
/* Parse input string :
* [device][@[type][title]] */
while( *psz_parser && *psz_parser != '@' )
{
psz_parser++;
}
if( *psz_parser == '@' )
{
/* Found the divide between the source name and the
type+entry number. */
unsigned int num;
*psz_parser = '\0';
++psz_parser;
if( *psz_parser )
switch(*psz_parser) {
case 'E':
p_itemid->type = VCDINFO_ITEM_TYPE_ENTRY;
++psz_parser;
*play_single_item = true;
break;
case 'P':
p_itemid->type = VCDINFO_ITEM_TYPE_LID;
++psz_parser;
*play_single_item = false;
break;
case 'S':
p_itemid->type = VCDINFO_ITEM_TYPE_SEGMENT;
++psz_parser;
*play_single_item = true;
break;
case 'T':
p_itemid->type = VCDINFO_ITEM_TYPE_TRACK;
++psz_parser;
*play_single_item = true;
break;
default:
break;
}
num = strtol( psz_parser, &psz_next, 10 );
if ( *psz_parser != '\0' && *psz_next == '\0')
{
p_itemid->num = num;
}
} else {
*play_single_item = ( VCDINFO_ITEM_TYPE_LID == p_itemid->type );
}
if( !*psz_source )
{
/* No source specified, so figure it out. */
if( !p_access->psz_access ) return NULL;
psz_source = var_InheritString( p_access, "vcd" );
if( !psz_source )
{
/* Scan for a CD-ROM drive with a VCD in it. */
char **cd_drives = cdio_get_devices_with_cap(NULL,
(CDIO_FS_ANAL_SVCD|CDIO_FS_ANAL_CVD
|CDIO_FS_ANAL_VIDEOCD|CDIO_FS_UNKNOWN),
true);
if( NULL == cd_drives ) return NULL;
if( cd_drives[0] == NULL )
{
cdio_free_device_list( cd_drives );
return NULL;
}
psz_source = strdup( cd_drives[0] );
cdio_free_device_list( cd_drives );
}
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_MRL),
"source=%s entry=%d type=%d",
psz_source, p_itemid->num, p_itemid->type);
return psz_source;
}
/*
Sets start origin for subsequent seeks/reads
*/
void
VCDSetOrigin( access_t *p_access, lsn_t i_lsn, track_t i_track,
const vcdinfo_itemid_t *p_itemid )
{
vcdplayer_t *p_vcdplayer= (vcdplayer_t *)p_access->p_sys;
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_LSN),
"i_lsn: %lu, track: %d", (long unsigned int) i_lsn, i_track );
vcdplayer_set_origin(p_access, i_lsn, i_track, p_itemid);
switch (p_vcdplayer->play_item.type)
{
case VCDINFO_ITEM_TYPE_ENTRY:
VCDUpdateVar( p_access, p_itemid->num, VLC_VAR_SETVALUE,
"chapter", _("Entry"), "Setting entry/segment");
p_vcdplayer->i_cur_title = i_track - 1;
if (p_vcdplayer->b_track_length)
{
p_vcdplayer->size = p_vcdplayer->p_title[i_track-1]->i_size;
p_access->info.i_pos = (uint64_t) M2F2_SECTOR_SIZE *
(vcdinfo_get_track_lsn(p_vcdplayer->vcd, i_track)-i_lsn);
} else {
p_vcdplayer->size = M2F2_SECTOR_SIZE * (int64_t)
vcdinfo_get_entry_sect_count(p_vcdplayer->vcd,p_itemid->num);
p_access->info.i_pos = 0;
}
dbg_print( (INPUT_DBG_LSN|INPUT_DBG_PBC), "size: %"PRIu64", pos: %"PRIu64,
p_vcdplayer->size, p_access->info.i_pos );
p_vcdplayer->i_cur_chapter = p_itemid->num;
break;
case VCDINFO_ITEM_TYPE_SEGMENT:
VCDUpdateVar( p_access, p_itemid->num, VLC_VAR_SETVALUE,
"chapter", _("Segment"), "Setting entry/segment");
/* The last title entry is the for segments (when segments exist
and they must here. The segment seekpoints are stored after
the entry seekpoints and (zeroed) lid seekpoints.
*/
p_vcdplayer->i_cur_title = p_vcdplayer->i_titles - 1;
p_vcdplayer->size = 0; /* No seeking on stills, please. */
p_access->info.i_pos = 0;
p_vcdplayer->i_cur_chapter = p_vcdplayer->i_entries
+ p_vcdplayer->i_lids + p_itemid->num;
break;
case VCDINFO_ITEM_TYPE_TRACK:
p_vcdplayer->i_cur_title = i_track - 1;
p_vcdplayer->size = p_vcdplayer->p_title[i_track - 1]->i_size;
p_access->info.i_pos = 0;
p_vcdplayer->i_cur_chapter = vcdinfo_track_get_entry(p_vcdplayer->vcd,
i_track);
break;
default:
msg_Warn( p_access, "can't set origin for play type %d",
p_vcdplayer->play_item.type );
}
VCDUpdateTitle( p_access );
}
