\hypertarget{xfc_8c}{
\section{xfc.c File Reference}
\label{xfc_8c}\index{xfc.c@{xfc.c}}
}
Utility/driver program for filter test code. 

{\tt \#include \char`\"{}xfc.h\char`\"{}}\par
{\tt \#include \char`\"{}xfc\_\-sdi.h\char`\"{}}\par
{\tt \#include \char`\"{}xfc\_\-rto\_\-def.h\char`\"{}}\par
{\tt \#include \char`\"{}xfc\_\-print\_\-def.h\char`\"{}}\par
{\tt \#include \char`\"{}xfc\_\-ebf\_\-output.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC\_\-DB/EFC\_\-DB\_\-schema.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC/EFC\_\-display.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC/EFS.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC/EFA.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/io/EBF\_\-stream.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/io/LCBP.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/io/EBF\_\-evts.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/EDS\_\-fw.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/LCBV.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/TMR.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC/EFC.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/EBF\_\-siv.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/EBF\_\-dir.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/EDSD\_\-print.h\char`\"{}}\par
{\tt \#include \char`\"{}EDS/FFS.h\char`\"{}}\par
{\tt \#include \char`\"{}EFC/EFC\_\-time.h\char`\"{}}\par
{\tt \#include \char`\"{}LSE/LFR\_\-key.h\char`\"{}}\par
{\tt \#include \char`\"{}LSE/LSE\_\-time.h\char`\"{}}\par
{\tt \#include \char`\"{}LSE/CCSDS\_\-ostream.h\char`\"{}}\par
{\tt \#include \char`\"{}LSEP/LSEPW.h\char`\"{}}\par
{\tt \#include \char`\"{}LSF/LSF\_\-reason.h\char`\"{}}\par
{\tt \#include \char`\"{}LSF/LSF\_\-ids.h\char`\"{}}\par
{\tt \#include \char`\"{}ITC/ITC\_\-pubdefs.h\char`\"{}}\par
{\tt \#include \char`\"{}IMM/FPM\_\-pubdefs.h\char`\"{}}\par
{\tt \#include \char`\"{}IMM/RBM\_\-pubdefs.h\char`\"{}}\par
{\tt \#include \char`\"{}MSG/MSG\_\-pubdefs.h\char`\"{}}\par
{\tt \#include \char`\"{}CMX/CMX\_\-lookup\-Pub.h\char`\"{}}\par
{\tt \#include \char`\"{}CDM/CDM\_\-pubdefs.h\char`\"{}}\par
{\tt \#include \char`\"{}PBS/PBS.h\char`\"{}}\par
{\tt \#include \char`\"{}PBS/MBA.h\char`\"{}}\par
{\tt \#include \char`\"{}PBS/CACHE.h\char`\"{}}\par
{\tt \#include \char`\"{}PBS/TASK.h\char`\"{}}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$stdlib.h$>$}\par


Include dependency graph for xfc.c:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=228pt]{xfc_8c__incl}
\end{center}
\end{figure}
\subsection*{Data Structures}
\begin{CompactItemize}
\item 
struct \hyperlink{struct__XfcStatsCtx}{\_\-Xfc\-Stats\-Ctx}
\begin{CompactList}\small\item\em The statistics context. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcResultsCtx}{\_\-Xfc\-Results\-Ctx}
\begin{CompactList}\small\item\em The filter results context. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcPosterCtx}{\_\-Xfc\-Poster\-Ctx}
\begin{CompactList}\small\item\em The posting context. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcEfcCtx}{\_\-Xfc\-Efc\-Ctx}
\begin{CompactList}\small\item\em Kludge structure to hold some of the context that gets hidden in the EFC interface. This should be replaced by query calls into EFC, but that requires a new EFC release, just not worth it at this time. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcHandlerCtx}{\_\-Xfc\-Handler\-Ctx}
\begin{CompactList}\small\item\em Description of a handler. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcDisplayerCtx}{\_\-Xfc\-Displayer\-Ctx}
\begin{CompactList}\small\item\em The displayer context. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcCtx}{\_\-Xfc\-Ctx}
\begin{CompactList}\small\item\em Structure to bind all the filtering parameters together into something suitable for passing to the LCB event call back handler. \item\end{CompactList}\item 
struct \hyperlink{struct__XfcConstructCtx}{\_\-Xfc\-Construct\-Ctx}
\begin{CompactList}\small\item\em Special structure to fee context to the services constructor. \item\end{CompactList}\end{CompactItemize}
\subsection*{Defines}
\begin{CompactItemize}
\item 
\#define \hyperlink{xfc_8c_a0}{RND8}(\_\-n)~(((\_\-n) + 7) \& $\sim$0x7)
\begin{CompactList}\small\item\em Rounds {\em \_\-n\/} to a value of 8. \item\end{CompactList}\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item 
\hypertarget{xfc_8c_a1}{
typedef \hyperlink{struct__XfcStatsCtx}{\_\-Xfc\-Stats\-Ctx} \hyperlink{xfc_8c_a1}{Xfc\-Stats\-Ctx}}
\label{xfc_8c_a1}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__XfcStatsCtx}{\_\-Xfc\-Stats\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a2}{
typedef \hyperlink{struct__XfcResultsCtx}{\_\-Xfc\-Results\-Ctx} \hyperlink{xfc_8c_a2}{Xfc\-Results\-Ctx}}
\label{xfc_8c_a2}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__XfcResultsCtx}{\_\-Xfc\-Results\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a3}{
typedef \hyperlink{struct__XfcPosterCtx}{\_\-Xfc\-Poster\-Ctx} \hyperlink{xfc_8c_a3}{Xfc\-Poster\-Ctx}}
\label{xfc_8c_a3}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__XfcPosterCtx}{\_\-Xfc\-Poster\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a4}{
typedef \hyperlink{struct__XfcEfcCtx}{\_\-Xfc\-Efc\-Ctx} \hyperlink{xfc_8c_a4}{Xfc\-Efc\-Ctx}}
\label{xfc_8c_a4}

\begin{CompactList}\small\item\em Typedef for stuct \hyperlink{struct__XfcEfcCtx}{\_\-Xfc\-Efc\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a5}{
typedef \hyperlink{struct__XfcHandlerCtx}{\_\-Xfc\-Handler\-Ctx} \hyperlink{xfc_8c_a5}{Xfc\-Handler\-Ctx}}
\label{xfc_8c_a5}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__XfcHandlerCtx}{\_\-Xfc\-Handler\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a6}{
typedef \hyperlink{struct__XfcDisplayerCtx}{\_\-Xfc\-Displayer\-Ctx} \hyperlink{xfc_8c_a6}{Xfc\-Displayer\-Ctx}}
\label{xfc_8c_a6}

\begin{CompactList}\small\item\em Typedef for struct \_\-Xfc\-Display\-Ctx. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a7}{
typedef \hyperlink{struct__XfcCtx}{\_\-Xfc\-Ctx} \hyperlink{xfc_8c_a7}{Xfc\-Ctx}}
\label{xfc_8c_a7}

\begin{CompactList}\small\item\em Typedef for struct \hyperlink{struct__XfcCtx}{\_\-Xfc\-Ctx}. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a8}{
typedef \hyperlink{struct__XfcConstructCtx}{\_\-Xfc\-Construct\-Ctx} \hyperlink{xfc_8c_a8}{Xfc\-Construct\-Ctx}}
\label{xfc_8c_a8}

\begin{CompactList}\small\item\em Typedef for struct Xfc\-Construct\-Ctx. \item\end{CompactList}\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item 
static int \hyperlink{xfc_8c_a9}{setup\_\-lcbp} (LCBP lcb, EDS\_\-fw $\ast$eds\-Fw, int rate)
\begin{CompactList}\small\item\em Does the primary setup of the LCBP. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a10}{xfc\_\-run\_\-start} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Notifies the handlers and posters of the start run. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a11}{xfc\_\-run\_\-stop} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Stops the run. \item\end{CompactList}\item 
static int \hyperlink{xfc_8c_a12}{create\-Poster} (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$poster, const char $\ast$name, unsigned int options)
\begin{CompactList}\small\item\em Creates an output file if {\em name\/} is not NULL. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a13}{print\-Poster} (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$poster, EDS\_\-fw\-Ixb $\ast$ixb)
\begin{CompactList}\small\item\em Prints a 1 line summary of the events that are output. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a14}{print\-Elapsed} (const char $\ast$caption, TMR\_\-tick beg, TMR\_\-tick end, int n)
\begin{CompactList}\small\item\em Utility routine to print elapsed times. \item\end{CompactList}\item 
int \hyperlink{xfc_8c_a15}{xfc\_\-initialize} (void)
\begin{CompactList}\small\item\em One time initialization routine. \item\end{CompactList}\item 
static unsigned int \hyperlink{xfc_8c_a16}{xfc\_\-time\_\-initialize} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)
\begin{CompactList}\small\item\em Initializes the time base (fakes out WCT and THS). \item\end{CompactList}\item 
static unsigned int \hyperlink{xfc_8c_a17}{xfc\_\-eds\-Fw\_\-build} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)
\begin{CompactList}\small\item\em Allocates and constructs the EDS framework. \item\end{CompactList}\item 
static unsigned int \hyperlink{xfc_8c_a18}{xfc\_\-istream\_\-build} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)
\begin{CompactList}\small\item\em Initializes the input data stream. \item\end{CompactList}\item 
static unsigned int \hyperlink{xfc_8c_a19}{xfc\_\-display\_\-build} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)
\begin{CompactList}\small\item\em Initializes the event display information. \item\end{CompactList}\item 
\hypertarget{xfc_8c_a20}{
static unsigned int {\bf xfc\_\-output\_\-build} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)}
\label{xfc_8c_a20}

\item 
\hypertarget{xfc_8c_a21}{
static unsigned int {\bf xfc\_\-handlers\_\-build} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto)}
\label{xfc_8c_a21}

