Update code by tizen coding convention.

Change-Id: I3a77e4dd6268d962bbabd4f1d953db4657c5e9c6
Signed-off-by: Sangkyu Park <sk1122.park@samsung.com>

diff --git a/include/mm_wfd_common_private.h b/include/mm_wfd_common_private.h
index 14f0247..ac4127e 100755 (executable)
--- a/include/mm_wfd_common_private.h
+++ b/include/mm_wfd_common_private.h
@@ -45,40 +45,40 @@ extern "C" {
 #define FONT_COLOR_GRAY     "\033[37m"
 
 #define wfd_debug(fmt, arg...) do { \
-                       LOGD(FONT_COLOR_RESET""fmt"", ##arg);     \
-               } while (0)
+               LOGD(FONT_COLOR_RESET""fmt"", ##arg);     \
+       } while (0)
 
 #define wfd_info(fmt, arg...) do { \
-                       LOGI(FONT_COLOR_GREEN""fmt""FONT_COLOR_RESET, ##arg);     \
-               } while (0)
+               LOGI(FONT_COLOR_GREEN""fmt""FONT_COLOR_RESET, ##arg);     \
+       } while (0)
 
 #define wfd_error(fmt, arg...) do { \
-                       LOGE(FONT_COLOR_RED""fmt""FONT_COLOR_RESET, ##arg);     \
-               } while (0)
+               LOGE(FONT_COLOR_RED""fmt""FONT_COLOR_RESET, ##arg);     \
+       } while (0)
 
 #define wfd_warning(fmt, arg...) do { \
-                       LOGW(FONT_COLOR_YELLOW""fmt""FONT_COLOR_RESET, ##arg);     \
-               } while (0)
+               LOGW(FONT_COLOR_YELLOW""fmt""FONT_COLOR_RESET, ##arg);     \
+       } while (0)
 
 #define wfd_debug_fenter() do { \
-                       LOGD(FONT_COLOR_RESET"<Enter>");     \
-               } while (0)
+               LOGD(FONT_COLOR_RESET"<Enter>");     \
+       } while (0)
 
 #define wfd_debug_fleave() do { \
-                       LOGD(FONT_COLOR_RESET"<Leave>");     \
-               } while (0)
+               LOGD(FONT_COLOR_RESET"<Leave>");     \
+       } while (0)
 
 #define wfd_error_fenter() do { \
-                       LOGE(FONT_COLOR_RESET"NO-ERROR : <Enter>");     \
-               } while (0)
+               LOGE(FONT_COLOR_RESET"NO-ERROR : <Enter>");     \
+       } while (0)
 
 #define wfd_error_fleave() do { \
-                       LOGE(FONT_COLOR_RESET"NO-ERROR : <Leave>");     \
-               } while (0)
+               LOGE(FONT_COLOR_RESET"NO-ERROR : <Leave>");     \
+       } while (0)
 
 #define wfd_sucure_info(fmt, arg...) do { \
-                       SECURE_LOGI(FONT_COLOR_GREEN""fmt""FONT_COLOR_RESET, ##arg);     \
-               } while (0)
+               SECURE_LOGI(FONT_COLOR_GREEN""fmt""FONT_COLOR_RESET, ##arg);     \
+       } while (0)
 
 #ifdef __cplusplus
 }

diff --git a/packaging/libmm-scmirroring-common.spec b/packaging/libmm-scmirroring-common.spec
index 056114a..66252cd 100755 (executable)
--- a/packaging/libmm-scmirroring-common.spec
+++ b/packaging/libmm-scmirroring-common.spec
@@ -1,6 +1,6 @@
 Name:       libmm-scmirroring-common
 Summary:    Multimedia Framework Wifi-Display Common Library
-Version:    0.0.36
+Version:    0.0.37
 Release:    0
 Group:      System/Libraries
 License:    Apache License 2.0

diff --git a/wfdconfig/include/wfdconfigmessage.h b/wfdconfig/include/wfdconfigmessage.h
index d02d597..afabba3 100755 (executable)
--- a/wfdconfig/include/wfdconfigmessage.h
+++ b/wfdconfig/include/wfdconfigmessage.h
@@ -35,312 +35,312 @@ G_BEGIN_DECLS
  * Return values for the WFD_CONFIG functions.
  */
 typedef enum {
-  WFD_OK     = 0,
-  WFD_EINVAL = -1,
-  WFD_NOT_IMPLEMENTED = -2,
-  WFD_NOT_SUPPORTED = -3
+       WFD_OK     = 0,
+       WFD_EINVAL = -1,
+       WFD_NOT_IMPLEMENTED = -2,
+       WFD_NOT_SUPPORTED = -3
 } WFDResult;
 
 typedef enum {
-  WFD_AUDIO_UNKNOWN    = 0,
-  WFD_AUDIO_LPCM               = (1 << 0),
-  WFD_AUDIO_AAC                = (1 << 1),
-  WFD_AUDIO_AC3                = (1 << 2)
-}WFDAudioFormats;
+       WFD_AUDIO_UNKNOWN       = 0,
+       WFD_AUDIO_LPCM          = (1 << 0),
+       WFD_AUDIO_AAC           = (1 << 1),
+       WFD_AUDIO_AC3           = (1 << 2)
+} WFDAudioFormats;
 
 typedef enum {
-  WFD_FREQ_UNKNOWN = 0,
-  WFD_FREQ_44100        = (1 << 0),
-  WFD_FREQ_48000        = (1 << 1)
-}WFDAudioFreq;
+       WFD_FREQ_UNKNOWN = 0,
+       WFD_FREQ_44100   = (1 << 0),
+       WFD_FREQ_48000   = (1 << 1)
+} WFDAudioFreq;
 
 typedef enum {
-  WFD_CHANNEL_UNKNOWN = 0,
-  WFD_CHANNEL_2                = (1 << 0),
-  WFD_CHANNEL_4                = (1 << 1),
-  WFD_CHANNEL_6                = (1 << 2),
-  WFD_CHANNEL_8                = (1 << 3)
-}WFDAudioChannels;
+       WFD_CHANNEL_UNKNOWN = 0,
+       WFD_CHANNEL_2           = (1 << 0),
+       WFD_CHANNEL_4           = (1 << 1),
+       WFD_CHANNEL_6           = (1 << 2),
+       WFD_CHANNEL_8           = (1 << 3)
+} WFDAudioChannels;
 
 
 typedef enum {
-  WFD_VIDEO_UNKNOWN = 0,
-  WFD_VIDEO_H264         = (1 << 0)
-}WFDVideoCodecs;
+       WFD_VIDEO_UNKNOWN = 0,
+       WFD_VIDEO_H264    = (1 << 0)
+} WFDVideoCodecs;
 
 typedef enum {
-  WFD_VIDEO_CEA_RESOLUTION = 0,
-  WFD_VIDEO_VESA_RESOLUTION,
-  WFD_VIDEO_HH_RESOLUTION
-}WFDVideoNativeResolution;
+       WFD_VIDEO_CEA_RESOLUTION = 0,
+       WFD_VIDEO_VESA_RESOLUTION,
+       WFD_VIDEO_HH_RESOLUTION
+} WFDVideoNativeResolution;
 
 typedef enum {
-  WFD_CEA_UNKNOWN              = 0,
-  WFD_CEA_640x480P60   = (1 << 0),
-  WFD_CEA_720x480P60   = (1 << 1),
-  WFD_CEA_720x480I60   = (1 << 2),
-  WFD_CEA_720x576P50   = (1 << 3),
-  WFD_CEA_720x576I50   = (1 << 4),
-  WFD_CEA_1280x720P30  = (1 << 5),
-  WFD_CEA_1280x720P60  = (1 << 6),
-  WFD_CEA_1920x1080P30= (1 << 7),
-  WFD_CEA_1920x1080P60= (1 << 8),
-  WFD_CEA_1920x1080I60= (1 << 9),
-  WFD_CEA_1280x720P25  = (1 << 10),
-  WFD_CEA_1280x720P50  = (1 << 11),
-  WFD_CEA_1920x1080P25= (1 << 12),
-  WFD_CEA_1920x1080P50= (1 << 13),
-  WFD_CEA_1920x1080I50= (1 << 14),
-  WFD_CEA_1280x720P24  = (1 << 15),
-  WFD_CEA_1920x1080P24= (1 << 16)
-}WFDVideoCEAResolution;
+       WFD_CEA_UNKNOWN         = 0,
+       WFD_CEA_640x480P60      = (1 << 0),
+       WFD_CEA_720x480P60      = (1 << 1),
+       WFD_CEA_720x480I60      = (1 << 2),
+       WFD_CEA_720x576P50      = (1 << 3),
+       WFD_CEA_720x576I50      = (1 << 4),
+       WFD_CEA_1280x720P30     = (1 << 5),
+       WFD_CEA_1280x720P60     = (1 << 6),
+       WFD_CEA_1920x1080P30 = (1 << 7),
+       WFD_CEA_1920x1080P60 = (1 << 8),
+       WFD_CEA_1920x1080I60 = (1 << 9),
+       WFD_CEA_1280x720P25     = (1 << 10),
+       WFD_CEA_1280x720P50     = (1 << 11),
+       WFD_CEA_1920x1080P25 = (1 << 12),
+       WFD_CEA_1920x1080P50 = (1 << 13),
+       WFD_CEA_1920x1080I50 = (1 << 14),
+       WFD_CEA_1280x720P24     = (1 << 15),
+       WFD_CEA_1920x1080P24 = (1 << 16)
+} WFDVideoCEAResolution;
 
 typedef enum {
-  WFD_VESA_UNKNOWN             = 0,
-  WFD_VESA_800x600P30  = (1 << 0),
-  WFD_VESA_800x600P60          = (1 << 1),
-  WFD_VESA_1024x768P30 = (1 << 2),
-  WFD_VESA_1024x768P60 = (1 << 3),
-  WFD_VESA_1152x864P30 = (1 << 4),
-  WFD_VESA_1152x864P60 = (1 << 5),
-  WFD_VESA_1280x768P30 = (1 << 6),
-  WFD_VESA_1280x768P60 = (1 << 7),
-  WFD_VESA_1280x800P30 = (1 << 8),
-  WFD_VESA_1280x800P60 = (1 << 9),
-  WFD_VESA_1360x768P30 = (1 << 10),
-  WFD_VESA_1360x768P60 = (1 << 11),
-  WFD_VESA_1366x768P30 = (1 << 12),
-  WFD_VESA_1366x768P60 = (1 << 13),
-  WFD_VESA_1280x1024P30        = (1 << 14),
-  WFD_VESA_1280x1024P60        = (1 << 15),
-  WFD_VESA_1400x1050P30        = (1 << 16),
-  WFD_VESA_1400x1050P60        = (1 << 17),
-  WFD_VESA_1440x900P30 = (1 << 18),
-  WFD_VESA_1440x900P60 = (1 << 19),
-  WFD_VESA_1600x900P30 = (1 << 20),
-  WFD_VESA_1600x900P60 = (1 << 21),
-  WFD_VESA_1600x1200P30        = (1 << 22),
-  WFD_VESA_1600x1200P60        = (1 << 23),
-  WFD_VESA_1680x1024P30        = (1 << 24),
-  WFD_VESA_1680x1024P60        = (1 << 25),
-  WFD_VESA_1680x1050P30        = (1 << 26),
-  WFD_VESA_1680x1050P60        = (1 << 27),
-  WFD_VESA_1920x1200P30        = (1 << 28),
-  WFD_VESA_1920x1200P60        = (1 << 29)
-}WFDVideoVESAResolution;
+       WFD_VESA_UNKNOWN                = 0,
+       WFD_VESA_800x600P30     = (1 << 0),
+       WFD_VESA_800x600P60             = (1 << 1),
+       WFD_VESA_1024x768P30    = (1 << 2),
+       WFD_VESA_1024x768P60    = (1 << 3),
+       WFD_VESA_1152x864P30    = (1 << 4),
+       WFD_VESA_1152x864P60    = (1 << 5),
+       WFD_VESA_1280x768P30    = (1 << 6),
+       WFD_VESA_1280x768P60    = (1 << 7),
+       WFD_VESA_1280x800P30    = (1 << 8),
+       WFD_VESA_1280x800P60    = (1 << 9),
+       WFD_VESA_1360x768P30    = (1 << 10),
+       WFD_VESA_1360x768P60    = (1 << 11),
+       WFD_VESA_1366x768P30    = (1 << 12),
+       WFD_VESA_1366x768P60    = (1 << 13),
+       WFD_VESA_1280x1024P30   = (1 << 14),
+       WFD_VESA_1280x1024P60   = (1 << 15),
+       WFD_VESA_1400x1050P30   = (1 << 16),
+       WFD_VESA_1400x1050P60   = (1 << 17),
+       WFD_VESA_1440x900P30    = (1 << 18),
+       WFD_VESA_1440x900P60    = (1 << 19),
+       WFD_VESA_1600x900P30    = (1 << 20),
+       WFD_VESA_1600x900P60    = (1 << 21),
+       WFD_VESA_1600x1200P30   = (1 << 22),
+       WFD_VESA_1600x1200P60   = (1 << 23),
+       WFD_VESA_1680x1024P30   = (1 << 24),
+       WFD_VESA_1680x1024P60   = (1 << 25),
+       WFD_VESA_1680x1050P30   = (1 << 26),
+       WFD_VESA_1680x1050P60   = (1 << 27),
+       WFD_VESA_1920x1200P30   = (1 << 28),
+       WFD_VESA_1920x1200P60   = (1 << 29)
+} WFDVideoVESAResolution;
 
 typedef enum {
-  WFD_HH_UNKNOWN               = 0,
-  WFD_HH_800x480P30    = (1 << 0),
-  WFD_HH_800x480P60    = (1 << 1),
-  WFD_HH_854x480P30    = (1 << 2),
-  WFD_HH_854x480P60    = (1 << 3),
-  WFD_HH_864x480P30    = (1 << 4),
-  WFD_HH_864x480P60    = (1 << 5),
-  WFD_HH_640x360P30    = (1 << 6),
-  WFD_HH_640x360P60    = (1 << 7),
-  WFD_HH_960x540P30    = (1 << 8),
-  WFD_HH_960x540P60    = (1 << 9),
-  WFD_HH_848x480P30    = (1 << 10),
-  WFD_HH_848x480P60    = (1 << 11)
-}WFDVideoHHResolution;
+       WFD_HH_UNKNOWN          = 0,
+       WFD_HH_800x480P30       = (1 << 0),
+       WFD_HH_800x480P60       = (1 << 1),
+       WFD_HH_854x480P30       = (1 << 2),
+       WFD_HH_854x480P60       = (1 << 3),
+       WFD_HH_864x480P30       = (1 << 4),
+       WFD_HH_864x480P60       = (1 << 5),
+       WFD_HH_640x360P30       = (1 << 6),
+       WFD_HH_640x360P60       = (1 << 7),
+       WFD_HH_960x540P30       = (1 << 8),
+       WFD_HH_960x540P60       = (1 << 9),
+       WFD_HH_848x480P30       = (1 << 10),
+       WFD_HH_848x480P60       = (1 << 11)
+} WFDVideoHHResolution;
 
 typedef enum {
-  WFD_H264_UNKNOWN_PROFILE= 0,
-  WFD_H264_BASE_PROFILE        = (1 << 0),
-  WFD_H264_HIGH_PROFILE        = (1 << 1)
-}WFDVideoH264Profile;
+       WFD_H264_UNKNOWN_PROFILE = 0,
+       WFD_H264_BASE_PROFILE   = (1 << 0),
+       WFD_H264_HIGH_PROFILE   = (1 << 1)
+} WFDVideoH264Profile;
 
 typedef enum {
-  WFD_H264_LEVEL_UNKNOWN = 0,
-  WFD_H264_LEVEL_3_1   = (1 << 0),
-  WFD_H264_LEVEL_3_2   = (1 << 1),
-  WFD_H264_LEVEL_4       = (1 << 2),
-  WFD_H264_LEVEL_4_1   = (1 << 3),
-  WFD_H264_LEVEL_4_2   = (1 << 4)
-}WFDVideoH264Level;
+       WFD_H264_LEVEL_UNKNOWN = 0,
+       WFD_H264_LEVEL_3_1   = (1 << 0),
+       WFD_H264_LEVEL_3_2   = (1 << 1),
+       WFD_H264_LEVEL_4       = (1 << 2),
+       WFD_H264_LEVEL_4_1   = (1 << 3),
+       WFD_H264_LEVEL_4_2   = (1 << 4)
+} WFDVideoH264Level;
 
 typedef enum {
-  WFD_HDCP_NONE        = 0,
-  WFD_HDCP_2_0 = (1 << 0),
-  WFD_HDCP_2_1 = (1 << 1)
-}WFDHDCPProtection;
+       WFD_HDCP_NONE   = 0,
+       WFD_HDCP_2_0    = (1 << 0),
+       WFD_HDCP_2_1    = (1 << 1)
+} WFDHDCPProtection;
 
 typedef enum {
-  WFD_SINK_UNKNOWN = -1,
-  WFD_SINK_NOT_COUPLED = 0,
-  WFD_SINK_COUPLED,
-  WFD_SINK_TEARDOWN_COUPLING,
-  WFD_SINK_RESERVED
-}WFDCoupledSinkStatus;
+       WFD_SINK_UNKNOWN = -1,
+       WFD_SINK_NOT_COUPLED    = 0,
+       WFD_SINK_COUPLED,
+       WFD_SINK_TEARDOWN_COUPLING,
+       WFD_SINK_RESERVED
+} WFDCoupledSinkStatus;
 
 typedef enum {
-  WFD_TRIGGER_UNKNOWN = 0,
-  WFD_TRIGGER_SETUP,
-  WFD_TRIGGER_PAUSE,
-  WFD_TRIGGER_TEARDOWN,
-  WFD_TRIGGER_PLAY
-}WFDTrigger;
+       WFD_TRIGGER_UNKNOWN = 0,
+       WFD_TRIGGER_SETUP,
+       WFD_TRIGGER_PAUSE,
+       WFD_TRIGGER_TEARDOWN,
+       WFD_TRIGGER_PLAY
+} WFDTrigger;
 
 typedef enum {
-  WFD_RTSP_TRANS_UNKNOWN =  0,
-  WFD_RTSP_TRANS_RTP     = (1 << 0),
-  WFD_RTSP_TRANS_RDT     = (1 << 1)
+       WFD_RTSP_TRANS_UNKNOWN =  0,
+       WFD_RTSP_TRANS_RTP     = (1 << 0),
+       WFD_RTSP_TRANS_RDT     = (1 << 1)
 } WFDRTSPTransMode;
 
 typedef enum {
-  WFD_RTSP_PROFILE_UNKNOWN =  0,
-  WFD_RTSP_PROFILE_AVP     = (1 << 0),
-  WFD_RTSP_PROFILE_SAVP    = (1 << 1)
+       WFD_RTSP_PROFILE_UNKNOWN =  0,
+       WFD_RTSP_PROFILE_AVP     = (1 << 0),
+       WFD_RTSP_PROFILE_SAVP    = (1 << 1)
 } WFDRTSPProfile;
 
 typedef enum {
-  WFD_RTSP_LOWER_TRANS_UNKNOWN   = 0,
-  WFD_RTSP_LOWER_TRANS_UDP       = (1 << 0),
-  WFD_RTSP_LOWER_TRANS_UDP_MCAST = (1 << 1),
-  WFD_RTSP_LOWER_TRANS_TCP       = (1 << 2),
-  WFD_RTSP_LOWER_TRANS_HTTP      = (1 << 3)
+       WFD_RTSP_LOWER_TRANS_UNKNOWN   = 0,
+       WFD_RTSP_LOWER_TRANS_UDP       = (1 << 0),
+       WFD_RTSP_LOWER_TRANS_UDP_MCAST = (1 << 1),
+       WFD_RTSP_LOWER_TRANS_TCP       = (1 << 2),
+       WFD_RTSP_LOWER_TRANS_HTTP      = (1 << 3)
 } WFDRTSPLowerTrans;
 
 typedef enum {
-  WFD_PRIMARY_SINK   = 0,
-  WFD_SECONDARY_SINK
-}WFDSinkType;
+       WFD_PRIMARY_SINK   = 0,
+       WFD_SECONDARY_SINK
+} WFDSinkType;
 
 typedef enum {
-  WFD_UIBC_INPUT_CAT_UNKNOWN   = 0,
-  WFD_UIBC_INPUT_CAT_GENERIC   = (1 << 0),
-  WFD_UIBC_INPUT_CAT_HIDC      = (1 << 1),
-}WFDUibcinput_cat;
+       WFD_UIBC_INPUT_CAT_UNKNOWN   = 0,
+       WFD_UIBC_INPUT_CAT_GENERIC   = (1 << 0),
+       WFD_UIBC_INPUT_CAT_HIDC      = (1 << 1),
+} WFDUibcinput_cat;
 
 typedef enum {
-  WFD_UIBC_INPUT_TYPE_UNKNOWN        = 0,
-  WFD_UIBC_INPUT_TYPE_KEYBOARD       = (1 << 0),
-  WFD_UIBC_INPUT_TYPE_MOUSE          = (1 << 1),
-  WFD_UIBC_INPUT_TYPE_SINGLETOUCH    = (1 << 2),
-  WFD_UIBC_INPUT_TYPE_MULTITOUCH     = (1 << 3),
-  WFD_UIBC_INPUT_TYPE_JOYSTICK       = (1 << 4),
-  WFD_UIBC_INPUT_TYPE_CAMERA         = (1 << 5),
-  WFD_UIBC_INPUT_TYPE_GESTURE        = (1 << 6),
-  WFD_UIBC_INPUT_TYPE_REMOTECONTROL  = (1 << 7)
-}WFDUibcinp_type;
+       WFD_UIBC_INPUT_TYPE_UNKNOWN        = 0,
+       WFD_UIBC_INPUT_TYPE_KEYBOARD       = (1 << 0),
+       WFD_UIBC_INPUT_TYPE_MOUSE          = (1 << 1),
+       WFD_UIBC_INPUT_TYPE_SINGLETOUCH    = (1 << 2),
+       WFD_UIBC_INPUT_TYPE_MULTITOUCH     = (1 << 3),
+       WFD_UIBC_INPUT_TYPE_JOYSTICK       = (1 << 4),
+       WFD_UIBC_INPUT_TYPE_CAMERA         = (1 << 5),
+       WFD_UIBC_INPUT_TYPE_GESTURE        = (1 << 6),
+       WFD_UIBC_INPUT_TYPE_REMOTECONTROL  = (1 << 7)
+} WFDUibcinp_type;
 
 typedef enum {
-  WFD_UIBC_INPUT_PATH_UNKNOWN   = 0,
-  WFD_UIBC_INPUT_PATH_INFRARED  = (1 << 0),
-  WFD_UIBC_INPUT_PATH_USB       = (1 << 1),
-  WFD_UIBC_INPUT_PATH_BT        = (1 << 2),
-  WFD_UIBC_INPUT_PATH_ZIGBEE    = (1 << 3),
-  WFD_UIBC_INPUT_PATH_WIFI      = (1 << 4),
-  WFD_UIBC_INPUT_PATH_NOSP      = (1 << 5)
-}WFDUibcinp_path;
+       WFD_UIBC_INPUT_PATH_UNKNOWN   = 0,
+       WFD_UIBC_INPUT_PATH_INFRARED  = (1 << 0),
+       WFD_UIBC_INPUT_PATH_USB       = (1 << 1),
+       WFD_UIBC_INPUT_PATH_BT        = (1 << 2),
+       WFD_UIBC_INPUT_PATH_ZIGBEE    = (1 << 3),
+       WFD_UIBC_INPUT_PATH_WIFI      = (1 << 4),
+       WFD_UIBC_INPUT_PATH_NOSP      = (1 << 5)
+} WFDUibcinp_path;
 
 typedef enum {
-  WFD_CONNECTOR_VGA           = 0,
-  WFD_CONNECTOR_S,
-  WFD_CONNECTOR_COMPOSITE,
-  WFD_CONNECTOR_COMPONENT,
-  WFD_CONNECTOR_DVI,
-  WFD_CONNECTOR_HDMI,
-  WFD_CONNECTOR_LVDS,
-  WFD_CONNECTOR_RESERVED_7,
-  WFD_CONNECTOR_JAPANESE_D,
-  WFD_CONNECTOR_SDI,
-  WFD_CONNECTOR_DP,
-  WFD_CONNECTOR_RESERVED_11,
-  WFD_CONNECTOR_UDI,
-  WFD_CONNECTOR_NO           = 254,
-  WFD_CONNECTOR_PHYSICAL     = 255
-}WFDConnector;
-
-
-typedef struct {
-  gchar        *audio_format;
-  guint32 modes;
-  guint latency;
+       WFD_CONNECTOR_VGA           = 0,
+       WFD_CONNECTOR_S,
+       WFD_CONNECTOR_COMPOSITE,
+       WFD_CONNECTOR_COMPONENT,
+       WFD_CONNECTOR_DVI,
+       WFD_CONNECTOR_HDMI,
+       WFD_CONNECTOR_LVDS,
+       WFD_CONNECTOR_RESERVED_7,
+       WFD_CONNECTOR_JAPANESE_D,
+       WFD_CONNECTOR_SDI,
+       WFD_CONNECTOR_DP,
+       WFD_CONNECTOR_RESERVED_11,
+       WFD_CONNECTOR_UDI,
+       WFD_CONNECTOR_NO           = 254,
+       WFD_CONNECTOR_PHYSICAL     = 255
+} WFDConnector;
+
+
+typedef struct {
+       gchar   *audio_format;
+       guint32 modes;
+       guint latency;
 } WFDAudioCodec;
 
 typedef struct {
-  guint        count;
-  WFDAudioCodec *list;
+       guint   count;
+       WFDAudioCodec *list;
 } WFDAudioCodeclist;
 
 
 typedef struct {
-  guint CEA_Support;
-  guint VESA_Support;
-  guint HH_Support;
-  guint latency;
-  guint min_slice_size;
-  guint slice_enc_params;
-  guint frame_rate_control_support;
+       guint CEA_Support;
+       guint VESA_Support;
+       guint HH_Support;
+       guint latency;
+       guint min_slice_size;
+       guint slice_enc_params;
+       guint frame_rate_control_support;
 } WFDVideoH264MiscParams;
 
 typedef struct {
-  guint profile;
-  guint level;
-  guint max_hres;
-  guint max_vres;
-  WFDVideoH264MiscParams misc_params;
+       guint profile;
+       guint level;
+       guint max_hres;
+       guint max_vres;
+       WFDVideoH264MiscParams misc_params;
 } WFDVideoH264Codec;
 
 typedef struct {
-  guint        native;
-  guint preferred_display_mode_supported;
-  WFDVideoH264Codec H264_codec;
+       guint   native;
+       guint preferred_display_mode_supported;
+       WFDVideoH264Codec H264_codec;
 } WFDVideoCodec;
 
 typedef struct {
-  guint                        count;
-  WFDVideoCodec *list;
+       guint                   count;
+       WFDVideoCodec *list;
 } WFDVideoCodeclist;
 
 typedef struct {
-  guint video_3d_capability;
-  guint latency;
-  guint min_slice_size;
-  guint slice_enc_params;
-  guint frame_rate_control_support;
+       guint video_3d_capability;
+       guint latency;
+       guint min_slice_size;
+       guint slice_enc_params;
+       guint frame_rate_control_support;
 } WFD3DVideoH264MiscParams;
 
 typedef struct {
-  guint profile;
-  guint level;
-  WFD3DVideoH264MiscParams misc_params;
-  guint max_hres;
-  guint max_vres;
+       guint profile;
+       guint level;
+       WFD3DVideoH264MiscParams misc_params;
+       guint max_hres;
+       guint max_vres;
 } WFD3DVideoH264Codec;
 
 typedef struct {
-  guint native;
-  guint preferred_display_mode_supported;
-  WFD3DVideoH264Codec H264_codec;
+       guint native;
+       guint preferred_display_mode_supported;
+       WFD3DVideoH264Codec H264_codec;
 } WFD3dCapList;
 
 typedef struct {
-  guint                        count;
-  WFD3dCapList *list;
+       guint                   count;
+       WFD3dCapList *list;
 } WFD3DFormats;
 
 typedef struct {
-  gchar *hdcpversion;
-  gchar *TCPPort;
+       gchar *hdcpversion;
+       gchar *TCPPort;
 } WFDHdcp2Spec;
 
 typedef struct {
-  WFDHdcp2Spec *hdcp2_spec;
+       WFDHdcp2Spec *hdcp2_spec;
 } WFDContentProtection;
 
 typedef struct {
-  guint edid_supported;
-  guint edid_block_count;
-  gchar *edid_payload;
+       guint edid_supported;
+       guint edid_block_count;
+       gchar *edid_payload;
 } WFDDisplayEdid;
 
 
 typedef struct {
-  guint status;
-  gchar *sink_address;
+       guint status;
+       gchar *sink_address;
 } WFDCoupled_sink_cap;
 
 typedef struct {
@@ -348,180 +348,180 @@ typedef struct {
 } WFDCoupledSink;
 
 typedef struct {
-  gchar *wfd_trigger_method;
+       gchar *wfd_trigger_method;
 } WFDTriggerMethod;
 
 typedef struct {
-  gchar *wfd_url0;
-  gchar *wfd_url1;
+       gchar *wfd_url0;
+       gchar *wfd_url1;
 } WFDPresentationUrl;
 
 typedef struct {
-  gchar *profile;
-  guint32 rtp_port0;
-  guint32 rtp_port1;
-  gchar *mode;
+       gchar *profile;
+       guint32 rtp_port0;
+       guint32 rtp_port1;
+       gchar *mode;
 } WFDClientRtpPorts;
 
 typedef struct {
- gchar *destination;
+       gchar *destination;
 } WFDRoute;
 
 typedef struct {
-  gboolean I2CPresent;
-  guint32 I2C_port;
+       gboolean I2CPresent;
+       guint32 I2C_port;
 } WFDI2C;
 
 typedef struct {
-  guint64 PTS;
-  guint64 DTS;
+       guint64 PTS;
+       guint64 DTS;
 } WFDAVFormatChangeTiming;
 
 typedef struct {
-  gboolean displaymodesupported;
-  guint64 p_clock;
-  guint32 H;
-  guint32 HB;
-  guint32 HSPOL_HSOFF;
-  guint32 HSW;
-  guint32 V;
-  guint32 VB;
-  guint32 VSPOL_VSOFF;
-  guint32 VSW;
-  guint VBS3D;
-  guint R;
-  guint V2d_s3d_modes;
-  guint P_depth;
-  WFDVideoH264Codec H264_codec;
+       gboolean displaymodesupported;
+       guint64 p_clock;
+       guint32 H;
+       guint32 HB;
+       guint32 HSPOL_HSOFF;
+       guint32 HSW;
+       guint32 V;
+       guint32 VB;
+       guint32 VSPOL_VSOFF;
+       guint32 VSW;
+       guint VBS3D;
+       guint R;
+       guint V2d_s3d_modes;
+       guint P_depth;
+       WFDVideoH264Codec H264_codec;
 } WFDPreferredDisplayMode;
 
 typedef struct {
-  guint32 input_cat;
-}WFDInputCategoryList;
+       guint32 input_cat;
+} WFDInputCategoryList;
 
 typedef struct {
-  guint32 inp_type;
-}WFDGenericCategoryList;
+       guint32 inp_type;
+} WFDGenericCategoryList;
 
 typedef struct _detailed_cap detailed_cap;
 
 typedef struct {
-  WFDUibcinp_type inp_type;
-  WFDUibcinp_path inp_path;
-}WFDHIDCTypePathPair;
+       WFDUibcinp_type inp_type;
+       WFDUibcinp_path inp_path;
+} WFDHIDCTypePathPair;
 
 struct _detailed_cap {
-  WFDHIDCTypePathPair p;
-  detailed_cap *next;
+       WFDHIDCTypePathPair p;
+       detailed_cap *next;
 };
 
 typedef struct {
-  guint cap_count;
-  detailed_cap *next;
-}WFDHIDCCategoryList;
+       guint cap_count;
+       detailed_cap *next;
+} WFDHIDCCategoryList;
 
 typedef struct {
-  gboolean uibcsupported;
-  WFDInputCategoryList input_category_list;
-  WFDGenericCategoryList generic_cap_list;
-  WFDHIDCCategoryList hidc_cap_list;
-  guint32 tcp_port;
+       gboolean uibcsupported;
+       WFDInputCategoryList input_category_list;
+       WFDGenericCategoryList generic_cap_list;
+       WFDHIDCCategoryList hidc_cap_list;
+       guint32 tcp_port;
 } WFDUibcCapability;
 
 typedef struct {
-  gboolean uibc_setting;
+       gboolean uibc_setting;
 } WFDUibcSetting;
 
 typedef struct {
-  gboolean standby_resume_cap;
+       gboolean standby_resume_cap;
 } WFDStandbyResumeCapability;
 
 typedef struct {
-  gboolean wfd_standby;
+       gboolean wfd_standby;
 } WFDStandby;
 
 typedef struct {
-  gboolean supported;
-  gint32 connector_type;
+       gboolean supported;
+       gint32 connector_type;
 } WFDConnectorType;
 
 typedef struct {
-  gboolean idr_request;
+       gboolean idr_request;
 } WFDIdrRequest;
 
 /***********************************************************/
 
 typedef struct {
 
-  WFDAudioCodeclist *audio_codecs;
-  WFDVideoCodeclist *video_formats;
-  WFD3DFormats *video_3d_formats;
-  WFDContentProtection *content_protection;
-  WFDDisplayEdid *display_edid;
-  WFDCoupledSink *coupled_sink;
-  WFDTriggerMethod *trigger_method;
-  WFDPresentationUrl *presentation_url;
-  WFDClientRtpPorts *client_rtp_ports;
-  WFDRoute *route;
-  WFDI2C *I2C;
-  WFDAVFormatChangeTiming *av_format_change_timing;
-  WFDPreferredDisplayMode *preferred_display_mode;
-  WFDUibcCapability *uibc_capability;
-  WFDUibcSetting *uibc_setting;
-  WFDStandbyResumeCapability *standby_resume_capability;
-  WFDStandby *standby;
-  WFDConnectorType *connector_type;
-  WFDIdrRequest *idr_request;
+       WFDAudioCodeclist *audio_codecs;
+       WFDVideoCodeclist *video_formats;
+       WFD3DFormats *video_3d_formats;
+       WFDContentProtection *content_protection;
+       WFDDisplayEdid *display_edid;
+       WFDCoupledSink *coupled_sink;
+       WFDTriggerMethod *trigger_method;
+       WFDPresentationUrl *presentation_url;
+       WFDClientRtpPorts *client_rtp_ports;
+       WFDRoute *route;
+       WFDI2C *I2C;
+       WFDAVFormatChangeTiming *av_format_change_timing;
+       WFDPreferredDisplayMode *preferred_display_mode;
+       WFDUibcCapability *uibc_capability;
+       WFDUibcSetting *uibc_setting;
+       WFDStandbyResumeCapability *standby_resume_capability;
+       WFDStandby *standby;
+       WFDConnectorType *connector_type;
+       WFDIdrRequest *idr_request;
 } WFDMessage;
 
 /* Session descriptions */
