static void *
loadedtoidle_ctor (void * ap_obj, va_list * app)
{
tiz_loadedtoidle_t * p_obj
= super_ctor (typeOf (ap_obj, "tizloadedtoidle"), ap_obj, app);
return p_obj;
}
static void *
idletoloaded_ctor (void * ap_obj, va_list * app)
{
tiz_idletoloaded_t * p_obj
= super_ctor (typeOf (ap_obj, "tizidletoloaded"), ap_obj, app);
return p_obj;
}
static void *spfysrc_cfgport_ctor (void *ap_obj, va_list *app)
{
spfysrc_cfgport_t *p_obj
= super_ctor (typeOf (ap_obj, "spfysrccfgport"), ap_obj, app);
assert (NULL != p_obj);
tiz_check_omx_err_ret_null (tiz_port_register_index (
p_obj, OMX_TizoniaIndexParamAudioSpotifySession));
tiz_check_omx_err_ret_null (tiz_port_register_index (
p_obj, OMX_TizoniaIndexParamAudioSpotifyPlaylist));
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_SPOTIFYSESSIONTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->spotifysession_);
snprintf ((char *)p_obj->spotifysession_.cUserName,
sizeof(p_obj->spotifysession_.cUserName), "tizonia");
snprintf ((char *)p_obj->spotifysession_.cUserPassword,
sizeof(p_obj->spotifysession_.cUserPassword), "pass");
p_obj->spotifysession_.bRememberCredentials = OMX_TRUE;
p_obj->spotifysession_.ePreferredBitRate = OMX_AUDIO_SpotifyBitrate320Kbps;
p_obj->spotifysession_.eConnectionType
= OMX_AUDIO_SpotifyConnectionMobileWired;
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_SPOTIFYPLAYLISTTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->playlist_);
snprintf ((char *)p_obj->playlist_.cPlaylistName,
sizeof(p_obj->playlist_.cPlaylistName), "playlist");
p_obj->playlist_.bShuffle = OMX_FALSE;
return p_obj;
}
static void *
gmusic_cfgport_ctor (void * ap_obj, va_list * app)
{
gmusic_cfgport_t * p_obj
= super_ctor (typeOf (ap_obj, "gmusiccfgport"), ap_obj, app);
assert (p_obj);
tiz_check_omx_ret_null (
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamAudioGmusicSession));
tiz_check_omx_ret_null (
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamAudioGmusicPlaylist));
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_GMUSICSESSIONTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->session_);
snprintf ((char *) p_obj->session_.cUserName,
sizeof (p_obj->session_.cUserName), "tizonia");
snprintf ((char *) p_obj->session_.cUserPassword,
sizeof (p_obj->session_.cUserPassword), "pass");
snprintf ((char *) p_obj->session_.cDeviceId,
sizeof (p_obj->session_.cDeviceId), "deviceId");
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_GMUSICPLAYLISTTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->playlist_);
snprintf ((char *) p_obj->playlist_.cPlaylistName,
sizeof (p_obj->playlist_.cPlaylistName), "playlist");
p_obj->playlist_.ePlaylistType = OMX_AUDIO_GmusicPlaylistTypeUnknown;
p_obj->playlist_.bShuffle = OMX_FALSE;
p_obj->playlist_.bUnlimitedSearch = OMX_FALSE;
return p_obj;
}
static void *
cc_youtube_cfgport_ctor (void * ap_obj, va_list * app)
{
cc_youtube_cfgport_t * p_obj
= super_ctor (typeOf (ap_obj, "cc_youtubecfgport"), ap_obj, app);
assert (p_obj);
tiz_check_omx_ret_null (
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamAudioYoutubeSession));
tiz_check_omx_ret_null (
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamAudioYoutubePlaylist));
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_YOUTUBESESSIONTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->session_);
snprintf ((char *) p_obj->session_.cApiKey, sizeof (p_obj->session_.cApiKey),
"xyzxyzxyzxyzxyz");
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_YOUTUBEPLAYLISTTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->playlist_);
snprintf ((char *) p_obj->playlist_.cPlaylistName,
sizeof (p_obj->playlist_.cPlaylistName), "playlist");
p_obj->playlist_.ePlaylistType = OMX_AUDIO_YoutubePlaylistTypeUnknown;
p_obj->playlist_.bShuffle = OMX_FALSE;
return p_obj;
}
static void *
fr_prc_ctor (void *ap_obj, va_list * app)
{
fr_prc_t *p_obj = super_ctor (typeOf (ap_obj, "frprc"), ap_obj, app);
p_obj->eos_ = false;
return p_obj;
}
static void *
waitforresources_ctor (void *ap_obj, va_list * app)
{
tiz_waitforresources_t *p_obj =
super_ctor (typeOf (ap_obj, "tizwaitforresources"), ap_obj, app);
return p_obj;
}
static void *httpr_mp3port_ctor (void *ap_obj, va_list *app)
{
httpr_mp3port_t *p_obj
= super_ctor (typeOf (ap_obj, "httprmp3port"), ap_obj, app);
assert (NULL != p_obj);
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamIcecastMountpoint);
tiz_port_register_index (p_obj, OMX_TizoniaIndexConfigIcecastMetadata);
p_obj->mountpoint_.nSize = sizeof(OMX_TIZONIA_ICECASTMOUNTPOINTTYPE);
p_obj->mountpoint_.nVersion.nVersion = OMX_VERSION;
p_obj->mountpoint_.nPortIndex = 0;
snprintf ((char *)p_obj->mountpoint_.cMountName,
sizeof(p_obj->mountpoint_.cMountName), "/");
snprintf ((char *)p_obj->mountpoint_.cStationName,
sizeof(p_obj->mountpoint_.cStationName), "Tizonia Radio!");
snprintf ((char *)p_obj->mountpoint_.cStationDescription,
sizeof(p_obj->mountpoint_.cStationDescription),
"Cool Radio Station");
snprintf ((char *)p_obj->mountpoint_.cStationGenre,
sizeof(p_obj->mountpoint_.cStationGenre), "Some punchy genre");
snprintf ((char *)p_obj->mountpoint_.cStationUrl,
sizeof(p_obj->mountpoint_.cStationUrl), "http://tizonia.org");
p_obj->mountpoint_.eEncoding = OMX_AUDIO_CodingMP3;
p_obj->mountpoint_.nIcyMetadataPeriod = ICE_DEFAULT_METADATA_INTERVAL;
p_obj->mountpoint_.bBurstOnConnect = OMX_TRUE;
p_obj->mountpoint_.nInitialBurstSize = ICE_INITIAL_BURST_SIZE;
p_obj->mountpoint_.nMaxClients = ICE_MAX_CLIENTS_PER_MOUNTPOINT;
p_obj->p_stream_title_ = NULL;
return p_obj;
}
static void *
fr_prc_ctor (void *ap_obj, va_list * app)
{
fr_prc_t *p_prc = super_ctor (typeOf (ap_obj, "frprc"), ap_obj, app);
assert (p_prc);
return p_prc;
}
static void *
scloud_cfgport_ctor (void * ap_obj, va_list * app)
{
scloud_cfgport_t * p_obj
= super_ctor (typeOf (ap_obj, "scloudcfgport"), ap_obj, app);
assert (p_obj);
tiz_check_omx_ret_null (tiz_port_register_index (
p_obj, OMX_TizoniaIndexParamAudioSoundCloudSession));
tiz_check_omx_ret_null (tiz_port_register_index (
p_obj, OMX_TizoniaIndexParamAudioSoundCloudPlaylist));
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDSESSIONTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->session_);
snprintf ((char *) p_obj->session_.cUserName,
sizeof (p_obj->session_.cUserName), "tizonia");
snprintf ((char *) p_obj->session_.cUserPassword,
sizeof (p_obj->session_.cUserPassword), "pass");
snprintf ((char *) p_obj->session_.cUserOauthToken,
sizeof (p_obj->session_.cUserOauthToken),
"1-111111-11111111-11111111111111");
/* Initialize the OMX_TIZONIA_AUDIO_PARAM_SOUNDCLOUDPLAYLISTTYPE structure */
TIZ_INIT_OMX_STRUCT (p_obj->playlist_);
snprintf ((char *) p_obj->playlist_.cPlaylistName,
sizeof (p_obj->playlist_.cPlaylistName), "playlist");
p_obj->playlist_.ePlaylistType = OMX_AUDIO_SoundCloudPlaylistTypeUnknown;
p_obj->playlist_.bShuffle = OMX_FALSE;
return p_obj;
}
static void *
oggdmux_prc_ctor (void * ap_obj, va_list * app)
{
oggdmux_prc_t * p_prc
= super_ctor (typeOf (ap_obj, "oggdmuxprc"), ap_obj, app);
assert (p_prc);
p_prc->p_file_ = NULL;
p_prc->p_uri_ = NULL;
p_prc->p_oggz_ = NULL;
p_prc->p_tracks_ = NULL;
p_prc->p_aud_hdr_ = NULL;
p_prc->p_vid_hdr_ = NULL;
p_prc->aud_buf_size_ = 0;
p_prc->vid_buf_size_ = 0;
p_prc->awaiting_buffers_ = true;
p_prc->p_aud_store_ = NULL;
p_prc->p_vid_store_ = NULL;
p_prc->aud_store_size_ = 0;
p_prc->vid_store_size_ = 0;
p_prc->aud_store_offset_ = 0;
p_prc->vid_store_offset_ = 0;
p_prc->file_eos_ = false;
p_prc->aud_eos_ = false;
p_prc->vid_eos_ = false;
p_prc->aud_port_disabled_ = false;
p_prc->vid_port_disabled_ = false;
return p_prc;
}
static void *
cc_http_prc_ctor (void * ap_obj, va_list * app)
{
cc_http_prc_t * p_prc
= super_ctor (typeOf (ap_obj, "cc_httpprc"), ap_obj, app);
p_prc->p_content_uri_ = NULL;
return p_prc;
}
static void *
sdlivr_proc_ctor (void *ap_obj, va_list * app)
{
sdlivr_prc_t *p_prc = super_ctor (typeOf (ap_obj, "sdlivrprc"), ap_obj, app);
assert (NULL != p_prc);
p_prc->pinhdr_ = NULL;
p_prc->pouthdr_ = NULL;
p_prc->eos_ = false;
return p_prc;
}
static void *
fr_proc_ctor (void *ap_obj, va_list * app)
{
fr_prc_t *p_obj = super_ctor (frprc, ap_obj, app);
p_obj->p_file_ = NULL;
p_obj->p_uri_param_ = NULL;
p_obj->counter_ = 0;
p_obj->eos_ = false;
return p_obj;
}
void BTBajoConsumoSafe_defConstructor(void * _self,va_list * args){
struct BTBajoConsumoSafe * self = _self;
struct ManejadorMemBTSafeData data;
super_ctor(&BTBajoConsumoSafe,_self,args);
ManejadorMemBTSafe_constructor(&manejadorMem);
if(ManejadorMemBTSafe_getLastData(&manejadorMem,&data)){
setFecha(_self,2000+data.data[0],data.data[1],data.data[2]);
BaseTiempo_setTime(_self,data.data[3],data.data[4],data.data[5]);
}
}
static void *
sdlivr_prc_ctor (void * ap_obj, va_list * app)
{
sdlivr_prc_t * p_prc = super_ctor (typeOf (ap_obj, "sdlivrprc"), ap_obj, app);
assert (p_prc);
tiz_mem_set (&(p_prc->port_def_), 0, sizeof (OMX_VIDEO_PORTDEFINITIONTYPE));
p_prc->p_surface = NULL;
p_prc->p_overlay = NULL;
p_prc->port_disabled_ = false;
return p_prc;
}
static void *
httpr_prc_ctor (void * ap_prc, va_list * app)
{
httpr_prc_t * p_prc = super_ctor (typeOf (ap_prc, "httprprc"), ap_prc, app);
assert (p_prc);
p_prc->mount_name_ = NULL;
p_prc->port_disabled_ = false;
p_prc->p_server_ = NULL;
p_prc->p_inhdr_ = NULL;
return p_prc;
}
static void *vorbisd_prc_ctor (void *ap_obj, va_list *app)
{
vorbisd_prc_t *p_prc
= super_ctor (typeOf (ap_obj, "vorbisdprc"), ap_obj, app);
assert (NULL != p_prc);
p_prc->p_fsnd_ = NULL;
reset_stream_parameters (p_prc);
p_prc->p_store_ = NULL;
p_prc->store_size_ = 0;
p_prc->store_offset_ = 0;
return p_prc;
}
static void *
webpd_proc_ctor (void *ap_obj, va_list * app)
{
struct webpdprc *p_obj = super_ctor (webpdprc, ap_obj, app);
TIZ_LOG (TIZ_TRACE, "Constructing webpdprc...[%p]", p_obj);
p_obj->pinhdr_ = 0;
p_obj->pouthdr_ = 0;
p_obj->eos_ = false;
return p_obj;
}
static void *
node_ctor (void *_self, va_list *ap)
{
node_t *self = super_ctor (Node, _self, ap);
char *text = va_arg (*ap, char *);
assert (Node == classOf (self));
self->_data = malloc (strlen (text) + 1);
strcpy ((char *)(self->_data), text);
self->_next = self->_prev = (void *) 0;
return self;
}
static void *httpsrc_port_ctor (void *ap_obj, va_list *app)
{
httpsrc_port_t *p_obj
= super_ctor (typeOf (ap_obj, "httpsrcport"), ap_obj, app);
assert (p_obj);
tiz_port_register_index (p_obj, OMX_IndexParamAudioMp3);
tiz_port_register_index (p_obj, OMX_IndexParamAudioAac);
tiz_port_register_index (p_obj, OMX_TizoniaIndexParamAudioOpus);
p_obj->mp3type_.nSize = sizeof (OMX_AUDIO_PARAM_MP3TYPE);
p_obj->mp3type_.nVersion.nVersion = OMX_VERSION;
p_obj->mp3type_.nPortIndex = ARATELIA_HTTP_SOURCE_PORT_INDEX;
p_obj->mp3type_.nChannels = 2;
p_obj->mp3type_.nBitRate = 0;
p_obj->mp3type_.nSampleRate = 44100;
p_obj->mp3type_.nAudioBandWidth = 0;
p_obj->mp3type_.eChannelMode = OMX_AUDIO_ChannelModeStereo;
p_obj->mp3type_.eFormat = OMX_AUDIO_MP3StreamFormatMP1Layer3;
p_obj->aactype_.nSize = sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE);
p_obj->aactype_.nVersion.nVersion = OMX_VERSION;
p_obj->aactype_.nPortIndex = ARATELIA_HTTP_SOURCE_PORT_INDEX;
p_obj->aactype_.nChannels = 2;
p_obj->aactype_.nSampleRate = 48000;
p_obj->aactype_.nBitRate = 0;
p_obj->aactype_.nAudioBandWidth = 0;
p_obj->aactype_.nFrameLength = 0;
p_obj->aactype_.nAACtools = OMX_AUDIO_AACToolAll;
p_obj->aactype_.nAACERtools = OMX_AUDIO_AACERAll;
p_obj->aactype_.eAACProfile = OMX_AUDIO_AACObjectLC;
p_obj->aactype_.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
p_obj->aactype_.eChannelMode = OMX_AUDIO_ChannelModeStereo;
p_obj->opustype_.nSize = sizeof (OMX_TIZONIA_AUDIO_PARAM_OPUSTYPE);
p_obj->opustype_.nVersion.nVersion = OMX_VERSION;
p_obj->opustype_.nPortIndex = ARATELIA_HTTP_SOURCE_PORT_INDEX;
p_obj->opustype_.nChannels = 2;
p_obj->opustype_.nBitRate = 256;
p_obj->opustype_.nSampleRate = 48000;
p_obj->opustype_.nFrameDuration = 2;
p_obj->opustype_.nEncoderComplexity = 0;
p_obj->opustype_.bPacketLossResilience = OMX_FALSE;
p_obj->opustype_.bForwardErrorCorrection = OMX_FALSE;
p_obj->opustype_.bDtx = OMX_FALSE;
p_obj->opustype_.eChannelMode = OMX_AUDIO_ChannelModeStereo;
p_obj->opustype_.eFormat = OMX_AUDIO_OPUSStreamFormatVBR;
return p_obj;
}
static void *
mp3d_proc_ctor (void * ap_obj, va_list * app)
{
mp3d_prc_t * p_obj = super_ctor (typeOf (ap_obj, "mp3dprc"), ap_obj, app);
p_obj->remaining_ = 0;
p_obj->frame_count_ = 0;
p_obj->p_inhdr_ = 0;
p_obj->p_outhdr_ = 0;
p_obj->next_synth_sample_ = 0;
p_obj->eos_ = false;
p_obj->in_port_disabled_ = false;
p_obj->out_port_disabled_ = false;
return p_obj;
}
static void *
ivrport_ctor (void * ap_obj, va_list * app)
{
tiz_ivrport_t * p_obj
= super_ctor (typeOf (ap_obj, "tizivrport"), ap_obj, app);
tiz_port_t * p_base = ap_obj;
tiz_port_register_index (p_obj, OMX_IndexConfigCommonRotate);
tiz_port_register_index (p_obj, OMX_IndexConfigCommonMirror);
tiz_port_register_index (p_obj, OMX_IndexConfigCommonScale);
tiz_port_register_index (p_obj, OMX_IndexConfigCommonInputCrop);
tiz_port_register_index (p_obj, OMX_IndexConfigTimeRenderingDelay);
/* Initialize the OMX_CONFIG_ROTATIONTYPE structure */
p_obj->crotate_.nSize = sizeof (OMX_CONFIG_ROTATIONTYPE);
p_obj->crotate_.nVersion.nVersion = OMX_VERSION;
p_obj->crotate_.nPortIndex = p_base->portdef_.nPortIndex;
p_obj->crotate_.nRotation = 0;
/* Initialize the OMX_CONFIG_MIRRORTYPE structure */
p_obj->cmirror_.nSize = sizeof (OMX_CONFIG_MIRRORTYPE);
p_obj->cmirror_.nVersion.nVersion = OMX_VERSION;
p_obj->cmirror_.nPortIndex = p_base->portdef_.nPortIndex;
p_obj->cmirror_.eMirror = OMX_MirrorNone;
/* Initialize the OMX_CONFIG_SCALEFACTORTYPE structure */
p_obj->cscale_.nSize = sizeof (OMX_CONFIG_SCALEFACTORTYPE);
p_obj->cscale_.nVersion.nVersion = OMX_VERSION;
p_obj->cscale_.nPortIndex = p_base->portdef_.nPortIndex;
p_obj->cscale_.xWidth = 1;
p_obj->cscale_.xHeight = 1;
/* Initialize the OMX_CONFIG_RECTTYPE structure */
p_obj->cincrop_.nSize = sizeof (OMX_CONFIG_RECTTYPE);
p_obj->cincrop_.nVersion.nVersion = OMX_VERSION;
p_obj->cincrop_.nPortIndex = p_base->portdef_.nPortIndex;
p_obj->cincrop_.nLeft = 0;
p_obj->cincrop_.nTop = 0;
p_obj->cincrop_.nWidth = 0;
p_obj->cincrop_.nHeight = 0;
/* Initialize the OMX_TIME_CONFIG_RENDERINGDELAYTYPE structure */
p_obj->crendelay_.nSize = sizeof (OMX_TIME_CONFIG_RENDERINGDELAYTYPE);
p_obj->crendelay_.nVersion.nVersion = OMX_VERSION;
p_obj->crendelay_.nPortIndex = p_base->portdef_.nPortIndex;
p_obj->crendelay_.nRenderingDelay = 0;
return p_obj;
}
static void *
nodeclass_ctor (void *_self, va_list *ap)
{
nodeclass_t *self = super_ctor (NodeClass, _self, ap);
typedef void (*fnptr) ();
fnptr selector, function;
selector = va_arg (*ap, fnptr);
function = va_arg (*ap, fnptr);
if (selector == (fnptr) show)
* (fnptr*) & self->_show = function;
return self;
}
static void *
demuxer_cfgport_ctor (void *ap_obj, va_list * app)
{
tiz_demuxercfgport_t *p_obj
= super_ctor (typeOf (ap_obj, "tizdemuxercfgport"), ap_obj, app);
/* In addition to the indexes registered by the parent class, register here
the demuxer-specific ones */
tiz_check_omx_err_ret_null
(tiz_port_register_index (p_obj, OMX_IndexConfigTimePosition)); /* r/w */
tiz_check_omx_err_ret_null
(tiz_port_register_index (p_obj, OMX_IndexConfigTimeSeekMode)); /* r/w */
return p_obj;
}
static void * h264d_prc_ctor(void *ap_obj, va_list * app)
{
vid_dec_PrivateType*priv = super_ctor(typeOf (ap_obj, "h264dprc"), ap_obj, app);
assert(priv);
priv->p_inhdr_ = 0;
priv->p_outhdr_ = 0;
priv->first_buf_in_frame = true;
priv->eos_ = false;
priv->in_port_disabled_ = false;
priv->out_port_disabled_ = false;
priv->picture.base.profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
priv->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
reset_stream_parameters(priv);
return priv;
}
static void *
scloud_prc_ctor (void * ap_obj, va_list * app)
{
scloud_prc_t * p_prc = super_ctor (typeOf (ap_obj, "scloudprc"), ap_obj, app);
p_prc->p_outhdr_ = NULL;
p_prc->p_uri_param_ = NULL;
p_prc->p_trans_ = NULL;
p_prc->p_scloud_ = NULL;
p_prc->eos_ = false;
p_prc->port_disabled_ = false;
p_prc->uri_changed_ = false;
p_prc->audio_coding_type_ = OMX_AUDIO_CodingUnused;
p_prc->num_channels_ = 2;
p_prc->samplerate_ = 44100;
p_prc->content_length_bytes_ = 0;
p_prc->auto_detect_on_ = false;
p_prc->bitrate_ = ARATELIA_HTTP_SOURCE_DEFAULT_BIT_RATE_KBITS;
p_prc->buffer_bytes_ = ((p_prc->bitrate_ * 1000) / 8)
* ARATELIA_HTTP_SOURCE_DEFAULT_BUFFER_SECONDS_SCLOUD;
return p_prc;
}
static void *
dirble_prc_ctor (void * ap_obj, va_list * app)
{
dirble_prc_t * p_prc = super_ctor (typeOf (ap_obj, "dirbleprc"), ap_obj, app);
p_prc->p_outhdr_ = NULL;
TIZ_INIT_OMX_STRUCT (p_prc->session_);
TIZ_INIT_OMX_STRUCT (p_prc->playlist_);
TIZ_INIT_OMX_STRUCT (p_prc->playlist_skip_);
p_prc->p_uri_param_ = NULL;
p_prc->p_trans_ = NULL;
p_prc->p_dirble_ = NULL;
p_prc->eos_ = false;
p_prc->port_disabled_ = false;
p_prc->uri_changed_ = false;
p_prc->audio_coding_type_ = OMX_AUDIO_CodingUnused;
p_prc->num_channels_ = 2;
p_prc->samplerate_ = 44100;
p_prc->auto_detect_on_ = false;
p_prc->bitrate_ = ARATELIA_HTTP_SOURCE_DEFAULT_BIT_RATE_KBITS;
update_cache_size (p_prc);
p_prc->remove_current_url_ = false;
return p_prc;
}
static void *
tiztc_proc_ctor (void *ap_obj, va_list * app)
{
struct tiztcproc *p_obj = super_ctor (tiztcproc, ap_obj, app);
return p_obj;
}
static void *
fr_prc_class_ctor (void *ap_obj, va_list * app)
{
/* NOTE: Class methods might be added in the future. None for now. */
return super_ctor (typeOf (ap_obj, "frprc_class"), ap_obj, app);
}