\item 
void $\ast$ \hyperlink{xfc_8c_a22}{xfc\_\-filter\-Ctx\_\-get} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Returns a pointer to the underlying user filter control structure. \item\end{CompactList}\item 
void $\ast$ \hyperlink{xfc_8c_a23}{xfc\_\-results\-Ctx\_\-get} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Returns a pointer to the results control structure. \item\end{CompactList}\item 
void $\ast$ \hyperlink{xfc_8c_a24}{xfc\_\-stats\-Ctx\_\-get} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Returns a pointer to the statistics control structure. \item\end{CompactList}\item 
int \hyperlink{xfc_8c_a25}{xfc\_\-sizeof} (\hyperlink{struct__XfcConstructCtx}{Xfc\-Construct\-Ctx} $\ast$ctxx, const EFC\_\-definition $\ast$def, const EFC\_\-DB\_\-Schema $\ast$schema, int stats\_\-size)
\begin{CompactList}\small\item\em Computes the size needed to hold configuration defined by the specified context, definition block and schema. \item\end{CompactList}\item 
const EDS\_\-fw\-Handler\-Services\-X1 $\ast$ \hyperlink{xfc_8c_a26}{xfc\_\-construct} (\hyperlink{struct__XfcConstructCtx}{Xfc\-Construct\-Ctx} $\ast$ctxx, EFC $\ast$efc, unsigned int handler\_\-id, const EFC\_\-DB\_\-Schema $\ast$schema, unsigned int schema\_\-key, EDS\_\-fw $\ast$eds\-Fw, unsigned int objects, unsigned int needs, Xfc\-Results\-Print\-Rtn results\-Print, Xfc\-Stats\-Clear\-Rtn stats\-Clear, Xfc\-Stats\-Accumulate\-Rtn stats\-Acc, Xfc\-Stats\-Print\-Rtn stats\-Print)
\begin{CompactList}\small\item\em Constructs the configuration for the specified set of parameters. \item\end{CompactList}\item 
int \hyperlink{xfc_8c_a27}{xfc\_\-any\_\-display} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Returns non-zero if there are any subsystems to display that need a directory. \item\end{CompactList}\item 
void \hyperlink{xfc_8c_a28}{xfc\_\-display} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, unsigned int pkt\-Bytes, EBF\_\-pkt $\ast$pkt, EBF\_\-siv siv, EDS\_\-fw\-Ixb $\ast$ixb)
\begin{CompactList}\small\item\em Displays the requested subsystems. \item\end{CompactList}\item 
int \hyperlink{xfc_8c_a29}{xfc\_\-process} (int id, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$rto, const EDS\_\-DB\_\-Handler\-Construct\-Services $\ast$services)
\begin{CompactList}\small\item\em Common routine to do the processing. \item\end{CompactList}\item 
void \hyperlink{xfc_8c_a30}{xfc\_\-results\_\-post} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, int reason, const void $\ast$beg, const void $\ast$end, const EFA\_\-span $\ast$span)
\begin{CompactList}\small\item\em Dummy result vector post routine. \item\end{CompactList}\item 
int \hyperlink{xfc_8c_a31}{xfc\_\-results\_\-start} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, int reason, int run\_\-id, int start\-Time, int mode)
\begin{CompactList}\small\item\em Handles the start run for the result analysis. \item\end{CompactList}\item 
void \hyperlink{xfc_8c_a32}{xfc\_\-begtick\_\-set} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, TMR\_\-tick tick)
\begin{CompactList}\small\item\em Seeds the beginning tick of this sample. \item\end{CompactList}\item 
void \hyperlink{xfc_8c_a33}{xfc\_\-endtick\_\-set} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, TMR\_\-tick tick)
\begin{CompactList}\small\item\em Seeds the ending tick of this sample. \item\end{CompactList}\item 
void \hyperlink{xfc_8c_a34}{xfc\_\-results\_\-print} (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx, const void $\ast$beg, const void $\ast$end)
\begin{CompactList}\small\item\em Prints the standard part of the results, then calls the filter specific piece. \item\end{CompactList}\item 
unsigned int \hyperlink{xfc_8c_a35}{xfc\_\-objects\_\-get} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Used to supply any additional EDS\_\-fw objects needed by this filter context. \item\end{CompactList}\item 
unsigned int \hyperlink{xfc_8c_a36}{xfc\_\-needs\_\-get} (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ctx)
\begin{CompactList}\small\item\em Used to supply any additional EDS\_\-fw needs for this filter context. \item\end{CompactList}\item 
static int \hyperlink{xfc_8c_a37}{dummy\-Start} (void $\ast$prm, unsigned int run\_\-id, unsigned int start\-Time, unsigned int mode, int reason)
\begin{CompactList}\small\item\em Dummy routine to intercept the posted events when one does not have a real posting routine. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a38}{dummy\-Write} (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$poster, EDS\_\-fw\-Ixb $\ast$ixb)
\begin{CompactList}\small\item\em Dummy routine to intercept the output events when one does not have a real output routine. \item\end{CompactList}\item 
static int \hyperlink{xfc_8c_a39}{dummy\-Notify} (void $\ast$prm, unsigned int mode, unsigned int active, const unsigned char cfgs\mbox{[}32\mbox{]}, const EDS\_\-rsd\-Tbl $\ast$rsd\-Tbl)
\begin{CompactList}\small\item\em Dummy routine to handle mode change notifications to the posting stream. \item\end{CompactList}\item 
static void \hyperlink{xfc_8c_a40}{dummy\-Flush} (void $\ast$prm, int reason)
\begin{CompactList}\small\item\em Dummy routine to close an posting stream. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Utility/driver program for filter test code. 