-WFDResult wfdconfig_message_new                 (WFDMessage **msg);
-WFDResult wfdconfig_message_init                (WFDMessage *msg);
-WFDResult wfdconfig_message_uninit              (WFDMessage *msg);
-WFDResult wfdconfig_message_free                (WFDMessage *msg);
-WFDResult wfdconfig_message_parse_buffer        (const guint8 *data, guint size, WFDMessage *msg);
-gchar* wfdconfig_message_as_text                (const WFDMessage *msg);
-gchar* wfdconfig_parameter_names_as_text        (const WFDMessage *msg);
-WFDResult wfdconfig_message_dump                (const WFDMessage *msg);
+WFDResult wfdconfig_message_new(WFDMessage **msg);
+WFDResult wfdconfig_message_init(WFDMessage *msg);
+WFDResult wfdconfig_message_uninit(WFDMessage *msg);
+WFDResult wfdconfig_message_free(WFDMessage *msg);
+WFDResult wfdconfig_message_parse_buffer(const guint8 *data, guint size, WFDMessage *msg);
+gchar *wfdconfig_message_as_text(const WFDMessage *msg);
+gchar *wfdconfig_parameter_names_as_text(const WFDMessage *msg);
+WFDResult wfdconfig_message_dump(const WFDMessage *msg);
 
 
 WFDResult wfdconfig_set_supported_audio_format(WFDMessage *msg,
-                                                                                               guint aCodec, guint aFreq, guint aChanels,
-                                                                                               guint aBitwidth, guint32 aLatency);
+                                               guint aCodec, guint aFreq, guint aChanels,
+                                               guint aBitwidth, guint32 aLatency);
 WFDResult wfdconfig_set_prefered_audio_format(WFDMessage *msg,
-                                                                                               WFDAudioFormats aCodec, WFDAudioFreq aFreq, WFDAudioChannels aChanels,
-                                                                                               guint aBitwidth, guint32 aLatency);
+                                              WFDAudioFormats aCodec, WFDAudioFreq aFreq, WFDAudioChannels aChanels,
+                                              guint aBitwidth, guint32 aLatency);
 WFDResult wfdconfig_get_supported_audio_format(WFDMessage *msg,
-                                                                                               guint *aCodec, guint *aFreq, guint *aChanels,
-                                                                                               guint *aBitwidth, guint32 *aLatency);
+                                               guint *aCodec, guint *aFreq, guint *aChanels,
+                                               guint *aBitwidth, guint32 *aLatency);
 WFDResult wfdconfig_get_prefered_audio_format(WFDMessage *msg,
-                                                                                               WFDAudioFormats *aCodec, WFDAudioFreq *aFreq, WFDAudioChannels *aChanels,
-                                                                                               guint *aBitwidth, guint32 *aLatency);
+                                              WFDAudioFormats *aCodec, WFDAudioFreq *aFreq, WFDAudioChannels *aChanels,
+                                              guint *aBitwidth, guint32 *aLatency);
 
 WFDResult wfdconfig_set_supported_video_format(WFDMessage *msg, WFDVideoCodecs vCodec,
-                                                                                               WFDVideoNativeResolution vNative, guint64 vNativeResolution,
-                                                                                               guint64 vCEAResolution, guint64 vVESAResolution, guint64 vHHResolution,
-                                                                                               guint vProfile, guint vLevel, guint32 vLatency, guint32 vMaxHeight,
-                                                                                               guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control);
+                                               WFDVideoNativeResolution vNative, guint64 vNativeResolution,
+                                               guint64 vCEAResolution, guint64 vVESAResolution, guint64 vHHResolution,
+                                               guint vProfile, guint vLevel, guint32 vLatency, guint32 vMaxHeight,
+                                               guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control);
 WFDResult wfdconfig_set_prefered_video_format(WFDMessage *msg, WFDVideoCodecs vCodec,
-                                                                                               WFDVideoNativeResolution vNative, guint64 vNativeResolution,
-                                                                                               WFDVideoCEAResolution vCEAResolution, WFDVideoVESAResolution vVESAResolution,
-                                                                                               WFDVideoHHResolution vHHResolution,     WFDVideoH264Profile vProfile,
-                                                                                               WFDVideoH264Level vLevel, guint32 vLatency, guint32 vMaxHeight,
-                                                                                               guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control);
+                                              WFDVideoNativeResolution vNative, guint64 vNativeResolution,
+                                              WFDVideoCEAResolution vCEAResolution, WFDVideoVESAResolution vVESAResolution,
+                                              WFDVideoHHResolution vHHResolution,      WFDVideoH264Profile vProfile,
+                                              WFDVideoH264Level vLevel, guint32 vLatency, guint32 vMaxHeight,
+                                              guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control);
 WFDResult wfdconfig_get_supported_video_format(WFDMessage *msg, WFDVideoCodecs *vCodec,
-                                                                                               WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
-                                                                                               guint64 *vCEAResolution, guint64 *vVESAResolution, guint64 *vHHResolution,
-                                                                                               guint *vProfile, guint *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
-                                                                                               guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control);
+                                               WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
+                                               guint64 *vCEAResolution, guint64 *vVESAResolution, guint64 *vHHResolution,
+                                               guint *vProfile, guint *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
+                                               guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control);
 WFDResult wfdconfig_get_prefered_video_format(WFDMessage *msg, WFDVideoCodecs *vCodec,
-                                                                                               WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
-                                                                                               WFDVideoCEAResolution *vCEAResolution, WFDVideoVESAResolution *vVESAResolution,
-                                                                                               WFDVideoHHResolution *vHHResolution,    WFDVideoH264Profile *vProfile,
-                                                                                               WFDVideoH264Level *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
-                                                                                               guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control);
+                                              WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
+                                              WFDVideoCEAResolution *vCEAResolution, WFDVideoVESAResolution *vVESAResolution,
+                                              WFDVideoHHResolution *vHHResolution,     WFDVideoH264Profile *vProfile,
+                                              WFDVideoH264Level *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
+                                              guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control);
 
-// Todo wfd-3d-formats
+/* Todo wfd-3d-formats */
 
 WFDResult wfdconfig_set_contentprotection_type(WFDMessage *msg, WFDHDCPProtection hdcpversion, guint32 TCPPort);
 WFDResult wfdconfig_get_contentprotection_type(WFDMessage *msg, WFDHDCPProtection *hdcpversion, guint32 *TCPPort);
@@ -540,9 +540,9 @@ WFDResult wfdconfig_set_presentation_url(WFDMessage *msg, gchar *wfd_url0, gchar
 WFDResult wfdconfig_get_presentation_url(WFDMessage *msg, gchar **wfd_url0, gchar **wfd_url1);
 
 WFDResult wfdconfig_set_prefered_RTP_ports(WFDMessage *msg, WFDRTSPTransMode trans, WFDRTSPProfile profile,
-                                                                                               WFDRTSPLowerTrans lowertrans, guint32 rtp_port0, guint32 rtp_port1);
+                                           WFDRTSPLowerTrans lowertrans, guint32 rtp_port0, guint32 rtp_port1);
 WFDResult wfdconfig_get_prefered_RTP_ports(WFDMessage *msg, WFDRTSPTransMode *trans, WFDRTSPProfile *profile,
-                                                                                               WFDRTSPLowerTrans *lowertrans, guint32 *rtp_port0, guint32 *rtp_port1);
+                                           WFDRTSPLowerTrans *lowertrans, guint32 *rtp_port0, guint32 *rtp_port1);
 
 WFDResult wfdconfig_set_audio_sink_type(WFDMessage *msg, WFDSinkType sinktype);
 WFDResult wfdconfig_get_audio_sink_type(WFDMessage *msg, WFDSinkType *sinktype);
@@ -553,12 +553,12 @@ WFDResult wfdconfig_get_I2C_port(WFDMessage *msg, gboolean *i2csupport, guint32
 WFDResult wfdconfig_set_av_format_change_timing(WFDMessage *msg, guint64 PTS, guint64 DTS);
 WFDResult wfdconfig_get_av_format_change_timing(WFDMessage *msg, guint64 *PTS, guint64 *DTS);
 
-// Todo wfd-preferred-display-mode
+/* Todo wfd-preferred-display-mode */
 
 WFDResult wfdconfig_set_uibc_capability(WFDMessage *msg, guint32 input_category, guint32 inp_type, WFDHIDCTypePathPair *inp_pair,
-                                                                                               guint32 inp_type_path_count, guint32 tcp_port);
+                                        guint32 inp_type_path_count, guint32 tcp_port);
 WFDResult wfdconfig_get_uibc_capability(WFDMessage *msg, guint32 *input_category, guint32 *inp_type, WFDHIDCTypePathPair **inp_pair,
-                                                                                               guint32 *inp_type_path_count, guint32 *tcp_port);
+                                        guint32 *inp_type_path_count, guint32 *tcp_port);
 
 WFDResult wfdconfig_set_uibc_status(WFDMessage *msg, gboolean uibc_enable);
 WFDResult wfdconfig_get_uibc_status(WFDMessage *msg, gboolean *uibc_enable);

diff --git a/wfdconfig/wfdconfigmessage.c b/wfdconfig/wfdconfigmessage.c
index 4ff1627..f6229f6 100755 (executable)
--- a/wfdconfig/wfdconfigmessage.c
+++ b/wfdconfig/wfdconfigmessage.c
@@ -36,21 +36,19 @@
 #include "mm_wfd_common_private.h"
 
 /* FIXME, is currently allocated on the stack */
-#define MAX_LINE_LEN    1024 * 16
+#define MAX_LINE_LEN    (1024 * 16)
 
-#define FREE_STRING(field)              if(field != NULL) g_free (field); (field) = NULL
-#define REPLACE_STRING(field, val)      FREE_STRING(field); (field) = g_strdup (val)
+#define FREE_STRING(field)              if (field != NULL) g_free(field); (field) = NULL;
+#define REPLACE_STRING(field, val)      FREE_STRING(field); (field) = g_strdup(val);
 #define EDID_BLOCK_SIZE 128
-enum
-{
-  WFD_SESSION,
-  WFD_MEDIA,
+enum {
+       WFD_SESSION,
+       WFD_MEDIA,
 };
 
-typedef struct
-{
-  guint state;
-  WFDMessage *msg;
+typedef struct {
+       guint state;
+       WFDMessage *msg;
 } WFDContext;
 
 /**
@@ -62,17 +60,17 @@ typedef struct
 * Returns: a #WFDResult.
 */
 WFDResult
-wfdconfig_message_new (WFDMessage ** msg)
+wfdconfig_message_new(WFDMessage **msg)
 {
-  WFDMessage *newmsg;
+       WFDMessage *newmsg;
 
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
 
-  newmsg = g_new0 (WFDMessage, 1);
+       newmsg = g_new0(WFDMessage, 1);
 
-  *msg = newmsg;
+       *msg = newmsg;
 
-  return wfdconfig_message_init (newmsg);
+       return wfdconfig_message_init(newmsg);
 }
 
 /**
@@ -83,17 +81,17 @@ wfdconfig_message_new (WFDMessage ** msg)
 * with wfdconfig_message_new(). This function is mostly used to initialize a message
 * allocated on the stack. wfdconfig_message_uninit() undoes this operation.
 *
-* When this function is invoked on newly allocated data (with malloc or on the
+* When this function is invoked on newly allocated data(with malloc or on the
 * stack), its contents should be set to 0 before calling this function.
 *
 * Returns: a #WFDResult.
 */
 WFDResult
-wfdconfig_message_init (WFDMessage * msg)
+wfdconfig_message_init(WFDMessage *msg)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
 
-  return WFD_OK;
+       return WFD_OK;
 }
 
 /**
@@ -107,102 +105,102 @@ wfdconfig_message_init (WFDMessage * msg)
 * Returns: a #WFDResult.
 */
 WFDResult
-wfdconfig_message_uninit (WFDMessage * msg)
+wfdconfig_message_uninit(WFDMessage *msg)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(msg->audio_codecs) {
-    guint i=0;
-    if(msg->audio_codecs->list) {
-      for(; i<msg->audio_codecs->count; i++) {
-        FREE_STRING(msg->audio_codecs->list[i].audio_format);
-        msg->audio_codecs->list[i].modes=0;
-        msg->audio_codecs->list[i].latency=0;
-      }
-      FREE_STRING(msg->audio_codecs->list);
-    }
-    FREE_STRING(msg->audio_codecs);
-  }
-
-  if(msg->video_formats) {
-    FREE_STRING(msg->video_formats->list);
-    FREE_STRING(msg->video_formats);
-  }
-
-  if(msg->video_3d_formats) {
-    FREE_STRING(msg->video_3d_formats);
-  }
-
-  if(msg->content_protection) {
-    FREE_STRING(msg->content_protection);
-  }
-
-  if(msg->display_edid) {
-    if(msg->display_edid->edid_payload)
-      FREE_STRING(msg->display_edid->edid_payload);
-    FREE_STRING(msg->display_edid);
-  }
-
-  if(msg->coupled_sink) {
-    FREE_STRING(msg->coupled_sink);
-  }
-
-  if(msg->trigger_method) {
-    FREE_STRING(msg->trigger_method->wfd_trigger_method);
-    FREE_STRING(msg->trigger_method);
-  }
-
-  if(msg->presentation_url) {
-    FREE_STRING(msg->trigger_method);
-  }
-
-  if(msg->client_rtp_ports) {
-    FREE_STRING(msg->client_rtp_ports->profile);
-    FREE_STRING(msg->client_rtp_ports->mode);
-    FREE_STRING(msg->client_rtp_ports);
-  }
-
-  if(msg->route) {
-    FREE_STRING(msg->route);
-  }
-
-  if(msg->I2C) {
-    FREE_STRING(msg->I2C);
-  }
-
-  if(msg->av_format_change_timing) {
-    FREE_STRING(msg->av_format_change_timing);
-  }
-
-  if(msg->preferred_display_mode) {
-    FREE_STRING(msg->preferred_display_mode);
-  }
-
-  if(msg->uibc_capability) {
-    FREE_STRING(msg->uibc_capability);
-  }
-
-  if(msg->uibc_setting) {
-    FREE_STRING(msg->uibc_setting);
-  }
-
-  if(msg->standby_resume_capability) {
-    FREE_STRING(msg->standby_resume_capability);
-  }
-
-  if(msg->standby) {
-    FREE_STRING(msg->standby);
-  }
-
-  if(msg->connector_type) {
-    FREE_STRING(msg->connector_type);
-  }
-
-  if(msg->idr_request) {
-    FREE_STRING(msg->idr_request);
-  }
-
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (msg->audio_codecs) {
+               guint i = 0;
+               if (msg->audio_codecs->list) {
+                       for (; i < msg->audio_codecs->count; i++) {
+                               FREE_STRING(msg->audio_codecs->list[i].audio_format);
+                               msg->audio_codecs->list[i].modes = 0;
+                               msg->audio_codecs->list[i].latency = 0;
+                       }
+                       FREE_STRING(msg->audio_codecs->list);
+               }
+               FREE_STRING(msg->audio_codecs);
+       }
+
+       if (msg->video_formats) {
+               FREE_STRING(msg->video_formats->list);
+               FREE_STRING(msg->video_formats);
+       }
+
+       if (msg->video_3d_formats) {
+               FREE_STRING(msg->video_3d_formats);
+       }
+
+       if (msg->content_protection) {
+               FREE_STRING(msg->content_protection);
+       }
+
+       if (msg->display_edid) {
+               if (msg->display_edid->edid_payload)
+                       FREE_STRING(msg->display_edid->edid_payload);
+               FREE_STRING(msg->display_edid);
+       }
+
+       if (msg->coupled_sink) {
+               FREE_STRING(msg->coupled_sink);
+       }
+
+       if (msg->trigger_method) {
+               FREE_STRING(msg->trigger_method->wfd_trigger_method);
+               FREE_STRING(msg->trigger_method);
+       }
+
+       if (msg->presentation_url) {
+               FREE_STRING(msg->trigger_method);
+       }
+
+       if (msg->client_rtp_ports) {
+               FREE_STRING(msg->client_rtp_ports->profile);
+               FREE_STRING(msg->client_rtp_ports->mode);
+               FREE_STRING(msg->client_rtp_ports);
+       }
+
+       if (msg->route) {
+               FREE_STRING(msg->route);
+       }
+
+       if (msg->I2C) {
+               FREE_STRING(msg->I2C);
+       }
+
+       if (msg->av_format_change_timing) {
+               FREE_STRING(msg->av_format_change_timing);
+       }
+
+       if (msg->preferred_display_mode) {
+               FREE_STRING(msg->preferred_display_mode);
+       }
+
+       if (msg->uibc_capability) {
+               FREE_STRING(msg->uibc_capability);
+       }
+
+       if (msg->uibc_setting) {
+               FREE_STRING(msg->uibc_setting);
+       }
+
+       if (msg->standby_resume_capability) {
+               FREE_STRING(msg->standby_resume_capability);
+       }
+
+       if (msg->standby) {
+               FREE_STRING(msg->standby);
+       }
+
+       if (msg->connector_type) {
+               FREE_STRING(msg->connector_type);
+       }
+
+       if (msg->idr_request) {
+               FREE_STRING(msg->idr_request);
+       }
+
+       return WFD_OK;
 }
 
 /**
@@ -216,14 +214,14 @@ wfdconfig_message_uninit (WFDMessage * msg)
 * Returns: a #WFDResult.
 */
 WFDResult
