|
#include "proto_dbg.h"
|
|
#ifndef max
|
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
#endif
|
|
#ifndef min
|
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
#endif
|
|
#define INDENTATION 3
|
|
#if defined(PROTO_DEBUG)
|
#define log_fmt printf
|
#else
|
#define log_fmt
|
#endif
|
|
#define log_func_in log_fmt("\n================= + %s + >>>\n", __FUNCTION__)
|
#define log_func_out log_fmt("================= - %s - <<<\n", __FUNCTION__)
|
|
#if defined(PROTO_DEBUG)
|
static void log_val(const char *prestr, enum LOG_TYPE type, const void *val)
|
{
|
#ifdef WIN32
|
#define POSFORMAT "(0x%p)"
|
#else
|
#define POSFORMAT "(%p)"
|
#endif
|
|
if (NULL == val) {
|
log_fmt("%s(null)\n", prestr);
|
return ;
|
}
|
|
switch (type)
|
{
|
case log_pos:
|
log_fmt("%s" POSFORMAT "\n", prestr, val);
|
break;
|
case log_int:
|
log_fmt("%s%d\n", prestr, *((int*)val));
|
break;
|
case log_str:
|
log_fmt("%s%s\n", prestr, (char*)val);
|
break;
|
case log_strp:
|
log_fmt("%s%s\n", prestr, *((char**)val));
|
break;
|
case log_float:
|
log_fmt("%s%f\n", prestr, *((float*)val));
|
break;
|
case log_bool:
|
log_fmt("%s%s\n", prestr, (*((enum xsd__boolean*)val)) ? "true" : "false" );
|
break;
|
case log_int64:
|
log_fmt("%s%lld\n", prestr, *((long long*)val));
|
break;
|
default:
|
assert(0);
|
break;
|
}
|
|
return ;
|
}
|
|
static void log_indentation(unsigned int level)
|
{
|
if (level > 0) {
|
log_fmt("%*s%s", level * INDENTATION, "", "|- ");
|
}
|
return ;
|
}
|
|
static void log_level_fmt(unsigned int level, const char *fmt, ...)
|
{
|
va_list ap;
|
|
log_indentation(level);
|
|
va_start(ap, fmt);
|
vprintf(fmt, ap);
|
va_end(ap);
|
|
return ;
|
}
|
|
void log_level_val(unsigned int level, const char *prestr, enum LOG_TYPE type, const void *val)
|
{
|
log_indentation(level);
|
log_val(prestr, type, val);
|
return ;
|
}
|
|
static const char *dump_enum2str_OSDType(enum tt__OSDType t)
|
{
|
switch(t) {
|
case tt__OSDType__Text: return "Text";
|
case tt__OSDType__Image: return "Image";
|
case tt__OSDType__Extended: return "Extended";
|
}
|
return "unknown";
|
}
|
|
static const char *dump_enum2str_VideoEncoding(enum tt__VideoEncoding e)
|
{
|
switch(e) {
|
case tt__VideoEncoding__JPEG: return "JPEG";
|
case tt__VideoEncoding__MPEG4: return "MPEG4";
|
case tt__VideoEncoding__H264: return "H264";
|
}
|
return "unknown";
|
}
|
|
static const char *dump_enum2str_AudioEncoding(enum tt__AudioEncoding e)
|
{
|
switch (e) {
|
case tt__AudioEncoding__G711: return "G711";
|
case tt__AudioEncoding__G726: return "G726";
|
case tt__AudioEncoding__AAC: return "AAC";
|
}
|
return "unknown";
|
}
|
|
static const char *dump_enum2str_H264Profile(enum tt__H264Profile e)
|
{
|
switch (e) {
|
case tt__H264Profile__Baseline: return "Baseline";
|
case tt__H264Profile__Main: return "Main";
|
case tt__H264Profile__Extended: return "Extended";
|
case tt__H264Profile__High: return "High";
|
}
|
return "unknown";
|
}
|
|
static void log_level_struct_tt__IntRange(unsigned int level, struct tt__IntRange *range)
|
{
|
if (NULL != range) {
|
log_level_val(level, "Min: ", log_int, &range->Min);
|
log_level_val(level, "Max: ", log_int, &range->Max);
|
}
|
}
|
|
static void log_level_struct_tt__VideoEncoderConfiguration(unsigned int level, struct tt__VideoEncoderConfiguration *vecfg)
|
{
|
if (NULL == vecfg) {
|
return;
|
}
|
|
log_level_val(level, "Name: ", log_str, vecfg->Name);
|
log_level_val(level, "UseCount: ", log_int, &vecfg->UseCount);
|
log_level_val(level, "token: ", log_str, vecfg->token);
|
log_level_val(level, "Encoding: ", log_str, dump_enum2str_VideoEncoding(vecfg->Encoding));
|
log_level_val(level, "Resolution: ", log_pos, vecfg->Resolution);
|
if (NULL != vecfg->Resolution) {
|
log_level_val(level + 1, "Width: ", log_int, &vecfg->Resolution->Width);
|
log_level_val(level + 1, "Height: ", log_int, &vecfg->Resolution->Height);
|
}
|
log_level_val(level, "Quality: ", log_float, &vecfg->Quality);
|
log_level_val(level, "RateControl: ", log_pos, vecfg->RateControl);
|
if (NULL != vecfg->RateControl) {
|
log_level_val(level + 1, "FrameRateLimit: ", log_int, &vecfg->RateControl->FrameRateLimit);
|
log_level_val(level + 1, "EncodingInterval: ", log_int, &vecfg->RateControl->EncodingInterval);
|
log_level_val(level + 1, "BitrateLimit: ", log_int, &vecfg->RateControl->BitrateLimit);
|
}
|
log_level_val(level, "MPEG4: ", log_pos, vecfg->MPEG4);
|
log_level_val(level, "H264: ", log_pos, vecfg->H264);
|
log_level_val(level, "Multicast: ", log_pos, vecfg->Multicast);
|
log_level_val(level, "SessionTimeout: ", log_int64, &vecfg->SessionTimeout);
|
}
|
|
static void log_level_struct_wsa__EndpointReferenceType(unsigned int level, struct wsa__EndpointReferenceType *a)
|
{
|
int i;
|
|
if (NULL == a) {
|
return;
|
}
|
|
log_level_val(level, "Address: ", log_str, a->Address);
|
log_level_val(level, "ReferenceProperties: ", log_pos, a->ReferenceProperties);
|
if (NULL != a->ReferenceProperties) {
|
log_level_val(level + 1, "__size: ", log_int, &a->ReferenceProperties->__size);
|
log_level_val(level + 1, "__any: ", log_pos, a->ReferenceProperties->__any);
|
for (i = 0; i < a->ReferenceProperties->__size; i++) {
|
log_level_val(level + 2, "", log_str, a->ReferenceProperties->__any[i]);
|
}
|
}
|
log_level_val(level, "ReferenceParameters: ", log_pos, a->ReferenceParameters);
|
if (NULL != a->ReferenceParameters) {
|
log_level_val(level + 1, "__size: ", log_int, &a->ReferenceParameters->__size);
|
log_level_val(level + 1, "__any: ", log_pos, a->ReferenceParameters->__any);
|
for (i = 0; i < a->ReferenceParameters->__size; i++) {
|
log_level_val(level + 2, "", log_str, a->ReferenceParameters->__any[i]);
|
}
|
}
|
log_level_val(level, "PortType: ", log_strp, a->PortType);
|
log_level_val(level, "ServiceName: ", log_pos, a->ServiceName);
|
if (NULL != a->ServiceName) {
|
log_level_val(level + 1, "ServiceName: ", log_str, a->ServiceName->__item);
|
log_level_val(level + 1, "PortName: ", log_str, a->ServiceName->PortName);
|
log_level_val(level + 1, "__anyAttribute: ",log_str, a->ServiceName->__anyAttribute);
|
}
|
log_level_val(level, "__size: ", log_int, &a->__size);
|
log_level_val(level, "__any: ", log_pos, a->__any);
|
for (i = 0; i < a->__size; i++) {
|
log_level_val(level + 1, "", log_str, a->__any[i]);
|
}
|
log_level_val(level, "__anyAttribute: ", log_str, a->__anyAttribute);
|
}
|
|
void dump__GetPresetsResponse(struct _tptz__GetPresetsResponse *rep)
|
{
|
int i;
|
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "sizePresets: ", log_int, &rep->__sizePreset);
|
log_level_val(0, "Presets: ", log_pos, rep->Preset);
|
for(i = 0; i < rep->__sizePreset; i++) {
|
struct tt__PTZPreset *Preset = &rep->Preset[i];
|
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "Name: ", log_str, Preset->Name);
|
log_level_val(2, "Token: ", log_str, Preset->token);
|
|
if (Preset->PTZPosition != NULL) {
|
if (Preset->PTZPosition->PanTilt != NULL) {
|
log_level_val(2, "p: ", log_float, &(Preset->PTZPosition->PanTilt->x));
|
log_level_val(2, "t: ", log_float, &(Preset->PTZPosition->PanTilt->y));
|
}
|
|
if (Preset->PTZPosition->Zoom != NULL) {
|
log_level_val(2, "z: ", log_float, &(Preset->PTZPosition->Zoom->x));
|
}
|
}
|
}
|
}
|
|
void dump__wsdd__ProbeMatches(struct __wsdd__ProbeMatches *rep)
|
{
|
int i;
|
struct wsdd__ProbeMatchType* probeMatch;
|
|
assert(NULL != rep);
|
log_func_in;
|
log_level_val(0, "wsdd__ProbeMatches: ", log_pos, rep->wsdd__ProbeMatches);
|
if (NULL != rep->wsdd__ProbeMatches) {
|
log_level_val(1, "__sizeProbeMatch: ", log_int, &rep->wsdd__ProbeMatches->__sizeProbeMatch);
|
log_level_val(1, "ProbeMatch: ", log_pos, &rep->wsdd__ProbeMatches->ProbeMatch);
|
for(i = 0; i < rep->wsdd__ProbeMatches->__sizeProbeMatch; i++) {
|
probeMatch = rep->wsdd__ProbeMatches->ProbeMatch + i;
|
log_level_fmt(2, "%d\n", i);
|
log_level_val(3, "wsa__EndpointReference: ", log_pos, &probeMatch->wsa__EndpointReference);
|
log_level_struct_wsa__EndpointReferenceType(4, &probeMatch->wsa__EndpointReference);
|
log_level_val(3, "Types: ", log_str, probeMatch->Types);
|
log_level_val(3, "Scopes: ", log_pos, probeMatch->Scopes);
|
if (NULL != probeMatch->Scopes) {
|
log_level_val(4, "__item: ", log_str, probeMatch->Scopes->__item);
|
log_level_val(4, "MatchBy: ", log_str, probeMatch->Scopes->MatchBy);
|
}
|
log_level_val(3, "XAddrs: ", log_str, probeMatch->XAddrs);
|
log_level_val(3, "MetadataVersion: ", log_int, &probeMatch->MetadataVersion);
|
}
|
}
|
log_func_out;
|
}
|
|
static void log_level_struct_tt__SystemCapabilities(unsigned int level, struct tt__SystemCapabilities *a)
|
{
|
int i;
|
if (NULL == a) {
|
return;
|
}
|
|
log_level_val(level, "DiscoveryResolve: ", log_bool, &a->DiscoveryResolve);
|
log_level_val(level, "DiscoveryBye: ", log_bool, &a->DiscoveryBye);
|
log_level_val(level, "RemoteDiscovery: ", log_bool, &a->RemoteDiscovery);
|
log_level_val(level, "SystemBackup: ", log_bool, &a->SystemBackup);
|
log_level_val(level, "SystemLogging: ", log_bool, &a->SystemLogging);
|
log_level_val(level, "FirmwareUpgrade: ", log_bool, &a->FirmwareUpgrade);
|
log_level_val(level, "__sizeSupportedVersions: ", log_int, &a->__sizeSupportedVersions);
|
log_level_val(level, "SupportedVersions: ", log_pos, a->SupportedVersions);
|
for (i = 0; i < a->__sizeSupportedVersions; i++) {
|
log_level_fmt(level + 1, "%d.%d\n", a->SupportedVersions[i].Major,
|
a->SupportedVersions[i].Minor);
|
}
|
}
|
|
static void log_level_struct_tt__DeviceCapabilities(unsigned int level, struct tt__DeviceCapabilities *a)
|
{
|
if (NULL == a) {
|
return;
|
}
|
|
log_level_val(level, "XAddr: ", log_str, a->XAddr);
|
log_level_val(level, "Network: ", log_pos, a->Network);
|
log_level_val(level, "System: ", log_pos, a->System);
|
log_level_struct_tt__SystemCapabilities(level + 1, a->System);
|
log_level_val(level, "IO: ", log_pos, a->IO);
|
log_level_val(level, "Security: ", log_pos, a->Security);
|
log_level_val(level, "Extension: ", log_pos, a->Extension);
|
}
|
|
static void log_level_struct_tt__MediaCapabilities(unsigned int level, struct tt__MediaCapabilities *a)
|
{
|
if (NULL == a) {
|
return;
|
}
|
|
log_level_val(level, "XAddr: ", log_str, a->XAddr);
|
log_level_val(level, "StreamingCapabilities: ", log_pos, a->StreamingCapabilities);
|
log_level_val(level, "Extension: ", log_pos, a->Extension);
|
}
|
|
void dump_tds__GetCapabilitiesResponse(struct _tds__GetCapabilitiesResponse *rep)
|
{
|
assert(NULL != rep);
|
log_func_in;
|
log_level_val(0, "Capabilities: ", log_pos, rep->Capabilities);
|
if (NULL != rep->Capabilities) {
|
log_level_val(1, "Analytics: ", log_pos, rep->Capabilities->Analytics);
|
if (NULL != rep->Capabilities->Analytics) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->Analytics->XAddr);
|
}
|
|
log_level_val(1, "Device: ", log_pos, rep->Capabilities->Device);
|
if (NULL != rep->Capabilities->Device) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->Device->XAddr);
|
}
|
|
log_level_val(1, "Events: ", log_pos, rep->Capabilities->Events);
|
if (NULL != rep->Capabilities->Events) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->Events->XAddr);
|
}
|
|
log_level_val(1, "Imaging: ", log_pos, rep->Capabilities->Imaging);
|
if (NULL != rep->Capabilities->Imaging) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->Imaging->XAddr);
|
}
|
|
log_level_val(1, "Media: ", log_pos, rep->Capabilities->Media);
|
if (NULL != rep->Capabilities->Media) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->Media->XAddr);
|
}
|
|
log_level_val(1, "PTZ: ", log_pos, rep->Capabilities->PTZ);
|
if (NULL != rep->Capabilities->PTZ) {
|
log_level_val(2, "XAddr: ", log_str, rep->Capabilities->PTZ->XAddr);
|
}
|
|
log_level_val(1, "Extension: ", log_pos, rep->Capabilities->Extension);
|
if (NULL != rep->Capabilities->Extension) {
|
log_level_val(2, "DeviceIO: ", log_pos, rep->Capabilities->Extension->DeviceIO);
|
if (NULL != rep->Capabilities->Extension->DeviceIO) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->DeviceIO->XAddr);
|
}
|
|
log_level_val(2, "Display: ", log_pos, rep->Capabilities->Extension->Display);
|
if (NULL != rep->Capabilities->Extension->Display) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->Display->XAddr);
|
}
|
|
log_level_val(2, "Recording: ", log_pos, rep->Capabilities->Extension->Recording);
|
if (NULL != rep->Capabilities->Extension->Recording) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->Recording->XAddr);
|
}
|
|
log_level_val(2, "Search: ", log_pos, rep->Capabilities->Extension->Search);
|
if (NULL != rep->Capabilities->Extension->Search) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->Search->XAddr);
|
}
|
|
log_level_val(2, "Replay: ", log_pos, rep->Capabilities->Extension->Replay);
|
if (NULL != rep->Capabilities->Extension->Replay) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->Replay->XAddr);
|
}
|
|
log_level_val(2, "Receiver: ", log_pos, rep->Capabilities->Extension->Receiver);
|
if (NULL != rep->Capabilities->Extension->Receiver) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->Receiver->XAddr);
|
}
|
|
log_level_val(2, "AnalyticsDevice: ", log_pos, rep->Capabilities->Extension->AnalyticsDevice);
|
if (NULL != rep->Capabilities->Extension->AnalyticsDevice) {
|
log_level_val(3, "XAddr: ", log_str, rep->Capabilities->Extension->AnalyticsDevice->XAddr);
|
}
|
}
|
}
|
log_func_out;
|
}
|
|
void dump_tds__GetDeviceInformationResponse(struct _tds__GetDeviceInformationResponse *rep)
|
{
|
assert(NULL != rep);
|
log_func_in;
|
log_val("Manufacturer: ", log_str, rep->Manufacturer);
|
log_val("Model: ", log_str, rep->Model);
|
log_val("Serial Number: ", log_str, rep->SerialNumber);
|
log_val("Hardware Id: ", log_str, rep->HardwareId);
|
log_val("Firmware Version: ", log_str, rep->FirmwareVersion);
|
log_func_out;
|
}
|
|
void dump_trt__GetProfilesResponse(struct _trt__GetProfilesResponse *rep)
|
{
|
int i;
|
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "sizeProfiles: ", log_int, &rep->__sizeProfiles);
|
log_level_val(0, "Profiles: ", log_pos, rep->Profiles);
|
for(i = 0; i < rep->__sizeProfiles; i++) {
|
struct tt__Profile *profiles = &rep->Profiles[i];
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "Name: ", log_str, profiles->Name);
|
log_level_val(2, "token: ", log_str, profiles->token);
|
log_level_val(2, "fixed: ", log_bool, profiles->fixed);
|
log_level_val(2, "VideoSourceConfiguration: ", log_pos, profiles->VideoSourceConfiguration);
|
if (NULL != profiles->VideoSourceConfiguration) {
|
struct tt__VideoSourceConfiguration *vsc = profiles->VideoSourceConfiguration;
|
|
log_level_val(3, "Name: ", log_str, vsc->Name);
|
log_level_val(3, "UseCount: ", log_int, &vsc->UseCount);
|
log_level_val(3, "token: ", log_str, vsc->token);
|
log_level_val(3, "SourceToken: ", log_str, vsc->SourceToken);
|
log_level_val(3, "Bounds: ", log_pos, vsc->Bounds);
|
if (NULL != vsc->Bounds) {
|
log_level_val(4, "x: ", log_int, &vsc->Bounds->x);
|
log_level_val(4, "y: ", log_int, &vsc->Bounds->y);
|
log_level_val(4, "width: ", log_int, &vsc->Bounds->width);
|
log_level_val(4, "height: ", log_int, &vsc->Bounds->height);
|
}
|
}
|
log_level_val(2, "VideoEncoderConfiguration: ", log_pos, profiles->VideoEncoderConfiguration);
|
if (NULL != profiles->VideoEncoderConfiguration) {
|
struct tt__VideoEncoderConfiguration *vec = profiles->VideoEncoderConfiguration;
|
log_level_val(3, "Name: ", log_str, vec->Name);
|
log_level_val(3, "UseCount: ", log_int, &vec->UseCount);
|
log_level_val(3, "token: ", log_str, vec->token);
|
log_level_val(3, "Encoding: ", log_str, dump_enum2str_VideoEncoding(vec->Encoding));
|
log_level_val(3, "Quality: ", log_float, &vec->Quality);
|
log_level_val(3, "Resolution: ", log_pos, vec->Resolution);
|
if (NULL != vec->Resolution) {
|
log_level_val(4, "Width: ", log_int, &vec->Resolution->Width);
|
log_level_val(4, "Height: ", log_int, &vec->Resolution->Height);
|
}
|
log_level_val(3, "RateControl: ",log_pos, vec->RateControl);
|
if (NULL != vec->RateControl) {
|
log_level_val(4, "FrameRateLimit: ", log_int, &vec->RateControl->FrameRateLimit);
|
log_level_val(4, "EncodingInterval: ", log_int, &vec->RateControl->EncodingInterval);
|
log_level_val(4, "BitrateLimit: ", log_int, &vec->RateControl->BitrateLimit);
|
}
|
}
|
log_level_val(2, "AudioSourceConfiguration: ", log_pos, profiles->AudioSourceConfiguration);
|
if (NULL != profiles->AudioSourceConfiguration) {
|
struct tt__AudioSourceConfiguration *asc = profiles->AudioSourceConfiguration;
|
log_level_val(3, "Name: ", log_str, asc->Name);
|
log_level_val(3, "UseCount: ", log_int, &asc->UseCount);
|
log_level_val(3, "token: ", log_str, asc->token);
|
log_level_val(3, "SourceToken: ", log_str, asc->SourceToken);
|
}
|
log_level_val(2, "AudioEncoderConfiguration: ", log_pos, profiles->AudioEncoderConfiguration);
|
if (NULL != profiles->AudioEncoderConfiguration) {
|
struct tt__AudioEncoderConfiguration *aec = profiles->AudioEncoderConfiguration;
|
log_level_val(3, "Name: ", log_str, aec->Name);
|
log_level_val(3, "UseCount: ", log_int, &aec->UseCount);
|
log_level_val(3, "token: ", log_str, aec->token);
|
log_level_val(3, "Bitrate: ", log_int, &aec->Bitrate);
|
log_level_val(3, "SampleRate: ", log_int, &aec->SampleRate);
|
log_level_val(3, "Encoding: ", log_str, dump_enum2str_AudioEncoding(aec->Encoding));
|
}
|
|
}
|
log_func_out;
|
}
|
|
void dump_trt__GetStreamUriResponse(struct _trt__GetStreamUriResponse *rep)
|
{
|
assert(NULL != rep);
|
log_func_in;
|
log_level_val(0, "MediaUri: ", log_pos, rep->MediaUri);
|
if (NULL != rep->MediaUri) {
|
log_level_val(1, "Uri: ", log_str, rep->MediaUri->Uri);
|
log_level_val(1, "InvalidAfterConnect: ", log_bool, &rep->MediaUri->InvalidAfterConnect);
|
log_level_val(1, "InvalidAfterReboot: ", log_bool, &rep->MediaUri->InvalidAfterReboot);
|
log_level_val(1, "Timeout: ", log_int64, &rep->MediaUri->Timeout);
|
}
|
log_func_out;
|
}
|
|
void dump_tds__GetServicesResponse(struct _tds__GetServicesResponse *rep)
|
{
|
int i;
|
|
assert(NULL != rep);
|
log_func_in;
|
log_level_val(0, "sizeService: ", log_int, &rep->__sizeService);
|
log_level_val(0, "Service: ", log_pos, rep->Service);
|
if (NULL != rep->Service) {
|
for(i = 0; i < rep->__sizeService; i++) {
|
struct tds__Service *s = rep->Service + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "Namespace: ", log_str, s->Namespace);
|
log_level_val(2, "XAddr: ", log_str, s->XAddr);
|
log_level_val(2, "Version: ", log_pos, s->Version);
|
if (NULL != s->Version) {
|
log_level_fmt(3, "%d.%d\n", s->Version->Major, s->Version->Minor);
|
}
|
}
|
}
|
log_func_out;
|
}
|
|
void dump_tds__GetSystemDateAndTime(struct _tds__GetSystemDateAndTimeResponse *rep)
|
{
|
struct tt__SystemDateTime *systm;
|
|
assert(NULL != rep);
|
assert(NULL != rep->SystemDateAndTime);
|
systm = rep->SystemDateAndTime;
|
|
log_func_in;
|
log_val("DateTimeType: ", log_int, &systm->DateTimeType);
|
log_val("DaylightSavings: ", log_int, &systm->DaylightSavings);
|
if (NULL == systm->TimeZone) {
|
log_val("TimeZone: ", log_pos, systm->TimeZone);
|
} else {
|
log_val("TimeZone: ", log_str, systm->TimeZone->TZ);
|
}
|
if (NULL == systm->UTCDateTime) {
|
log_val("UTCDateTime: ", log_pos, systm->UTCDateTime);
|
} else {
|
assert(NULL != systm->UTCDateTime->Date);
|
assert(NULL != systm->UTCDateTime->Time);
|
log_fmt("UTCDateTime: %04d-%02d-%02d %02d:%02d:%02d \n",
|
systm->UTCDateTime->Date->Year,
|
systm->UTCDateTime->Date->Month,
|
systm->UTCDateTime->Date->Day,
|
systm->UTCDateTime->Time->Hour,
|
systm->UTCDateTime->Time->Minute,
|
systm->UTCDateTime->Time->Second);
|
}
|
if (NULL == systm->LocalDateTime) {
|
log_val("LocalDateTime: ", log_pos, systm->LocalDateTime);
|
} else {
|
assert(NULL != systm->LocalDateTime->Date);
|
assert(NULL != systm->LocalDateTime->Time);
|
log_fmt("LocalDateTime: %04d-%02d-%02d %02d:%02d:%02d \n",
|
systm->LocalDateTime->Date->Year,
|
systm->LocalDateTime->Date->Month,
|
systm->LocalDateTime->Date->Day,
|
systm->LocalDateTime->Time->Hour,
|
systm->LocalDateTime->Time->Minute,
|
systm->LocalDateTime->Time->Second);
|
}
|
log_func_out;
|
}
|
|
void dump_trt__GetOSDOptions(struct _trt__GetOSDOptionsResponse *rep)
|
{
|
int i;
|
struct tt__OSDConfigurationOptions *p;
|
|
assert(NULL != rep);
|
assert(NULL != rep->OSDOptions);
|
p = rep->OSDOptions;
|
|
log_func_in;
|
|
log_level_val(0, "MaximumNumberOfOSDs: ", log_pos, p->MaximumNumberOfOSDs);
|
if (NULL != p->MaximumNumberOfOSDs) {
|
struct tt__MaximumNumberOfOSDs *m = p->MaximumNumberOfOSDs;
|
log_level_val(1, "Total: ", log_int, &(m->Total));
|
log_level_val(1, "Image: ", log_int, m->Image);
|
log_level_val(1, "PlainText: ", log_int, m->PlainText);
|
log_level_val(1, "Date: ", log_int, m->Date);
|
log_level_val(1, "Time: ", log_int, m->Time);
|
log_level_val(1, "DateAndTime: ", log_int, m->DateAndTime);
|
}
|
|
log_level_val(0, "sizeType: ", log_int, &p->__sizeType);
|
log_level_val(0, "Type: ", log_pos, p->Type);
|
for (i = 0; i < p->__sizeType; i++) {
|
log_level_fmt(1, "%s\n", dump_enum2str_OSDType(p->Type[i]));
|
}
|
|
log_level_val(0, "sizePositionOption: ", log_int, &p->__sizePositionOption);
|
log_level_val(0, "PositionOption: ", log_pos, p->PositionOption);
|
for (i = 0; i < p->__sizePositionOption; i++) {
|
log_level_fmt(1, "%s\n", p->PositionOption[i]);
|
}
|
|
log_level_val(0, "TextOption: ", log_pos, p->TextOption);
|
if (NULL != p->TextOption) {
|
struct tt__OSDTextOptions *to = p->TextOption;
|
log_level_val(1, "sizeType: ", log_int, &(to->__sizeType));
|
log_level_val(1, "Type: ", log_pos, to->Type);
|
for (i = 0; i < to->__sizeType; i++) {
|
log_level_fmt(2, "%s\n", to->Type[i]);
|
}
|
|
log_level_val(1, "FontSizeRange: ", log_pos, to->FontSizeRange);
|
log_level_struct_tt__IntRange(2, to->FontSizeRange);
|
|
log_level_val(1, "sizeDateFormat: ", log_int, &(to->__sizeDateFormat));
|
log_level_val(1, "DateFormat: ", log_pos, to->DateFormat);
|
for (i = 0; i < to->__sizeDateFormat; i++) {
|
log_level_fmt(2, "%s\n", to->DateFormat[i]);
|
}
|
|
log_level_val(1, "sizeTimeFormat: ", log_int, &(to->__sizeTimeFormat));
|
log_level_val(1, "TimeFormat: ", log_pos, to->TimeFormat);
|
for (i = 0; i < to->__sizeTimeFormat; i++) {
|
log_level_fmt(2, "%s\n", to->TimeFormat[i]);
|
}
|
|
log_level_val(1, "FontColor: ", log_pos, to->FontColor);
|
log_level_val(1, "BackgroundColor: ", log_pos, to->BackgroundColor);
|
}
|
|
log_level_val(0, "ImageOption: ", log_pos, p->ImageOption);
|
|
log_func_out;
|
}
|
|
void dump_trt__GetOSDs(struct _trt__GetOSDsResponse *rep)
|
{
|
int i;
|
assert(NULL != rep);
|
|
log_func_in;
|
log_level_val(0, "sizeOSDs: ", log_int, &rep->__sizeOSDs);
|
log_level_val(0, "OSDs: ", log_pos, rep->OSDs);
|
for (i = 0; i < rep->__sizeOSDs; i++) {
|
struct tt__OSDConfiguration *o = rep->OSDs + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "token: ", log_str, o->token);
|
log_level_val(2, "VideoSourceConfigurationToken: ", log_pos, o->VideoSourceConfigurationToken);
|
if (NULL != o->VideoSourceConfigurationToken) {
|
log_level_val(3, "item: ", log_str, o->VideoSourceConfigurationToken->__item);
|
}
|
|
log_level_val(2, "Type: ", log_str, dump_enum2str_OSDType(o->Type));
|
log_level_val(2, "Position: ", log_pos, o->Position);
|
if (NULL != o->Position) {
|
log_level_val(3, "Type: ", log_str, o->Position->Type);
|
log_level_val(3, "Pos: ", log_pos, o->Position->Pos);
|
if (NULL != o->Position->Pos) {
|
log_level_val(4, "x: ", log_float, o->Position->Pos->x);
|
log_level_val(4, "y: ", log_float, o->Position->Pos->y);
|
}
|
}
|
|
log_level_val(2, "TextString: ", log_pos, o->TextString);
|
if (NULL != o->TextString) {
|
log_level_val(3, "Type: ", log_str, o->TextString->Type);
|
log_level_val(3, "DateFormat: ", log_str, o->TextString->DateFormat);
|
log_level_val(3, "TimeFormat: ", log_str, o->TextString->TimeFormat);
|
log_level_val(3, "FontSize: ", log_int, o->TextString->FontSize);
|
log_level_val(3, "PlainText: ", log_str, o->TextString->PlainText);
|
log_level_val(3, "FontColor: ", log_pos, o->TextString->FontColor);
|
log_level_val(3, "BackgroundColor: ", log_pos, o->TextString->BackgroundColor);
|
}
|
|
log_level_val(2, "Image: ", log_pos, o->Image);
|
}
|
log_func_out;
|
}
|
|
void dump_trt__GetVideoSourcesResponse(struct _trt__GetVideoSourcesResponse *rep)
|
{
|
int i;
|
|
assert(NULL != rep);
|
|
log_func_in;
|
log_level_val(0, "sizeVideoSources: ", log_int, &rep->__sizeVideoSources);
|
log_level_val(0, "VideoSources: ", log_pos, rep->VideoSources);
|
for (i = 0; i < rep->__sizeVideoSources; i++) {
|
struct tt__VideoSource *vs = rep->VideoSources + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "token: ", log_str, vs->token);
|
log_level_val(2, "Framerate: ", log_float, &vs->Framerate);
|
log_level_val(2, "Resolution: ", log_pos, vs->Resolution);
|
log_level_val(3, "Width: ", log_int, &vs->Resolution->Width);
|
log_level_val(3, "Height: ", log_int, &vs->Resolution->Height);
|
log_level_val(2, "Imaging: ", log_pos, vs->Imaging);
|
log_level_val(2, "Extension: ", log_pos, vs->Extension);
|
}
|
log_func_out;
|
}
|
|
void dump_trt__GetVideoSourceConfigurationsResponse(struct _trt__GetVideoSourceConfigurationsResponse *rep)
|
{
|
int i;
|
|
assert(NULL != rep);
|
|
log_func_in;
|
log_level_val(0, "sizeConfigurations: ", log_int, &rep->__sizeConfigurations);
|
log_level_val(0, "Configurations: ", log_pos, rep->Configurations);
|
for (i = 0; i < rep->__sizeConfigurations; i++) {
|
struct tt__VideoSourceConfiguration *cfg = rep->Configurations + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "Name: ", log_str, cfg->Name);
|
log_level_val(2, "UseCount: ", log_int, &cfg->UseCount);
|
log_level_val(2, "token: ", log_str, cfg->token);
|
log_level_val(2, "SourceToken: ", log_str, cfg->SourceToken);
|
log_level_val(2, "Bounds: ", log_pos, cfg->Bounds);
|
log_level_val(3, "x: ", log_int, &cfg->Bounds->x);
|
log_level_val(3, "y: ", log_int, &cfg->Bounds->y);
|
log_level_val(3, "width: ", log_int, &cfg->Bounds->width);
|
log_level_val(3, "height: ", log_int, &cfg->Bounds->height);
|
log_level_val(2, "Extension: ", log_pos, cfg->Extension);
|
}
|
log_func_out;
|
}
|
|
void dump_trt__GetSnapshotUriResponse(struct _trt__GetSnapshotUriResponse *rep)
|
{
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "MediaUri: ", log_pos, rep->MediaUri);
|
if (NULL != rep->MediaUri) {
|
log_level_val(1, "Uri: ", log_str, rep->MediaUri->Uri);
|
log_level_val(1, "InvalidAfterConnect: ", log_bool, &rep->MediaUri->InvalidAfterConnect);
|
log_level_val(1, "InvalidAfterReboot: ", log_bool, &rep->MediaUri->InvalidAfterReboot);
|
log_level_val(1, "Timeout: ", log_int64, &rep->MediaUri->Timeout);
|
}
|
|
log_func_out;
|
}
|
|
void dump_tds__GetNetworkInterfaces(struct _tds__GetNetworkInterfacesResponse *rep)
|
{
|
int i, j;
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "sizeNetworkInterfaces: ", log_int, &rep->__sizeNetworkInterfaces);
|
log_level_val(0, "NetworkInterfaces: ", log_pos, rep->NetworkInterfaces);
|
for (i=0; i < rep->__sizeNetworkInterfaces; i++) {
|
struct tt__NetworkInterface *ni = rep->NetworkInterfaces + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_val(2, "token: ", log_str, ni->token);
|
log_level_val(2, "Enabled: ", log_bool, &ni->Enabled);
|
log_level_val(2, "Info: ", log_pos, ni->Info);
|
if (NULL != ni->Info) {
|
log_level_val(3, "Name: ", log_str, ni->Info->Name);
|
log_level_val(3, "HwAddress: ", log_str, ni->Info->HwAddress);
|
log_level_val(3, "MTU: ", log_int, ni->Info->MTU);
|
}
|
log_level_val(1, "Link: ", log_pos, ni->Link);
|
if (NULL != ni->Link) {
|
log_level_val(3, "AdminSettings: ", log_pos, ni->Link->AdminSettings);
|
if (NULL != ni->Link->AdminSettings) {
|
log_level_val(4, "AutoNegotiation: ", log_bool, &ni->Link->AdminSettings->AutoNegotiation);
|
log_level_val(4, "Speed: ", log_int, &ni->Link->AdminSettings->Speed);
|
log_level_val(4, "Duplex: ", log_int, &ni->Link->AdminSettings->Duplex);
|
}
|
log_level_val(3, "OperSettings: ", log_pos, ni->Link->OperSettings);
|
if (NULL != ni->Link->OperSettings) {
|
log_level_val(4, "AutoNegotiation: ", log_bool, &ni->Link->AdminSettings->AutoNegotiation);
|
log_level_val(4, "Speed: ", log_int, &ni->Link->AdminSettings->Speed);
|
log_level_val(4, "Duplex: ", log_int, &ni->Link->AdminSettings->Duplex);
|
}
|
log_level_val(3, "InterfaceType: ", log_int, &ni->Link->InterfaceType);
|
}
|
log_level_val(1, "IPv4: ", log_pos, ni->IPv4);
|
if (NULL != ni->IPv4) {
|
log_level_val(3, "Enabled: ", log_bool, &ni->IPv4->Enabled);
|
log_level_val(3, "Config: ", log_pos, ni->IPv4->Config);
|
if (NULL != ni->IPv4->Config) {
|
log_level_val(4, "sizeManual: ", log_int, &ni->IPv4->Config->__sizeManual);
|
log_level_val(4, "Manual: ", log_pos, ni->IPv4->Config->Manual);
|
for (j=0; j < ni->IPv4->Config->__sizeManual; j++) {
|
log_level_fmt(5, "%d\n", j);
|
log_level_val(6, "Address: ", log_str, ni->IPv4->Config->Manual[j].Address);
|
log_level_val(6, "PrefixLength: ", log_int, &ni->IPv4->Config->Manual[j].PrefixLength);
|
}
|
log_level_val(3, "LinkLocal: ", log_pos, ni->IPv4->Config->LinkLocal);
|
if (NULL != ni->IPv4->Config->LinkLocal) {
|
log_level_val(5, "Address: ", log_str, ni->IPv4->Config->LinkLocal->Address);
|
log_level_val(5, "PrefixLength: ", log_int, &ni->IPv4->Config->LinkLocal->PrefixLength);
|
}
|
log_level_val(3, "FromDHCP: ", log_pos, ni->IPv4->Config->FromDHCP);
|
if (NULL != ni->IPv4->Config->FromDHCP) {
|
log_level_val(5, "Address: ", log_str, ni->IPv4->Config->FromDHCP->Address);
|
log_level_val(5, "PrefixLength: ", log_int, &ni->IPv4->Config->FromDHCP->PrefixLength);
|
}
|
log_level_val(4, "DHCP: ", log_bool, &ni->IPv4->Config->DHCP);
|
}
|
log_level_val(1, "IPv6: ", log_pos, ni->IPv6);
|
if (NULL != ni->IPv6) {
|
log_level_val(3, "Enabled: ", log_bool, &ni->IPv6->Enabled);
|
log_level_val(3, "Config: ", log_pos, ni->IPv6->Config);
|
}
|
log_level_val(1, "Extension: ", log_pos, ni->Extension);
|
}
|
}
|
|
log_func_out;
|
}
|
|
void dump_trt__GetServiceCapabilitiesResponse(struct _trt__GetServiceCapabilitiesResponse *rep)
|
{
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "Capabilities: ", log_pos, rep->Capabilities);
|
if (NULL != rep->Capabilities) {
|
log_level_val(1, "ProfileCapabilities: ", log_pos, rep->Capabilities->ProfileCapabilities);
|
if (NULL != rep->Capabilities->ProfileCapabilities) {
|
log_level_val(2, "MaximumNumberOfProfiles: ", log_int, rep->Capabilities->ProfileCapabilities->MaximumNumberOfProfiles);
|
|
}
|
log_level_val(1, "StreamingCapabilities: ", log_pos, rep->Capabilities->StreamingCapabilities);
|
if (NULL != rep->Capabilities->StreamingCapabilities) {
|
log_level_val(2, "RTPMulticast: ", log_bool, rep->Capabilities->StreamingCapabilities->RTPMulticast);
|
log_level_val(2, "RTP_USCORETCP: ", log_bool, rep->Capabilities->StreamingCapabilities->RTP_USCORETCP);
|
log_level_val(2, "RTP_USCORERTSP_USCORETCP: ", log_bool, rep->Capabilities->StreamingCapabilities->RTP_USCORERTSP_USCORETCP);
|
log_level_val(2, "NonAggregateControl: ", log_bool, rep->Capabilities->StreamingCapabilities->NonAggregateControl);
|
log_level_val(2, "NoRTSPStreaming: ", log_bool, rep->Capabilities->StreamingCapabilities->NoRTSPStreaming);
|
}
|
log_level_val(1, "SnapshotUri: ", log_bool, rep->Capabilities->SnapshotUri);
|
log_level_val(1, "Rotation: ", log_bool, rep->Capabilities->Rotation);
|
log_level_val(1, "VideoSourceMode: ", log_bool, rep->Capabilities->VideoSourceMode);
|
log_level_val(1, "OSD: ", log_bool, rep->Capabilities->OSD);
|
log_level_val(1, "EXICompression: ", log_bool, rep->Capabilities->EXICompression);
|
}
|
|
log_func_out;
|
}
|
|
void dump_trt__GetVideoEncoderConfigurationResponse(struct _trt__GetVideoEncoderConfigurationResponse *rep)
|
{
|
assert(NULL != rep);
|
|
log_func_in;
|
log_level_struct_tt__VideoEncoderConfiguration(1, rep->Configuration);
|
log_func_out;
|
}
|
|
void dump_trt__GetVideoEncoderConfigurationsResponse(struct _trt__GetVideoEncoderConfigurationsResponse *rep)
|
{
|
int i;
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "__sizeConfigurations: ", log_int, &rep->__sizeConfigurations);
|
log_level_val(0, "Configurations: ", log_pos, rep->Configurations);
|
if (NULL != rep->Configurations) {
|
for (i=0; i < rep->__sizeConfigurations; i++) {
|
struct tt__VideoEncoderConfiguration *pcfg = rep->Configurations + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_struct_tt__VideoEncoderConfiguration(2, pcfg);
|
}
|
}
|
|
log_func_out;
|
}
|
|
void dump_trt__GetCompatibleVideoEncoderConfigurationsResponse(struct _trt__GetCompatibleVideoEncoderConfigurationsResponse *rep)
|
{
|
int i;
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "__sizeConfigurations: ", log_int, &rep->__sizeConfigurations);
|
log_level_val(0, "Configurations: ", log_pos, rep->Configurations);
|
if (NULL != rep->Configurations) {
|
for (i=0; i < rep->__sizeConfigurations; i++) {
|
struct tt__VideoEncoderConfiguration *pcfg = rep->Configurations + i;
|
log_level_fmt(1, "%d\n", i);
|
log_level_struct_tt__VideoEncoderConfiguration(2, pcfg);
|
}
|
}
|
|
log_func_out;
|
}
|
|
void dump_trt__GetVideoEncoderConfigurationOptionsResponse(struct _trt__GetVideoEncoderConfigurationOptionsResponse *rep)
|
{
|
int i;
|
assert(NULL != rep);
|
|
log_func_in;
|
|
log_level_val(0, "Options: ", log_pos, rep->Options);
|
if (NULL != rep->Options) {
|
log_level_val(1, "QualityRange: ", log_pos, rep->Options->QualityRange);
|
log_level_struct_tt__IntRange(2, rep->Options->QualityRange);
|
log_level_val(1, "JPEG: ", log_pos, rep->Options->JPEG);
|
log_level_val(1, "MPEG4: ", log_pos, rep->Options->MPEG4);
|
log_level_val(1, "H264: ", log_pos, rep->Options->H264);
|
if (NULL != rep->Options->H264) {
|
struct tt__H264Options *pH264 = rep->Options->H264;
|
log_level_val(2, "sizeResolutionsAvailable: ", log_int, &pH264->__sizeResolutionsAvailable);
|
log_level_val(2, "ResolutionsAvailable: ", log_pos, pH264->ResolutionsAvailable);
|
for (i = 0; i < pH264->__sizeResolutionsAvailable; i++) {
|
log_level_fmt(3, "%d * %d\n", pH264->ResolutionsAvailable[i].Width,
|
pH264->ResolutionsAvailable[i].Height);
|
}
|
log_level_val(2, "GovLengthRange: ", log_pos, pH264->GovLengthRange);
|
log_level_struct_tt__IntRange(3, pH264->GovLengthRange);
|
log_level_val(2, "FrameRateRange: ", log_pos, pH264->FrameRateRange);
|
log_level_struct_tt__IntRange(3, pH264->FrameRateRange);
|
log_level_val(2, "EncodingIntervalRange: ", log_pos, pH264->EncodingIntervalRange);
|
log_level_struct_tt__IntRange(3, pH264->EncodingIntervalRange);
|
log_level_val(2, "sizeH264ProfilesSupported: ", log_int, &pH264->__sizeH264ProfilesSupported);
|
log_level_val(2, "H264ProfilesSupported: ", log_pos, &pH264->H264ProfilesSupported);
|
for (i = 0; i < pH264->__sizeH264ProfilesSupported; i++) {
|
log_level_fmt(3, "%s\n", dump_enum2str_H264Profile(pH264->H264ProfilesSupported[i]));
|
}
|
}
|
log_level_val(1, "Extension: ", log_pos, rep->Options->Extension);
|
}
|
|
log_func_out;
|
}
|
#endif
|
|