\begin{Desc}
\item[Author:]JJRussell - \href{mailto:russell@slac.stanford.edu}{\tt russell@slac.stanford.edu}\end{Desc}


\footnotesize\begin{verbatim}   CVS $Id: xfc.c,v 1.1 2007/10/17 02:12:28 russell Exp $
\end{verbatim}
\normalsize


\subsection{Define Documentation}
\hypertarget{xfc_8c_a0}{
\index{xfc.c@{xfc.c}!RND8@{RND8}}
\index{RND8@{RND8}!xfc.c@{xfc.c}}
\subsubsection[RND8]{\setlength{\rightskip}{0pt plus 5cm}\#define RND8(\_\-n)~(((\_\-n) + 7) \& $\sim$0x7)}}
\label{xfc_8c_a0}


Rounds {\em \_\-n\/} to a value of 8. 

\begin{Desc}
\item[Returns:]The rounded value\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-n}]The value to round\end{description}
\end{Desc}


\subsection{Function Documentation}
\hypertarget{xfc_8c_a12}{
\index{xfc.c@{xfc.c}!createPoster@{createPoster}}
\index{createPoster@{createPoster}!xfc.c@{xfc.c}}
\subsubsection[createPoster]{\setlength{\rightskip}{0pt plus 5cm}static int create\-Poster (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$ {\em poster}, const char $\ast$ {\em name}, unsigned int {\em options})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a12}


Creates an output file if {\em name\/} is not NULL. 

\begin{Desc}
\item[Returns:]Status\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em poster}]The poster to fill in \item[{\em name}]The name of the output file to create \item[{\em options}]Bit list of output options.\end{description}
\end{Desc}
\hypertarget{xfc_8c_a40}{
\index{xfc.c@{xfc.c}!dummyFlush@{dummyFlush}}
\index{dummyFlush@{dummyFlush}!xfc.c@{xfc.c}}
\subsubsection[dummyFlush]{\setlength{\rightskip}{0pt plus 5cm}void dummy\-Flush (void $\ast$ {\em prm}, int {\em reason})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a40}


Dummy routine to close an posting stream. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em prm}]The user context parameter \item[{\em reason}]The reason flush is being called\end{description}
\end{Desc}
\hypertarget{xfc_8c_a39}{
\index{xfc.c@{xfc.c}!dummyNotify@{dummyNotify}}
\index{dummyNotify@{dummyNotify}!xfc.c@{xfc.c}}
\subsubsection[dummyNotify]{\setlength{\rightskip}{0pt plus 5cm}int dummy\-Notify (void $\ast$ {\em prm}, unsigned int {\em mode}, unsigned int {\em active}, const unsigned char {\em cfgs}\mbox{[}32\mbox{]}, const EDS\_\-rsd\-Tbl $\ast$ {\em rsd\-Tbl})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a39}


Dummy routine to handle mode change notifications to the posting stream. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em prm}]The user context parameter \item[{\em mode}]The current mode \item[{\em active}]The list of active handlers \item[{\em cfgs}]The array of handler configurations \item[{\em rsd\-Tbl}]The result summary data table\end{description}
\end{Desc}
\hypertarget{xfc_8c_a37}{
\index{xfc.c@{xfc.c}!dummyStart@{dummyStart}}
\index{dummyStart@{dummyStart}!xfc.c@{xfc.c}}
\subsubsection[dummyStart]{\setlength{\rightskip}{0pt plus 5cm}int dummy\-Start (void $\ast$ {\em prm}, unsigned int {\em run\_\-id}, unsigned int {\em start\-Time}, unsigned int {\em mode}, int {\em reason})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a37}


Dummy routine to intercept the posted events when one does not have a real posting routine. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em prm}]The user context parameter \item[{\em run\_\-id}]The run identifier \item[{\em start\-Time}]The start time (in seconds since the SA epoch) \item[{\em mode}]The starting mode \item[{\em reason}]The reason for starting\end{description}
\end{Desc}
\hypertarget{xfc_8c_a38}{
\index{xfc.c@{xfc.c}!dummyWrite@{dummyWrite}}
\index{dummyWrite@{dummyWrite}!xfc.c@{xfc.c}}
\subsubsection[dummyWrite]{\setlength{\rightskip}{0pt plus 5cm}void dummy\-Write (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$ {\em post}, EDS\_\-fw\-Ixb $\ast$ {\em ixb})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a38}


Dummy routine to intercept the output events when one does not have a real output routine. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em post}]The posting context handle \item[{\em ixb}]The information exchange block, contains a reference to the event to write plus other event related information\end{description}
\end{Desc}
\hypertarget{xfc_8c_a14}{
\index{xfc.c@{xfc.c}!printElapsed@{printElapsed}}
\index{printElapsed@{printElapsed}!xfc.c@{xfc.c}}
\subsubsection[printElapsed]{\setlength{\rightskip}{0pt plus 5cm}static void print\-Elapsed (const char $\ast$ {\em caption}, TMR\_\-tick {\em beg}, TMR\_\-tick {\em end}, int {\em n})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a14}


Utility routine to print elapsed times. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em caption}]The caption to print \item[{\em beg}]The beginning time \item[{\em end}]The ending time \item[{\em n}]The normalizing count\end{description}
\end{Desc}
\hypertarget{xfc_8c_a13}{
\index{xfc.c@{xfc.c}!printPoster@{printPoster}}
\index{printPoster@{printPoster}!xfc.c@{xfc.c}}
\subsubsection[printPoster]{\setlength{\rightskip}{0pt plus 5cm}static void print\-Poster (\hyperlink{struct__XfcPosterCtx}{Xfc\-Poster\-Ctx} $\ast$ {\em poster}, EDS\_\-fw\-Ixb $\ast$ {\em ixb})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a13}


Prints a 1 line summary of the events that are output. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em poster}]The posting context handle \item[{\em ixb}]The information exchange block\end{description}
\end{Desc}
\hypertarget{xfc_8c_a9}{
\index{xfc.c@{xfc.c}!setup_lcbp@{setup\_\-lcbp}}
\index{setup_lcbp@{setup\_\-lcbp}!xfc.c@{xfc.c}}
\subsubsection[setup\_\-lcbp]{\setlength{\rightskip}{0pt plus 5cm}static int setup\_\-lcbp (LCBP {\em lcb}, EDS\_\-fw $\ast$ {\em eds\-Fw}, int {\em rate})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a9}


Does the primary setup of the LCBP. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em lcb}]The LCBP device handle \item[{\em eds\-Fw}]The EDS framework handle \item[{\em rate}]If non-zero, then deliver events asynchronously, -1 means at the rate specified in the event file.\end{description}
\end{Desc}
\hypertarget{xfc_8c_a27}{
\index{xfc.c@{xfc.c}!xfc_any_display@{xfc\_\-any\_\-display}}
\index{xfc_any_display@{xfc\_\-any\_\-display}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-any\_\-display]{\setlength{\rightskip}{0pt plus 5cm}int xfc\_\-any\_\-display (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a27}


Returns non-zero if there are any subsystems to display that need a directory. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter context parameter\end{description}
\end{Desc}
\hypertarget{xfc_8c_a32}{
\index{xfc.c@{xfc.c}!xfc_begtick_set@{xfc\_\-begtick\_\-set}}
\index{xfc_begtick_set@{xfc\_\-begtick\_\-set}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-begtick\_\-set]{\setlength{\rightskip}{0pt plus 5cm}void xfc\_\-begtick\_\-set (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, TMR\_\-tick {\em tick})}}
\label{xfc_8c_a32}


Seeds the beginning tick of this sample. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The xfc context \item[{\em tick}]The beginning tick value\end{description}
\end{Desc}
\hypertarget{xfc_8c_a26}{
\index{xfc.c@{xfc.c}!xfc_construct@{xfc\_\-construct}}
\index{xfc_construct@{xfc\_\-construct}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-construct]{\setlength{\rightskip}{0pt plus 5cm}const EDS\_\-fw\-Handler\-Services\-X1$\ast$ xfc\_\-construct (\hyperlink{struct__XfcConstructCtx}{Xfc\-Construct\-Ctx} $\ast$ {\em ctxx}, EFC $\ast$ {\em efc}, unsigned int {\em handler\_\-id}, const EFC\_\-DB\_\-Schema $\ast$ {\em schema}, unsigned int {\em schema\_\-key}, EDS\_\-fw $\ast$ {\em eds\-Fw}, unsigned int {\em objects}, unsigned int {\em needs}, Xfc\-Results\-Print\-Rtn {\em results\-Print}, Xfc\-Stats\-Clear\-Rtn {\em stats\-Clear}, Xfc\-Stats\-Accumulate\-Rtn {\em stats\-Acc}, Xfc\-Stats\-Print\-Rtn {\em stats\-Print})}}
\label{xfc_8c_a26}


Constructs the configuration for the specified set of parameters. 

!!!results; \hypertarget{xfc_8c_a28}{
\index{xfc.c@{xfc.c}!xfc_display@{xfc\_\-display}}
\index{xfc_display@{xfc\_\-display}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-display]{\setlength{\rightskip}{0pt plus 5cm}void xfc\_\-display (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, unsigned int {\em pkt\-Bytes}, EBF\_\-pkt $\ast$ {\em pkt}, EBF\_\-siv {\em siv}, EDS\_\-fw\-Ixb $\ast$ {\em ixb})}}
\label{xfc_8c_a28}


Displays the requested subsystems. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter context \item[{\em pkt\-Bytes}]The number of bytes in the packet \item[{\em pkt}]The event data packet \item[{\em siv}]The packet state information vector \item[{\em ixb}]The EDS information exchange block\end{description}
\end{Desc}
\hypertarget{xfc_8c_a19}{
\index{xfc.c@{xfc.c}!xfc_display_build@{xfc\_\-display\_\-build}}
\index{xfc_display_build@{xfc\_\-display\_\-build}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-display\_\-build]{\setlength{\rightskip}{0pt plus 5cm}static unsigned int xfc\_\-display\_\-build (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$ {\em rto})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a19}


Initializes the event display information. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle \item[{\em rto}]The run time options\end{description}
\end{Desc}
\hypertarget{xfc_8c_a17}{
\index{xfc.c@{xfc.c}!xfc_edsFw_build@{xfc\_\-edsFw\_\-build}}
\index{xfc_edsFw_build@{xfc\_\-edsFw\_\-build}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-edsFw\_\-build]{\setlength{\rightskip}{0pt plus 5cm}static unsigned int xfc\_\-eds\-Fw\_\-build (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$ {\em rto})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a17}


Allocates and constructs the EDS framework. 

\begin{Desc}
\item[Returns:]Status\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle \item[{\em rto}]The run time options\end{description}
\end{Desc}
\hypertarget{xfc_8c_a33}{
\index{xfc.c@{xfc.c}!xfc_endtick_set@{xfc\_\-endtick\_\-set}}
\index{xfc_endtick_set@{xfc\_\-endtick\_\-set}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-endtick\_\-set]{\setlength{\rightskip}{0pt plus 5cm}void xfc\_\-endtick\_\-set (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, TMR\_\-tick {\em tick})}}
\label{xfc_8c_a33}


Seeds the ending tick of this sample. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The xfc context \item[{\em tick}]The ending tick value\end{description}
\end{Desc}
\hypertarget{xfc_8c_a22}{
\index{xfc.c@{xfc.c}!xfc_filterCtx_get@{xfc\_\-filterCtx\_\-get}}
\index{xfc_filterCtx_get@{xfc\_\-filterCtx\_\-get}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-filterCtx\_\-get]{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ xfc\_\-filter\-Ctx\_\-get (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a22}


Returns a pointer to the underlying user filter control structure. 

\begin{Desc}
\item[Returns:]A pointer to the underlying user filter control structure\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter control context\end{description}
\end{Desc}
\hypertarget{xfc_8c_a15}{
\index{xfc.c@{xfc.c}!xfc_initialize@{xfc\_\-initialize}}
\index{xfc_initialize@{xfc\_\-initialize}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-initialize]{\setlength{\rightskip}{0pt plus 5cm}int xfc\_\-initialize (void)}}
\label{xfc_8c_a15}


One time initialization routine. 

\begin{Desc}
\item[Returns:]Status\end{Desc}
\hypertarget{xfc_8c_a18}{
\index{xfc.c@{xfc.c}!xfc_istream_build@{xfc\_\-istream\_\-build}}
\index{xfc_istream_build@{xfc\_\-istream\_\-build}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-istream\_\-build]{\setlength{\rightskip}{0pt plus 5cm}static unsigned int status xfc\_\-istream\_\-build (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$ {\em rto})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a18}


Initializes the input data stream. 

\begin{Desc}
\item[Returns:]Status\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle \item[{\em rto}]The run time options\end{description}
\end{Desc}
\hypertarget{xfc_8c_a36}{
\index{xfc.c@{xfc.c}!xfc_needs_get@{xfc\_\-needs\_\-get}}
\index{xfc_needs_get@{xfc\_\-needs\_\-get}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-needs\_\-get]{\setlength{\rightskip}{0pt plus 5cm}unsigned int xfc\_\-needs\_\-get (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a36}


Used to supply any additional EDS\_\-fw needs for this filter context. 

\begin{Desc}
\item[Returns:]Bit mask of the addition objects\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter context handle\end{description}
\end{Desc}
\hypertarget{xfc_8c_a35}{
\index{xfc.c@{xfc.c}!xfc_objects_get@{xfc\_\-objects\_\-get}}
\index{xfc_objects_get@{xfc\_\-objects\_\-get}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-objects\_\-get]{\setlength{\rightskip}{0pt plus 5cm}unsigned int xfc\_\-objects\_\-get (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a35}


Used to supply any additional EDS\_\-fw objects needed by this filter context. 

\begin{Desc}
\item[Returns:]Bit mask of the addition objects\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter context handle\end{description}
\end{Desc}
\hypertarget{xfc_8c_a29}{
\index{xfc.c@{xfc.c}!xfc_process@{xfc\_\-process}}
\index{xfc_process@{xfc\_\-process}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-process]{\setlength{\rightskip}{0pt plus 5cm}int xfc\_\-process (int {\em id}, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$ {\em rto}, const EDS\_\-DB\_\-Handler\-Construct\-Services $\ast$ {\em services})}}
\label{xfc_8c_a29}


Common routine to do the processing. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em id}]The EFC\_\-DB\_\-id of this filter \item[{\em rto}]The runtime options structure \item[{\em services}]An alternative set of construction services, may be NULL, in which case the services resolved by the database schema and instance buried in the {\em rto\/} will be used. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Status\end{Desc}
\hypertarget{xfc_8c_a30}{
\index{xfc.c@{xfc.c}!xfc_results_post@{xfc\_\-results\_\-post}}
\index{xfc_results_post@{xfc\_\-results\_\-post}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-results\_\-post]{\setlength{\rightskip}{0pt plus 5cm}void xfc\_\-results\_\-post (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, int {\em reason}, const void $\ast$ {\em beg}, const void $\ast$ {\em end}, const EFA\_\-span $\ast$ {\em span})}}
\label{xfc_8c_a30}


Dummy result vector post routine. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The xfc context \item[{\em reason}]The posting reason \item[{\em beg}]The first result vector \item[{\em end}]The last result vector (actually one past the last one) \item[{\em span}]The span of the sample\end{description}
\end{Desc}
\hypertarget{xfc_8c_a34}{
\index{xfc.c@{xfc.c}!xfc_results_print@{xfc\_\-results\_\-print}}
\index{xfc_results_print@{xfc\_\-results\_\-print}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-results\_\-print]{\setlength{\rightskip}{0pt plus 5cm}void xfc\_\-results\_\-print (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, const void $\ast$ {\em beg}, const void $\ast$ {\em end})}}
\label{xfc_8c_a34}


Prints the standard part of the results, then calls the filter specific piece. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The xfc context \item[{\em beg}]Pointer to the first filter specific result vector \item[{\em end}]Pointer to the last filter specific result vector\end{description}
\end{Desc}
\hypertarget{xfc_8c_a31}{
\index{xfc.c@{xfc.c}!xfc_results_start@{xfc\_\-results\_\-start}}
\index{xfc_results_start@{xfc\_\-results\_\-start}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-results\_\-start]{\setlength{\rightskip}{0pt plus 5cm}int xfc\_\-results\_\-start (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, int {\em reason}, int {\em run\_\-id}, int {\em start\-Time}, int {\em mode})}}
\label{xfc_8c_a31}


Handles the start run for the result analysis. 

\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em ==0,if}]successfully started \item[{\em !=0,if}]not successfully started\end{description}
\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The callback context parameter \item[{\em reason}]The LSF\_\-REASON\_\-OPEN to indicate why the stream is being started \item[{\em run\_\-id}]Suggested use is to identify the block of events between when EDS\_\-fw\-Handler\-Start is called and EDS\_\-fw\-Handler\-Flush is called with a stop reason \item[{\em start\-Time}]The run start time rounded to the nearest second \item[{\em mode}]This must be the running mode.\end{description}
\end{Desc}
\hypertarget{xfc_8c_a23}{
\index{xfc.c@{xfc.c}!xfc_resultsCtx_get@{xfc\_\-resultsCtx\_\-get}}
\index{xfc_resultsCtx_get@{xfc\_\-resultsCtx\_\-get}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-resultsCtx\_\-get]{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ xfc\_\-results\-Ctx\_\-get (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a23}


Returns a pointer to the results control structure. 

\begin{Desc}
\item[Returns:]A pointer to the results control structure\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter control context\end{description}
\end{Desc}
\hypertarget{xfc_8c_a10}{
\index{xfc.c@{xfc.c}!xfc_run_start@{xfc\_\-run\_\-start}}
\index{xfc_run_start@{xfc\_\-run\_\-start}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-run\_\-start]{\setlength{\rightskip}{0pt plus 5cm}static void xfc\_\-run\_\-start (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a10}


Notifies the handlers and posters of the start run. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle\end{description}
\end{Desc}
\hypertarget{xfc_8c_a11}{
\index{xfc.c@{xfc.c}!xfc_run_stop@{xfc\_\-run\_\-stop}}
\index{xfc_run_stop@{xfc\_\-run\_\-stop}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-run\_\-stop]{\setlength{\rightskip}{0pt plus 5cm}static void xfc\_\-run\_\-stop (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a11}


Stops the run. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle\end{description}
\end{Desc}
\hypertarget{xfc_8c_a25}{
\index{xfc.c@{xfc.c}!xfc_sizeof@{xfc\_\-sizeof}}
\index{xfc_sizeof@{xfc\_\-sizeof}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-sizeof]{\setlength{\rightskip}{0pt plus 5cm}int xfc\_\-sizeof (\hyperlink{struct__XfcConstructCtx}{Xfc\-Construct\-Ctx} $\ast$ {\em ctxx}, const EFC\_\-definition $\ast$ {\em def}, const EFC\_\-DB\_\-Schema $\ast$ {\em schema}, int {\em stats\_\-size})}}
\label{xfc_8c_a25}


Computes the size needed to hold configuration defined by the specified context, definition block and schema. 

\begin{Desc}
\item[Returns:]The size, in bytes,\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctxx}]The filter control construction context \item[{\em def}]The EFC definition block \item[{\em schema}]The defining schema \item[{\em stats\_\-size}]The size, in bytes, of one statistics buffer\end{description}
\end{Desc}
\hypertarget{xfc_8c_a24}{
\index{xfc.c@{xfc.c}!xfc_statsCtx_get@{xfc\_\-statsCtx\_\-get}}
\index{xfc_statsCtx_get@{xfc\_\-statsCtx\_\-get}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-statsCtx\_\-get]{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ xfc\_\-stats\-Ctx\_\-get (const \hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx})}}
\label{xfc_8c_a24}


Returns a pointer to the statistics control structure. 

\begin{Desc}
\item[Returns:]A pointer to the statistics control structure\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The filter control context\end{description}
\end{Desc}
\hypertarget{xfc_8c_a16}{
\index{xfc.c@{xfc.c}!xfc_time_initialize@{xfc\_\-time\_\-initialize}}
\index{xfc_time_initialize@{xfc\_\-time\_\-initialize}!xfc.c@{xfc.c}}
\subsubsection[xfc\_\-time\_\-initialize]{\setlength{\rightskip}{0pt plus 5cm}static unsigned int xfc\_\-time\_\-initialize (\hyperlink{struct__XfcCtx}{Xfc\-Ctx} $\ast$ {\em ctx}, const \hyperlink{struct__XfcRto}{Xfc\-Rto} $\ast$ {\em rto})\hspace{0.3cm}{\tt  \mbox{[}static\mbox{]}}}}
\label{xfc_8c_a16}


Initializes the time base (fakes out WCT and THS). 

\begin{Desc}
\item[Returns:]Status\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ctx}]The Xfc context handle \item[{\em rto}]The run time options\end{description}
\end{Desc}