-wfdconfig_message_free (WFDMessage * msg)
+wfdconfig_message_free(WFDMessage *msg)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
 
-  wfdconfig_message_uninit (msg);
-  g_free (msg);
+       wfdconfig_message_uninit(msg);
+       g_free(msg);
 
-  return WFD_OK;
+       return WFD_OK;
 }
 
 /**
@@ -235,905 +233,902 @@ wfdconfig_message_free (WFDMessage * msg)
 * Returns: A dynamically allocated string representing the WFD description.
 */
 gchar *
-wfdconfig_message_as_text (const WFDMessage * msg)
+wfdconfig_message_as_text(const WFDMessage *msg)
 {
-  /* change all vars so they match rfc? */
-  GString *lines;
-  g_return_val_if_fail (msg != NULL, NULL);
-
-  lines = g_string_new ("");
-
-  /* list of audio codecs */
-  if(msg->audio_codecs) {
-    guint i=0;
-    g_string_append_printf (lines,"wfd_audio_codecs");
-    if(msg->audio_codecs->list) {
-      g_string_append_printf (lines,":");
-      for(; i<msg->audio_codecs->count; i++) {
-        g_string_append_printf (lines," %s",msg->audio_codecs->list[i].audio_format);
-        g_string_append_printf (lines," %08x",msg->audio_codecs->list[i].modes);
-        g_string_append_printf (lines," %02x",msg->audio_codecs->list[i].latency);
-        if((i+1)<msg->audio_codecs->count)
-          g_string_append_printf (lines,",");
-      }
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  /* list of video codecs */
-  if(msg->video_formats) {
-    g_string_append_printf (lines,"wfd_video_formats");
-    if(msg->video_formats->list) {
-      g_string_append_printf (lines,":");
-      g_string_append_printf (lines," %02x", msg->video_formats->list->native);
-      g_string_append_printf (lines," %02x", msg->video_formats->list->preferred_display_mode_supported);
-      g_string_append_printf (lines," %02x", msg->video_formats->list->H264_codec.profile);
-      g_string_append_printf (lines," %02x", msg->video_formats->list->H264_codec.level);
-      g_string_append_printf (lines," %08x", msg->video_formats->list->H264_codec.misc_params.CEA_Support);
-      g_string_append_printf (lines," %08x", msg->video_formats->list->H264_codec.misc_params.VESA_Support);
-      g_string_append_printf (lines," %08x", msg->video_formats->list->H264_codec.misc_params.HH_Support);
-      g_string_append_printf (lines," %02x", msg->video_formats->list->H264_codec.misc_params.latency);
-      g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.misc_params.min_slice_size);
-      g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
-      g_string_append_printf (lines," %02x", msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
-
-      if(msg->video_formats->list->H264_codec.max_hres)
-        g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.max_hres);
-      else
-        g_string_append_printf (lines," none");
-
-      if(msg->video_formats->list->H264_codec.max_vres)
-        g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.max_vres);
-      else
-        g_string_append_printf (lines," none");
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  /* list of video 3D codecs */
-  if(msg->video_3d_formats) {
-    g_string_append_printf (lines,"wfd_3d_video_formats");
-    g_string_append_printf (lines,":");
-    if(msg->video_3d_formats->list) {
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->native);
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->preferred_display_mode_supported);
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->H264_codec.profile);
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->H264_codec.level);
-      g_string_append_printf (lines," %16x", msg->video_3d_formats->list->H264_codec.misc_params.video_3d_capability);
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->H264_codec.misc_params.latency);
-      g_string_append_printf (lines," %04x", msg->video_3d_formats->list->H264_codec.misc_params.min_slice_size);
-      g_string_append_printf (lines," %04x", msg->video_3d_formats->list->H264_codec.misc_params.slice_enc_params);
-      g_string_append_printf (lines," %02x", msg->video_3d_formats->list->H264_codec.misc_params.frame_rate_control_support);
-      if(msg->video_3d_formats->list->H264_codec.max_hres)
-        g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.max_hres);
-      else
-        g_string_append_printf (lines," none");
-      if(msg->video_3d_formats->list->H264_codec.max_vres)
-        g_string_append_printf (lines," %04x", msg->video_formats->list->H264_codec.max_vres);
-      else
-        g_string_append_printf (lines," none");
-    } else {
-      g_string_append_printf (lines," none");
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->content_protection) {
-    g_string_append_printf (lines,"wfd_content_protection");
-    g_string_append_printf (lines,":");
-    if(msg->content_protection->hdcp2_spec) {
-      if( msg->content_protection->hdcp2_spec->hdcpversion) {
-        g_string_append_printf (lines," %s", msg->content_protection->hdcp2_spec->hdcpversion);
-        g_string_append_printf (lines," %s", msg->content_protection->hdcp2_spec->TCPPort);
-      } else {
-        g_string_append_printf (lines," none");
-      }
-    } else {
-      g_string_append_printf (lines," none");
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->display_edid) {
-    g_string_append_printf (lines,"wfd_display_edid");
-    g_string_append_printf (lines,":");
-    if(msg->display_edid->edid_supported) {
-      g_string_append_printf (lines," %d", msg->display_edid->edid_supported);
-      if(msg->display_edid->edid_block_count)
-        g_string_append_printf (lines," %d", msg->display_edid->edid_block_count);
-      else
-        g_string_append_printf (lines," none");
-    } else {
-      g_string_append_printf (lines," none");
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->coupled_sink) {
-    g_string_append_printf (lines,"wfd_coupled_sink");
-    g_string_append_printf (lines,":");
-    if(msg->coupled_sink->coupled_sink_cap) {
-      g_string_append_printf (lines," %02x", msg->coupled_sink->coupled_sink_cap->status);
-      if(msg->coupled_sink->coupled_sink_cap->sink_address)
-        g_string_append_printf (lines," %s", msg->coupled_sink->coupled_sink_cap->sink_address);
-      else
-        g_string_append_printf (lines," none");
-    } else {
-      g_string_append_printf (lines," none");
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->trigger_method) {
-    g_string_append_printf (lines,"wfd_trigger_method");
-    g_string_append_printf (lines,":");
-    g_string_append_printf (lines," %s", msg->trigger_method->wfd_trigger_method);
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->presentation_url) {
-    g_string_append_printf (lines,"wfd_presentation_URL");
-    g_string_append_printf (lines,":");
-    if(msg->presentation_url->wfd_url0)
-      g_string_append_printf (lines," %s", msg->presentation_url->wfd_url0);
-    else
-      g_string_append_printf (lines," none");
-    if(msg->presentation_url->wfd_url1)
-      g_string_append_printf (lines," %s", msg->presentation_url->wfd_url1);
-    else
-      g_string_append_printf (lines," none");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->client_rtp_ports) {
-    g_string_append_printf (lines,"wfd_client_rtp_ports");
-    if(msg->client_rtp_ports->profile) {
-      g_string_append_printf (lines,":");
-      g_string_append_printf (lines," %s", msg->client_rtp_ports->profile);
-      g_string_append_printf (lines," %d", msg->client_rtp_ports->rtp_port0);
-      g_string_append_printf (lines," %d", msg->client_rtp_ports->rtp_port1);
-      g_string_append_printf (lines," %s", msg->client_rtp_ports->mode);
-    }
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->route) {
-    g_string_append_printf (lines,"wfd_route");
-    g_string_append_printf (lines,":");
-    g_string_append_printf (lines," %s", msg->route->destination);
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->I2C) {
-    g_string_append_printf (lines,"wfd_I2C");
-    g_string_append_printf (lines,":");
-    if(msg->I2C->I2CPresent)
-      g_string_append_printf (lines," %x", msg->I2C->I2C_port);
-    else
-      g_string_append_printf (lines," none");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->av_format_change_timing) {
-    g_string_append_printf (lines,"wfd_av_format_change_timing");
-    g_string_append_printf (lines,":");
-    g_string_append_printf (lines," %10"G_GUINT64_FORMAT, msg->av_format_change_timing->PTS);
-    g_string_append_printf (lines," %10"G_GUINT64_FORMAT, msg->av_format_change_timing->DTS);
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->preferred_display_mode) {
-    g_string_append_printf (lines,"wfd_preferred_display_mode");
-    g_string_append_printf (lines,":");
-    if(msg->preferred_display_mode->displaymodesupported) {
-      g_string_append_printf (lines," %06"G_GUINT64_FORMAT, msg->preferred_display_mode->p_clock);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->H);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->HB);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->HSPOL_HSOFF);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->HSW);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->V);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->VB);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->VSPOL_VSOFF);
-      g_string_append_printf (lines," %04x", msg->preferred_display_mode->VSW);
-      g_string_append_printf (lines," %02x", msg->preferred_display_mode->VBS3D);
-      g_string_append_printf (lines," %02x", msg->preferred_display_mode->V2d_s3d_modes);
-      g_string_append_printf (lines," %02x", msg->preferred_display_mode->P_depth);
-    } else g_string_append_printf (lines," none");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->uibc_capability) {
-    g_string_append_printf (lines,"wfd_uibc_capability");
-    g_string_append_printf (lines,":");
-    if(msg->uibc_capability->uibcsupported) {
-      g_string_append_printf (lines," input_category_list=");
-      if(msg->uibc_capability->input_category_list.input_cat) {
-        guint32 tempcap = 0;
-        if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC) {
-          tempcap |= WFD_UIBC_INPUT_CAT_GENERIC;
-          g_string_append_printf (lines,"GENERIC");
-          if(msg->uibc_capability->input_category_list.input_cat != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC) {
-          tempcap |= WFD_UIBC_INPUT_CAT_HIDC;
-          g_string_append_printf (lines,"HIDC");
-          if(msg->uibc_capability->input_category_list.input_cat != tempcap) g_string_append_printf (lines,", ");
-        }
-      }
-      else g_string_append_printf (lines,"none");
-      g_string_append_printf (lines,";");
-      g_string_append_printf (lines," generic_cap_list=");
-      if(msg->uibc_capability->generic_cap_list.inp_type) {
-        guint32 tempcap = 0;
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_KEYBOARD;
-          g_string_append_printf (lines,"Keyboard");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_MOUSE;
-          g_string_append_printf (lines,"Mouse");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
-          g_string_append_printf (lines,"SingleTouch");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_MULTITOUCH;
-          g_string_append_printf (lines,"MultiTouch");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_JOYSTICK;
-          g_string_append_printf (lines,"Joystick");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_CAMERA;
-          g_string_append_printf (lines,"Camera");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_GESTURE;
-          g_string_append_printf (lines,"Gesture");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-        if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL) {
-          tempcap |= WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
-          g_string_append_printf (lines,"RemoteControl");
-          if(msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf (lines,", ");
-        }
-      }
-      else g_string_append_printf (lines,"none");
-      g_string_append_printf (lines,";");
-      g_string_append_printf (lines," hidc_cap_list=");
-      if(msg->uibc_capability->hidc_cap_list.cap_count) {
-        detailed_cap *temp_cap = msg->uibc_capability->hidc_cap_list.next;
-        while(temp_cap)
-        {
-          if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_KEYBOARD) g_string_append_printf (lines,"Keyboard");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_MOUSE) g_string_append_printf (lines,"Mouse");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_SINGLETOUCH) g_string_append_printf (lines,"SingleTouch");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_MULTITOUCH) g_string_append_printf (lines,"MultiTouch");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_JOYSTICK) g_string_append_printf (lines,"Joystick");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_CAMERA) g_string_append_printf (lines,"Camera");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_GESTURE) g_string_append_printf (lines,"Gesture");
-          else if(temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_REMOTECONTROL) g_string_append_printf (lines,"RemoteControl");
-          g_string_append_printf (lines,"/");
-          if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_INFRARED) g_string_append_printf (lines,"Infrared");
-          else if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_USB) g_string_append_printf (lines,"USB");
-          else if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_BT) g_string_append_printf (lines,"BT");
-          else if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_ZIGBEE) g_string_append_printf (lines,"Zigbee");
-          else if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_WIFI) g_string_append_printf (lines,"Wi-Fi");
-          else if(temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_NOSP) g_string_append_printf (lines,"No-SP");
-          temp_cap = temp_cap->next;
-          if(temp_cap) g_string_append_printf (lines,", ");
-        }
-      } else g_string_append_printf (lines,"none");
-      g_string_append_printf (lines,";");
-      if(msg->uibc_capability->tcp_port) g_string_append_printf (lines,"port=%u", msg->uibc_capability->tcp_port);
-      else  g_string_append_printf (lines,"port=none");
-    } else g_string_append_printf (lines," none");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->uibc_setting) {
-    g_string_append_printf (lines,"wfd_uibc_setting");
-    g_string_append_printf (lines,":");
-    if(msg->uibc_setting->uibc_setting)
-      g_string_append_printf (lines," enable");
-    else
-      g_string_append_printf (lines," disable");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->standby_resume_capability) {
-    g_string_append_printf (lines,"wfd_standby_resume_capability");
-    g_string_append_printf (lines,":");
-    if(msg->standby_resume_capability->standby_resume_cap)
-      g_string_append_printf (lines," supported");
-    else
-      g_string_append_printf (lines," none");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->standby) {
-    g_string_append_printf (lines,"wfd_standby");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->connector_type) {
-    g_string_append_printf (lines,"wfd_connector_type");
-    g_string_append_printf (lines,":");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  if(msg->idr_request) {
-    g_string_append_printf (lines,"wfd_idr_request");
-    g_string_append_printf (lines,"\r\n");
-  }
-
-  //g_string_append_printf (lines,"\0");
-  /*if(g_str_has_suffix (lines,"\r\n\0"))
-  {
-  guint32 length = g_strlen(lines);
-  lines[length-2] = '\0';
-  }*/
-  return g_string_free (lines, FALSE);
+       /* change all vars so they match rfc? */
+       GString *lines;
+       g_return_val_if_fail(msg != NULL, NULL);
+
+       lines = g_string_new("");
+
+       /* list of audio codecs */
+       if (msg->audio_codecs) {
+               guint i = 0;
+               g_string_append_printf(lines, "wfd_audio_codecs");
+               if (msg->audio_codecs->list) {
+                       g_string_append_printf(lines, ":");
+                       for (; i < msg->audio_codecs->count; i++) {
+                               g_string_append_printf(lines, " %s", msg->audio_codecs->list[i].audio_format);
+                               g_string_append_printf(lines, " %08x", msg->audio_codecs->list[i].modes);
+                               g_string_append_printf(lines, " %02x", msg->audio_codecs->list[i].latency);
+                               if ((i + 1) < msg->audio_codecs->count)
+                                       g_string_append_printf(lines, ", ");
+                       }
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       /* list of video codecs */
+       if (msg->video_formats) {
+               g_string_append_printf(lines, "wfd_video_formats");
+               if (msg->video_formats->list) {
+                       g_string_append_printf(lines, ":");
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->native);
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->preferred_display_mode_supported);
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->H264_codec.profile);
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->H264_codec.level);
+                       g_string_append_printf(lines, " %08x", msg->video_formats->list->H264_codec.misc_params.CEA_Support);
+                       g_string_append_printf(lines, " %08x", msg->video_formats->list->H264_codec.misc_params.VESA_Support);
+                       g_string_append_printf(lines, " %08x", msg->video_formats->list->H264_codec.misc_params.HH_Support);
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->H264_codec.misc_params.latency);
+                       g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.misc_params.min_slice_size);
+                       g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
+                       g_string_append_printf(lines, " %02x", msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
+
+                       if (msg->video_formats->list->H264_codec.max_hres)
+                               g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.max_hres);
+                       else
+                               g_string_append_printf(lines, " none");
+
+                       if (msg->video_formats->list->H264_codec.max_vres)
+                               g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.max_vres);
+                       else
+                               g_string_append_printf(lines, " none");
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       /* list of video 3D codecs */
+       if (msg->video_3d_formats) {
+               g_string_append_printf(lines, "wfd_3d_video_formats");
+               g_string_append_printf(lines, ":");
+               if (msg->video_3d_formats->list) {
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->native);
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->preferred_display_mode_supported);
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->H264_codec.profile);
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->H264_codec.level);
+                       g_string_append_printf(lines, " %16x", msg->video_3d_formats->list->H264_codec.misc_params.video_3d_capability);
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->H264_codec.misc_params.latency);
+                       g_string_append_printf(lines, " %04x", msg->video_3d_formats->list->H264_codec.misc_params.min_slice_size);
+                       g_string_append_printf(lines, " %04x", msg->video_3d_formats->list->H264_codec.misc_params.slice_enc_params);
+                       g_string_append_printf(lines, " %02x", msg->video_3d_formats->list->H264_codec.misc_params.frame_rate_control_support);
+                       if (msg->video_3d_formats->list->H264_codec.max_hres)
+                               g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.max_hres);
+                       else
+                               g_string_append_printf(lines, " none");
+                       if (msg->video_3d_formats->list->H264_codec.max_vres)
+                               g_string_append_printf(lines, " %04x", msg->video_formats->list->H264_codec.max_vres);
+                       else
+                               g_string_append_printf(lines, " none");
+               } else {
+                       g_string_append_printf(lines, " none");
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->content_protection) {
+               g_string_append_printf(lines, "wfd_content_protection");
+               g_string_append_printf(lines, ":");
+               if (msg->content_protection->hdcp2_spec) {
+                       if (msg->content_protection->hdcp2_spec->hdcpversion) {
+                               g_string_append_printf(lines, " %s", msg->content_protection->hdcp2_spec->hdcpversion);
+                               g_string_append_printf(lines, " %s", msg->content_protection->hdcp2_spec->TCPPort);
+                       } else {
+                               g_string_append_printf(lines, " none");
+                       }
+               } else {
+                       g_string_append_printf(lines, " none");
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->display_edid) {
+               g_string_append_printf(lines, "wfd_display_edid");
+               g_string_append_printf(lines, ":");
+               if (msg->display_edid->edid_supported) {
+                       g_string_append_printf(lines, " %d", msg->display_edid->edid_supported);
+                       if (msg->display_edid->edid_block_count)
+                               g_string_append_printf(lines, " %d", msg->display_edid->edid_block_count);
+                       else
+                               g_string_append_printf(lines, " none");
+               } else {
+                       g_string_append_printf(lines, " none");
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->coupled_sink) {
+               g_string_append_printf(lines, "wfd_coupled_sink");
+               g_string_append_printf(lines, ":");
+               if (msg->coupled_sink->coupled_sink_cap) {
+                       g_string_append_printf(lines, " %02x", msg->coupled_sink->coupled_sink_cap->status);
+                       if (msg->coupled_sink->coupled_sink_cap->sink_address)
+                               g_string_append_printf(lines, " %s", msg->coupled_sink->coupled_sink_cap->sink_address);
+                       else
+                               g_string_append_printf(lines, " none");
+               } else {
+                       g_string_append_printf(lines, " none");
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->trigger_method) {
+               g_string_append_printf(lines, "wfd_trigger_method");
+               g_string_append_printf(lines, ":");
+               g_string_append_printf(lines, " %s", msg->trigger_method->wfd_trigger_method);
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->presentation_url) {
+               g_string_append_printf(lines, "wfd_presentation_URL");
+               g_string_append_printf(lines, ":");
+               if (msg->presentation_url->wfd_url0)
+                       g_string_append_printf(lines, " %s", msg->presentation_url->wfd_url0);
+               else
+                       g_string_append_printf(lines, " none");
+               if (msg->presentation_url->wfd_url1)
+                       g_string_append_printf(lines, " %s", msg->presentation_url->wfd_url1);
+               else
+                       g_string_append_printf(lines, " none");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->client_rtp_ports) {
+               g_string_append_printf(lines, "wfd_client_rtp_ports");
+               if (msg->client_rtp_ports->profile) {
+                       g_string_append_printf(lines, ":");
+                       g_string_append_printf(lines, " %s", msg->client_rtp_ports->profile);
+                       g_string_append_printf(lines, " %d", msg->client_rtp_ports->rtp_port0);
+                       g_string_append_printf(lines, " %d", msg->client_rtp_ports->rtp_port1);
+                       g_string_append_printf(lines, " %s", msg->client_rtp_ports->mode);
+               }
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->route) {
+               g_string_append_printf(lines, "wfd_route");
+               g_string_append_printf(lines, ":");
+               g_string_append_printf(lines, " %s", msg->route->destination);
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->I2C) {
+               g_string_append_printf(lines, "wfd_I2C");
+               g_string_append_printf(lines, ":");
+               if (msg->I2C->I2CPresent)
+                       g_string_append_printf(lines, " %x", msg->I2C->I2C_port);
+               else
+                       g_string_append_printf(lines, " none");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->av_format_change_timing) {
+               g_string_append_printf(lines, "wfd_av_format_change_timing");
+               g_string_append_printf(lines, ":");
+               g_string_append_printf(lines, " %10"G_GUINT64_FORMAT, msg->av_format_change_timing->PTS);
+               g_string_append_printf(lines, " %10"G_GUINT64_FORMAT, msg->av_format_change_timing->DTS);
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->preferred_display_mode) {
+               g_string_append_printf(lines, "wfd_preferred_display_mode");
+               g_string_append_printf(lines, ":");
+               if (msg->preferred_display_mode->displaymodesupported) {
+                       g_string_append_printf(lines, " %06"G_GUINT64_FORMAT, msg->preferred_display_mode->p_clock);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->H);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->HB);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->HSPOL_HSOFF);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->HSW);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->V);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->VB);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->VSPOL_VSOFF);
+                       g_string_append_printf(lines, " %04x", msg->preferred_display_mode->VSW);
+                       g_string_append_printf(lines, " %02x", msg->preferred_display_mode->VBS3D);
+                       g_string_append_printf(lines, " %02x", msg->preferred_display_mode->V2d_s3d_modes);
+                       g_string_append_printf(lines, " %02x", msg->preferred_display_mode->P_depth);
+               } else g_string_append_printf(lines, " none");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->uibc_capability) {
+               g_string_append_printf(lines, "wfd_uibc_capability");
+               g_string_append_printf(lines, ":");
+               if (msg->uibc_capability->uibcsupported) {
+                       g_string_append_printf(lines, " input_category_list=");
+                       if (msg->uibc_capability->input_category_list.input_cat) {
+                               guint32 tempcap = 0;
+                               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC) {
+                                       tempcap |= WFD_UIBC_INPUT_CAT_GENERIC;
+                                       g_string_append_printf(lines, "GENERIC");
+                                       if (msg->uibc_capability->input_category_list.input_cat != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC) {
+                                       tempcap |= WFD_UIBC_INPUT_CAT_HIDC;
+                                       g_string_append_printf(lines, "HIDC");
+                                       if (msg->uibc_capability->input_category_list.input_cat != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                       } else g_string_append_printf(lines, "none");
+                       g_string_append_printf(lines, ";");
+                       g_string_append_printf(lines, " generic_cap_list=");
+                       if (msg->uibc_capability->generic_cap_list.inp_type) {
+                               guint32 tempcap = 0;
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_KEYBOARD;
+                                       g_string_append_printf(lines, "Keyboard");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_MOUSE;
+                                       g_string_append_printf(lines, "Mouse");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
+                                       g_string_append_printf(lines, "SingleTouch");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_MULTITOUCH;
+                                       g_string_append_printf(lines, "MultiTouch");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_JOYSTICK;
+                                       g_string_append_printf(lines, "Joystick");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_CAMERA;
+                                       g_string_append_printf(lines, "Camera");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_GESTURE;
+                                       g_string_append_printf(lines, "Gesture");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                               if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL) {
+                                       tempcap |= WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
+                                       g_string_append_printf(lines, "RemoteControl");
+                                       if (msg->uibc_capability->generic_cap_list.inp_type != tempcap) g_string_append_printf(lines, ", ");
+                               }
+                       } else g_string_append_printf(lines, "none");
+                       g_string_append_printf(lines, ";");
+                       g_string_append_printf(lines, " hidc_cap_list=");
+                       if (msg->uibc_capability->hidc_cap_list.cap_count) {
+                               detailed_cap *temp_cap = msg->uibc_capability->hidc_cap_list.next;
+                               while (temp_cap) {
+                                       if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_KEYBOARD) g_string_append_printf(lines, "Keyboard");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_MOUSE) g_string_append_printf(lines, "Mouse");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_SINGLETOUCH) g_string_append_printf(lines, "SingleTouch");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_MULTITOUCH) g_string_append_printf(lines, "MultiTouch");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_JOYSTICK) g_string_append_printf(lines, "Joystick");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_CAMERA) g_string_append_printf(lines, "Camera");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_GESTURE) g_string_append_printf(lines, "Gesture");
+                                       else if (temp_cap->p.inp_type == WFD_UIBC_INPUT_TYPE_REMOTECONTROL) g_string_append_printf(lines, "RemoteControl");
+                                       g_string_append_printf(lines, "/");
+                                       if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_INFRARED) g_string_append_printf(lines, "Infrared");
+                                       else if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_USB) g_string_append_printf(lines, "USB");
+                                       else if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_BT) g_string_append_printf(lines, "BT");
+                                       else if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_ZIGBEE) g_string_append_printf(lines, "Zigbee");
+                                       else if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_WIFI) g_string_append_printf(lines, "Wi-Fi");
+                                       else if (temp_cap->p.inp_path == WFD_UIBC_INPUT_PATH_NOSP) g_string_append_printf(lines, "No-SP");
+                                       temp_cap = temp_cap->next;
+                                       if (temp_cap) g_string_append_printf(lines, ", ");
+                               }
+                       } else g_string_append_printf(lines, "none");
+                       g_string_append_printf(lines, ";");
+                       if (msg->uibc_capability->tcp_port) g_string_append_printf(lines, "port=%u", msg->uibc_capability->tcp_port);
+                       else  g_string_append_printf(lines, "port=none");
+               } else g_string_append_printf(lines, " none");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->uibc_setting) {
+               g_string_append_printf(lines, "wfd_uibc_setting");
+               g_string_append_printf(lines, ":");
+               if (msg->uibc_setting->uibc_setting)
+                       g_string_append_printf(lines, " enable");
+               else
+                       g_string_append_printf(lines, " disable");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->standby_resume_capability) {
+               g_string_append_printf(lines, "wfd_standby_resume_capability");
+               g_string_append_printf(lines, ":");
+               if (msg->standby_resume_capability->standby_resume_cap)
+                       g_string_append_printf(lines, " supported");
+               else
+                       g_string_append_printf(lines, " none");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->standby) {
+               g_string_append_printf(lines, "wfd_standby");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->connector_type) {
+               g_string_append_printf(lines, "wfd_connector_type");
+               g_string_append_printf(lines, ":");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       if (msg->idr_request) {
+               g_string_append_printf(lines, "wfd_idr_request");
+               g_string_append_printf(lines, "\r\n");
+       }
+
+       /*g_string_append_printf (lines, "\0"); */
+       /*if(g_str_has_suffix (lines, "\r\n\0"))
+       {
+       guint32 length = g_strlen(lines);
+       lines[length-2] = '\0';
+       }*/
+       return g_string_free(lines, FALSE);
 }
 
-gchar* wfdconfig_parameter_names_as_text (const WFDMessage *msg)
+gchar *wfdconfig_parameter_names_as_text(const WFDMessage *msg)
 {
-  /* change all vars so they match rfc? */
-  GString *lines;
-  g_return_val_if_fail (msg != NULL, NULL);
-
-  lines = g_string_new ("");
-
-  /* list of audio codecs */
-  if(msg->audio_codecs) {
-    g_string_append_printf (lines,"wfd_audio_codecs");
-    g_string_append_printf (lines,"\r\n");
-  }
-  /* list of video codecs */
-  if(msg->video_formats) {
-    g_string_append_printf (lines,"wfd_video_formats");
-    g_string_append_printf (lines,"\r\n");
-  }
-  /* list of video 3D codecs */
-  if(msg->video_3d_formats) {
-    g_string_append_printf (lines,"wfd_3d_video_formats");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->content_protection) {
-    g_string_append_printf (lines,"wfd_content_protection");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->display_edid) {
-    g_string_append_printf (lines,"wfd_display_edid");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->coupled_sink) {
-    g_string_append_printf (lines,"wfd_coupled_sink");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->trigger_method) {
-    g_string_append_printf (lines,"wfd_trigger_method");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->presentation_url) {
-    g_string_append_printf (lines,"wfd_presentation_URL");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->client_rtp_ports) {
-    g_string_append_printf (lines,"wfd_client_rtp_ports");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->route) {
-    g_string_append_printf (lines,"wfd_route");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->I2C) {
-    g_string_append_printf (lines,"wfd_I2C");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->av_format_change_timing) {
-    g_string_append_printf (lines,"wfd_av_format_change_timing");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->preferred_display_mode) {
-    g_string_append_printf (lines,"wfd_preferred_display_mode");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->uibc_capability) {
-    g_string_append_printf (lines,"wfd_uibc_capability");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->uibc_setting) {
-    g_string_append_printf (lines,"wfd_uibc_setting");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->standby_resume_capability) {
-    g_string_append_printf (lines,"wfd_standby_resume_capability");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->standby) {
-    g_string_append_printf (lines,"wfd_standby");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->connector_type) {
-    g_string_append_printf (lines,"wfd_connector_type");
-    g_string_append_printf (lines,"\r\n");
-  }
-  if(msg->idr_request) {
-    g_string_append_printf (lines,"wfd_idr_request");
-    g_string_append_printf (lines,"\r\n");
-  }
-  return g_string_free (lines, FALSE);
+       /* change all vars so they match rfc? */
+       GString *lines;
+       g_return_val_if_fail(msg != NULL, NULL);
+
+       lines = g_string_new("");
+
+       /* list of audio codecs */
+       if (msg->audio_codecs) {
+               g_string_append_printf(lines, "wfd_audio_codecs");
+               g_string_append_printf(lines, "\r\n");
+       }
+       /* list of video codecs */
+       if (msg->video_formats) {
+               g_string_append_printf(lines, "wfd_video_formats");
+               g_string_append_printf(lines, "\r\n");
+       }
+       /* list of video 3D codecs */
+       if (msg->video_3d_formats) {
+               g_string_append_printf(lines, "wfd_3d_video_formats");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->content_protection) {
+               g_string_append_printf(lines, "wfd_content_protection");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->display_edid) {
+               g_string_append_printf(lines, "wfd_display_edid");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->coupled_sink) {
+               g_string_append_printf(lines, "wfd_coupled_sink");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->trigger_method) {
+               g_string_append_printf(lines, "wfd_trigger_method");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->presentation_url) {
+               g_string_append_printf(lines, "wfd_presentation_URL");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->client_rtp_ports) {
+               g_string_append_printf(lines, "wfd_client_rtp_ports");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->route) {
+               g_string_append_printf(lines, "wfd_route");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->I2C) {
+               g_string_append_printf(lines, "wfd_I2C");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->av_format_change_timing) {
+               g_string_append_printf(lines, "wfd_av_format_change_timing");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->preferred_display_mode) {
+               g_string_append_printf(lines, "wfd_preferred_display_mode");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->uibc_capability) {
+               g_string_append_printf(lines, "wfd_uibc_capability");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->uibc_setting) {
+               g_string_append_printf(lines, "wfd_uibc_setting");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->standby_resume_capability) {
+               g_string_append_printf(lines, "wfd_standby_resume_capability");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->standby) {
+               g_string_append_printf(lines, "wfd_standby");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->connector_type) {
+               g_string_append_printf(lines, "wfd_connector_type");
+               g_string_append_printf(lines, "\r\n");
+       }
+       if (msg->idr_request) {
+               g_string_append_printf(lines, "wfd_idr_request");
+               g_string_append_printf(lines, "\r\n");
+       }
+       return g_string_free(lines, FALSE);
 }
 
 static void
-read_string_space_ended (gchar * dest, guint size, gchar * src)
+read_string_space_ended(gchar *dest, guint size, gchar *src)
 {
-  guint idx = 0;
+       guint idx = 0;
 
-  while (!g_ascii_isspace (*src) && *src != '\0') {
-    if (idx < size - 1)
-      dest[idx++] = *src;
-    src++;
-  }
+       while (!g_ascii_isspace(*src) && *src != '\0') {
+               if (idx < size - 1)
+                       dest[idx++] = *src;
+               src++;
+       }
 
-  if (size > 0)
-    dest[idx] = '\0';
+       if (size > 0)
+               dest[idx] = '\0';
 }
 
 static void
-read_string_char_ended (gchar * dest, guint size, gchar del, gchar * src)
+read_string_char_ended(gchar *dest, guint size, gchar del, gchar *src)
 {
-  guint idx = 0;
+       guint idx = 0;
 
-  while (*src != del && *src != '\0') {
-    if (idx < size - 1)
-      dest[idx++] = *src;
-    src++;
-  }
+       while (*src != del && *src != '\0') {
+               if (idx < size - 1)
+                       dest[idx++] = *src;
+               src++;
+       }
 
-  if (size > 0)
-    dest[idx] = '\0';
+       if (size > 0)
+               dest[idx] = '\0';
 }
 
 static void
-read_string_type_and_value (gchar * type, gchar * value, guint tsize, guint vsize, gchar del, gchar * src)
+read_string_type_and_value(gchar *type, gchar *value, guint tsize, guint vsize, gchar del, gchar *src)
 {
-  guint idx;
-
-  idx = 0;
-  while (*src != del && *src != '\0') {
-    if (idx < tsize - 1)
-      type[idx++] = *src;
-    src++;
-  }
-
-  if (tsize > 0)
-    type[idx] = '\0';
-
-  src++;
-  idx = 0;
-  while (*src != '\0') {
-    if (idx < vsize - 1)
-      value[idx++] = *src;
-    src++;
-  }
-  if (vsize > 0)
-    value[idx] = '\0';
+       guint idx;
+
+       idx = 0;
+       while (*src != del && *src != '\0') {
+               if (idx < tsize - 1)
+                       type[idx++] = *src;
+               src++;
+       }
+
+       if (tsize > 0)
+               type[idx] = '\0';
+
+       src++;
+       idx = 0;
+       while (*src != '\0') {
+               if (idx < vsize - 1)
+                       value[idx++] = *src;
+               src++;
+       }
+       if (vsize > 0)
+               value[idx] = '\0';
 }
 
 static gboolean
-wfdconfig_parse_line (WFDMessage * msg, gchar * buffer)
+wfdconfig_parse_line(WFDMessage *msg, gchar *buffer)
 {
-  gchar type[8192] = {0};
-  gchar value[8192] = {0};
-  gchar temp[8192] = {0};
-  gchar *p = buffer;
-  gchar *v = value;
-  gchar *result = NULL;
-
-  #define WFD_SKIP_SPACE(q) if (*q && g_ascii_isspace (*q)) q++
-  #define WFD_SKIP_EQUAL(q) if (*q && *q == '=') q++
-  #define WFD_SKIP_COMMA(q) if (*q && g_ascii_ispunct (*q)) q++
-  #define WFD_READ_STRING(field) read_string_space_ended (temp, sizeof (temp), v); v+=strlen(temp); REPLACE_STRING (field, temp)
-  #define WFD_READ_CHAR_END_STRING(field, del) read_string_char_ended (temp, sizeof (temp), del, v); v+=strlen(temp); REPLACE_STRING (field, temp)
-  #define WFD_READ_UINT32(field) read_string_space_ended (temp, sizeof (temp), v); v+=strlen(temp); field = strtoul (temp, NULL, 16)
-  #define WFD_READ_UINT32_DIGIT(field) read_string_space_ended (temp, sizeof (temp), v); v+=strlen(temp); field = strtoul (temp, NULL, 10)
-
-  //g_print("wfdconfig_parse_line input: %s\n", buffer);
-  read_string_type_and_value (type, value, sizeof(type), sizeof(value), ':', p);
-  //g_print("wfdconfig_parse_line type:%s value:%s\n", type, value);
-  if(!g_strcmp0(type,"wfd_audio_codecs")) {
-    msg->audio_codecs = g_new0 (WFDAudioCodeclist, 1);
-    if(strlen(v)) {
-      guint i=0;
-      msg->audio_codecs->count= strlen(v)/16;
-      msg->audio_codecs->list = g_new0 (WFDAudioCodec, msg->audio_codecs->count);
-      for(;i<msg->audio_codecs->count;i++) {
-        WFD_SKIP_SPACE(v);
-        WFD_READ_STRING(msg->audio_codecs->list[i].audio_format);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->audio_codecs->list[i].modes);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->audio_codecs->list[i].latency);
-        WFD_SKIP_COMMA(v);
-      }
-    }
-  } else if(!g_strcmp0(type,"wfd_video_formats")) {
-    msg->video_formats = g_new0 (WFDVideoCodeclist, 1);
-    if(strlen(v)) {
-      msg->video_formats->count = 1;
-      msg->video_formats->list = g_new0 (WFDVideoCodec, 1);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->native);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->preferred_display_mode_supported);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.profile);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.level);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.CEA_Support);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.VESA_Support);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.HH_Support);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.latency);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.min_slice_size);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
-      WFD_SKIP_SPACE(v);
-      if(msg->video_formats->list->preferred_display_mode_supported == 1) {
-        WFD_READ_UINT32(msg->video_formats->list->H264_codec.max_hres);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->video_formats->list->H264_codec.max_vres);
-        WFD_SKIP_SPACE(v);
-      }
-    }
-  }else if(!g_strcmp0(type,"wfd_3d_video_formats")) {
-    msg->video_3d_formats = g_new0 (WFD3DFormats, 1);
-    if(strlen(v)) {
-      msg->video_3d_formats->count = 1;
-      msg->video_3d_formats->list = g_new0 (WFD3dCapList, 1);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->native);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->preferred_display_mode_supported);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.profile);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.level);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.video_3d_capability);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.latency);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.min_slice_size);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.slice_enc_params);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.frame_rate_control_support);
-      WFD_SKIP_SPACE(v);
-      if(msg->video_3d_formats->list->preferred_display_mode_supported == 1) {
-        WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.max_hres);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.max_vres);
-        WFD_SKIP_SPACE(v);
-      }
-    }
-  } else if(!g_strcmp0(type,"wfd_content_protection")) {
-    msg->content_protection = g_new0 (WFDContentProtection, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      msg->content_protection->hdcp2_spec = g_new0 (WFDHdcp2Spec, 1);
-      if(strstr(v,"none")) {
-        msg->content_protection->hdcp2_spec->hdcpversion=g_strdup("none");
-      } else {
-        WFD_READ_STRING(msg->content_protection->hdcp2_spec->hdcpversion);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_STRING(msg->content_protection->hdcp2_spec->TCPPort);
-      }
-    }
-  } else if(!g_strcmp0(type,"wfd_display_edid")) {
-    msg->display_edid = g_new0 (WFDDisplayEdid, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      if(strstr(v,"none")) {
-        msg->display_edid->edid_supported = 0;
-      } else {
-        msg->display_edid->edid_supported = 1;
-        WFD_READ_UINT32(msg->display_edid->edid_block_count);
-        WFD_SKIP_SPACE(v);
-        if(msg->display_edid->edid_block_count) {
-          gchar *edid_string = v;
-          int i=0, j=0, size =0;
-          guint32 payload_size = EDID_BLOCK_SIZE * msg->display_edid->edid_block_count;
-          msg->display_edid->edid_payload = g_malloc(payload_size);
-          size = EDID_BLOCK_SIZE*msg->display_edid->edid_block_count*2;
-          for (;i<size; j++) {
-            int k=0,kk=0;
-            if(edid_string[i]>0x29 && edid_string[i]<0x40) k=edid_string[i]-48;
-            else if(edid_string[i]>0x60 && edid_string[i]<0x67) k=edid_string[i]-87;
-            else if(edid_string[i]>0x40 && edid_string[i]<0x47) k=edid_string[i]-55;
-
-            if(edid_string[i+1]>0x29 && edid_string[i+1]<0x40) kk=edid_string[i+1]-48;
-            else if(edid_string[i+1]>0x60 && edid_string[i+1]<0x67) kk=edid_string[i+1]-87;
-            else if(edid_string[i+1]>0x40 && edid_string[i+1]<0x47) kk=edid_string[i+1]-55;
-
-            msg->display_edid->edid_payload[j] = (k<<4)|kk;
-            i+=2;
-          }
-          //memcpy(msg->display_edid->edid_payload, v, payload_size);
-               v += (payload_size*2);
-        } else v += strlen(v);
-      }
-    }
-  } else if(!g_strcmp0(type,"wfd_coupled_sink")) {
-    msg->coupled_sink = g_new0 (WFDCoupledSink, 1);
-    if(strlen(v)) {
-    msg->coupled_sink->coupled_sink_cap = g_new0 (WFDCoupled_sink_cap, 1);
-    WFD_SKIP_SPACE(v);
-    WFD_READ_UINT32(msg->coupled_sink->coupled_sink_cap->status);
-    WFD_SKIP_SPACE(v);
-    WFD_READ_STRING(msg->coupled_sink->coupled_sink_cap->sink_address);
-    }
-  } else if(!g_strcmp0(type,"wfd_trigger_method")) {
-    msg->trigger_method = g_new0 (WFDTriggerMethod, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->trigger_method->wfd_trigger_method);
-    }
-  } else if(!g_strcmp0(type,"wfd_presentation_URL")) {
-    msg->presentation_url = g_new0 (WFDPresentationUrl, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->presentation_url->wfd_url0);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->presentation_url->wfd_url1);
-    }
-  } else if(!g_strcmp0(type,"wfd_client_rtp_ports")) {
-    msg->client_rtp_ports = g_new0 (WFDClientRtpPorts, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->client_rtp_ports->profile);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32_DIGIT(msg->client_rtp_ports->rtp_port0);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32_DIGIT(msg->client_rtp_ports->rtp_port1);
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->client_rtp_ports->mode);
-    }
-  } else if(!g_strcmp0(type,"wfd_route")) {
-    msg->route = g_new0 (WFDRoute, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      WFD_READ_STRING(msg->route->destination);
-    }
-  } else if(!g_strcmp0(type,"wfd_I2C")) {
-    msg->I2C = g_new0 (WFDI2C, 1);
-    if(strlen(v)) {
-      msg->I2C->I2CPresent = TRUE;
-      WFD_SKIP_SPACE(v);
-      WFD_READ_UINT32_DIGIT(msg->I2C->I2C_port);
-      if(msg->I2C->I2C_port) msg->I2C->I2CPresent = TRUE;
-    }
-  } else if(!g_strcmp0(type,"wfd_av_format_change_timing")) {
-    msg->av_format_change_timing = g_new0 (WFDAVFormatChangeTiming, 1);
-    if(strlen(v)) {
-    WFD_SKIP_SPACE(v);
-    WFD_READ_UINT32(msg->av_format_change_timing->PTS);
-    WFD_SKIP_SPACE(v);
-    WFD_READ_UINT32(msg->av_format_change_timing->DTS);
-    }
-  } else if(!g_strcmp0(type,"wfd_preferred_display_mode")) {
-    msg->preferred_display_mode = g_new0 (WFDPreferredDisplayMode, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      if(!strstr(v,"none")) {
-        msg->preferred_display_mode->displaymodesupported = FALSE;
-      } else {
-        WFD_READ_UINT32(msg->preferred_display_mode->p_clock);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->HB);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->HSPOL_HSOFF);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->HSW);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->V);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->VB);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->VSPOL_VSOFF);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->VSW);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->VBS3D);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->V2d_s3d_modes);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->P_depth);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.profile);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.level);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.CEA_Support);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.VESA_Support);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.HH_Support);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.latency);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.min_slice_size);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.slice_enc_params);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.frame_rate_control_support);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.max_hres);
-        WFD_SKIP_SPACE(v);
-        WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.max_vres);
-        WFD_SKIP_SPACE(v);
-      }
-    }
-  } else if(!g_strcmp0(type,"wfd_uibc_capability")) {
-    msg->uibc_capability = g_new0 (WFDUibcCapability, 1);
-    if(strstr(v,"input_category_list")) {
-      gchar *tstring = NULL;
-      msg->uibc_capability->uibcsupported = TRUE;
-      WFD_SKIP_SPACE(v);
-      WFD_READ_CHAR_END_STRING(tstring, '=');
-      if(!g_strcmp0(tstring,"input_category_list")) {
-        gchar temp2[8192]={0};
-        guint rem_len=0, read_len=0;
-        WFD_READ_CHAR_END_STRING(tstring, ';');
-        rem_len = strlen(tstring);
-        do {
-          WFD_SKIP_SPACE(v);
-          read_string_char_ended (temp2, 8192, ',', tstring+read_len);
-          read_len += (strlen(temp2)+1);
-          if(strstr(temp2,"GENERIC")) msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_GENERIC;
-          else if(strstr(temp2,"HIDC")) msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_HIDC;
-          else msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_UNKNOWN;
-        } while(read_len < rem_len);
-
-        result = strstr(v,"generic_cap_list");
-        if(result != NULL){
-          memset(temp2, 0, 8192);
-          rem_len=0;
-          read_len=0;
-          v = result;
-          WFD_READ_CHAR_END_STRING(tstring, '=');
-          if(!g_strcmp0(tstring,"generic_cap_list")) {
-            WFD_SKIP_SPACE(v);
-            WFD_READ_CHAR_END_STRING(tstring, ';');
-            rem_len = strlen(tstring);
-            do {
-              read_string_char_ended (temp2, 8192, ',', tstring+read_len);
-              read_len += (strlen(temp2)+1);
-              if(strstr(temp2,"Keyboard")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_KEYBOARD;
-              else if(strstr(temp2,"Mouse")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_MOUSE;
-              else if(strstr(temp2,"SingleTouch")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
-              else if(strstr(temp2,"MultiTouch")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_MULTITOUCH;
-              else if(strstr(temp2,"Joystick")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_JOYSTICK;
-              else if(strstr(temp2,"Camera")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_CAMERA;
-              else if(strstr(temp2,"Gesture")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_GESTURE;
-              else if(strstr(temp2,"RemoteControl")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
-              else msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_UNKNOWN;
-            } while(read_len < rem_len);
-          }
-        }
-        result = strstr (v, "hidc_cap_list");
-        if(result != NULL){
-          v = result;
-          WFD_SKIP_SPACE(v);
-          WFD_READ_CHAR_END_STRING(tstring, '=');
-          if(!g_strcmp0(tstring,"hidc_cap_list")) {
-            gchar inp_type[8192];
-            gchar inp_path[8192];
-            memset(temp2, 0, 8192);
-            rem_len=0;
-            read_len=0;
-            detailed_cap *temp_cap;
-            WFD_READ_CHAR_END_STRING(tstring, ';');
-            rem_len = strlen(tstring);
-            msg->uibc_capability->hidc_cap_list.next = g_new0 (detailed_cap, 1);
-            temp_cap = msg->uibc_capability->hidc_cap_list.next;
-            do {
-              msg->uibc_capability->hidc_cap_list.cap_count++;
-              read_string_char_ended (temp2, 8192, ',', tstring+read_len);
-              read_len += (strlen(temp2)+1);
-              read_string_type_and_value (inp_type, inp_path, sizeof(inp_type), sizeof(inp_path), '/',temp2);
-              if(strstr(inp_type,"Keyboard")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_KEYBOARD;
-              else if(strstr(inp_type,"Mouse")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_MOUSE;
-              else if(strstr(inp_type,"SingleTouch")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
-              else if(strstr(inp_type,"MultiTouch")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_MULTITOUCH;
-              else if(strstr(inp_type,"Joystick")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_JOYSTICK;
-              else if(strstr(inp_type,"Camera")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_CAMERA;
-              else if(strstr(inp_type,"Gesture")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_GESTURE;
-              else if(strstr(inp_type,"RemoteControl")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
-              else temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_UNKNOWN;
-
-              if(strstr(inp_path,"Infrared")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_INFRARED;
-              else if(strstr(inp_path,"USB")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_USB;
-              else if(strstr(inp_path,"BT")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_BT;
-              else if(strstr(inp_path,"Zigbee")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_ZIGBEE;
-              else if(strstr(inp_path,"Wi-Fi")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_WIFI;
-              else if(strstr(inp_path,"No-SP")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_NOSP;
-              else temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_UNKNOWN;
-              if(read_len < rem_len) {
-                temp_cap->next = g_new0 (detailed_cap, 1);
-                temp_cap = temp_cap->next;
-              }
-            } while(read_len < rem_len);
-          }
-        }
-        result = strstr(v,"port");
-        if(result != NULL) {
-          v = result;
-          WFD_READ_CHAR_END_STRING(tstring, '=');
-          if(!g_strcmp0(tstring,"port")) {
-            WFD_SKIP_EQUAL(v);
-            WFD_READ_CHAR_END_STRING(tstring, ';');
-            if(!strstr(tstring,"none")) {
-              msg->uibc_capability->tcp_port = strtoul (tstring, NULL, 10);
-            }
-          }
-        }
-      }
-    } else if (strstr(v,"none")) {
-      msg->uibc_capability->uibcsupported = FALSE;
-    }
-  } else if(!g_strcmp0(type,"wfd_uibc_setting")) {
-    msg->uibc_setting = g_new0 (WFDUibcSetting, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      if(!g_strcmp0(v, "enable"))
-        msg->uibc_setting->uibc_setting = TRUE;
-      else
-        msg->uibc_setting->uibc_setting = FALSE;
-    }
-  } else if(!g_strcmp0(type,"wfd_standby_resume_capability")) {
-    msg->standby_resume_capability = g_new0 (WFDStandbyResumeCapability, 1);
-    if(strlen(v)) {
-      WFD_SKIP_SPACE(v);
-      if(!g_strcmp0(v, "supported"))
-        msg->standby_resume_capability->standby_resume_cap = TRUE;
-      else
-        msg->standby_resume_capability->standby_resume_cap = FALSE;
-    }
-  } else if(!g_strcmp0(type,"wfd_standby")) {
-    msg->standby = g_new0 (WFDStandby, 1);
-    msg->standby->wfd_standby = TRUE;
-  } else if(!g_strcmp0(type,"wfd_connector_type")) {
-    msg->connector_type = g_new0 (WFDConnectorType, 1);
-    if(strlen(v)) {
-    msg->connector_type->supported = TRUE;
-    WFD_SKIP_SPACE(v);
-    WFD_READ_UINT32(msg->connector_type->connector_type);
-    }
-  } else if(!g_strcmp0(type,"wfd_idr_request")) {
-    msg->idr_request = g_new0 (WFDIdrRequest, 1);
-    msg->idr_request->idr_request = TRUE;
-  }
-
-  return TRUE;
+       gchar type[8192] = {0};
+       gchar value[8192] = {0};
+       gchar temp[8192] = {0};
+       gchar *p = buffer;
+       gchar *v = value;
+       gchar *result = NULL;
+
+#define WFD_SKIP_SPACE(q) if (*q && g_ascii_isspace(*q)) q++;
+#define WFD_SKIP_EQUAL(q) if (*q && *q == '=') q++;
+#define WFD_SKIP_COMMA(q) if (*q && g_ascii_ispunct(*q)) q++;
+#define WFD_READ_STRING(field) read_string_space_ended(temp, sizeof(temp), v); v += strlen(temp); REPLACE_STRING(field, temp);
+#define WFD_READ_CHAR_END_STRING(field, del) read_string_char_ended(temp, sizeof(temp), del, v); v += strlen(temp); REPLACE_STRING(field, temp);
+#define WFD_READ_UINT32(field) read_string_space_ended(temp, sizeof(temp), v); v += strlen(temp); field = strtoul(temp, NULL, 16);
+#define WFD_READ_UINT32_DIGIT(field) read_string_space_ended(temp, sizeof(temp), v); v += strlen(temp); field = strtoul(temp, NULL, 10);
+
+       /*g_print("wfdconfig_parse_line input: %s\n", buffer); */
+       read_string_type_and_value(type, value, sizeof(type), sizeof(value), ':', p);
+       /*g_print("wfdconfig_parse_line type:%s value:%s\n", type, value); */
+       if (!g_strcmp0(type, "wfd_audio_codecs")) {
+               msg->audio_codecs = g_new0(WFDAudioCodeclist, 1);
+               if (strlen(v)) {
+                       guint i = 0;
+                       msg->audio_codecs->count = strlen(v) / 16;
+                       msg->audio_codecs->list = g_new0(WFDAudioCodec, msg->audio_codecs->count);
+                       for (; i < msg->audio_codecs->count; i++) {
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_STRING(msg->audio_codecs->list[i].audio_format);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->audio_codecs->list[i].modes);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->audio_codecs->list[i].latency);
+                               WFD_SKIP_COMMA(v);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_video_formats")) {
+               msg->video_formats = g_new0(WFDVideoCodeclist, 1);
+               if (strlen(v)) {
+                       msg->video_formats->count = 1;
+                       msg->video_formats->list = g_new0(WFDVideoCodec, 1);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->native);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->preferred_display_mode_supported);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.profile);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.level);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.CEA_Support);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.VESA_Support);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.HH_Support);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.latency);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.min_slice_size);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
+                       WFD_SKIP_SPACE(v);
+                       if (msg->video_formats->list->preferred_display_mode_supported == 1) {
+                               WFD_READ_UINT32(msg->video_formats->list->H264_codec.max_hres);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->video_formats->list->H264_codec.max_vres);
+                               WFD_SKIP_SPACE(v);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_3d_video_formats")) {
+               msg->video_3d_formats = g_new0(WFD3DFormats, 1);
+               if (strlen(v)) {
+                       msg->video_3d_formats->count = 1;
+                       msg->video_3d_formats->list = g_new0(WFD3dCapList, 1);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->native);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->preferred_display_mode_supported);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.profile);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.level);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.video_3d_capability);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.latency);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.min_slice_size);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.slice_enc_params);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.misc_params.frame_rate_control_support);
+                       WFD_SKIP_SPACE(v);
+                       if (msg->video_3d_formats->list->preferred_display_mode_supported == 1) {
+                               WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.max_hres);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->video_3d_formats->list->H264_codec.max_vres);
+                               WFD_SKIP_SPACE(v);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_content_protection")) {
+               msg->content_protection = g_new0(WFDContentProtection, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       msg->content_protection->hdcp2_spec = g_new0(WFDHdcp2Spec, 1);
+                       if (strstr(v, "none")) {
+                               msg->content_protection->hdcp2_spec->hdcpversion = g_strdup("none");
+                       } else {
+                               WFD_READ_STRING(msg->content_protection->hdcp2_spec->hdcpversion);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_STRING(msg->content_protection->hdcp2_spec->TCPPort);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_display_edid")) {
+               msg->display_edid = g_new0(WFDDisplayEdid, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       if (strstr(v, "none")) {
+                               msg->display_edid->edid_supported = 0;
+                       } else {
+                               msg->display_edid->edid_supported = 1;
+                               WFD_READ_UINT32(msg->display_edid->edid_block_count);
+                               WFD_SKIP_SPACE(v);
+                               if (msg->display_edid->edid_block_count) {
+                                       gchar *edid_string = v;
+                                       int i = 0, j = 0, size = 0;
+                                       guint32 payload_size = EDID_BLOCK_SIZE * msg->display_edid->edid_block_count;
+                                       msg->display_edid->edid_payload = g_malloc(payload_size);
+                                       size = EDID_BLOCK_SIZE * msg->display_edid->edid_block_count * 2;
+                                       for (; i < size; j++) {
+                                               int k = 0, kk = 0;
+                                               if (edid_string[i] > 0x29 && edid_string[i] < 0x40) k = edid_string[i] - 48;
+                                               else if (edid_string[i] > 0x60 && edid_string[i] < 0x67) k = edid_string[i] - 87;
+                                               else if (edid_string[i] > 0x40 && edid_string[i] < 0x47) k = edid_string[i] - 55;
+
+                                               if (edid_string[i + 1] > 0x29 && edid_string[i + 1] < 0x40) kk = edid_string[i + 1] - 48;
+                                               else if (edid_string[i + 1] > 0x60 && edid_string[i + 1] < 0x67) kk = edid_string[i + 1] - 87;
+                                               else if (edid_string[i + 1] > 0x40 && edid_string[i + 1] < 0x47) kk = edid_string[i + 1] - 55;
+
+                                               msg->display_edid->edid_payload[j] = (k << 4) | kk;
+                                               i += 2;
+                                       }
+                                       /*memcpy(msg->display_edid->edid_payload, v, payload_size); */
+                                       v += (payload_size * 2);
+                               } else v += strlen(v);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_coupled_sink")) {
+               msg->coupled_sink = g_new0(WFDCoupledSink, 1);
+               if (strlen(v)) {
+                       msg->coupled_sink->coupled_sink_cap = g_new0(WFDCoupled_sink_cap, 1);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->coupled_sink->coupled_sink_cap->status);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->coupled_sink->coupled_sink_cap->sink_address);
+               }
+       } else if (!g_strcmp0(type, "wfd_trigger_method")) {
+               msg->trigger_method = g_new0(WFDTriggerMethod, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->trigger_method->wfd_trigger_method);
+               }
+       } else if (!g_strcmp0(type, "wfd_presentation_URL")) {
+               msg->presentation_url = g_new0(WFDPresentationUrl, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->presentation_url->wfd_url0);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->presentation_url->wfd_url1);
+               }
+       } else if (!g_strcmp0(type, "wfd_client_rtp_ports")) {
+               msg->client_rtp_ports = g_new0(WFDClientRtpPorts, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->client_rtp_ports->profile);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32_DIGIT(msg->client_rtp_ports->rtp_port0);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32_DIGIT(msg->client_rtp_ports->rtp_port1);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->client_rtp_ports->mode);
+               }
+       } else if (!g_strcmp0(type, "wfd_route")) {
+               msg->route = g_new0(WFDRoute, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_STRING(msg->route->destination);
+               }
+       } else if (!g_strcmp0(type, "wfd_I2C")) {
+               msg->I2C = g_new0(WFDI2C, 1);
+               if (strlen(v)) {
+                       msg->I2C->I2CPresent = TRUE;
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32_DIGIT(msg->I2C->I2C_port);
+                       if (msg->I2C->I2C_port) msg->I2C->I2CPresent = TRUE;
+               }
+       } else if (!g_strcmp0(type, "wfd_av_format_change_timing")) {
+               msg->av_format_change_timing = g_new0(WFDAVFormatChangeTiming, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->av_format_change_timing->PTS);
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->av_format_change_timing->DTS);
+               }
+       } else if (!g_strcmp0(type, "wfd_preferred_display_mode")) {
+               msg->preferred_display_mode = g_new0(WFDPreferredDisplayMode, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       if (!strstr(v, "none")) {
+                               msg->preferred_display_mode->displaymodesupported = FALSE;
+                       } else {
+                               WFD_READ_UINT32(msg->preferred_display_mode->p_clock);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->HB);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->HSPOL_HSOFF);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->HSW);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->V);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->VB);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->VSPOL_VSOFF);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->VSW);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->VBS3D);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->V2d_s3d_modes);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->P_depth);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.profile);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.level);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.CEA_Support);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.VESA_Support);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.HH_Support);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.latency);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.min_slice_size);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.slice_enc_params);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.misc_params.frame_rate_control_support);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.max_hres);
+                               WFD_SKIP_SPACE(v);
+                               WFD_READ_UINT32(msg->preferred_display_mode->H264_codec.max_vres);
+                               WFD_SKIP_SPACE(v);
+                       }
+               }
+       } else if (!g_strcmp0(type, "wfd_uibc_capability")) {
+               msg->uibc_capability = g_new0(WFDUibcCapability, 1);
+               if (strstr(v, "input_category_list")) {
+                       gchar *tstring = NULL;
+                       msg->uibc_capability->uibcsupported = TRUE;
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_CHAR_END_STRING(tstring, '=');
+                       if (!g_strcmp0(tstring, "input_category_list")) {
+                               gchar temp2[8192] = {0};
+                               guint rem_len = 0, read_len = 0;
+                               WFD_READ_CHAR_END_STRING(tstring, ';');
+                               rem_len = strlen(tstring);
+                               do {
+                                       WFD_SKIP_SPACE(v);
+                                       read_string_char_ended(temp2, 8192, ',', tstring + read_len);
+                                       read_len += (strlen(temp2) + 1);
+                                       if (strstr(temp2, "GENERIC")) msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_GENERIC;
+                                       else if (strstr(temp2, "HIDC")) msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_HIDC;
+                                       else msg->uibc_capability->input_category_list.input_cat |= WFD_UIBC_INPUT_CAT_UNKNOWN;
+                               } while (read_len < rem_len);
+
+                               result = strstr(v, "generic_cap_list");
+                               if (result != NULL) {
+                                       memset(temp2, 0, 8192);
+                                       rem_len = 0;
+                                       read_len = 0;
+                                       v = result;
+                                       WFD_READ_CHAR_END_STRING(tstring, '=');
+                                       if (!g_strcmp0(tstring, "generic_cap_list")) {
+                                               WFD_SKIP_SPACE(v);
+                                               WFD_READ_CHAR_END_STRING(tstring, ';');
+                                               rem_len = strlen(tstring);
+                                               do {
+                                                       read_string_char_ended(temp2, 8192, ',', tstring + read_len);
+                                                       read_len += (strlen(temp2) + 1);
+                                                       if (strstr(temp2, "Keyboard")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_KEYBOARD;
+                                                       else if (strstr(temp2, "Mouse")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_MOUSE;
+                                                       else if (strstr(temp2, "SingleTouch")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
+                                                       else if (strstr(temp2, "MultiTouch")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_MULTITOUCH;
+                                                       else if (strstr(temp2, "Joystick")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_JOYSTICK;
+                                                       else if (strstr(temp2, "Camera")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_CAMERA;
+                                                       else if (strstr(temp2, "Gesture")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_GESTURE;
+                                                       else if (strstr(temp2, "RemoteControl")) msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
+                                                       else msg->uibc_capability->generic_cap_list.inp_type |= WFD_UIBC_INPUT_TYPE_UNKNOWN;
+                                               } while (read_len < rem_len);
+                                       }
+                               }
+                               result = strstr(v, "hidc_cap_list");
+                               if (result != NULL) {
+                                       v = result;
+                                       WFD_SKIP_SPACE(v);
+                                       WFD_READ_CHAR_END_STRING(tstring, '=');
+                                       if (!g_strcmp0(tstring, "hidc_cap_list")) {
+                                               gchar inp_type[8192];
+                                               gchar inp_path[8192];
+                                               memset(temp2, 0, 8192);
+                                               rem_len = 0;
+                                               read_len = 0;
+                                               detailed_cap *temp_cap;
+                                               WFD_READ_CHAR_END_STRING(tstring, ';');
+                                               rem_len = strlen(tstring);
+                                               msg->uibc_capability->hidc_cap_list.next = g_new0(detailed_cap, 1);
+                                               temp_cap = msg->uibc_capability->hidc_cap_list.next;
+                                               do {
+                                                       msg->uibc_capability->hidc_cap_list.cap_count++;
+                                                       read_string_char_ended(temp2, 8192, ',', tstring + read_len);
+                                                       read_len += (strlen(temp2) + 1);
+                                                       read_string_type_and_value(inp_type, inp_path, sizeof(inp_type), sizeof(inp_path), '/', temp2);
+                                                       if (strstr(inp_type, "Keyboard")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_KEYBOARD;
+                                                       else if (strstr(inp_type, "Mouse")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_MOUSE;
+                                                       else if (strstr(inp_type, "SingleTouch")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_SINGLETOUCH;
+                                                       else if (strstr(inp_type, "MultiTouch")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_MULTITOUCH;
+                                                       else if (strstr(inp_type, "Joystick")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_JOYSTICK;
+                                                       else if (strstr(inp_type, "Camera")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_CAMERA;
+                                                       else if (strstr(inp_type, "Gesture")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_GESTURE;
+                                                       else if (strstr(inp_type, "RemoteControl")) temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_REMOTECONTROL;
+                                                       else temp_cap->p.inp_type = WFD_UIBC_INPUT_TYPE_UNKNOWN;
+
+                                                       if (strstr(inp_path, "Infrared")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_INFRARED;
+                                                       else if (strstr(inp_path, "USB")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_USB;
+                                                       else if (strstr(inp_path, "BT")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_BT;
+                                                       else if (strstr(inp_path, "Zigbee")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_ZIGBEE;
+                                                       else if (strstr(inp_path, "Wi-Fi")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_WIFI;
+                                                       else if (strstr(inp_path, "No-SP")) temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_NOSP;
+                                                       else temp_cap->p.inp_path = WFD_UIBC_INPUT_PATH_UNKNOWN;
+                                                       if (read_len < rem_len) {
+                                                               temp_cap->next = g_new0(detailed_cap, 1);
+                                                               temp_cap = temp_cap->next;
+                                                       }
+                                               } while (read_len < rem_len);
+                                       }
+                               }
+                               result = strstr(v, "port");
+                               if (result != NULL) {
+                                       v = result;
+                                       WFD_READ_CHAR_END_STRING(tstring, '=');
+                                       if (!g_strcmp0(tstring, "port")) {
+                                               WFD_SKIP_EQUAL(v);
+                                               WFD_READ_CHAR_END_STRING(tstring, ';');
+                                               if (!strstr(tstring, "none")) {
+                                                       msg->uibc_capability->tcp_port = strtoul(tstring, NULL, 10);
+                                               }
+                                       }
+                               }
+                       }
+               } else if (strstr(v, "none")) {
+                       msg->uibc_capability->uibcsupported = FALSE;
+               }
+       } else if (!g_strcmp0(type, "wfd_uibc_setting")) {
+               msg->uibc_setting = g_new0(WFDUibcSetting, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       if (!g_strcmp0(v, "enable"))
+                               msg->uibc_setting->uibc_setting = TRUE;
+                       else
+                               msg->uibc_setting->uibc_setting = FALSE;
+               }
+       } else if (!g_strcmp0(type, "wfd_standby_resume_capability")) {
+               msg->standby_resume_capability = g_new0(WFDStandbyResumeCapability, 1);
+               if (strlen(v)) {
+                       WFD_SKIP_SPACE(v);
+                       if (!g_strcmp0(v, "supported"))
+                               msg->standby_resume_capability->standby_resume_cap = TRUE;
+                       else
+                               msg->standby_resume_capability->standby_resume_cap = FALSE;
+               }
+       } else if (!g_strcmp0(type, "wfd_standby")) {
+               msg->standby = g_new0(WFDStandby, 1);
+               msg->standby->wfd_standby = TRUE;
+       } else if (!g_strcmp0(type, "wfd_connector_type")) {
+               msg->connector_type = g_new0(WFDConnectorType, 1);
+               if (strlen(v)) {
+                       msg->connector_type->supported = TRUE;
+                       WFD_SKIP_SPACE(v);
+                       WFD_READ_UINT32(msg->connector_type->connector_type);
+               }
+       } else if (!g_strcmp0(type, "wfd_idr_request")) {
+               msg->idr_request = g_new0(WFDIdrRequest, 1);
+               msg->idr_request->idr_request = TRUE;
+       }
+
+       return TRUE;
 }
 
 /**
@@ -1148,37 +1143,37 @@ wfdconfig_parse_line (WFDMessage * msg, gchar * buffer)
 * Returns: #WFD_OK on success.
 */
 WFDResult
-wfdconfig_message_parse_buffer (const guint8 * data, guint size, WFDMessage * msg)
+wfdconfig_message_parse_buffer(const guint8 *data, guint size, WFDMessage *msg)
 {
-  const gchar *p;
-  gchar buffer[MAX_LINE_LEN] = {0};
-  guint idx = 0;
-
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  g_return_val_if_fail (data != NULL, WFD_EINVAL);
-  g_return_val_if_fail (size != 0, WFD_EINVAL);
-
-  p = (const gchar *) data;
-  while (TRUE) {
-
-    if (*p == '\0')
-    break;
-
-    idx = 0;
-    while (*p != '\n' && *p != '\r' && *p != '\0') {
-      if (idx < sizeof (buffer) - 1)
-        buffer[idx++] = *p;
-      p++;
-    }
-    buffer[idx] = '\0';
-    wfdconfig_parse_line (msg, buffer);
-
-    if (*p == '\0')
-      break;
-    p+=2;
-  }
-
-  return WFD_OK;
+       const gchar *p;
+       gchar buffer[MAX_LINE_LEN] = {0};
+       guint idx = 0;
+
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(data != NULL, WFD_EINVAL);
+       g_return_val_if_fail(size != 0, WFD_EINVAL);
+
+       p = (const gchar *) data;
+       while (TRUE) {
+
+               if (*p == '\0')
+                       break;
+
+               idx = 0;
+               while (*p != '\n' && *p != '\r' && *p != '\0') {
+                       if (idx < sizeof(buffer) - 1)
+                               buffer[idx++] = *p;
+                       p++;
+               }
+               buffer[idx] = '\0';
+               wfdconfig_parse_line(msg, buffer);
+
+               if (*p == '\0')
+                       break;
+               p += 2;
+       }
+
+       return WFD_OK;
 }
 
 /**
@@ -1190,922 +1185,923 @@ wfdconfig_message_parse_buffer (const guint8 * data, guint size, WFDMessage * ms
 * Returns: a #WFDResult.
 */
 WFDResult
-wfdconfig_message_dump (const WFDMessage * msg)
+wfdconfig_message_dump(const WFDMessage *msg)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  wfd_debug("===========WFD Message dump=========");
-
-  if(msg->audio_codecs) {
-    guint i=0;
-    wfd_debug("Audio supported formats : \n");
-    for(;i<msg->audio_codecs->count;i++) {
-      wfd_debug("Codec: %s\n",msg->audio_codecs->list[i].audio_format);
-      if(!strcmp(msg->audio_codecs->list[i].audio_format,"LPCM")) {
-        if(msg->audio_codecs->list[i].modes & WFD_FREQ_44100)
-          wfd_debug("  Freq: %d\n", 44100);
-        if(msg->audio_codecs->list[i].modes & WFD_FREQ_48000)
-          wfd_debug("  Freq: %d\n", 48000);
-        wfd_debug("    Channels: %d\n", 2);
-      }
-      if(!strcmp(msg->audio_codecs->list[i].audio_format,"AAC")) {
-        wfd_debug("    Freq: %d\n", 48000);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_2)
-          wfd_debug("  Channels: %d\n", 2);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_4)
-          wfd_debug("  Channels: %d\n", 4);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_6)
-          wfd_debug("  Channels: %d\n", 6);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_8)
-          wfd_debug("  Channels: %d\n", 8);
-      }
-      if(!strcmp(msg->audio_codecs->list[i].audio_format,"AC3")) {
-        wfd_debug("    Freq: %d\n", 48000);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_2)
-          wfd_debug("  Channels: %d\n", 2);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_4)
-          wfd_debug("  Channels: %d\n", 4);
-        if(msg->audio_codecs->list[i].modes & WFD_CHANNEL_6)
-          wfd_debug("  Channels: %d\n", 6);
-      }
-      wfd_debug("      Bitwidth: %d\n", 16);
-      wfd_debug("      Latency: %d\n", msg->audio_codecs->list[i].latency);
-    }
-  }
-
-
-  if(msg->video_formats) {
-    wfd_debug("Video supported formats : \n");
-    if(msg->video_formats->list) {
-      wfd_debug("Codec: H264\n");
-      guint nativeindex = 0;
-      if((msg->video_formats->list->native & 0x7) == WFD_VIDEO_CEA_RESOLUTION) {
-        wfd_debug ("   Native type: CEA\n");
-      } else if((msg->video_formats->list->native & 0x7) == WFD_VIDEO_VESA_RESOLUTION) {
-        wfd_debug ("   Native type: VESA\n");
-      } else if((msg->video_formats->list->native & 0x7) == WFD_VIDEO_HH_RESOLUTION) {
-        wfd_debug ("   Native type: HH\n");
-      }
-      nativeindex = msg->video_formats->list->native >> 3;
-      wfd_debug ("     Resolution: %d\n", (1 << nativeindex));
-
-      if(msg->video_formats->list->H264_codec.profile & WFD_H264_BASE_PROFILE) {
-        wfd_debug ("   Profile: BASE\n");
-      } else if(msg->video_formats->list->H264_codec.profile & WFD_H264_HIGH_PROFILE) {
-        wfd_debug ("   Profile: HIGH\n");
-      } if(msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_3_1) {
-        wfd_debug ("   Level: 3.1\n");
-      } else if(msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_3_2) {
-        wfd_debug ("   Level: 3.2\n");
-      } else if(msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4) {
-        wfd_debug ("   Level: 4\n");
-      } else if(msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4_1) {
-        wfd_debug ("   Level: 4.1\n");
-      } else if(msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4_2) {
-        wfd_debug ("   Level: 4.2\n");
-      }
-      wfd_debug ("     Latency: %d\n", msg->video_formats->list->H264_codec.misc_params.latency);
-      wfd_debug ("     min_slice_size: %x\n", msg->video_formats->list->H264_codec.misc_params.min_slice_size);
-      wfd_debug ("     slice_enc_params: %x\n", msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
-      wfd_debug ("     frame_rate_control_support: %x\n", msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
-      if(msg->video_formats->list->H264_codec.max_hres) {
-        wfd_debug ("   Max Width: %04d\n", msg->video_formats->list->H264_codec.max_hres);
-      }
-      if(msg->video_formats->list->H264_codec.max_vres) {
-        wfd_debug ("   Max Height: %04d\n", msg->video_formats->list->H264_codec.max_vres);
-      }
-    }
-  }
-
-  if(msg->video_3d_formats) {
-    wfd_debug ("wfd_3d_formats");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->content_protection) {
-    wfd_debug ("wfd_content_protection");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->display_edid) {
-    wfd_debug ("wfd_display_edid");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->coupled_sink) {
-    wfd_debug ("wfd_coupled_sink");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->trigger_method) {
-    wfd_debug ("       Trigger type: %s\n", msg->trigger_method->wfd_trigger_method);
-  }
-
-  if(msg->presentation_url) {
-    wfd_debug ("wfd_presentation_URL");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->client_rtp_ports) {
-    wfd_debug(" Client RTP Ports : \n");
-    if(msg->client_rtp_ports->profile) {
-      wfd_debug ("%s\n", msg->client_rtp_ports->profile);
-      wfd_debug ("     %d\n", msg->client_rtp_ports->rtp_port0);
-      wfd_debug ("     %d\n", msg->client_rtp_ports->rtp_port1);
-      wfd_debug ("     %s\n", msg->client_rtp_ports->mode);
-    }
-    wfd_debug("\r\n");
-  }
-
-  if(msg->route) {
-    wfd_debug ("wfd_route");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->I2C) {
-    wfd_debug ("wfd_I2C");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->av_format_change_timing) {
-    wfd_debug ("wfd_av_format_change_timing");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->preferred_display_mode) {
-    wfd_debug ("wfd_preferred_display_mode");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->uibc_capability) {
-    wfd_debug ("wfd_uibc_capability \r\n");
-    wfd_debug ("input category list:");
-    if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC)
-      wfd_debug ("GENERIC");
-    if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC)
-      wfd_debug ("HIDC");
-    if(!msg->uibc_capability->input_category_list.input_cat)
-      wfd_debug ("none");
-    if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC) {
-      wfd_debug ("generic cap list: ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD)
-        wfd_debug("keyboard ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE)
-        wfd_debug("mouse ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH)
-        wfd_debug("single-touch ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH)
-        wfd_debug("multi-touch ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK)
-        wfd_debug("joystick ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA)
-        wfd_debug("camera ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE)
-        wfd_debug("gesture ");
-      if(msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL)
-        wfd_debug("remote control ");
-      if(!msg->uibc_capability->generic_cap_list.inp_type)
-        wfd_debug("none ");
-    }
-    if(msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC) {
-      wfd_debug ("hidc cap list:");
-      if(msg->uibc_capability->hidc_cap_list.cap_count) {
-        detailed_cap *temp_cap = msg->uibc_capability->hidc_cap_list.next;
-        while (temp_cap) {
-          if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD) {
-            wfd_debug("keyboard ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE) {
-            wfd_debug("mouse ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH) {
-            wfd_debug("single-touch ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH) {
-            wfd_debug("multi-touch ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK) {
-            wfd_debug("joystick ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA) {
-            wfd_debug("camera ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE) {
-            wfd_debug("gesture ");
-          } else if(temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL) {
-            wfd_debug("remote control ");
-          } else if(!temp_cap->p.inp_type) {
-            wfd_debug("none ");
-          }
-          if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_INFRARED) {
-            wfd_debug("infrared");
-          } else if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_USB) {
-            wfd_debug("usb");
-          } else if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_BT) {
-            wfd_debug("bluetooth");
-          } else if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_WIFI) {
-            wfd_debug("Wi-Fi");
-          } else if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_ZIGBEE) {
-            wfd_debug("Zigbee");
-          } else if(temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_NOSP) {
-            wfd_debug("No-SP");
-          } else if(!temp_cap->p.inp_path) {
-            wfd_debug("none");
-          }
-          temp_cap = temp_cap->next;
-        }
-      }
-    }
-    if(msg->uibc_capability->tcp_port)
-      wfd_debug("tcp port:%u", msg->uibc_capability->tcp_port);
-    if(!msg->uibc_capability->tcp_port)
-      wfd_debug ("tcp port: none");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->uibc_setting) {
-    wfd_debug ("wfd_uibc_setting: ");
-    if(msg->uibc_setting->uibc_setting) {
-      wfd_debug("true");
-    } else wfd_debug("false");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->standby_resume_capability) {
-    wfd_debug ("wfd_standby_resume_capability");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->standby) {
-    wfd_debug ("wfd_standby");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->connector_type) {
-    wfd_debug ("wfd_connector_type");
-    wfd_debug ("\r\n");
-  }
-
-  if(msg->idr_request) {
-    wfd_debug ("wfd_idr_request");
-    wfd_debug ("\r\n");
-  }
-
-  wfd_debug("===============================================\n");
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       wfd_debug("===========WFD Message dump=========");
+
+       if (msg->audio_codecs) {
+               guint i = 0;
+               wfd_debug("Audio supported formats : \n");
+               for (; i < msg->audio_codecs->count; i++) {
+                       wfd_debug("Codec: %s\n", msg->audio_codecs->list[i].audio_format);
+                       if (!strcmp(msg->audio_codecs->list[i].audio_format, "LPCM")) {
+                               if (msg->audio_codecs->list[i].modes & WFD_FREQ_44100)
+                                       wfd_debug("     Freq: %d\n", 44100);
+                               if (msg->audio_codecs->list[i].modes & WFD_FREQ_48000)
+                                       wfd_debug("     Freq: %d\n", 48000);
+                               wfd_debug("     Channels: %d\n", 2);
+                       }
+                       if (!strcmp(msg->audio_codecs->list[i].audio_format, "AAC")) {
+                               wfd_debug("     Freq: %d\n", 48000);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_2)
+                                       wfd_debug("     Channels: %d\n", 2);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_4)
+                                       wfd_debug("     Channels: %d\n", 4);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_6)
+                                       wfd_debug("     Channels: %d\n", 6);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_8)
+                                       wfd_debug("     Channels: %d\n", 8);
+                       }
+                       if (!strcmp(msg->audio_codecs->list[i].audio_format, "AC3")) {
+                               wfd_debug("     Freq: %d\n", 48000);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_2)
+                                       wfd_debug("     Channels: %d\n", 2);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_4)
+                                       wfd_debug("     Channels: %d\n", 4);
+                               if (msg->audio_codecs->list[i].modes & WFD_CHANNEL_6)
+                                       wfd_debug("     Channels: %d\n", 6);
+                       }
+                       wfd_debug("     Bitwidth: %d\n", 16);
+                       wfd_debug("     Latency: %d\n", msg->audio_codecs->list[i].latency);
+               }
+       }
+
+
+       if (msg->video_formats) {
+               wfd_debug("Video supported formats : \n");
+               if (msg->video_formats->list) {
+                       wfd_debug("Codec: H264\n");
+                       guint nativeindex = 0;
+                       if ((msg->video_formats->list->native & 0x7) == WFD_VIDEO_CEA_RESOLUTION) {
+                               wfd_debug("     Native type: CEA\n");
+                       } else if ((msg->video_formats->list->native & 0x7) == WFD_VIDEO_VESA_RESOLUTION) {
+                               wfd_debug("     Native type: VESA\n");
+                       } else if ((msg->video_formats->list->native & 0x7) == WFD_VIDEO_HH_RESOLUTION) {
+                               wfd_debug("     Native type: HH\n");
+                       }
+                       nativeindex = msg->video_formats->list->native >> 3;
+                       wfd_debug("     Resolution: %d\n", (1 << nativeindex));
+
+                       if (msg->video_formats->list->H264_codec.profile & WFD_H264_BASE_PROFILE) {
+                               wfd_debug("     Profile: BASE\n");
+                       } else if (msg->video_formats->list->H264_codec.profile & WFD_H264_HIGH_PROFILE) {
+                               wfd_debug("     Profile: HIGH\n");
+                       }
+                       if (msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_3_1) {
+                               wfd_debug("     Level: 3.1\n");
+                       } else if (msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_3_2) {
+                               wfd_debug("     Level: 3.2\n");
+                       } else if (msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4) {
+                               wfd_debug("     Level: 4\n");
+                       } else if (msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4_1) {
+                               wfd_debug("     Level: 4.1\n");
+                       } else if (msg->video_formats->list->H264_codec.level & WFD_H264_LEVEL_4_2) {
+                               wfd_debug("     Level: 4.2\n");
+                       }
+                       wfd_debug("     Latency: %d\n", msg->video_formats->list->H264_codec.misc_params.latency);
+                       wfd_debug("     min_slice_size: %x\n", msg->video_formats->list->H264_codec.misc_params.min_slice_size);
+                       wfd_debug("     slice_enc_params: %x\n", msg->video_formats->list->H264_codec.misc_params.slice_enc_params);
+                       wfd_debug("     frame_rate_control_support: %x\n", msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support);
+                       if (msg->video_formats->list->H264_codec.max_hres) {
+                               wfd_debug("     Max Width: %04d\n", msg->video_formats->list->H264_codec.max_hres);
+                       }
+                       if (msg->video_formats->list->H264_codec.max_vres) {
+                               wfd_debug("     Max Height: %04d\n", msg->video_formats->list->H264_codec.max_vres);
+                       }
+               }
+       }
+
+       if (msg->video_3d_formats) {
+               wfd_debug("wfd_3d_formats");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->content_protection) {
+               wfd_debug("wfd_content_protection");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->display_edid) {
+               wfd_debug("wfd_display_edid");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->coupled_sink) {
+               wfd_debug("wfd_coupled_sink");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->trigger_method) {
+               wfd_debug("     Trigger type: %s\n", msg->trigger_method->wfd_trigger_method);
+       }
+
+       if (msg->presentation_url) {
+               wfd_debug("wfd_presentation_URL");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->client_rtp_ports) {
+               wfd_debug(" Client RTP Ports : \n");
+               if (msg->client_rtp_ports->profile) {
+                       wfd_debug("%s\n", msg->client_rtp_ports->profile);
+                       wfd_debug("     %d\n", msg->client_rtp_ports->rtp_port0);
+                       wfd_debug("     %d\n", msg->client_rtp_ports->rtp_port1);
+                       wfd_debug("     %s\n", msg->client_rtp_ports->mode);
+               }
+               wfd_debug("\r\n");
+       }
+
+       if (msg->route) {
+               wfd_debug("wfd_route");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->I2C) {
+               wfd_debug("wfd_I2C");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->av_format_change_timing) {
+               wfd_debug("wfd_av_format_change_timing");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->preferred_display_mode) {
+               wfd_debug("wfd_preferred_display_mode");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->uibc_capability) {
+               wfd_debug("wfd_uibc_capability \r\n");
+               wfd_debug("input category list:");
+               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC)
+                       wfd_debug("GENERIC");
+               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC)
+                       wfd_debug("HIDC");
+               if (!msg->uibc_capability->input_category_list.input_cat)
+                       wfd_debug("none");
+               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_GENERIC) {
+                       wfd_debug("generic cap list: ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD)
+                               wfd_debug("keyboard ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE)
+                               wfd_debug("mouse ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH)
+                               wfd_debug("single-touch ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH)
+                               wfd_debug("multi-touch ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK)
+                               wfd_debug("joystick ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA)
+                               wfd_debug("camera ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE)
+                               wfd_debug("gesture ");
+                       if (msg->uibc_capability->generic_cap_list.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL)
+                               wfd_debug("remote control ");
+                       if (!msg->uibc_capability->generic_cap_list.inp_type)
+                               wfd_debug("none ");
+               }
+               if (msg->uibc_capability->input_category_list.input_cat & WFD_UIBC_INPUT_CAT_HIDC) {
+                       wfd_debug("hidc cap list:");
+                       if (msg->uibc_capability->hidc_cap_list.cap_count) {
+                               detailed_cap *temp_cap = msg->uibc_capability->hidc_cap_list.next;
+                               while (temp_cap) {
+                                       if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_KEYBOARD) {
+                                               wfd_debug("keyboard ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_MOUSE) {
+                                               wfd_debug("mouse ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_SINGLETOUCH) {
+                                               wfd_debug("single-touch ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_MULTITOUCH) {
+                                               wfd_debug("multi-touch ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_JOYSTICK) {
+                                               wfd_debug("joystick ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_CAMERA) {
+                                               wfd_debug("camera ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_GESTURE) {
+                                               wfd_debug("gesture ");
+                                       } else if (temp_cap->p.inp_type & WFD_UIBC_INPUT_TYPE_REMOTECONTROL) {
+                                               wfd_debug("remote control ");
+                                       } else if (!temp_cap->p.inp_type) {
+                                               wfd_debug("none ");
+                                       }
+                                       if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_INFRARED) {
+                                               wfd_debug("infrared");
+                                       } else if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_USB) {
+                                               wfd_debug("usb");
+                                       } else if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_BT) {
+                                               wfd_debug("bluetooth");
+                                       } else if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_WIFI) {
+                                               wfd_debug("Wi-Fi");
+                                       } else if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_ZIGBEE) {
+                                               wfd_debug("Zigbee");
+                                       } else if (temp_cap->p.inp_path & WFD_UIBC_INPUT_PATH_NOSP) {
+                                               wfd_debug("No-SP");
+                                       } else if (!temp_cap->p.inp_path) {
+                                               wfd_debug("none");
+                                       }
+                                       temp_cap = temp_cap->next;
+                               }
+                       }
+               }
+               if (msg->uibc_capability->tcp_port)
+                       wfd_debug("tcp port:%u", msg->uibc_capability->tcp_port);
+               if (!msg->uibc_capability->tcp_port)
+                       wfd_debug("tcp port: none");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->uibc_setting) {
+               wfd_debug("wfd_uibc_setting: ");
+               if (msg->uibc_setting->uibc_setting) {
+                       wfd_debug("true");
+               } else wfd_debug("false");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->standby_resume_capability) {
+               wfd_debug("wfd_standby_resume_capability");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->standby) {
+               wfd_debug("wfd_standby");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->connector_type) {
+               wfd_debug("wfd_connector_type");
+               wfd_debug("\r\n");
+       }
+
+       if (msg->idr_request) {
+               wfd_debug("wfd_idr_request");
+               wfd_debug("\r\n");
+       }
+
+       wfd_debug("===============================================\n");
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_supported_audio_format(WFDMessage *msg, WFDAudioFormats aCodec, guint aFreq, guint aChanels,
-                                                                                              guint aBitwidth, guint32 aLatency)
+                                               guint aBitwidth, guint32 aLatency)
 {
-  guint temp = aCodec;
-  guint i = 0;
-  guint pcm = 0, aac = 0, ac3 = 0;
-
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->audio_codecs)
-    msg->audio_codecs = g_new0 (WFDAudioCodeclist, 1);
-
-  if(aCodec != WFD_AUDIO_UNKNOWN) {
-    while(temp) {
-      msg->audio_codecs->count++;
-      temp >>= 1;
-    }
-    msg->audio_codecs->list = g_new0 (WFDAudioCodec, msg->audio_codecs->count);
-    for(; i<msg->audio_codecs->count; i++) {
-      if((aCodec & WFD_AUDIO_LPCM) && (!pcm)) {
-        msg->audio_codecs->list[i].audio_format = g_strdup("LPCM");
-        msg->audio_codecs->list[i].modes = aFreq;
-        msg->audio_codecs->list[i].latency = aLatency;
-        pcm = 1;
-      } else if((aCodec & WFD_AUDIO_AAC) && (!aac)) {
-        msg->audio_codecs->list[i].audio_format = g_strdup("AAC");
-        msg->audio_codecs->list[i].modes = aChanels;
-        msg->audio_codecs->list[i].latency = aLatency;
-        aac = 1;
-      } else if((aCodec & WFD_AUDIO_AC3) && (!ac3)) {
-        msg->audio_codecs->list[i].audio_format = g_strdup("AC3");
-        msg->audio_codecs->list[i].modes = aChanels;
-        msg->audio_codecs->list[i].latency = aLatency;
-        ac3 = 1;
-      }
-    }
-  }
-  return WFD_OK;
+       guint temp = aCodec;
+       guint i = 0;
+       guint pcm = 0, aac = 0, ac3 = 0;
+
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->audio_codecs)
+               msg->audio_codecs = g_new0(WFDAudioCodeclist, 1);
+
+       if (aCodec != WFD_AUDIO_UNKNOWN) {
+               while (temp) {
+                       msg->audio_codecs->count++;
+                       temp >>= 1;
+               }
+               msg->audio_codecs->list = g_new0(WFDAudioCodec, msg->audio_codecs->count);
+               for (; i < msg->audio_codecs->count; i++) {
+                       if ((aCodec & WFD_AUDIO_LPCM) && (!pcm)) {
+                               msg->audio_codecs->list[i].audio_format = g_strdup("LPCM");
+                               msg->audio_codecs->list[i].modes = aFreq;
+                               msg->audio_codecs->list[i].latency = aLatency;
+                               pcm = 1;
+                       } else if ((aCodec & WFD_AUDIO_AAC) && (!aac)) {
+                               msg->audio_codecs->list[i].audio_format = g_strdup("AAC");
+                               msg->audio_codecs->list[i].modes = aChanels;
+                               msg->audio_codecs->list[i].latency = aLatency;
+                               aac = 1;
+                       } else if ((aCodec & WFD_AUDIO_AC3) && (!ac3)) {
+                               msg->audio_codecs->list[i].audio_format = g_strdup("AC3");
+                               msg->audio_codecs->list[i].modes = aChanels;
+                               msg->audio_codecs->list[i].latency = aLatency;
+                               ac3 = 1;
+                       }
+               }
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_prefered_audio_format(WFDMessage *msg, WFDAudioFormats aCodec, WFDAudioFreq aFreq, WFDAudioChannels aChanels,
-                                                                                          guint aBitwidth, guint32 aLatency)
+                                              guint aBitwidth, guint32 aLatency)
 {
 
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->audio_codecs)
-    msg->audio_codecs = g_new0 (WFDAudioCodeclist, 1);
-
-  msg->audio_codecs->list = g_new0 (WFDAudioCodec, 1);
-  msg->audio_codecs->count = 1;
-  if(aCodec == WFD_AUDIO_LPCM) {
-    msg->audio_codecs->list->audio_format = g_strdup("LPCM");
-    msg->audio_codecs->list->modes = aFreq;
-    msg->audio_codecs->list->latency = aLatency;
-  } else if(aCodec == WFD_AUDIO_AAC) {
-    msg->audio_codecs->list->audio_format = g_strdup("AAC");
-    msg->audio_codecs->list->modes = aChanels;
-    msg->audio_codecs->list->latency = aLatency;
-  } else if(aCodec == WFD_AUDIO_AC3) {
-    msg->audio_codecs->list->audio_format = g_strdup("AC3");
-    msg->audio_codecs->list->modes = aChanels;
-    msg->audio_codecs->list->latency = aLatency;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->audio_codecs)
+               msg->audio_codecs = g_new0(WFDAudioCodeclist, 1);
+
+       msg->audio_codecs->list = g_new0(WFDAudioCodec, 1);
+       msg->audio_codecs->count = 1;
+       if (aCodec == WFD_AUDIO_LPCM) {
+               msg->audio_codecs->list->audio_format = g_strdup("LPCM");
+               msg->audio_codecs->list->modes = aFreq;
+               msg->audio_codecs->list->latency = aLatency;
+       } else if (aCodec == WFD_AUDIO_AAC) {
+               msg->audio_codecs->list->audio_format = g_strdup("AAC");
+               msg->audio_codecs->list->modes = aChanels;
+               msg->audio_codecs->list->latency = aLatency;
+       } else if (aCodec == WFD_AUDIO_AC3) {
+               msg->audio_codecs->list->audio_format = g_strdup("AC3");
+               msg->audio_codecs->list->modes = aChanels;
+               msg->audio_codecs->list->latency = aLatency;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_supported_audio_format(WFDMessage *msg, guint *aCodec, guint *aFreq, guint *aChanels,
-                                                                                             guint *aBitwidth, guint32 *aLatency)
+                                               guint *aBitwidth, guint32 *aLatency)
 {
-  guint i = 0;
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->audio_codecs != NULL, WFD_EINVAL);
-
-  for(; i<msg->audio_codecs->count; i++) {
-    if(!g_strcmp0(msg->audio_codecs->list[i].audio_format,"LPCM")) {
-      *aCodec |= WFD_AUDIO_LPCM;
-      *aFreq |= msg->audio_codecs->list[i].modes;
-      *aChanels |= WFD_CHANNEL_2;
-      *aBitwidth = 16;
-      *aLatency = msg->audio_codecs->list[i].latency;
-    } else if(!g_strcmp0(msg->audio_codecs->list[i].audio_format,"AAC")) {
-      *aCodec |= WFD_AUDIO_AAC;
-      *aFreq |= WFD_FREQ_48000;
-      *aChanels |= msg->audio_codecs->list[i].modes;
-      *aBitwidth = 16;
-      *aLatency = msg->audio_codecs->list[i].latency;
-    } else if(!g_strcmp0(msg->audio_codecs->list[i].audio_format,"AC3")) {
-      *aCodec |= WFD_AUDIO_AC3;
-      *aFreq |= WFD_FREQ_48000;
-      *aChanels |= msg->audio_codecs->list[i].modes;
-      *aBitwidth = 16;
-      *aLatency = msg->audio_codecs->list[i].latency;
-    }
-  }
-  return WFD_OK;
+       guint i = 0;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->audio_codecs != NULL, WFD_EINVAL);
+
+       for (; i < msg->audio_codecs->count; i++) {
+               if (!g_strcmp0(msg->audio_codecs->list[i].audio_format, "LPCM")) {
+                       *aCodec |= WFD_AUDIO_LPCM;
+                       *aFreq |= msg->audio_codecs->list[i].modes;
+                       *aChanels |= WFD_CHANNEL_2;
+                       *aBitwidth = 16;
+                       *aLatency = msg->audio_codecs->list[i].latency;
+               } else if (!g_strcmp0(msg->audio_codecs->list[i].audio_format, "AAC")) {
+                       *aCodec |= WFD_AUDIO_AAC;
+                       *aFreq |= WFD_FREQ_48000;
+                       *aChanels |= msg->audio_codecs->list[i].modes;
+                       *aBitwidth = 16;
+                       *aLatency = msg->audio_codecs->list[i].latency;
+               } else if (!g_strcmp0(msg->audio_codecs->list[i].audio_format, "AC3")) {
+                       *aCodec |= WFD_AUDIO_AC3;
+                       *aFreq |= WFD_FREQ_48000;
+                       *aChanels |= msg->audio_codecs->list[i].modes;
+                       *aBitwidth = 16;
+                       *aLatency = msg->audio_codecs->list[i].latency;
+               }
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_prefered_audio_format(WFDMessage *msg, WFDAudioFormats *aCodec, WFDAudioFreq *aFreq, WFDAudioChannels *aChanels,
-                                                                                          guint *aBitwidth, guint32 *aLatency)
+                                              guint *aBitwidth, guint32 *aLatency)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!g_strcmp0(msg->audio_codecs->list->audio_format,"LPCM")) {
-    *aCodec = WFD_AUDIO_LPCM;
-    *aFreq = msg->audio_codecs->list->modes;
-    *aChanels = WFD_CHANNEL_2;
-    *aBitwidth = 16;
-    *aLatency = msg->audio_codecs->list->latency;
-  } else if(!g_strcmp0(msg->audio_codecs->list->audio_format,"AAC")) {
-    *aCodec = WFD_AUDIO_AAC;
-    *aFreq = WFD_FREQ_48000;
-    *aChanels = msg->audio_codecs->list->modes;
-    *aBitwidth = 16;
-    *aLatency = msg->audio_codecs->list->latency;
-  } else if(!g_strcmp0(msg->audio_codecs->list->audio_format,"AC3")) {
-    *aCodec = WFD_AUDIO_AC3;
-    *aFreq = WFD_FREQ_48000;
-    *aChanels = msg->audio_codecs->list->modes;
-    *aBitwidth = 16;
-    *aLatency = msg->audio_codecs->list->latency;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!g_strcmp0(msg->audio_codecs->list->audio_format, "LPCM")) {
+               *aCodec = WFD_AUDIO_LPCM;
+               *aFreq = msg->audio_codecs->list->modes;
+               *aChanels = WFD_CHANNEL_2;
+               *aBitwidth = 16;
+               *aLatency = msg->audio_codecs->list->latency;
+       } else if (!g_strcmp0(msg->audio_codecs->list->audio_format, "AAC")) {
+               *aCodec = WFD_AUDIO_AAC;
+               *aFreq = WFD_FREQ_48000;
+               *aChanels = msg->audio_codecs->list->modes;
+               *aBitwidth = 16;
+               *aLatency = msg->audio_codecs->list->latency;
+       } else if (!g_strcmp0(msg->audio_codecs->list->audio_format, "AC3")) {
+               *aCodec = WFD_AUDIO_AC3;
+               *aFreq = WFD_FREQ_48000;
+               *aChanels = msg->audio_codecs->list->modes;
+               *aBitwidth = 16;
+               *aLatency = msg->audio_codecs->list->latency;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_supported_video_format(WFDMessage *msg, WFDVideoCodecs vCodec,
-                      WFDVideoNativeResolution vNative, guint64 vNativeResolution,
-                      guint64 vCEAResolution, guint64 vVESAResolution, guint64 vHHResolution,
-                      guint vProfile, guint vLevel, guint32 vLatency, guint32 vMaxHeight,
-                      guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control)
+                                               WFDVideoNativeResolution vNative, guint64 vNativeResolution,
+                                               guint64 vCEAResolution, guint64 vVESAResolution, guint64 vHHResolution,
+                                               guint vProfile, guint vLevel, guint32 vLatency, guint32 vMaxHeight,
+                                               guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control)
 {
-  guint nativeindex = 0;
-  guint64 temp = vNativeResolution;
-
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->video_formats)
-  msg->video_formats = g_new0 (WFDVideoCodeclist, 1);
-
-  if(vCodec != WFD_VIDEO_UNKNOWN) {
-    msg->video_formats->list = g_new0 (WFDVideoCodec, 1);
-    while(temp) {
-      nativeindex++;
-      temp >>= 1;
-    }
-
-    msg->video_formats->list->native = nativeindex-1;
-    msg->video_formats->list->native <<= 3;
-
-    if(vNative == WFD_VIDEO_VESA_RESOLUTION)
-      msg->video_formats->list->native |= 1;
-    else if(vNative == WFD_VIDEO_HH_RESOLUTION)
-      msg->video_formats->list->native |= 2;
-
-    msg->video_formats->list->preferred_display_mode_supported = 1;
-    msg->video_formats->list->H264_codec.profile = vProfile;
-    msg->video_formats->list->H264_codec.level = vLevel;
-    msg->video_formats->list->H264_codec.max_hres = vMaxWidth;
-    msg->video_formats->list->H264_codec.max_vres = vMaxHeight;
-    msg->video_formats->list->H264_codec.misc_params.CEA_Support = vCEAResolution;
-    msg->video_formats->list->H264_codec.misc_params.VESA_Support = vVESAResolution;
-    msg->video_formats->list->H264_codec.misc_params.HH_Support = vHHResolution;
-    msg->video_formats->list->H264_codec.misc_params.latency = vLatency;
-    msg->video_formats->list->H264_codec.misc_params.min_slice_size = min_slice_size;
-    msg->video_formats->list->H264_codec.misc_params.slice_enc_params = slice_enc_params;
-    msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support = frame_rate_control;
-  }
-  return WFD_OK;
+       guint nativeindex = 0;
+       guint64 temp = vNativeResolution;
+
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->video_formats)
+               msg->video_formats = g_new0(WFDVideoCodeclist, 1);
+
+       if (vCodec != WFD_VIDEO_UNKNOWN) {
+               msg->video_formats->list = g_new0(WFDVideoCodec, 1);
+               while (temp) {
+                       nativeindex++;
+                       temp >>= 1;
+               }
+
+               msg->video_formats->list->native = nativeindex - 1;
+               msg->video_formats->list->native <<= 3;
+
+               if (vNative == WFD_VIDEO_VESA_RESOLUTION)
+                       msg->video_formats->list->native |= 1;
+               else if (vNative == WFD_VIDEO_HH_RESOLUTION)
+                       msg->video_formats->list->native |= 2;
+
+               msg->video_formats->list->preferred_display_mode_supported = 1;
+               msg->video_formats->list->H264_codec.profile = vProfile;
+               msg->video_formats->list->H264_codec.level = vLevel;
+               msg->video_formats->list->H264_codec.max_hres = vMaxWidth;
+               msg->video_formats->list->H264_codec.max_vres = vMaxHeight;
+               msg->video_formats->list->H264_codec.misc_params.CEA_Support = vCEAResolution;
+               msg->video_formats->list->H264_codec.misc_params.VESA_Support = vVESAResolution;
+               msg->video_formats->list->H264_codec.misc_params.HH_Support = vHHResolution;
+               msg->video_formats->list->H264_codec.misc_params.latency = vLatency;
+               msg->video_formats->list->H264_codec.misc_params.min_slice_size = min_slice_size;
+               msg->video_formats->list->H264_codec.misc_params.slice_enc_params = slice_enc_params;
+               msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support = frame_rate_control;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_prefered_video_format(WFDMessage *msg, WFDVideoCodecs vCodec,
-                  WFDVideoNativeResolution vNative, guint64 vNativeResolution,
-                  WFDVideoCEAResolution vCEAResolution, WFDVideoVESAResolution vVESAResolution,
-                  WFDVideoHHResolution vHHResolution,  WFDVideoH264Profile vProfile,
-                  WFDVideoH264Level vLevel, guint32 vLatency, guint32 vMaxHeight,
-                  guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control)
+                                              WFDVideoNativeResolution vNative, guint64 vNativeResolution,
+                                              WFDVideoCEAResolution vCEAResolution, WFDVideoVESAResolution vVESAResolution,
+                                              WFDVideoHHResolution vHHResolution,      WFDVideoH264Profile vProfile,
+                                              WFDVideoH264Level vLevel, guint32 vLatency, guint32 vMaxHeight,
+                                              guint32 vMaxWidth, guint32 min_slice_size, guint32 slice_enc_params, guint frame_rate_control)
 {
-  guint nativeindex = 0;
-  guint64 temp = vNativeResolution;
-
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->video_formats)
-    msg->video_formats = g_new0 (WFDVideoCodeclist, 1);
-  msg->video_formats->list = g_new0 (WFDVideoCodec, 1);
-
-  while(temp) {
-    nativeindex++;
-    temp >>= 1;
-  }
-
-  if(nativeindex) msg->video_formats->list->native = nativeindex-1;
-  msg->video_formats->list->native <<= 3;
-
-  if(vNative == WFD_VIDEO_VESA_RESOLUTION)
-    msg->video_formats->list->native |= 1;
-  else if(vNative == WFD_VIDEO_HH_RESOLUTION)
-    msg->video_formats->list->native |= 2;
-
-  msg->video_formats->list->preferred_display_mode_supported = 0;
-  msg->video_formats->list->H264_codec.profile = vProfile;
-  msg->video_formats->list->H264_codec.level = vLevel;
-  msg->video_formats->list->H264_codec.max_hres = vMaxWidth;
-  msg->video_formats->list->H264_codec.max_vres = vMaxHeight;
-  msg->video_formats->list->H264_codec.misc_params.CEA_Support = vCEAResolution;
-  msg->video_formats->list->H264_codec.misc_params.VESA_Support = vVESAResolution;
-  msg->video_formats->list->H264_codec.misc_params.HH_Support = vHHResolution;
-  msg->video_formats->list->H264_codec.misc_params.latency = vLatency;
-  msg->video_formats->list->H264_codec.misc_params.min_slice_size = min_slice_size;
-  msg->video_formats->list->H264_codec.misc_params.slice_enc_params = slice_enc_params;
-  msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support = frame_rate_control;
-  return WFD_OK;
+       guint nativeindex = 0;
+       guint64 temp = vNativeResolution;
+
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->video_formats)
+               msg->video_formats = g_new0(WFDVideoCodeclist, 1);
+       msg->video_formats->list = g_new0(WFDVideoCodec, 1);
+
+       while (temp) {
+               nativeindex++;
+               temp >>= 1;
+       }
+
+       if (nativeindex) msg->video_formats->list->native = nativeindex - 1;
+       msg->video_formats->list->native <<= 3;
+
+       if (vNative == WFD_VIDEO_VESA_RESOLUTION)
+               msg->video_formats->list->native |= 1;
+       else if (vNative == WFD_VIDEO_HH_RESOLUTION)
+               msg->video_formats->list->native |= 2;
+
+       msg->video_formats->list->preferred_display_mode_supported = 0;
+       msg->video_formats->list->H264_codec.profile = vProfile;
+       msg->video_formats->list->H264_codec.level = vLevel;
+       msg->video_formats->list->H264_codec.max_hres = vMaxWidth;
+       msg->video_formats->list->H264_codec.max_vres = vMaxHeight;
+       msg->video_formats->list->H264_codec.misc_params.CEA_Support = vCEAResolution;
+       msg->video_formats->list->H264_codec.misc_params.VESA_Support = vVESAResolution;
+       msg->video_formats->list->H264_codec.misc_params.HH_Support = vHHResolution;
+       msg->video_formats->list->H264_codec.misc_params.latency = vLatency;
+       msg->video_formats->list->H264_codec.misc_params.min_slice_size = min_slice_size;
+       msg->video_formats->list->H264_codec.misc_params.slice_enc_params = slice_enc_params;
+       msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support = frame_rate_control;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_supported_video_format(WFDMessage *msg, WFDVideoCodecs *vCodec,
-                  WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
-                  guint64 *vCEAResolution, guint64 *vVESAResolution, guint64 *vHHResolution,
-                  guint *vProfile, guint *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
-                  guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control)
+                                               WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
+                                               guint64 *vCEAResolution, guint64 *vVESAResolution, guint64 *vHHResolution,
+                                               guint *vProfile, guint *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
+                                               guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control)
 {
-  guint nativeindex = 0;
-
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->video_formats != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->video_formats->list != NULL, WFD_EINVAL);
-
-  *vCodec = WFD_VIDEO_H264;
-  *vNative = msg->video_formats->list->native & 0x7;
-  nativeindex = msg->video_formats->list->native >> 3;
-  *vNativeResolution = (guint64)1 << nativeindex;
-  *vProfile = msg->video_formats->list->H264_codec.profile;
-  *vLevel = msg->video_formats->list->H264_codec.level;
-  *vMaxWidth = msg->video_formats->list->H264_codec.max_hres;
-  *vMaxHeight = msg->video_formats->list->H264_codec.max_vres;
-  *vCEAResolution = msg->video_formats->list->H264_codec.misc_params.CEA_Support;
-  *vVESAResolution = msg->video_formats->list->H264_codec.misc_params.VESA_Support;
-  *vHHResolution = msg->video_formats->list->H264_codec.misc_params.HH_Support;
-  *vLatency = msg->video_formats->list->H264_codec.misc_params.latency;
-  *min_slice_size = msg->video_formats->list->H264_codec.misc_params.min_slice_size;
-  *slice_enc_params = msg->video_formats->list->H264_codec.misc_params.slice_enc_params;
-  *frame_rate_control = msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support;
-  return WFD_OK;
+       guint nativeindex = 0;
+
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->video_formats != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->video_formats->list != NULL, WFD_EINVAL);
+
+       *vCodec = WFD_VIDEO_H264;
+       *vNative = msg->video_formats->list->native & 0x7;
+       nativeindex = msg->video_formats->list->native >> 3;
+       *vNativeResolution = (guint64)1 << nativeindex;
+       *vProfile = msg->video_formats->list->H264_codec.profile;
+       *vLevel = msg->video_formats->list->H264_codec.level;
+       *vMaxWidth = msg->video_formats->list->H264_codec.max_hres;
+       *vMaxHeight = msg->video_formats->list->H264_codec.max_vres;
+       *vCEAResolution = msg->video_formats->list->H264_codec.misc_params.CEA_Support;
+       *vVESAResolution = msg->video_formats->list->H264_codec.misc_params.VESA_Support;
+       *vHHResolution = msg->video_formats->list->H264_codec.misc_params.HH_Support;
+       *vLatency = msg->video_formats->list->H264_codec.misc_params.latency;
+       *min_slice_size = msg->video_formats->list->H264_codec.misc_params.min_slice_size;
+       *slice_enc_params = msg->video_formats->list->H264_codec.misc_params.slice_enc_params;
+       *frame_rate_control = msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_prefered_video_format(WFDMessage *msg, WFDVideoCodecs *vCodec,
-                 WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
-                 WFDVideoCEAResolution *vCEAResolution, WFDVideoVESAResolution *vVESAResolution,
-                 WFDVideoHHResolution *vHHResolution,  WFDVideoH264Profile *vProfile,
-                 WFDVideoH264Level *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
-                 guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control)
+                                              WFDVideoNativeResolution *vNative, guint64 *vNativeResolution,
+                                              WFDVideoCEAResolution *vCEAResolution, WFDVideoVESAResolution *vVESAResolution,
+                                              WFDVideoHHResolution *vHHResolution,     WFDVideoH264Profile *vProfile,
+                                              WFDVideoH264Level *vLevel, guint32 *vLatency, guint32 *vMaxHeight,
+                                              guint32 *vMaxWidth, guint32 *min_slice_size, guint32 *slice_enc_params, guint *frame_rate_control)
 {
-  guint nativeindex = 0;
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->video_formats != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->video_formats->list != NULL, WFD_EINVAL);
-
-  *vCodec = WFD_VIDEO_H264;
-  *vNative = msg->video_formats->list->native & 0x7;
-  nativeindex = msg->video_formats->list->native >> 3;
-  *vNativeResolution = (guint64)1 << nativeindex;
-  *vProfile = msg->video_formats->list->H264_codec.profile;
-  *vLevel = msg->video_formats->list->H264_codec.level;
-  *vMaxWidth = msg->video_formats->list->H264_codec.max_hres;
-  *vMaxHeight = msg->video_formats->list->H264_codec.max_vres;
-  *vCEAResolution = msg->video_formats->list->H264_codec.misc_params.CEA_Support;
-  *vVESAResolution = msg->video_formats->list->H264_codec.misc_params.VESA_Support;
-  *vHHResolution = msg->video_formats->list->H264_codec.misc_params.HH_Support;
-  *vLatency = msg->video_formats->list->H264_codec.misc_params.latency;
-  *min_slice_size = msg->video_formats->list->H264_codec.misc_params.min_slice_size;
-  *slice_enc_params = msg->video_formats->list->H264_codec.misc_params.slice_enc_params;
-  *frame_rate_control = msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support;
-  return WFD_OK;
+       guint nativeindex = 0;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->video_formats != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->video_formats->list != NULL, WFD_EINVAL);
+
+       *vCodec = WFD_VIDEO_H264;
+       *vNative = msg->video_formats->list->native & 0x7;
+       nativeindex = msg->video_formats->list->native >> 3;
+       *vNativeResolution = (guint64)1 << nativeindex;
+       *vProfile = msg->video_formats->list->H264_codec.profile;
+       *vLevel = msg->video_formats->list->H264_codec.level;
+       *vMaxWidth = msg->video_formats->list->H264_codec.max_hres;
+       *vMaxHeight = msg->video_formats->list->H264_codec.max_vres;
+       *vCEAResolution = msg->video_formats->list->H264_codec.misc_params.CEA_Support;
+       *vVESAResolution = msg->video_formats->list->H264_codec.misc_params.VESA_Support;
+       *vHHResolution = msg->video_formats->list->H264_codec.misc_params.HH_Support;
+       *vLatency = msg->video_formats->list->H264_codec.misc_params.latency;
+       *min_slice_size = msg->video_formats->list->H264_codec.misc_params.min_slice_size;
+       *slice_enc_params = msg->video_formats->list->H264_codec.misc_params.slice_enc_params;
+       *frame_rate_control = msg->video_formats->list->H264_codec.misc_params.frame_rate_control_support;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_contentprotection_type(WFDMessage *msg, WFDHDCPProtection hdcpversion, guint32 TCPPort)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->content_protection) msg->content_protection = g_new0 (WFDContentProtection, 1);
-  if(hdcpversion == WFD_HDCP_NONE) return WFD_OK;
-  msg->content_protection->hdcp2_spec = g_new0 (WFDHdcp2Spec, 1);
-  if(hdcpversion == WFD_HDCP_2_0) msg->content_protection->hdcp2_spec->hdcpversion = g_strdup("HDCP2.0");
-  else if(hdcpversion == WFD_HDCP_2_1) msg->content_protection->hdcp2_spec->hdcpversion = g_strdup("HDCP2.1");
-  char str[11]={0,};
-  snprintf(str, 11, "port=%d", TCPPort);
-  msg->content_protection->hdcp2_spec->TCPPort = g_strdup(str);
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->content_protection) msg->content_protection = g_new0(WFDContentProtection, 1);
+       if (hdcpversion == WFD_HDCP_NONE) return WFD_OK;
+       msg->content_protection->hdcp2_spec = g_new0(WFDHdcp2Spec, 1);
+       if (hdcpversion == WFD_HDCP_2_0) msg->content_protection->hdcp2_spec->hdcpversion = g_strdup("HDCP2.0");
+       else if (hdcpversion == WFD_HDCP_2_1) msg->content_protection->hdcp2_spec->hdcpversion = g_strdup("HDCP2.1");
+       char str[11] = {0, };
+       snprintf(str, 11, "port=%d", TCPPort);
+       msg->content_protection->hdcp2_spec->TCPPort = g_strdup(str);
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_contentprotection_type(WFDMessage *msg, WFDHDCPProtection *hdcpversion, guint32 *TCPPort)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->content_protection && msg->content_protection->hdcp2_spec) {
-    char *result = NULL;
-    char *ptr = NULL;
-    if(!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion,"none")) {
-         wfd_warning("HDCP none");
-         *hdcpversion = WFD_HDCP_NONE;
-         *TCPPort = 0;
-         return WFD_OK;
-    }
-    if(!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion,"HDCP2.0")) *hdcpversion = WFD_HDCP_2_0;
-    else if(!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion,"HDCP2.1")) *hdcpversion = WFD_HDCP_2_1;
-    else {
-         wfd_warning("Unknown protection type");
-         *hdcpversion = WFD_HDCP_NONE;
-         *TCPPort = 0;
-         return WFD_OK;
-    }
-
-    result = strtok_r(msg->content_protection->hdcp2_spec->TCPPort, "=", &ptr);
-    while (result !=NULL) {
-         result = strtok_r(NULL, "=", &ptr);
-         *TCPPort = atoi (result);
-         break;
-    }
-  } else *hdcpversion = WFD_HDCP_NONE;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->content_protection && msg->content_protection->hdcp2_spec) {
+               char *result = NULL;
+               char *ptr = NULL;
+               if (!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion, "none")) {
+                       wfd_warning("HDCP none");
+                       *hdcpversion = WFD_HDCP_NONE;
+                       *TCPPort = 0;
+                       return WFD_OK;
+               }
+               if (!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion, "HDCP2.0")) *hdcpversion = WFD_HDCP_2_0;
+               else if (!g_strcmp0(msg->content_protection->hdcp2_spec->hdcpversion, "HDCP2.1")) *hdcpversion = WFD_HDCP_2_1;
+               else {
+                       wfd_warning("Unknown protection type");
+                       *hdcpversion = WFD_HDCP_NONE;
+                       *TCPPort = 0;
+                       return WFD_OK;
+               }
+
+               result = strtok_r(msg->content_protection->hdcp2_spec->TCPPort, "=", &ptr);
+               while (result != NULL) {
+                       result = strtok_r(NULL, "=", &ptr);
+                       *TCPPort = atoi(result);
+                       break;
+               }
+       } else *hdcpversion = WFD_HDCP_NONE;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_display_EDID(WFDMessage *msg, gboolean edid_supported, guint32 edid_blockcount, gchar *edid_playload)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->display_edid) msg->display_edid = g_new0 (WFDDisplayEdid, 1);
-  msg->display_edid->edid_supported = edid_supported;
-  if(!edid_supported) return WFD_OK;
-  msg->display_edid->edid_block_count = edid_blockcount;
-  if(edid_blockcount) {
-    msg->display_edid->edid_payload = g_malloc(128 * edid_blockcount);
-    if(!msg->display_edid->edid_payload)
-      memcpy(msg->display_edid->edid_payload, edid_playload, 128 * edid_blockcount);
-  } else msg->display_edid->edid_payload = g_strdup("none");
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->display_edid) msg->display_edid = g_new0(WFDDisplayEdid, 1);
+       msg->display_edid->edid_supported = edid_supported;
+       if (!edid_supported) return WFD_OK;
+       msg->display_edid->edid_block_count = edid_blockcount;
+       if (edid_blockcount) {
+               msg->display_edid->edid_payload = g_malloc(128 * edid_blockcount);
+               if (!msg->display_edid->edid_payload)
+                       memcpy(msg->display_edid->edid_payload, edid_playload, 128 * edid_blockcount);
+       } else msg->display_edid->edid_payload = g_strdup("none");
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_display_EDID(WFDMessage *msg, gboolean *edid_supported, guint32 *edid_blockcount, gchar **edid_playload)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->display_edid ) {
-    if(msg->display_edid->edid_supported) {
-      *edid_blockcount = msg->display_edid->edid_block_count;
-      if(msg->display_edid->edid_block_count) {
-        char * temp;
-        temp = g_malloc(EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
-        if(temp) {
-          memset(temp, 0, EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
-          memcpy(temp, msg->display_edid->edid_payload, EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
-          *edid_playload = temp;
-          *edid_supported = TRUE;
-        }
-      } else *edid_playload = g_strdup("none");
-    }
-  } else *edid_supported = FALSE;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->display_edid) {
+               if (msg->display_edid->edid_supported) {
+                       *edid_blockcount = msg->display_edid->edid_block_count;
+                       if (msg->display_edid->edid_block_count) {
+                               char *temp;
+                               temp = g_malloc(EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
+                               if (temp) {
+                                       memset(temp, 0, EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
+                                       memcpy(temp, msg->display_edid->edid_payload, EDID_BLOCK_SIZE * msg->display_edid->edid_block_count);
+                                       *edid_playload = temp;
+                                       *edid_supported = TRUE;
+                               }
+                       } else *edid_playload = g_strdup("none");
+               }
+       } else *edid_supported = FALSE;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_coupled_sink(WFDMessage *msg, WFDCoupledSinkStatus status, gchar *sink_address)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->coupled_sink) msg->coupled_sink = g_new0 (WFDCoupledSink, 1);
-  if(status == WFD_SINK_UNKNOWN) return WFD_OK;
-  msg->coupled_sink->coupled_sink_cap = g_new0 (WFDCoupled_sink_cap, 1);
-  msg->coupled_sink->coupled_sink_cap->status = status;
-  msg->coupled_sink->coupled_sink_cap->sink_address = g_strdup(sink_address);
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->coupled_sink) msg->coupled_sink = g_new0(WFDCoupledSink, 1);
+       if (status == WFD_SINK_UNKNOWN) return WFD_OK;
+       msg->coupled_sink->coupled_sink_cap = g_new0(WFDCoupled_sink_cap, 1);
+       msg->coupled_sink->coupled_sink_cap->status = status;
+       msg->coupled_sink->coupled_sink_cap->sink_address = g_strdup(sink_address);
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_coupled_sink(WFDMessage *msg, WFDCoupledSinkStatus *status, gchar **sink_address)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->coupled_sink && msg->coupled_sink->coupled_sink_cap) {
-    *status = msg->coupled_sink->coupled_sink_cap->status;
-    *sink_address = g_strdup(msg->coupled_sink->coupled_sink_cap->sink_address);
-  } else *status = WFD_SINK_UNKNOWN;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->coupled_sink && msg->coupled_sink->coupled_sink_cap) {
+               *status = msg->coupled_sink->coupled_sink_cap->status;
+               *sink_address = g_strdup(msg->coupled_sink->coupled_sink_cap->sink_address);
+       } else *status = WFD_SINK_UNKNOWN;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_trigger_type(WFDMessage *msg, WFDTrigger trigger)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->trigger_method)
-    msg->trigger_method = g_new0 (WFDTriggerMethod, 1);
-  if(trigger == WFD_TRIGGER_SETUP)
-    msg->trigger_method->wfd_trigger_method = g_strdup("SETUP");
-  else if(trigger == WFD_TRIGGER_PAUSE)
-    msg->trigger_method->wfd_trigger_method = g_strdup("PAUSE");
-  else if(trigger == WFD_TRIGGER_TEARDOWN)
-    msg->trigger_method->wfd_trigger_method = g_strdup("TEARDOWN");
-  else if(trigger == WFD_TRIGGER_PLAY)
-    msg->trigger_method->wfd_trigger_method = g_strdup("PLAY");
-  else
-    return WFD_EINVAL;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->trigger_method)
+               msg->trigger_method = g_new0(WFDTriggerMethod, 1);
+       if (trigger == WFD_TRIGGER_SETUP)
+               msg->trigger_method->wfd_trigger_method = g_strdup("SETUP");
+       else if (trigger == WFD_TRIGGER_PAUSE)
+               msg->trigger_method->wfd_trigger_method = g_strdup("PAUSE");
+       else if (trigger == WFD_TRIGGER_TEARDOWN)
+               msg->trigger_method->wfd_trigger_method = g_strdup("TEARDOWN");
+       else if (trigger == WFD_TRIGGER_PLAY)
+               msg->trigger_method->wfd_trigger_method = g_strdup("PLAY");
+       else
+               return WFD_EINVAL;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_trigger_type(WFDMessage *msg, WFDTrigger *trigger)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!g_strcmp0(msg->trigger_method->wfd_trigger_method, "SETUP"))
-    *trigger = WFD_TRIGGER_SETUP;
-  else if(!g_strcmp0(msg->trigger_method->wfd_trigger_method, "PAUSE"))
-    *trigger = WFD_TRIGGER_PAUSE;
-  else if(!g_strcmp0(msg->trigger_method->wfd_trigger_method, "TEARDOWN"))
-    *trigger = WFD_TRIGGER_TEARDOWN;
-  else if(!g_strcmp0(msg->trigger_method->wfd_trigger_method, "PLAY"))
-    *trigger = WFD_TRIGGER_PLAY;
-  else {
-    *trigger = WFD_TRIGGER_UNKNOWN;
-    return WFD_EINVAL;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!g_strcmp0(msg->trigger_method->wfd_trigger_method, "SETUP"))
+               *trigger = WFD_TRIGGER_SETUP;
+       else if (!g_strcmp0(msg->trigger_method->wfd_trigger_method, "PAUSE"))
+               *trigger = WFD_TRIGGER_PAUSE;
+       else if (!g_strcmp0(msg->trigger_method->wfd_trigger_method, "TEARDOWN"))
+               *trigger = WFD_TRIGGER_TEARDOWN;
+       else if (!g_strcmp0(msg->trigger_method->wfd_trigger_method, "PLAY"))
+               *trigger = WFD_TRIGGER_PLAY;
+       else {
+               *trigger = WFD_TRIGGER_UNKNOWN;
+               return WFD_EINVAL;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_presentation_url(WFDMessage *msg, gchar *wfd_url0, gchar *wfd_url1)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->presentation_url) msg->presentation_url = g_new0 (WFDPresentationUrl, 1);
-  if(wfd_url0) msg->presentation_url->wfd_url0 = g_strdup(wfd_url0);
-  if(wfd_url1) msg->presentation_url->wfd_url1 = g_strdup(wfd_url1);
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->presentation_url) msg->presentation_url = g_new0(WFDPresentationUrl, 1);
+       if (wfd_url0) msg->presentation_url->wfd_url0 = g_strdup(wfd_url0);
+       if (wfd_url1) msg->presentation_url->wfd_url1 = g_strdup(wfd_url1);
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_presentation_url(WFDMessage *msg, gchar **wfd_url0, gchar **wfd_url1)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->presentation_url) {
-    *wfd_url0 = g_strdup(msg->presentation_url->wfd_url0);
-    *wfd_url1 = g_strdup(msg->presentation_url->wfd_url1);
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->presentation_url) {
+               *wfd_url0 = g_strdup(msg->presentation_url->wfd_url0);
+               *wfd_url1 = g_strdup(msg->presentation_url->wfd_url1);
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_prefered_RTP_ports(WFDMessage *msg, WFDRTSPTransMode trans, WFDRTSPProfile profile,
-                 WFDRTSPLowerTrans lowertrans, guint32 rtp_port0, guint32 rtp_port1)
+                                           WFDRTSPLowerTrans lowertrans, guint32 rtp_port0, guint32 rtp_port1)
 {
-  GString *lines;
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-
-  if(!msg->client_rtp_ports)
-    msg->client_rtp_ports = g_new0 (WFDClientRtpPorts, 1);
-
-  if(trans != WFD_RTSP_TRANS_UNKNOWN) {
-    lines = g_string_new ("");
-    if(trans == WFD_RTSP_TRANS_RTP)    g_string_append_printf (lines,"RTP");
-    else if(trans == WFD_RTSP_TRANS_RDT) g_string_append_printf (lines,"RDT");
-
-    if(profile == WFD_RTSP_PROFILE_AVP) g_string_append_printf (lines,"/AVP");
-    else if(profile == WFD_RTSP_PROFILE_SAVP) g_string_append_printf (lines,"/SAVP");
-
-    if(lowertrans == WFD_RTSP_LOWER_TRANS_UDP) g_string_append_printf (lines,"/UDP;unicast");
-    else if(lowertrans == WFD_RTSP_LOWER_TRANS_UDP_MCAST) g_string_append_printf (lines,"/UDP;multicast");
-    else if(lowertrans == WFD_RTSP_LOWER_TRANS_TCP) g_string_append_printf (lines,"/TCP;unicast");
-    else if(lowertrans == WFD_RTSP_LOWER_TRANS_HTTP) g_string_append_printf (lines,"/HTTP");
-
-    msg->client_rtp_ports->profile = g_string_free (lines, FALSE);
-    msg->client_rtp_ports->rtp_port0 = rtp_port0;
-    msg->client_rtp_ports->rtp_port1 = rtp_port1;
-    msg->client_rtp_ports->mode = g_strdup("mode=play");
-  }
-  return WFD_OK;
+       GString *lines;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+
+       if (!msg->client_rtp_ports)
+               msg->client_rtp_ports = g_new0(WFDClientRtpPorts, 1);
+
+       if (trans != WFD_RTSP_TRANS_UNKNOWN) {
+               lines = g_string_new("");
+               if (trans == WFD_RTSP_TRANS_RTP)        g_string_append_printf(lines, "RTP");
+               else if (trans == WFD_RTSP_TRANS_RDT) g_string_append_printf(lines, "RDT");
+
+               if (profile == WFD_RTSP_PROFILE_AVP) g_string_append_printf(lines, "/AVP");
+               else if (profile == WFD_RTSP_PROFILE_SAVP) g_string_append_printf(lines, "/SAVP");
+
+               if (lowertrans == WFD_RTSP_LOWER_TRANS_UDP) g_string_append_printf(lines, "/UDP;unicast");
+               else if (lowertrans == WFD_RTSP_LOWER_TRANS_UDP_MCAST) g_string_append_printf(lines, "/UDP;multicast");
+               else if (lowertrans == WFD_RTSP_LOWER_TRANS_TCP) g_string_append_printf(lines, "/TCP;unicast");
+               else if (lowertrans == WFD_RTSP_LOWER_TRANS_HTTP) g_string_append_printf(lines, "/HTTP");
+
+               msg->client_rtp_ports->profile = g_string_free(lines, FALSE);
+               msg->client_rtp_ports->rtp_port0 = rtp_port0;
+               msg->client_rtp_ports->rtp_port1 = rtp_port1;
+               msg->client_rtp_ports->mode = g_strdup("mode=play");
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_prefered_RTP_ports(WFDMessage *msg, WFDRTSPTransMode *trans, WFDRTSPProfile *profile,
-                WFDRTSPLowerTrans *lowertrans, guint32 *rtp_port0, guint32 *rtp_port1)
+                                           WFDRTSPLowerTrans *lowertrans, guint32 *rtp_port0, guint32 *rtp_port1)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  g_return_val_if_fail (msg->client_rtp_ports != NULL, WFD_EINVAL);
-
-  if(g_strrstr(msg->client_rtp_ports->profile, "RTP")) *trans = WFD_RTSP_TRANS_RTP;
-  if(g_strrstr(msg->client_rtp_ports->profile, "RDT")) *trans = WFD_RTSP_TRANS_RDT;
-  if(g_strrstr(msg->client_rtp_ports->profile, "AVP")) *profile = WFD_RTSP_PROFILE_AVP;
-  if(g_strrstr(msg->client_rtp_ports->profile, "SAVP")) *profile = WFD_RTSP_PROFILE_SAVP;
-  if(g_strrstr(msg->client_rtp_ports->profile, "UDP;unicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_UDP;
-  if(g_strrstr(msg->client_rtp_ports->profile, "UDP;multicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_UDP_MCAST;
-  if(g_strrstr(msg->client_rtp_ports->profile, "TCP;unicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_TCP;
-  if(g_strrstr(msg->client_rtp_ports->profile, "HTTP")) *lowertrans = WFD_RTSP_LOWER_TRANS_HTTP;
-
-  *rtp_port0 = msg->client_rtp_ports->rtp_port0;
-  *rtp_port1 = msg->client_rtp_ports->rtp_port1;
-
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       g_return_val_if_fail(msg->client_rtp_ports != NULL, WFD_EINVAL);
+
+       if (g_strrstr(msg->client_rtp_ports->profile, "RTP")) *trans = WFD_RTSP_TRANS_RTP;
+       if (g_strrstr(msg->client_rtp_ports->profile, "RDT")) *trans = WFD_RTSP_TRANS_RDT;
+       if (g_strrstr(msg->client_rtp_ports->profile, "AVP")) *profile = WFD_RTSP_PROFILE_AVP;
+       if (g_strrstr(msg->client_rtp_ports->profile, "SAVP")) *profile = WFD_RTSP_PROFILE_SAVP;
+       if (g_strrstr(msg->client_rtp_ports->profile, "UDP;unicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_UDP;
+       if (g_strrstr(msg->client_rtp_ports->profile, "UDP;multicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_UDP_MCAST;
+       if (g_strrstr(msg->client_rtp_ports->profile, "TCP;unicast")) *lowertrans = WFD_RTSP_LOWER_TRANS_TCP;
+       if (g_strrstr(msg->client_rtp_ports->profile, "HTTP")) *lowertrans = WFD_RTSP_LOWER_TRANS_HTTP;
+
+       *rtp_port0 = msg->client_rtp_ports->rtp_port0;
+       *rtp_port1 = msg->client_rtp_ports->rtp_port1;
+
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_audio_sink_type(WFDMessage *msg, WFDSinkType sinktype)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->route) msg->route = g_new0 (WFDRoute, 1);
-  if(sinktype == WFD_PRIMARY_SINK) msg->route->destination = g_strdup("primary");
-  else if(sinktype == WFD_SECONDARY_SINK) msg->route->destination = g_strdup("secondary");
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->route) msg->route = g_new0(WFDRoute, 1);
+       if (sinktype == WFD_PRIMARY_SINK) msg->route->destination = g_strdup("primary");
+       else if (sinktype == WFD_SECONDARY_SINK) msg->route->destination = g_strdup("secondary");
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_audio_sink_type(WFDMessage *msg, WFDSinkType *sinktype)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->route) {
-    if(!g_strcmp0(msg->route->destination,"primary")) *sinktype = WFD_PRIMARY_SINK;
-    else if(!g_strcmp0(msg->route->destination,"secondary")) *sinktype = WFD_SECONDARY_SINK;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->route) {
+               if (!g_strcmp0(msg->route->destination, "primary")) *sinktype = WFD_PRIMARY_SINK;
+               else if (!g_strcmp0(msg->route->destination, "secondary")) *sinktype = WFD_SECONDARY_SINK;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_I2C_port(WFDMessage *msg, gboolean i2csupport, guint32 i2cport)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->I2C) msg->I2C = g_new0 (WFDI2C, 1);
-  msg->I2C->I2CPresent = i2csupport;
-  msg->I2C->I2C_port = i2cport;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->I2C) msg->I2C = g_new0(WFDI2C, 1);
+       msg->I2C->I2CPresent = i2csupport;
+       msg->I2C->I2C_port = i2cport;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_I2C_port(WFDMessage *msg, gboolean *i2csupport, guint32 *i2cport)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->I2C && msg->I2C->I2CPresent) {
-    *i2csupport = msg->I2C->I2CPresent;
-    *i2cport = msg->I2C->I2C_port;
-  } else *i2csupport = FALSE;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->I2C && msg->I2C->I2CPresent) {
+               *i2csupport = msg->I2C->I2CPresent;
+               *i2cport = msg->I2C->I2C_port;
+       } else *i2csupport = FALSE;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_av_format_change_timing(WFDMessage *msg, guint64 PTS, guint64 DTS)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->av_format_change_timing) msg->av_format_change_timing = g_new0 (WFDAVFormatChangeTiming, 1);
-  msg->av_format_change_timing->PTS = PTS;
-  msg->av_format_change_timing->DTS = DTS;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->av_format_change_timing) msg->av_format_change_timing = g_new0(WFDAVFormatChangeTiming, 1);
+       msg->av_format_change_timing->PTS = PTS;
+       msg->av_format_change_timing->DTS = DTS;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_av_format_change_timing(WFDMessage *msg, guint64 *PTS, guint64 *DTS)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->av_format_change_timing) {
-    *PTS = msg->av_format_change_timing->PTS;
-    *DTS = msg->av_format_change_timing->DTS;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->av_format_change_timing) {
+               *PTS = msg->av_format_change_timing->PTS;
+               *DTS = msg->av_format_change_timing->DTS;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_uibc_capability(WFDMessage *msg, guint32 input_category, guint32 inp_type, WFDHIDCTypePathPair *inp_pair,
-                                                                                               guint32 inp_type_path_count, guint32 tcp_port)
+                                        guint32 inp_type_path_count, guint32 tcp_port)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->uibc_capability) msg->uibc_capability = g_new0 (WFDUibcCapability, 1);
-  msg->uibc_capability->uibcsupported = TRUE;
-  msg->uibc_capability->input_category_list.input_cat = input_category;
-  msg->uibc_capability->generic_cap_list.inp_type = inp_type;
-  msg->uibc_capability->hidc_cap_list.cap_count = inp_type_path_count;
-  if(msg->uibc_capability->hidc_cap_list.cap_count) {
-    detailed_cap *temp_cap;
-    guint i=0;
-    msg->uibc_capability->hidc_cap_list.next = g_new0 (detailed_cap, 1);
-    temp_cap = msg->uibc_capability->hidc_cap_list.next;
-    for(;i<inp_type_path_count;) {
-      temp_cap->p.inp_type = inp_pair[i].inp_type;
-      temp_cap->p.inp_path = inp_pair[i].inp_path;
-      i++;
-      if(i<inp_type_path_count) {
-        temp_cap->next = g_new0 (detailed_cap, 1);
-        temp_cap = temp_cap->next;
-      }
-    }
-  }
-  msg->uibc_capability->tcp_port = tcp_port;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->uibc_capability) msg->uibc_capability = g_new0(WFDUibcCapability, 1);
+       msg->uibc_capability->uibcsupported = TRUE;
+       msg->uibc_capability->input_category_list.input_cat = input_category;
+       msg->uibc_capability->generic_cap_list.inp_type = inp_type;
+       msg->uibc_capability->hidc_cap_list.cap_count = inp_type_path_count;
+       if (msg->uibc_capability->hidc_cap_list.cap_count) {
+               detailed_cap *temp_cap;
+               guint i = 0;
+               msg->uibc_capability->hidc_cap_list.next = g_new0(detailed_cap, 1);
+               temp_cap = msg->uibc_capability->hidc_cap_list.next;
+               for (; i < inp_type_path_count;) {
+                       temp_cap->p.inp_type = inp_pair[i].inp_type;
+                       temp_cap->p.inp_path = inp_pair[i].inp_path;
+                       i++;
+                       if (i < inp_type_path_count) {
+                               temp_cap->next = g_new0(detailed_cap, 1);
+                               temp_cap = temp_cap->next;
+                       }
+               }
+       }
+       msg->uibc_capability->tcp_port = tcp_port;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_uibc_capability(WFDMessage *msg, guint32 *input_category, guint32 *inp_type, WFDHIDCTypePathPair **inp_pair,
-                                                                                               guint32 *inp_type_path_count, guint32 *tcp_port)
+                                        guint32 *inp_type_path_count, guint32 *tcp_port)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->uibc_capability && msg->uibc_capability->uibcsupported) {
-    *input_category = msg->uibc_capability->input_category_list.input_cat;
-    *inp_type = msg->uibc_capability->generic_cap_list.inp_type;
-    *inp_type_path_count = msg->uibc_capability->hidc_cap_list.cap_count;
-    if(msg->uibc_capability->hidc_cap_list.cap_count) {
-      detailed_cap *temp_cap;
-      guint i = 0;
-      *inp_pair = g_new0 (WFDHIDCTypePathPair, msg->uibc_capability->hidc_cap_list.cap_count);
-      temp_cap = msg->uibc_capability->hidc_cap_list.next;
-      while(temp_cap) {
-        (*(inp_pair))[i].inp_type = temp_cap->p.inp_type;
-        (*(inp_pair))[i].inp_path = temp_cap->p.inp_path;
-        temp_cap = temp_cap->next;
-        i++;
-      }
-    }
-    *tcp_port = msg->uibc_capability->tcp_port;
-  }
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->uibc_capability && msg->uibc_capability->uibcsupported) {
+               *input_category = msg->uibc_capability->input_category_list.input_cat;
+               *inp_type = msg->uibc_capability->generic_cap_list.inp_type;
+               *inp_type_path_count = msg->uibc_capability->hidc_cap_list.cap_count;
+               if (msg->uibc_capability->hidc_cap_list.cap_count) {
+                       detailed_cap *temp_cap;
+                       guint i = 0;
+                       *inp_pair = g_new0(WFDHIDCTypePathPair, msg->uibc_capability->hidc_cap_list.cap_count);
+                       temp_cap = msg->uibc_capability->hidc_cap_list.next;
+                       while (temp_cap) {
+                               (*(inp_pair))[i].inp_type = temp_cap->p.inp_type;
+                               (*(inp_pair))[i].inp_path = temp_cap->p.inp_path;
+                               temp_cap = temp_cap->next;
+                               i++;
+                       }
+               }
+               *tcp_port = msg->uibc_capability->tcp_port;
+       }
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_uibc_status(WFDMessage *msg, gboolean uibc_enable)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->uibc_setting) msg->uibc_setting = g_new0 (WFDUibcSetting, 1);
-  msg->uibc_setting->uibc_setting = uibc_enable;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->uibc_setting) msg->uibc_setting = g_new0(WFDUibcSetting, 1);
+       msg->uibc_setting->uibc_setting = uibc_enable;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_uibc_status(WFDMessage *msg, gboolean *uibc_enable)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->uibc_setting) *uibc_enable = msg->uibc_setting->uibc_setting;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->uibc_setting) *uibc_enable = msg->uibc_setting->uibc_setting;
+       return WFD_OK;
 }
 #ifdef STANDBY_RESUME_CAPABILITY
 WFDResult wfdconfig_set_standby_resume_capability(WFDMessage *msg, gboolean supported)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->standby_resume_capability) msg->standby_resume_capability = g_new0 (WFDStandbyResumeCapability, 1);
-  msg->standby_resume_capability->standby_resume_cap = supported;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->standby_resume_capability) msg->standby_resume_capability = g_new0(WFDStandbyResumeCapability, 1);
+       msg->standby_resume_capability->standby_resume_cap = supported;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_standby_resume_capability(WFDMessage *msg, gboolean *supported)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->standby_resume_capability) *supported = msg->standby_resume_capability->standby_resume_cap;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->standby_resume_capability) *supported = msg->standby_resume_capability->standby_resume_cap;
+       return WFD_OK;
 }
 #endif
 WFDResult wfdconfig_set_standby(WFDMessage *msg, gboolean standby_enable)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->standby) msg->standby = g_new0 (WFDStandby, 1);
-  msg->standby->wfd_standby = standby_enable;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->standby) msg->standby = g_new0(WFDStandby, 1);
+       msg->standby->wfd_standby = standby_enable;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_standby(WFDMessage *msg, gboolean *standby_enable)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->standby) *standby_enable = msg->standby->wfd_standby;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->standby) *standby_enable = msg->standby->wfd_standby;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_connector_type(WFDMessage *msg, WFDConnector connector)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->connector_type) msg->connector_type = g_new0 (WFDConnectorType, 1);
-  msg->connector_type->connector_type = connector;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->connector_type) msg->connector_type = g_new0(WFDConnectorType, 1);
+       msg->connector_type->connector_type = connector;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_get_connector_type(WFDMessage *msg, WFDConnector *connector)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(msg->connector_type) *connector = msg->connector_type->connector_type;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (msg->connector_type) *connector = msg->connector_type->connector_type;
+       return WFD_OK;
 }
 
 WFDResult wfdconfig_set_idr_request(WFDMessage *msg)
 {
-  g_return_val_if_fail (msg != NULL, WFD_EINVAL);
-  if(!msg->idr_request) msg->idr_request = g_new0 (WFDIdrRequest, 1);
-  msg->idr_request->idr_request = TRUE;
-  return WFD_OK;
+       g_return_val_if_fail(msg != NULL, WFD_EINVAL);
+       if (!msg->idr_request) msg->idr_request = g_new0(WFDIdrRequest, 1);
+       msg->idr_request->idr_request = TRUE;
+       return WFD_OK;
 }