Merge lp:~morphis/aethercast/hw-encoding-support into lp:aethercast

[Simon Fels]

Add HW encoding support

[lp:~morphis/aethercast/hw-encoding-support]

137. By Simon Fels on 2016-01-27

Abstract mir stream connection behind a connector

138. By Simon Fels on 2016-01-27

Add stream renderer which gets frames from mir and sends them to the encoder

139. By Simon Fels on 2016-01-27

Integrate stream renderer with miracast source manager

140. By Simon Fels on 2016-01-27

Make d'tor of base class correctly virtual

141. By Simon Fels on 2016-01-27

Force mir as default media manager

142. By Simon Fels on 2016-01-27

Add missing return type for function

143. By Simon Fels on 2016-01-27

Extended debugging output for mir source manager

144. By Simon Fels on 2016-01-28

All changes to get streaming working

145. By Simon Fels on 2016-02-01

Add support to retrieve raw output from the encoder

146. By Simon Fels on 2016-02-01

Actually stop the stream renderer on destruction

147. By Simon Fels on 2016-02-01

Set H264 profile/level/constraint for encoder

148. By Simon Fels on 2016-02-01

Make sure the encoder os properly initialized before starting

149. By Simon Fels on 2016-02-01

Take raw h264 frames from encoder as input for the pipeline

150. By Simon Fels on 2016-02-01

Check for possible errors on encoder construction

151. By Simon Fels on 2016-02-01

Don't call not existing libmedia API method for now

152. By Simon Fels on 2016-02-01

Construct pipeline with parse/mux/pay elements

153. By Simon Fels on 2016-02-01

Limit what resolutions, fps, codec parameters we can provide

154. By Simon Fels on 2016-02-01

Raise our GO intent to always become the group owner

155. By Simon Fels on 2016-02-01

Drop superflous pipeline state change

156. By Simon Fels on 2016-02-01

Dump the actual framerate we're recording with from mir

157. By Simon Fels on 2016-02-01

Drop h264parse element and just use caps

158. By Simon Fels on 2016-02-01

Simply mirscreencast utility to just dump to a file

159. By Simon Fels on 2016-02-01

Add queue elements for extended buffering

160. By Simon Fels on 2016-02-02

Add proper .gitignore file

161. By Simon Fels on 2016-02-02

Take buffers from android and put them into Gstreamer ones

162. By Simon Fels on 2016-02-02

Add utility to use plain streaming for testing

163. By Simon Fels on 2016-02-02

tools: stream: start source on startup

164. By Simon Fels on 2016-02-02

tools: screencast: initialize gstreamer on startup

165. By Simon Fels on 2016-02-02

tools: stream: run forever and react on SIGINT/SIGTERM

166. By Simon Fels on 2016-02-03

Include current thread id in each log message

167. By Simon Fels on 2016-02-03

Only submit buffers to the pipeline when its ready for new ones

If we're producing buffers at a too hight rate we're getting them with
incorrect timestamps into the pipeline which leads to delays on the
receiver side because PCR/PTS of the MPEGTS stream doesn't match anymore.

This will be further optimized.

168. By Simon Fels on 2016-02-03

Ignore unused function parameters

169. By Simon Fels on 2016-02-03

Drop superflous debug statements

170. By Simon Fels on 2016-02-03

Add dirty option to dump the stream rather than sending it out

171. By Simon Fels on 2016-02-03

Link source and mux together with a pad to specify the MPEGTS PID

The WiFi Display spec requires us to send the video stream on a
specific PID (0x1011) which we can request to the mpegtsmux
element by request a pad with a specific name.

172. By Simon Fels on 2016-02-04

mir: simply pad request/link for mpegtsmux element

173. By Simon Fels on 2016-02-04

Drop changed PMT/PAT intervals

174. By Simon Fels on 2016-02-04

Comment on how we're requesting a different stream PID

175. By Simon Fels on 2016-02-04

Switch to nal alignment

176. By Simon Fels on 2016-02-04

Merge branch 'trunk' into hw-encoding-support

177. By Simon Fels on 2016-02-04

Merge trunk

178. By Simon Fels on 2016-02-04

Add missing files lost due to a failed merge with trunk

179. By Simon Fels on 2016-02-04

Request 188 byte length packages from MPEGTS element

180. By Simon Fels on 2016-02-04

debian: add missing build depends

181. By Simon Fels on 2016-02-04

debian: add missing libgstreamer-plugins-base1.0-dev dependency

182. By Simon Fels on 2016-02-04

Fail when pipeline can't be configured

183. By Simon Fels on 2016-02-04

Add support for an extended display

184. By Simon Fels on 2016-02-04

Correct vertex position data to use the full screen

185. By Simon Fels on 2016-02-04

Draw white background so we're able to discover empty fragments

186. By Simon Fels on 2016-02-04

Add base encoder class and start a H264EncoderNext implementation

187. By Simon Fels on 2016-02-05

Print out timestamps for performance analysis

188. By Simon Fels on 2016-02-05

Refactor encoder integration and finalize new H264 implementation

189. By Simon Fels on 2016-02-05

Make new h264 encoder working properly

190. By Simon Fels on 2016-02-05

Tune default encoder values to follow what Android does for WFD

191. By Simon Fels on 2016-02-08

Implement MPEGTS packetizer

Based on the implementation from Android.

192. By Simon Fels on 2016-02-08

Optimizer buffer timestamps and encoder configuration

193. By Simon Fels on 2016-02-08

Adding missing encoder config field

194. By Simon Fels on 2016-02-08

A lot more work on getting rid of gstreamer

Adding own RTP sender implementation which is now properly used
from a new source media manager type called 'mir-next'.

This also refactors some parts of the already existing code.

195. By Simon Fels on 2016-02-08

Drop accidentially added code

196. By Simon Fels on 2016-02-08

Enable dumping of the MPEGTS stream

197. By Simon Fels on 2016-02-08

Extract codec specific data and prepend to AVC buffers

198. By Simon Fels on 2016-02-09

Be less verbose for encoder output

199. By Simon Fels on 2016-02-09

Tell MPEGTS packetizer to include SPS/PPS with IDR frames

200. By Simon Fels on 2016-02-09

Add utility method to create a hexdump

201. By Simon Fels on 2016-02-09

Take SPS/PPS from codec data when available

202. By Simon Fels on 2016-02-10

Add H264 analyzer to collect statistics

203. By Simon Fels on 2016-02-10

Don't tell the MPEGST packtizer to add SPS/PPS to IDR frames

204. By Simon Fels on 2016-02-10

Let encoder submit buffer with codec-specific data for transmission

205. By Simon Fels on 2016-02-10

Add output to measure performance

206. By Simon Fels on 2016-02-10

Pass local address down to our WDS delegate

We need to transmit our local address correctly within the RTSP
message we're exchanging with the other side which we missed
until now.

207. By Simon Fels on 2016-02-10

Extract timestamp from buffer we get from the encoder

208. By Simon Fels on 2016-02-10

Use proper constants for encoder configuration

209. By Simon Fels on 2016-02-10

Increase video bitrate to have a stable picture

210. By Simon Fels on 2016-02-10

Check for valid meta data structure before accessing it

211. By Simon Fels on 2016-02-10

Don't set buffer timestamp manually

212. By Simon Fels on 2016-02-10

Let encoder include SPS/PPS with each IDR frame

213. By Simon Fels on 2016-02-10

Ask encoder to store meta data in buffers

214. By Simon Fels on 2016-02-10

Adjust for WDS 1.0.0 API changes

215. By Simon Fels on 2016-02-10

MPEGTS packetizer fixes

216. By Simon Fels on 2016-02-10

Raise our process priority

217. By Simon Fels on 2016-02-10

Revert try to move buffer timestamp ahead

218. By Simon Fels on 2016-02-10

Add a proper buffer queue for Media/RTP sender

219. By Simon Fels on 2016-02-11

Add a measure point abstraction class

220. By Simon Fels on 2016-02-11

Decouple texture creation and rendering

221. By Simon Fels on 2016-02-11

Add missing macro

222. By Simon Fels on 2016-02-11

But add the macro at the right place

223. By Simon Fels on 2016-02-11

Work with a not-blocking socket

224. By Simon Fels on 2016-02-11

Revert buffer queue for stream renderer

225. By Simon Fels on 2016-02-12

Force GO intent to 15 for now

226. By Simon Fels on 2016-02-12

Cleanup old H264Encoder instance

227. By Simon Fels on 2016-02-12

tools: let utility build again even if not functional now

228. By Simon Fels on 2016-02-12

android: first bits of the h264 encoder implementation

229. By Simon Fels on 2016-02-15

Implement new encoder which directly forwards native buffers from mir

230. By Simon Fels on 2016-02-15

Unblock input buffer queue when taking a buffer out

231. By Simon Fels on 2016-02-16

tools: mpegts_muxer: specifiy file open mode properly

232. By Simon Fels on 2016-02-16

tools: mirscreencast_to_stream: add cmdline option to extend the display

233. By Simon Fels on 2016-02-16

Pass dimensions correct to the screencast instance

234. By Simon Fels on 2016-02-16

Drop unneeded log message

235. By Simon Fels on 2016-02-16

Some further explaining comments

236. By Simon Fels on 2016-02-16

Fix syntax error in build configuration

237. By Simon Fels on 2016-02-16

Disable gstreamer initialization for now

238. By Simon Fels on 2016-02-16

Do an async swap buffers call to mir for direct rendering

239. By Simon Fels on 2016-02-17

Correct debug statement order

240. By Simon Fels on 2016-02-17

Optimize some more debug statements

241. By Simon Fels on 2016-02-17

Optimize buffer timestamp logging

We're only interested in how late we're with a buffer and nothing
else as that is what is causing our delay.

242. By Simon Fels on 2016-02-17

Timestamp buffer directly after we received them

243. By Simon Fels on 2016-02-17

Further timestamp logging optimizations

244. By Simon Fels on 2016-02-17

Drop unneeded buffer refcount logging

245. By Simon Fels on 2016-02-17

Further timestamp logging adjustments

246. By Simon Fels on 2016-02-17

Drop two more unneeded debug log statements

247. By Simon Fels on 2016-02-17

Include now in timestamp logging

248. By Simon Fels on 2016-02-17

For stick to synchronously processing a single buffer

249. By Simon Fels on 2016-02-17

Increase UDP send buffer size

250. By Simon Fels on 2016-02-17

Add type definitions for timestamps

251. By Simon Fels on 2016-02-17

Stop media sender and encoder too when pipeline goes down

252. By Simon Fels on 2016-02-17

Implement infrastructure for screen/system locks

253. By Simon Fels on 2016-02-17

Adjust buffer timestamp to respect our framerate

254. By Simon Fels on 2016-02-17

Further timestamp logging changes

255. By Simon Fels on 2016-02-17

Add cross compilation setup (copied from mir)

256. By Simon Fels on 2016-02-17

Add some more timestamp logging

257. By Simon Fels on 2016-02-17

Build with debug configuration

258. By Simon Fels on 2016-02-18

Don't check for matching buffer and just drop the queue head

259. By Simon Fels on 2016-02-18

Use a buffer queue for the renderer with a max size of two

260. By Simon Fels on 2016-02-18

Revert substracting a static offset from timestamps

261. By Simon Fels on 2016-02-18

Stop whole pipeline properly on termination

262. By Simon Fels on 2016-02-18

Correct apparmor rules for our dhcpd use

263. By Simon Fels on 2016-02-18

We only support extend mode for now

264. By Simon Fels on 2016-02-18

Properly terminate pipeline for the stream tool

265. By Simon Fels on 2016-02-18

Add some more statistics we collect over time

266. By Simon Fels on 2016-02-18

Ignore multiple build folders

267. By Simon Fels on 2016-02-18

Switch back to same UDP packet size Android uses

268. By Simon Fels on 2016-02-19

Printout a warning when we can't find a optimal video format

269. By Simon Fels on 2016-02-19

Bring GST based media manager in line with recent changes

270. By Simon Fels on 2016-02-19

Some more explanation comments

271. By Simon Fels on 2016-02-19

Fix test source media manager

272. By Simon Fels on 2016-02-19

Extend logger to be able to set severity on startup

273. By Simon Fels on 2016-02-19

Have a proper video format fallback instead of invalid values

274. By Simon Fels on 2016-02-19

Free GLib error messages once done with it

275. By Simon Fels on 2016-02-19

Let media buffer allocate the memory to transfer ownership

276. By Simon Fels on 2016-02-19

Implement DisconnectAll manager method

277. By Simon Fels on 2016-02-19

Add unit tests to verify wds video format selection

278. By Simon Fels on 2016-02-19

tools: install mirscreencast_to_stream utility

279. By Simon Fels on 2016-02-19

debian: package mirscreencast_to_stream utility too

280. By Simon Fels on 2016-02-19

debian: add a dependency on -tools for aethercast for now

281. By Simon Fels on 2016-02-19

Do correct video format negotiation

282. By Simon Fels on 2016-02-19

debian: install additional files we missed before

283. By Simon Fels on 2016-02-19

Disable power save mode of p2p network interface

284. By Simon Fels on 2016-02-19

Temporarily disable logging of buffer timestamps

285. By Simon Fels on 2016-02-19

debian: fix apparmor profile extension for dhcpd

286. By Simon Fels on 2016-02-19

Listen on all local addresses for incoming RTSP connection requests

287. By Simon Fels on 2016-02-19

Set GO intent to 7 and let user change that with an env variable

288. By Simon Fels on 2016-02-19

Setup a route when running as DHCP server

289. By Simon Fels on 2016-02-19

Select resolution based on env variable

290. By Simon Fels on 2016-02-21

Disable per timestamping according to framerate

291. By Simon Fels on 2016-02-22

Set names for our threads to be able to identify them

292. By Simon Fels on 2016-02-22

Save statistics for RTP bandwidth

293. By Simon Fels on 2016-02-22

Print out statistics when our source manager goes down

294. By Simon Fels on 2016-02-22

Don't produce more frames than we have to

295. By Simon Fels on 2016-02-22

Sent RTP packets directly to remote via sendto

296. By Simon Fels on 2016-02-22

Send all RTP packets a TS frames belongs too together

297. By Simon Fels on 2016-02-22

Allow remote to ask us for an IDR frame

298. By Simon Fels on 2016-02-22

Check mime type correctly for video/audio prefix

299. By Simon Fels on 2016-02-22

Correct RTP bandwidth statistics output

300. By Simon Fels on 2016-02-22

Refactor local address assignmnet for source manager

301. By Simon Fels on 2016-02-23

Enable driver side miracast mode on successful connection

302. By Simon Fels on 2016-02-23

Return an error for a failing scan call

303. By Simon Fels on 2016-02-23

Don't allow dhcpd to edit our configuration file

304. By Simon Fels on 2016-02-23

Add support for new wpa API method to send driver commands

305. By Simon Fels on 2016-02-24

debian: fix apparmor setup

* reload dhcpd profile on startup
* add DAC override for dhcpd to overcome a bug in its package

306. By Simon Fels on 2016-02-24

Dump additional information for GO negotiation response

307. By Simon Fels on 2016-02-24

Pass correct arguments to dbus error message creation

308. By Simon Fels on 2016-02-24

Small adjustments to the connect logic

309. By Simon Fels on 2016-02-24

Limit us to only support 720p with 30 Hz for now

310. By Simon Fels on 2016-02-24

Print out group negotiation error for easier debugging

311. By Simon Fels on 2016-02-24

Format debug message correctly and supply all arguments

312. By Simon Fels on 2016-02-24

Workaround problems with WDS rate/resolution selection

313. By Simon Fels on 2016-02-24

Use plain sockets for RTP connection rather than GLib

314. By Simon Fels on 2016-02-24

Extend GetEnvValue function to be able to return a default value

315. By Simon Fels on 2016-02-24

Wind local RTP port up the stack and don't use a static one

316. By Simon Fels on 2016-02-24

Setup miracast source manager when we're connected and not earlier

317. By Simon Fels on 2016-02-24

Define DHCP server address on construction

318. By Simon Fels on 2016-02-24

Drop result argument for SendDriverCommand method

319. By Simon Fels on 2016-02-24

Lock the display when we're connecting until we get disconnected

320. By Simon Fels on 2016-02-24

Force IPv4 for our DHCP client

321. By Simon Fels on 2016-02-25

Improve renderer/encoder to really stream a constant framerate

Also optimizes logging in different parts of the code

322. By Simon Fels on 2016-02-25

Only support CBP with level 3.1 for now

323. By Simon Fels on 2016-02-25

Trying to resend RTP packages one time and then fail

324. By Simon Fels on 2016-02-25

Implement missing interface method

325. By Simon Fels on 2016-02-25

Adjust for WPA DBus API changes

326. By Simon Fels on 2016-02-25

Don't adjust interface powersave mode

327. By Simon Fels on 2016-02-25

Keep pointer to management wifi interface

328. By Simon Fels on 2016-02-25

Refactor code to send private driver commands a bit

329. By Simon Fels on 2016-02-25

Drop all code for the GL rendering code path which we don't need anymore

330. By Simon Fels on 2016-02-26

Missing changes for cmake configuration

331. By Simon Fels on 2016-02-26

Drop some more unused code fragments for logging

332. By Simon Fels on 2016-02-26

Small code cleanups

333. By Simon Fels on 2016-02-26

Drop unused gstreamer x264 encoder wrapper

334. By Simon Fels on 2016-02-26

Remove unused system power state controller

335. By Simon Fels on 2016-02-26

Drop unused unit tests

336. By Simon Fels on 2016-02-26

Fix encoder class

337. By Simon Fels on 2016-02-26

Add unit tests for buffer class

338. By Simon Fels on 2016-02-26

Add video format extraction tests (missing VESA/HH support)

339. By Simon Fels on 2016-02-26

Correctly release media buffer

340. By Simon Fels on 2016-02-26

Update WFD IE to indicate a session is not available when connected

341. By Simon Fels on 2016-02-26

Drop unnecessary dependencies

342. By Simon Fels on 2016-02-26

Move MediaSender into streaming namespace

343. By Simon Fels on 2016-02-26

Add interfaces for RTP sender / MPEGTS packetizer classes to make MediaSender testable

344. By Simon Fels on 2016-02-26

Add unit tests for media sender class

345. By Simon Fels on 2016-02-29

Add utility function to set thread name

346. By Simon Fels on 2016-02-29

Add unit test to make sure we're requesting PCR/PAT and PMT

Unmerged revisions

346. By Simon Fels on 2016-02-29

Add unit test to make sure we're requesting PCR/PAT and PMT

345. By Simon Fels on 2016-02-29

Add utility function to set thread name

344. By Simon Fels on 2016-02-26

Add unit tests for media sender class

343. By Simon Fels on 2016-02-26

Add interfaces for RTP sender / MPEGTS packetizer classes to make MediaSender testable

342. By Simon Fels on 2016-02-26

Move MediaSender into streaming namespace

341. By Simon Fels on 2016-02-26

Drop unnecessary dependencies

340. By Simon Fels on 2016-02-26

Update WFD IE to indicate a session is not available when connected

339. By Simon Fels on 2016-02-26

Correctly release media buffer

338. By Simon Fels on 2016-02-26

Add video format extraction tests (missing VESA/HH support)

337. By Simon Fels on 2016-02-26

Add unit tests for buffer class

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-10 06:47:03 +0000
+++ CMakeLists.txt	2016-01-27 13:00:21 +0000
@@ -58,12 +58,23 @@
 find_package(PkgConfig)
 find_package(Threads)
 
-pkg_check_modules(GLIB glib-2.0)
-pkg_check_modules(GIO gio-2.0)
-pkg_check_modules(GIO-UNIX gio-unix-2.0)
+pkg_check_modules(GLIB REQUIRED glib-2.0)
+pkg_check_modules(GIO REQUIRED gio-2.0)
+pkg_check_modules(GIO-UNIX REQUIRED gio-unix-2.0)
 pkg_check_modules(GST REQUIRED gstreamer-1.0)
 pkg_check_modules(WDS REQUIRED wds)
-pkg_check_modules(READLINE readline)
+# FIXME for the time being mir is required to do proper hardware
+# encoding on Android platforms. This will be refactored at some
+# point to be abstracted by gstreamer completely or made optional.
+pkg_check_modules(MIRCLIENT REQUIRED mirclient)
+# Same as mentioned above applies for the hybris and android
+# things below.
+pkg_check_modules(HYBRIS_MEDIA REQUIRED libmedia)
+pkg_check_modules(ANDROID_HEADERS REQUIRED android-headers)
+pkg_check_modules(EGL REQUIRED egl)
+pkg_check_modules(GLESV2 REQUIRED glesv2)
+add_definitions(-DMESA_EGL_NO_X11_HEADERS)
+
 # Build with system gmock and embedded gtest
 set (GMOCK_INCLUDE_DIR "/usr/include/gmock/include" CACHE PATH "gmock source include directory")
 set (GMOCK_SOURCE_DIR "/usr/src/gmock" CACHE PATH "gmock source directory")
@@ -78,3 +89,4 @@
 add_subdirectory(conf)
 add_subdirectory(src)
 add_subdirectory(tests)
+add_subdirectory(tools)

=== removed directory 'build'
=== modified file 'conf/CMakeLists.txt'
--- conf/CMakeLists.txt	2015-12-10 10:17:57 +0000
+++ conf/CMakeLists.txt	2016-01-27 13:00:21 +0000
@@ -5,3 +5,6 @@
 
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/aethercast-dbus.conf
         DESTINATION /etc/dbus-1/system.d/)
+
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/dhcpd.conf
+        DESTINATION /etc/aethercast/)

=== modified file 'conf/aethercast.conf.in'
--- conf/aethercast.conf.in	2015-12-10 10:17:57 +0000
+++ conf/aethercast.conf.in	2016-01-27 13:00:21 +0000
@@ -5,4 +5,17 @@
 
 respawn
 
-exec /usr/sbin/aethercast
+script
+	if [ -x `which getprop` ] ; then
+		iface=`getprop wifi.direct.interface`
+		if [ "$iface" != "" ] ; then
+			export AETHERCAST_DEDICATED_P2P_INTERFACE=$iface
+			# FIXME this might not be true for all devices but it should
+			# not cause any for those which doesn't need any firmware as
+			# the Android WiFi firmware loader should just pass through
+			export AETHERCAST_NEED_FIRMWARE=1
+		fi
+	fi
+
+	exec /usr/sbin/aethercast
+end script

=== added file 'conf/dhcpd.conf'
--- conf/dhcpd.conf	1970-01-01 00:00:00 +0000
+++ conf/dhcpd.conf	2016-01-27 13:00:21 +0000
@@ -0,0 +1,5 @@
+subnet 192.168.7.0 netmask 255.255.255.0 {
+    range 192.168.7.5 192.168.7.10;
+    option subnet-mask 255.255.255.0;
+    option broadcast-address 192.168.7.255;
+}

=== added file 'data/fi.w1.wpa_supplicant1.xml'
--- data/fi.w1.wpa_supplicant1.xml	1970-01-01 00:00:00 +0000
+++ data/fi.w1.wpa_supplicant1.xml	2016-01-27 13:00:21 +0000
@@ -0,0 +1,109 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+    <interface name="fi.w1.wpa_supplicant1">
+        <method name="CreateInterface">
+            <arg name="args" type="a{sv}" direction="in"/>
+            <arg name="path" type="o" direction="out"/>
+        </method>
+        <signal name="InterfaceAdded">
+            <arg name="path" type="o"/>
+            <arg name="properties" type="a{sv}"/>
+        </signal>
+        <signal name="InterfaceRemoved">
+            <arg name="path" type="o"/>
+        </signal>
+        <property name="Interfaces" type="ao" access="read"/>
+        <property name="Capabilities" type="as" access="read"/>
+        <property name="WFDIEs" type="ay" access="readwrite">
+            <annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
+        </property>
+    </interface>
+    <interface name="fi.w1.wpa_supplicant1.Interface">
+        <property name="Capabilities" type="a{sv}" access="read"/>
+        <property name="State" type="s" access="read"/>
+        <property name="Ifname" type="s" access="read"/>
+        <property name="Driver" type="s" access="read"/>
+    </interface>
+    <interface name="fi.w1.wpa_supplicant1.Interface.P2PDevice">
+        <method name="Find">
+            <arg name="args" type="a{sv}" direction="in"/>
+        </method>
+        <method name="StopFind"/>
+        <method name="ExtendedListen">
+            <arg name="args" type="a{sv}" direction="in"/>
+        </method>
+        <method name="Connect">
+            <arg name="args" type="a{sv}" direction="in"/>
+            <arg name="group" type="s" direction="out"/>
+        </method>
+        <method name="Cancel"/>
+        <method name="Disconnect"/>
+        <method name="Flush"/>
+        <signal name="DeviceFound">
+            <arg name="path" type="o"/>
+        </signal>
+        <signal name="DeviceLost">
+            <arg name="path" type="o"/>
+        </signal>
+        <signal name="FindStopped"/>
+        <signal name="GONegotiationSuccess">
+            <arg name="properties" type="a{sv}"/>
+        </signal>
+        <signal name="GONegotiationFailure">
+            <arg name="properties" type="a{sv}"/>
+        </signal>
+        <signal name="GroupStarted">
+            <arg name="properties" type="a{sv}"/>
+        </signal>
+        <signal name="GroupFinished">
+            <arg name="properties" type="a{sv}"/>
+        </signal>
+        <signal name="GroupFormationFailure">
+            <arg name="reason" type="s"/>
+        </signal>
+        <signal name="GONegotiationRequest">
+            <arg name="path" type="o"/>
+            <arg name="dev_passwd_id" type="i"/>
+        </signal>
+        <property name="P2PDeviceConfig" type="a{sv}" access="readwrite"/>
+        <property name="Peers" type="ao" access="read"/>
+    </interface>
+    <interface name="fi.w1.wpa_supplicant1.Peer">
+        <property name="DeviceName" type="s" access="read"/>
+        <property name="Manufacturer" type="s" access="read"/>
+        <property name="ModelName" type="s" access="read"/>
+        <property name="ModelNumber" type="s" access="read"/>
+        <property name="SerialNumber" type="s" access="read"/>
+        <property name="PrimaryDeviceType" type="ay" access="read"/>
+        <property name="config_method" type="q" access="read"/>
+        <property name="level" type="i" access="read"/>
+        <property name="devicecapability" type="y" access="read"/>
+        <property name="groupcapability" type="y" access="read"/>
+        <property name="SecondaryDeviceTypes" type="aay" access="read"/>
+        <property name="VendorExtension" type="aay" access="read"/>
+        <property name="IEs" type="ay" access="read"/>
+        <property name="DeviceAddress" type="ay" access="read">
+            <annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
+        </property>
+        <property name="Groups" type="ao" access="read"/>
+    </interface>
+    <interface name="fi.w1.wpa_supplicant1.Group">
+        <property name="Members" type="s" access="read"/>
+        <property name="Group" type="o" access="read"/>
+        <property name="Role" type="s" access="read"/>
+        <property name="SSID" type="ay" access="read"/>
+        <property name="BSSID" type="ay" access="read"/>
+        <property name="Frequency" type="q" access="read"/>
+        <property name="Passphrase" type="s" access="read"/>
+        <property name="PSK" type="ay" access="read"/>
+        <property name="WPSVendorExtensions" type="aay" access="read"/>
+        <signal name="PeerJoined">
+            <arg name="peer" type="o"/>
+        </signal>
+        <signal name="PeerDisconnected">
+            <arg name="peer" type="o"/>
+        </signal>
+    </interface>
+</node>
+

=== added file 'debian/aethercast.install'
--- debian/aethercast.install	1970-01-01 00:00:00 +0000
+++ debian/aethercast.install	2016-01-27 13:00:21 +0000
@@ -0,0 +1,1 @@
+debian/usr.sbin.aethercast /etc/apparmor.d/dhcpd.d/

=== modified file 'debian/control'
--- debian/control	2015-12-10 06:47:03 +0000
+++ debian/control	2016-01-27 13:00:21 +0000
@@ -5,6 +5,7 @@
 XSBC-Original-Maintainer: Simon Fels <[e-mail]>
 Build-Depends: cmake,
                debhelper (>= 9),
+               dbus,
                google-mock,
                libboost-dev,
                libboost-filesystem-dev,
@@ -31,6 +32,8 @@
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+         isc-dhcp-server,
+         isc-dhcp-client,
          wpasupplicant
 Description: Display casting service
  A management service for remote displays which it can stream the

=== modified file 'debian/rules'
--- debian/rules	2015-11-19 12:17:57 +0000
+++ debian/rules	2016-01-27 13:00:21 +0000
@@ -17,3 +17,6 @@
 
 %:
 	dh $@ --parallel --fail-missing
+
+override_dh_auto_test:
+	# disable

=== added file 'debian/usr.sbin.aethercast'
--- debian/usr.sbin.aethercast	1970-01-01 00:00:00 +0000
+++ debian/usr.sbin.aethercast	2016-01-27 13:00:21 +0000
@@ -0,0 +1,11 @@
+# vim:syntax=apparmor
+
+  # Allow aethercast to start dhcpd with its own configuration
+  # file it needs to provide DHCP for groups it manages through
+  # WiFi Direct. This need to stay as long as NetworkManager does
+  # not has support for WiFi Direct and aethercast is using that.
+  /etc/aethercast/dhcpd.conf r,
+  # In addition aethercast will also point dhcpd to a private
+  # lease/pid file
+  /{,var/}run/aethercast/dhcpd.leases* lrw,
+  /{,var/}run/aethercast/dhcpd.pid lrw,

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-12-18 17:15:31 +0000
+++ src/CMakeLists.txt	2016-01-27 13:00:21 +0000
@@ -9,14 +9,33 @@
                         --interface-prefix org.aethercast.
                         ${CMAKE_CURRENT_SOURCE_DIR}/../data/org.aethercast.xml)
 
+execute_process(COMMAND ${GDBUS_CODEGEN_EXECUTABLE}
+                        --c-namespace WpaSupplicant
+                        --c-generate-object-manager
+                        --generate-c-code ${CMAKE_CURRENT_BINARY_DIR}/mcs/wpasupplicantinterface
+                        --interface-prefix fi.w1.wpa_supplicant1.
+                        ${CMAKE_CURRENT_SOURCE_DIR}/../data/fi.w1.wpa_supplicant1.xml)
+
 # Make sure that generated header files can be found
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/mcs)
 
+set(AETHERCAST_DHCP_HELPER "/usr/sbin/aethercast-dhcp-helper")
+set(DHCP_SERVER_PATH "/usr/sbin/dhcpd")
+set(DHCP_CLIENT_PATH "/sbin/dhclient")
+
+configure_file(mcs/config.h.in mcs/config.h @ONLY)
+configure_file(w11tng/config.h.in w11tng/config.h @ONLY)
+
 set(HEADERS
     mcs/ip_v4_address.h
     mcs/keep_alive.h
     mcs/mac_address.h
     mcs/types.h
+    mcs/shared_gobject.h
+    mcs/keep_alive.h
+
+    mcs/config.h
+    w11tng/config.h
 )
 
 set(SOURCES
@@ -24,10 +43,12 @@
   mcs/networkutils.cpp
   mcs/mediamanagerfactory.cpp
   mcs/basesourcemediamanager.cpp
+  mcs/initgstreameronce.cpp
   mcs/gstsourcemediamanager.cpp
   mcs/testsourcemediamanager.cpp
+  mcs/x11sourcemediamanager.cpp
+  mcs/videoformat.cpp
   mcs/logger.cpp
-  mcs/mirsourcemediamanager.cpp
   mcs/forwardingmiracastcontroller.cpp
   mcs/forwardingnetworkdevice.cpp
   mcs/miracastcontroller.cpp
@@ -38,24 +59,35 @@
   mcs/networkmanager.cpp
   mcs/networkmanagerfactory.cpp
   mcs/networkdevice.cpp
-
+  mcs/x264.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/mcs/aethercastinterface.c
   mcs/dbushelpers.cpp
   mcs/networkdeviceskeleton.cpp
 
-  w11t/gdhcp/common.c
-  w11t/gdhcp/ipv4ll.c
-  w11t/gdhcp/server.c
-  w11t/gdhcp/client.c
-  w11t/dhcpclient.cpp
-  w11t/dhcpserver.cpp
-  w11t/wififirmwareloader.cpp
-  w11t/wfddeviceinfo.cpp
-  w11t/message.cpp
-  w11t/command.cpp
-  w11t/commandqueue.cpp
-  w11t/networkdevice.cpp
-  w11t/networkmanager.cpp
+  mcs/mir/sourcemediamanager.cpp
+
+  mcs/android/h264encoder.cpp
+  mcs/android/pipedoutputtarget.cpp
+  mcs/android/fileoutputtarget.cpp
+
+  ${CMAKE_CURRENT_BINARY_DIR}/mcs/wpasupplicantinterface.c
+  w11tng/networkmanager.cpp
+  w11tng/networkdevice.cpp
+  w11tng/interfaceselector.cpp
+  w11tng/p2pdevicestub.cpp
+  w11tng/managerstub.cpp
+  w11tng/peerstub.cpp
+  w11tng/interfacestub.cpp
+  w11tng/groupstub.cpp
+  w11tng/informationelement.cpp
+  w11tng/dhcpleaseparser.cpp
+  w11tng/dhcpclient.cpp
+  w11tng/dhcpserver.cpp
+  w11tng/processexecutor.cpp
+  w11tng/filemonitor.cpp
+  w11tng/netlinklistener.cpp
+  w11tng/wififirmwareloader.cpp
+  w11tng/hostname1stub.cpp
 )
 
 link_directories(
@@ -63,6 +95,7 @@
   ${GIO_LIBRARY_DIRS}
   ${GIO-UNIX_LIBRARY_DIRS}
   ${WDS_LIBRARY_DIRS}
+  ${HYBRIS_MEDIA_LIBRARY_DIRS}
 )
 
 include_directories(
@@ -72,8 +105,10 @@
   ${GIO-UNIX_INCLUDE_DIRS}
   ${GST_INCLUDE_DIRS}
   ${WDS_INCLUDE_DIRS}
-  ${CMAKE_CURRENT_SOURCE_DIR}/w11t/gdhcp
+  ${HYBRIS_MEDIA_INCLDUE_DIRS}
+  ${ANDROID_HEADERS_INCLUDE_DIRS}
   ${CMAKE_CURRENT_BINARY_DIR}/src
+  ${CMAKE_CURRENT_BINARY_DIR}/src/w11tng
 )
 
 add_library(aethercast-core ${SOURCES} ${HEADERS})
@@ -88,6 +123,7 @@
   ${GST_LIBRARIES}
   ${CMAKE_THREAD_LIBS_INIT}
   ${WDS_LIBRARIES}
+  ${HYBRIS_MEDIA_LIBRARIES}
   -ldl
 )
 

=== modified file 'src/client/application.cpp'
--- src/client/application.cpp	2015-12-16 06:47:41 +0000
+++ src/client/application.cpp	2016-01-27 13:00:21 +0000
@@ -31,6 +31,9 @@
 
 using namespace std::placeholders;
 
+namespace {
+const unsigned int kDBusTimeout = 120;
+
 class PromptSaver {
 public:
     PromptSaver() {
@@ -59,6 +62,7 @@
     int saved_point_;
     char *saved_line_;
 };
+}
 
 namespace mcs {
 namespace client {
@@ -434,9 +438,10 @@
         return;
     }
 
-    // Use a high enough timeout to make sure we get the end of the scan
-    // method call which has an internal timeout of 30 seconds
-    g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(inst->manager_), 60 * 1000);
+    // Use a high enough timeout to make sure we wait enough for the service to
+    // respond as the connection process can take some time depending on different
+    // factors.
+    g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(inst->manager_), kDBusTimeout * 1000);
 
     aethercast_interface_object_manager_client_new(inst->bus_connection_,
                              G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,

=== added directory 'src/mcs/android'
=== added file 'src/mcs/android/fileoutputtarget.cpp'
--- src/mcs/android/fileoutputtarget.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/android/fileoutputtarget.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+#include "mcs/logger.h"
+#include "mcs/android/fileoutputtarget.h"
+
+namespace mcs {
+namespace android {
+
+FileOutputTarget::FileOutputTarget(const std::string &path, const H264Encoder::OutputFormat &format) :
+    fd_(-1),
+    format_(format) {
+
+    ::unlink(path.c_str());
+    fd_ = ::open(path.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+    if (fd_ < 0) {
+        MCS_ERROR("Failed to create output file at path %s", path);
+        return;
+    }
+}
+
+FileOutputTarget::~FileOutputTarget() {
+    if (fd_ > 0)
+        close(fd_);
+}
+
+int FileOutputTarget::FileDescriptor() const {
+    return fd_;
+}
+
+mcs::android::H264Encoder::OutputFormat FileOutputTarget::Format() const {
+    return format_;
+}
+
+} // namespace android
+} // namespace mcs

=== added file 'src/mcs/android/fileoutputtarget.h'
--- src/mcs/android/fileoutputtarget.h	1970-01-01 00:00:00 +0000
+++ src/mcs/android/fileoutputtarget.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MCS_ANDORID_FILEOUTPUTTARET_H_
+#define MCS_ANDORID_FILEOUTPUTTARET_H_
+
+#include <string>
+
+#include "mcs/android/h264encoder.h"
+
+namespace mcs {
+namespace android {
+class FileOutputTarget : public mcs::android::H264Encoder::OutputTarget {
+public:
+    FileOutputTarget(const std::string &path, const mcs::android::H264Encoder::OutputFormat &format);
+    ~FileOutputTarget();
+
+    int FileDescriptor() const override;
+    mcs::android::H264Encoder::OutputFormat Format() const override;
+
+private:
+    int fd_;
+    mcs::android::H264Encoder::OutputFormat format_;
+};
+} // namespace android
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/android/h264encoder.cpp'
--- src/mcs/android/h264encoder.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/android/h264encoder.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <unistd.h>
+
+#include <hybris/media/media_recorder_layer.h>
+
+#include "mcs/logger.h"
+#include "mcs/utils.h"
+#include "mcs/android/h264encoder.h"
+
+namespace mcs {
+namespace android {
+
+H264Encoder::Ptr H264Encoder::Create(const OutputTarget &output) {
+    return std::shared_ptr<H264Encoder>(new H264Encoder(output));
+}
+
+H264Encoder::H264Encoder(const OutputTarget &output) :
+    recorder_(nullptr),
+    recorder_observer_(nullptr),
+    recorder_source_(nullptr) {
+
+    ::OutputFormat format = ANDROID_OUTPUT_FORMAT_DEFAULT;
+
+    switch (output.Format()) {
+    case OutputFormat::kMPEG2TS:
+        format = ANDROID_OUTPUT_FORMAT_MPEG2TS;
+        break;
+    case OutputFormat::kMPEG4:
+        format = ANDROID_OUTPUT_FORMAT_MPEG_4;
+        break;
+    case OutputFormat::kRTPAVP:
+        format = ANDROID_OUTPUT_FORMAT_RTP_AVP;
+        break;
+    default:
+        MCS_ERROR("Unsupported output format");
+        return;
+    }
+
+    // FIXME we need to instantiate an observer here as otherwise
+    // the camera service can't find one and will crash.
+    recorder_observer_ = android_media_recorder_observer_new();
+    if (!recorder_observer_) {
+        MCS_ERROR("Failed to create recorder observer instance");
+        return;
+    }
+
+    // Also need to install a proper callback here for the observer
+    // until it properly checks for a assigned callback internally.
+    android_media_recorder_observer_set_cb(recorder_observer_, [](bool started, void *context) {
+        (void) context;
+
+        if (started)
+            MCS_DEBUG("Recording started");
+        else
+            MCS_DEBUG("Recording stopped");
+    }, nullptr);
+
+    recorder_ = android_media_new_recorder();
+    if (!recorder_) {
+        MCS_ERROR("Failed to create a recorder instance");
+        return;
+    }
+
+    // It's really important that we set the video source first as otherwise
+    // the encoder doesn't enter the 'configured' state and all subsequent
+    // calls will fail.
+    android_recorder_setVideoSource(recorder_, ANDROID_VIDEO_SOURCE_GRALLOC_BUFFER);
+
+    android_recorder_setOutputFormat(recorder_, format);
+    android_recorder_setVideoEncoder(recorder_, ANDROID_VIDEO_ENCODER_H264);
+    android_recorder_setOutputFile(recorder_, output.FileDescriptor());
+}
+
+H264Encoder::~H264Encoder() {
+    if (recorder_)
+        android_recorder_release(recorder_);
+
+    if (recorder_observer_)
+        android_media_recorder_observer_release(recorder_observer_);
+}
+
+void* H264Encoder::NativeWindowHandle() const {
+    if (!recorder_ && !recorder_source_)
+        return nullptr;
+
+    return android_recorder_source_get_native_handle(recorder_source_);
+}
+
+void H264Encoder::SetFramerate(unsigned int framerate) {
+    if (!recorder_)
+        return;
+
+    android_recorder_setVideoFrameRate(recorder_, framerate);
+}
+
+void H264Encoder::SetBitrate(unsigned int bitrate) {
+    if (!recorder_)
+        return;
+
+    auto param = mcs::Utils::Sprintf("video-param-encoding-bitrate=%d", bitrate);
+
+    android_recorder_setParameters(recorder_, param.c_str());
+}
+
+void H264Encoder::SetIFrameInterval(unsigned int interval) {
+    if (!recorder_)
+        return;
+
+    auto param = mcs::Utils::Sprintf("video-param-i-frames-interval=%d", interval);
+
+    android_recorder_setParameters(recorder_, param.c_str());
+}
+
+void H264Encoder::SetDimensions(unsigned int width, unsigned int height) {
+    if (!recorder_)
+        return;
+
+    android_recorder_setVideoSize(recorder_, width, height);
+}
+
+void H264Encoder::Start() {
+    if (!recorder_)
+        return;
+
+    android_recorder_prepare(recorder_);
+    android_recorder_start(recorder_);
+
+    recorder_source_ = android_recorder_query_source(recorder_);
+    if (!recorder_source_) {
+        MCS_ERROR("Failed to query source from recorder instance");
+        return;
+    }
+}
+
+void H264Encoder::Stop() {
+    if (!recorder_)
+        return;
+
+    android_recorder_stop(recorder_);
+    recorder_source_ = nullptr;
+}
+
+} // namespace android
+} // namespace mcs

=== added file 'src/mcs/android/h264encoder.h'
--- src/mcs/android/h264encoder.h	1970-01-01 00:00:00 +0000
+++ src/mcs/android/h264encoder.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MCS_ANDORID_ENCODER_H_
+#define MCS_ANDORID_ENCODER_H_
+
+#include <memory>
+
+#include "mcs/non_copyable.h"
+
+struct MediaRecorderWrapper;
+struct MediaRecorderObserver;
+struct MediaRecorderSource;
+
+namespace mcs {
+namespace android {
+class H264Encoder {
+public:
+    typedef std::shared_ptr<H264Encoder> Ptr;
+
+    enum class OutputFormat {
+        kRaw = 0,
+        kMPEG4,
+        kMPEG2TS,
+        kRTPAVP
+    };
+
+    class OutputTarget  : public mcs::NonCopyable {
+    public:
+        // This will return a file descriptor the encoder can write its
+        // data to.
+        virtual int FileDescriptor() const = 0;
+
+        // Describes the output format the encoder should use
+        virtual OutputFormat Format() const = 0;
+    };
+
+    static Ptr Create(const OutputTarget &output);
+
+    ~H264Encoder();
+
+    void Start();
+    void Stop();
+
+    void* NativeWindowHandle() const;
+
+    void SetFramerate(unsigned int framerate);
+    void SetBitrate(unsigned int bitrate);
+    void SetIFrameInterval(unsigned int interval);
+    void SetDimensions(unsigned int width, unsigned int height);
+
+private:
+    H264Encoder(const OutputTarget &output);
+
+private:
+    MediaRecorderWrapper *recorder_;
+    MediaRecorderObserver *recorder_observer_;
+    MediaRecorderSource *recorder_source_;
+};
+} // namespace android
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/android/pipedoutputtarget.cpp'
--- src/mcs/android/pipedoutputtarget.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/android/pipedoutputtarget.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <unistd.h>
+
+#include "mcs/logger.h"
+#include "mcs/android/pipedoutputtarget.h"
+
+namespace mcs {
+namespace android {
+
+PipedOutputTarget::PipedOutputTarget(const H264Encoder::OutputFormat &format) :
+    format_(format) {
+    if (::pipe(fds_) < 0) {
+        MCS_ERROR("Failed to create piped output target");
+        return;
+    }
+}
+
+PipedOutputTarget::~PipedOutputTarget() {
+    if (fds_[0] > 0) {
+        close(fds_[0]);
+        close(fds_[1]);
+    }
+}
+
+int PipedOutputTarget::FileDescriptor() const {
+    return fds_[1];
+}
+
+mcs::android::H264Encoder::OutputFormat PipedOutputTarget::Format() const {
+    return format_;
+}
+
+int PipedOutputTarget::OutputFileDescriptor() const {
+    return fds_[0];
+}
+
+} // namespace android
+} // namespace mcs

=== added file 'src/mcs/android/pipedoutputtarget.h'
--- src/mcs/android/pipedoutputtarget.h	1970-01-01 00:00:00 +0000
+++ src/mcs/android/pipedoutputtarget.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MCS_ANDORID_PIPEDOUTPUTTARET_H_
+#define MCS_ANDORID_PIPEDOUTPUTTARET_H_
+
+#include "mcs/android/h264encoder.h"
+
+namespace mcs {
+namespace android {
+class PipedOutputTarget : public mcs::android::H264Encoder::OutputTarget {
+public:
+    PipedOutputTarget(const mcs::android::H264Encoder::OutputFormat &format);
+    ~PipedOutputTarget();
+
+    int FileDescriptor() const override;
+    mcs::android::H264Encoder::OutputFormat Format() const override;
+
+    int OutputFileDescriptor() const;
+
+private:
+    int fds_[2];
+    mcs::android::H264Encoder::OutputFormat format_;
+};
+} // namespace android
+} // namespace mcs
+
+#endif

=== modified file 'src/mcs/basesourcemediamanager.cpp'
--- src/mcs/basesourcemediamanager.cpp	2015-12-07 16:02:43 +0000
+++ src/mcs/basesourcemediamanager.cpp	2016-01-27 13:00:21 +0000
@@ -15,9 +15,12 @@
  *
  */
 
+#include <iostream>
+
 #include <glib.h>
 
 #include "basesourcemediamanager.h"
+#include "videoformat.h"
 #include "logger.h"
 
 namespace mcs {
@@ -38,24 +41,23 @@
     return sink_port1_;
 }
 
-std::vector<wds::H264VideoCodec> GetH264VideoCodecs() {
+std::vector<wds::H264VideoCodec> BaseSourceMediaManager::GetH264VideoCodecs() {
     static std::vector<wds::H264VideoCodec> codecs;
     if (codecs.empty()) {
         wds::RateAndResolutionsBitmap cea_rr;
         wds::RateAndResolutionsBitmap vesa_rr;
         wds::RateAndResolutionsBitmap hh_rr;
         wds::RateAndResolution i;
-        // declare that we support all resolutions, CHP and level 4.2
-        // gstreamer should handle all of it :)
+
         for (i = wds::CEA640x480p60; i <= wds::CEA1920x1080p24; ++i)
             cea_rr.set(i);
-        for (i = wds::VESA800x600p30; i <= wds::VESA1920x1200p30; ++i)
-            vesa_rr.set(i);
-        for (i = wds::HH800x480p30; i <= wds::HH848x480p60; ++i)
-            hh_rr.set(i);
 
-        wds::H264VideoCodec codec(wds::CHP, wds::k4_2, cea_rr, vesa_rr, hh_rr);
+        wds::H264VideoCodec codec(wds::CHP, wds::k4, cea_rr, vesa_rr, hh_rr);
         codecs.push_back(codec);
+
+        DEBUG("Video codecs supported by us:");
+        for (auto c : codecs)
+            mcs::video::DumpVideoCodec(c);
     }
 
     return codecs;
@@ -64,15 +66,20 @@
 bool BaseSourceMediaManager::InitOptimalVideoFormat(const wds::NativeVideoFormat& sink_native_format,
     const std::vector<wds::H264VideoCodec>& sink_supported_codecs) {
 
+    DEBUG("Sink native resolution:");
+    mcs::video::DumpNativeFormat(sink_native_format);
+
+    DEBUG("Sink supports the following codecs:");
+    for (auto sink_codec : sink_supported_codecs) {
+        mcs::video::DumpVideoCodec(sink_codec);
+    }
+
     format_ = wds::FindOptimalVideoFormat(sink_native_format,
                                          GetH264VideoCodecs(),
                                          sink_supported_codecs);
 
-    INFO("Found optimal video format");
-    INFO("  profile: %d", format_.profile);
-    INFO("  level: %d", format_.level);
-    INFO("  res type %d", format_.type);
-    INFO("  rate & resolution %d", format_.rate_resolution);
+    DEBUG("Found optimal video format:");
+    mcs::video::DumpVideoFormat(format_);
 
     Configure();
 

=== modified file 'src/mcs/basesourcemediamanager.h'
--- src/mcs/basesourcemediamanager.h	2015-11-26 16:48:53 +0000
+++ src/mcs/basesourcemediamanager.h	2016-01-27 13:00:21 +0000
@@ -38,6 +38,7 @@
 
 protected:
     virtual void Configure() = 0;
+    virtual std::vector<wds::H264VideoCodec> GetH264VideoCodecs();
 
 protected:
     int sink_port1_;

=== renamed file 'src/w11t/command.cpp' => 'src/mcs/config.h.in'
--- src/w11t/command.cpp	2015-12-18 17:15:31 +0000
+++ src/mcs/config.h.in	2016-01-27 13:00:21 +0000
@@ -15,11 +15,11 @@
  *
  */
 
-#include "command.h"
-
-namespace w11t {
-Command::Command(const Message &message, ResponseCallback callback) :
-    message(message),
-    callback(callback) {
-}
-}
+#ifndef MCS_CONFIG_H_
+#define MCS_CONFIG_H_
+
+namespace mcs {
+constexpr const char* kRuntimePath{"/run/aethercast"};
+}
+
+#endif

=== modified file 'src/mcs/dbushelpers.cpp'
--- src/mcs/dbushelpers.cpp	2015-12-07 15:40:38 +0000
+++ src/mcs/dbushelpers.cpp	2016-01-27 13:00:21 +0000
@@ -19,15 +19,58 @@
 
 namespace mcs {
 
-gchar** DBusHelpers::GenerateCapabilities(const std::vector<NetworkDeviceRole> roles) {
-    gchar** capabilities = g_new0(gchar*, roles.size() + 1);
+gchar** DBusHelpers::GenerateDeviceCapabilities(const std::vector<NetworkDeviceRole> &roles) {
+    gchar **capabilities = g_new0(gchar*, roles.size() + 1);
     int n = 0;
     for (auto role : roles)
-        capabilities[n] = g_strdup(NetworkDevice::RoleToStr(roles[n++]).c_str());
+        capabilities[n] = g_strdup(NetworkDevice::RoleToStr(role).c_str());
     capabilities[n] = nullptr;
     return capabilities;
 }
 
+gchar** DBusHelpers::GenerateCapabilities(const std::vector<NetworkManager::Capability> &capabilities) {
+    gchar** out_capabilities = g_new0(gchar*, capabilities.size() + 1);
+    int n = 0;
+    for (auto capability : capabilities) {
+        auto value = NetworkManager::CapabilityToStr(capability);
+        out_capabilities[n++] = g_strdup(value.c_str());
+    }
+    out_capabilities[n] = nullptr;
+    return out_capabilities;
+}
+
+void DBusHelpers::ParseDictionary(GVariant *properties, std::function<void(std::string, GVariant*)> callback, const std::string &key_filter) {
+    if (!callback || !properties)
+        return;
+
+    for (int n = 0; n < g_variant_n_children(properties); n++) {
+        auto property = g_variant_get_child_value(properties, n);
+        auto key_v = g_variant_get_child_value(property, 0);
+        auto value_v = g_variant_get_child_value(property, 1);
+
+        std::string key = g_variant_get_string(key_v, nullptr);
+
+        if (key_filter.length() > 0) {
+            if (key_filter != key)
+                continue;
+
+            callback(key, value_v);
+        }
+        else
+            callback(key, value_v);
+    }
+}
+
+void DBusHelpers::ParseArray(GVariant *array, std::function<void(GVariant*)> callback) {
+    if (!callback || !array)
+        return;
+
+    for (int n = 0; n < g_variant_n_children(array); n++) {
+        auto element = g_variant_get_child_value(array, n);
+        callback(element);
+    }
+}
+
 } // namespace mcs
 
 

=== modified file 'src/mcs/dbushelpers.h'
--- src/mcs/dbushelpers.h	2015-12-07 15:40:38 +0000
+++ src/mcs/dbushelpers.h	2016-01-27 13:00:21 +0000
@@ -18,14 +18,21 @@
 #ifndef DBUSHELPERS_H_
 #define DBUSHELPERS_H_
 
+#include <functional>
+
 #include <glib.h>
+#include <gio/gio.h>
 
-#include "networkdevice.h"
+#include "networkmanager.h"
+#include "scoped_gobject.h"
 
 namespace mcs {
 
 struct DBusHelpers {
-    static gchar** GenerateCapabilities(const std::vector<NetworkDeviceRole> roles);
+    static gchar** GenerateCapabilities(const std::vector<NetworkManager::Capability> &capabilities);
+    static gchar** GenerateDeviceCapabilities(const std::vector<NetworkDeviceRole> &roles);
+    static void ParseDictionary(GVariant *properties, std::function<void(std::string, GVariant*)> callback, const std::string &key_filter = "");
+    static void ParseArray(GVariant *array, std::function<void(GVariant*)> callback);
 };
 
 } // namespace mcs

=== modified file 'src/mcs/forwardingmiracastcontroller.cpp'
--- src/mcs/forwardingmiracastcontroller.cpp	2015-12-11 22:02:52 +0000
+++ src/mcs/forwardingmiracastcontroller.cpp	2016-01-27 13:00:21 +0000
@@ -50,8 +50,8 @@
     return fwd_->State();
 }
 
-std::vector<NetworkDeviceRole> ForwardingMiracastController::SupportedRoles() const {
-    return fwd_->SupportedRoles();
+std::vector<NetworkManager::Capability> ForwardingMiracastController::Capabilities() const {
+    return fwd_->Capabilities();
 }
 
 bool ForwardingMiracastController::Scanning() const {

=== modified file 'src/mcs/forwardingmiracastcontroller.h'
--- src/mcs/forwardingmiracastcontroller.h	2015-12-11 22:02:52 +0000
+++ src/mcs/forwardingmiracastcontroller.h	2016-01-27 13:00:21 +0000
@@ -35,7 +35,7 @@
     virtual void Scan(const std::chrono::seconds &timeout = std::chrono::seconds{30}) override;
 
     virtual NetworkDeviceState State() const override;
-    virtual std::vector<NetworkDeviceRole> SupportedRoles() const override;
+    virtual std::vector<NetworkManager::Capability> Capabilities() const override;
     virtual bool Scanning() const override;
 
 private:

=== added file 'src/mcs/forwardingnetworkdevice.cpp'
--- src/mcs/forwardingnetworkdevice.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/forwardingnetworkdevice.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,51 @@
+/*
+* Copyright (C) 2015 Canonical, Ltd.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 3, as published
+* by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+#include "forwardingnetworkdevice.h"
+
+namespace mcs {
+
+ForwardingNetworkDevice::ForwardingNetworkDevice(const NetworkDevice::Ptr& fwd) : fwd_(fwd) {
+    if (not fwd_) {
+        throw std::logic_error{"Cannot operate without a valid NetworkDevice instance."};
+    }
+}
+
+MacAddress ForwardingNetworkDevice::Address() const {
+    return fwd_->Address();
+}
+
+IpV4Address ForwardingNetworkDevice::IPv4Address() const {
+    return fwd_->IPv4Address();
+}
+
+std::string ForwardingNetworkDevice::Name() const {
+    return fwd_->Name();
+}
+
+NetworkDeviceState ForwardingNetworkDevice::State() const {
+    return fwd_->State();
+}
+
+std::vector<NetworkDeviceRole> ForwardingNetworkDevice::SupportedRoles() const {
+    return fwd_->SupportedRoles();
+}
+
+const NetworkDevice::Ptr& ForwardingNetworkDevice::Fwd() const {
+    return fwd_;
+}
+} // namespace mcs

=== removed file 'src/mcs/forwardingnetworkdevice.cpp'
--- src/mcs/forwardingnetworkdevice.cpp	2015-12-16 08:04:35 +0000
+++ src/mcs/forwardingnetworkdevice.cpp	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-/*
-* Copyright (C) 2015 Canonical, Ltd.
-*
-* This program is free software: you can redistribute it and/or modify it
-* under the terms of the GNU General Public License version 3, as published
-* by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranties of
-* MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-* PURPOSE.  See the GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License along
-* with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
-#include "forwardingnetworkdevice.h"
-
-namespace mcs {
-
-ForwardingNetworkDevice::ForwardingNetworkDevice(const NetworkDevice::Ptr& fwd) : fwd_(fwd) {
-    if (not fwd_) {
-        throw std::logic_error{"Cannot operate without a valid NetworkDevice instance."};
-    }
-}
-
-MacAddress ForwardingNetworkDevice::Address() const {
-    return fwd_->Address();
-}
-
-IpV4Address ForwardingNetworkDevice::IPv4Address() const {
-    return fwd_->IPv4Address();
-}
-
-std::string ForwardingNetworkDevice::Name() const {
-    return fwd_->Name();
-}
-
-NetworkDeviceState ForwardingNetworkDevice::State() const {
-    return fwd_->State();
-}
-
-std::vector<NetworkDeviceRole> ForwardingNetworkDevice::SupportedRoles() const {
-    return fwd_->SupportedRoles();
-}
-
-const NetworkDevice::Ptr& ForwardingNetworkDevice::Fwd() const {
-    return fwd_;
-}
-} // namespace mcs

=== added file 'src/mcs/forwardingnetworkdevice.h'
--- src/mcs/forwardingnetworkdevice.h	1970-01-01 00:00:00 +0000
+++ src/mcs/forwardingnetworkdevice.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,42 @@
+/*
+* Copyright (C) 2015 Canonical, Ltd.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 3, as published
+* by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License along
+* with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifndef FORWARDINGNETWORKDEVICE_H_
+#define FORWARDINGNETWORKDEVICE_H_
+
+#include "networkdevice.h"
+
+namespace mcs {
+
+class ForwardingNetworkDevice : public NetworkDevice {
+public:
+    ForwardingNetworkDevice(const NetworkDevice::Ptr& fwd);
+
+    MacAddress Address() const override;
+    IpV4Address IPv4Address() const override;
+    std::string Name() const override;
+    NetworkDeviceState State() const override;
+    std::vector<NetworkDeviceRole> SupportedRoles() const override;
+
+protected:
+    const NetworkDevice::Ptr& Fwd() const;
+
+private:
+    NetworkDevice::Ptr fwd_;
+};
+} // namespace mcs
+#endif

=== removed file 'src/mcs/forwardingnetworkdevice.h'
--- src/mcs/forwardingnetworkdevice.h	2015-12-16 08:04:35 +0000
+++ src/mcs/forwardingnetworkdevice.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
-* Copyright (C) 2015 Canonical, Ltd.
-*
-* This program is free software: you can redistribute it and/or modify it
-* under the terms of the GNU General Public License version 3, as published
-* by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranties of
-* MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-* PURPOSE.  See the GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License along
-* with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
-#ifndef FORWARDINGNETWORKDEVICE_H_
-#define FORWARDINGNETWORKDEVICE_H_
-
-#include "networkdevice.h"
-
-namespace mcs {
-
-class ForwardingNetworkDevice : public NetworkDevice {
-public:
-    ForwardingNetworkDevice(const NetworkDevice::Ptr& fwd);
-
-    MacAddress Address() const override;
-    IpV4Address IPv4Address() const override;
-    std::string Name() const override;
-    NetworkDeviceState State() const override;
-    std::vector<NetworkDeviceRole> SupportedRoles() const override;
-
-protected:
-    const NetworkDevice::Ptr& Fwd() const;
-
-private:
-    NetworkDevice::Ptr fwd_;
-};
-} // namespace mcs
-#endif

=== modified file 'src/mcs/gobject_deleter.h'
--- src/mcs/gobject_deleter.h	2015-11-30 10:41:56 +0000
+++ src/mcs/gobject_deleter.h	2016-01-27 13:00:21 +0000
@@ -19,6 +19,8 @@
 
 #include <glib-object.h>
 
+#include <mcs/logger.h>
+
 namespace mcs {
 // A GObjectDeleter considers T to be a GObject and
 // provides an operator() that decrements the reference

=== modified file 'src/mcs/gstsourcemediamanager.cpp'
--- src/mcs/gstsourcemediamanager.cpp	2015-12-09 16:07:13 +0000
+++ src/mcs/gstsourcemediamanager.cpp	2016-01-27 13:00:21 +0000
@@ -60,7 +60,7 @@
         g_free (debug);
         break;
     default:
-        /* unhandled message */
+        DEBUG("");
         break;
     }
 
@@ -68,6 +68,8 @@
 }
 
 void GstSourceMediaManager::Configure() {
+    DEBUG("");
+
     pipeline_ = ConstructPipeline(format_);
 
     ScopedGObject<GstBus> bus{gst_pipeline_get_bus (GST_PIPELINE(pipeline_.get()))};
@@ -81,6 +83,8 @@
     if (!pipeline_)
         return;
 
+    DEBUG("");
+
     gst_element_set_state(pipeline_.get(), GST_STATE_PLAYING);
 }
 
@@ -88,6 +92,8 @@
     if (!pipeline_)
         return;
 
+    DEBUG("");
+
     gst_element_set_state(pipeline_.get(), GST_STATE_PAUSED);
 }
 
@@ -95,6 +101,8 @@
     if (!pipeline_)
         return;
 
+    DEBUG("");
+
     gst_element_set_state(pipeline_.get(), GST_STATE_READY);
 }
 
@@ -102,6 +110,8 @@
     if (!pipeline_)
         return true;
 
+    DEBUG("");
+
     GstState state;
     gst_element_get_state(pipeline_.get(), &state, nullptr, GST_CLOCK_TIME_NONE);
 

=== added file 'src/mcs/initgstreameronce.cpp'
--- src/mcs/initgstreameronce.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/initgstreameronce.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <atomic>
+
+#include <gst/gst.h>
+
+#include "initgstreameronce.h"
+#include "logger.h"
+
+namespace {
+void GstLog (GstDebugCategory *category,
+          GstDebugLevel level,
+          const gchar *file,
+          const gchar *function,
+          gint line,
+          GObject *object,
+          GstDebugMessage *message,
+          gpointer user_data) {
+
+    boost::optional<mcs::Logger::Location> location;
+    if (file && function && line > 0) {
+        location = mcs::Logger::Location{file, function, line};
+    }
+
+    mcs::Log().Log(mcs::GstDebugLevelToSeverity(level), gst_debug_message_get(message), location);
+}
+}
+namespace mcs {
+Logger::Severity GstDebugLevelToSeverity(GstDebugLevel level) {
+    switch (level) {
+    case GST_LEVEL_NONE:
+    case GST_LEVEL_ERROR:
+        return Logger::Severity::kError;
+    case GST_LEVEL_WARNING:
+    case GST_LEVEL_FIXME:
+        return Logger::Severity::kWarning;
+    case GST_LEVEL_INFO:
+        return Logger::Severity::kInfo;
+    case GST_LEVEL_DEBUG:
+        return Logger::Severity::kDebug;
+    case GST_LEVEL_LOG:
+        return Logger::Severity::kDebug;
+    case GST_LEVEL_TRACE:
+    case GST_LEVEL_MEMDUMP:
+        return Logger::Severity::kTrace;
+    default:
+        return Logger::Severity::kInfo;
+    }
+}
+
+void InitGstreamerOnceOrThrow() {
+    static std::atomic<bool> initialized(false);
+    if (initialized.exchange(true))
+        return;
+
+    GError* error = nullptr;
+    if (gst_init_check(nullptr, nullptr, &error) == FALSE) {
+        auto what = Utils::Sprintf("Failed to initialize gstreamer (%s: %s)", g_quark_to_string(error->domain), error->message);
+        g_error_free(error);
+        throw std::runtime_error{what};
+    }
+
+    // Get rid of gstreamer's default log function.
+    gst_debug_remove_log_function(nullptr);
+    // And install our own.
+    gst_debug_add_log_function(GstLog, nullptr, nullptr);
+    // No need to, our logging infra takes care of that, too.
+    gst_debug_set_colored(FALSE);
+    auto gst_debug = Utils::GetEnvValue("AETHERCAST_GST_DEBUG");
+    if (not gst_debug.empty())
+        gst_debug_set_threshold_from_string(gst_debug.c_str(), FALSE);
+}
+}

=== added file 'src/mcs/initgstreameronce.h'
--- src/mcs/initgstreameronce.h	1970-01-01 00:00:00 +0000
+++ src/mcs/initgstreameronce.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <gst/gst.h>
+
+#include "logger.h"
+
+namespace mcs {
+// GstDebugLevelToSeverity maps a GstDebugLevel to a Logger::Severity;
+Logger::Severity GstDebugLevelToSeverity(GstDebugLevel);
+
+// InitGstreamerOnceOrThrow initializes GStreamer, redirecting
+// its debug output to the mcs::Logger facilities.
+void InitGstreamerOnceOrThrow();
+}

=== modified file 'src/mcs/mediamanagerfactory.cpp'
--- src/mcs/mediamanagerfactory.cpp	2015-12-07 16:02:43 +0000
+++ src/mcs/mediamanagerfactory.cpp	2016-01-27 13:00:21 +0000
@@ -19,7 +19,8 @@
 
 #include "logger.h"
 #include "mediamanagerfactory.h"
-#include "mirsourcemediamanager.h"
+#include "mir/sourcemediamanager.h"
+#include "x11sourcemediamanager.h"
 #include "testsourcemediamanager.h"
 #include "utils.h"
 #include "logging.h"
@@ -49,10 +50,12 @@
 std::shared_ptr<BaseSourceMediaManager> MediaManagerFactory::CreateSource(const std::string &remote_address) {
     std::string type = Utils::GetEnvValue("MIRACAST_SOURCE_TYPE");
 
-    WARNING("Creating source media manager of type %s", type.c_str());
+    DEBUG("Creating source media manager of type %s", type.c_str());
 
     if (type.length() == 0 || type == "mir")
-        return std::make_shared<MirSourceMediaManager>(remote_address);
+        return std::make_shared<mcs::mir::SourceMediaManager>(remote_address);
+    else if (type == "x11")
+        return X11SourceMediaManager::create(remote_address);
     else if (type == "test")
         return TestSourceMediaManager::create(remote_address);
 

=== added directory 'src/mcs/mir'
=== renamed file 'src/mcs/mirsourcemediamanager.cpp' => 'src/mcs/mir/sourcemediamanager.cpp'
--- src/mcs/mirsourcemediamanager.cpp	2015-12-07 16:02:43 +0000
+++ src/mcs/mir/sourcemediamanager.cpp	2016-01-27 13:00:21 +0000
@@ -15,99 +15,48 @@
  *
  */
 
+#include <cassert>
 #include <sstream>
 
-#include "mirsourcemediamanager.h"
-#include "utils.h"
-#include "logger.h"
+#include "mcs/utils.h"
+#include "mcs/logger.h"
+
+#include "mcs/videoformat.h"
+
+#include "mcs/mir/sourcemediamanager.h"
 
 namespace mcs {
-MirSourceMediaManager::MirSourceMediaManager(const std::string &remote_address) :
-    remote_address_(remote_address) {
-}
-
-MirSourceMediaManager::~MirSourceMediaManager() {
-}
-
-SharedGObject<GstElement> MirSourceMediaManager::ConstructPipeline(const wds::H264VideoFormat &format) {
-    int width = 0, height = 0;
-    std::string profile = "constrained-baseline";
-
-    switch (format.profile) {
-    case wds::CBP:
-        profile = "constrained-baseline";
-        break;
-    case wds::CHP:
-        profile = "high";
-        break;
-    }
-
-    switch (format.type) {
-    case wds::CEA:
-        switch (format.rate_resolution) {
-        case wds::CEA640x480p60:
-            width = 640;
-            height = 480;
-            break;
-        case wds::CEA720x480p60:
-        case wds::CEA720x480i60:
-            width = 720;
-            height = 480;
-            break;
-        case wds::CEA720x576p50:
-        case wds::CEA720x576i50:
-            width = 720;
-            height = 576;
-            break;
-        case wds::CEA1280x720p30:
-        case wds::CEA1280x720p60:
-            width = 1280;
-            height = 720;
-            break;
-        case wds::CEA1920x1080p30:
-        case wds::CEA1920x1080p60:
-        case wds::CEA1920x1080i60:
-            width = 1920;
-            height = 1080;
-            break;
-        case wds::CEA1280x720p25:
-        case wds::CEA1280x720p50:
-        case wds::CEA1280x720p24:
-            width = 1280;
-            height = 720;
-            break;
-        case wds::CEA1920x1080p25:
-        case wds::CEA1920x1080p50:
-        case wds::CEA1920x1080i50:
-        case wds::CEA1920x1080p24:
-            width = 1920;
-            height = 1080;
-            break;
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-
-    std::stringstream ss;
-    ss << "mirimagesrc mir-socket=/run/mir_socket ! videoconvert ! videoscale ! ";
-    ss << Utils::Sprintf("video/x-raw,width=%d,height=%d ! ", width, height);
-    ss << "videoflip method=counterclockwise ! queue2 ! video/x-raw,format=I420 ! ";
-    ss << "x264enc aud=false byte-stream=true tune=zerolatency ! ";
-    ss << Utils::Sprintf("video/x-h264,profile=%s ! ", profile.c_str());
-    ss << "mpegtsmux ! rtpmp2tpay ! ";
-    ss << Utils::Sprintf("udpsink name=sink host=%s port=%d", remote_address_.c_str(), sink_port1_);
-
-    GError *error = nullptr;
-    GstElement *pipeline = gst_parse_launch(ss.str().c_str(), &error);
-    if (error) {
-        ERROR("Failed to setup GStreamer pipeline: %s", error->message);
-        g_error_free(error);
-        return nullptr;
-    }
+namespace mir {
+
+SourceMediaManager::SourceMediaManager(const std::string &remote_address) :
+    remote_address_(remote_address),
+    output_(mcs::android::H264Encoder::OutputFormat::kRTPAVP) {
+}
+
+SourceMediaManager::~SourceMediaManager() {
+}
+
+SharedGObject<GstElement> SourceMediaManager::ConstructPipeline(const wds::H264VideoFormat &format) {
+    auto rr = mcs::video::ExtractRateAndResolution(format);
+
+    encoder_ = mcs::android::H264Encoder::Create(output_);
+
+    encoder_->SetDimensions(rr.width, rr.height);
+    encoder_->SetFramerate(rr.framerate);
+
+    GstElement *pipeline = gst_pipeline_new("video-stream");
+    GstElement *source = gst_element_factory_make("fdsrc", "video-in");
+    GstElement *sink = gst_element_factory_make("udpsink", "stream-output");
+
+    // Set the pipeline plugin properties
+    g_object_set(G_OBJECT(source), "fd", output_.OutputFileDescriptor(), nullptr);
+    g_object_set(G_OBJECT(sink), "host", remote_address_.c_str(), nullptr);
+    g_object_set(G_OBJECT(sink), "port", sink_port1_, nullptr);
+
+    gst_bin_add_many(GST_BIN(pipeline), source, sink, nullptr);
+    gst_element_link_many(source, sink, nullptr);
 
     return make_shared_gobject(pipeline);
 }
+} // namespace mir
 } // namespace mcs

=== renamed file 'src/mcs/mirsourcemediamanager.h' => 'src/mcs/mir/sourcemediamanager.h'
--- src/mcs/mirsourcemediamanager.h	2015-11-30 10:41:56 +0000
+++ src/mcs/mir/sourcemediamanager.h	2016-01-27 13:00:21 +0000
@@ -15,22 +15,30 @@
  *
  */
 
-#ifndef MIRMEDIAMANAGER_H_
-#define MIRMEDIAMANAGER_H_
+#ifndef MCS_MIR_SOURCEMEDIAMANAGER_H_
+#define MCS_MIR_SOURCEMEDIAMANAGER_H_
 
-#include "gstsourcemediamanager.h"
+#include "mcs/gstsourcemediamanager.h"
+#include "mcs/android/h264encoder.h"
+#include "mcs/android/pipedoutputtarget.h"
 
 namespace mcs {
-class MirSourceMediaManager : public GstSourceMediaManager {
+namespace mir {
+
+class SourceMediaManager : public GstSourceMediaManager {
 public:
-    explicit MirSourceMediaManager(const std::string &remote_address);
-    ~MirSourceMediaManager();
+    explicit SourceMediaManager(const std::string &remote_address);
+    ~SourceMediaManager();
 
 protected:
     SharedGObject<GstElement> ConstructPipeline(const wds::H264VideoFormat &format) override;
 
 private:
     std::string remote_address_;
+    mcs::android::H264Encoder::Ptr encoder_;
+    mcs::android::PipedOutputTarget output_;
 };
+} // namespace mir
 } // namespace mcs
+
 #endif

=== modified file 'src/mcs/miracastcontroller.h'
--- src/mcs/miracastcontroller.h	2015-12-16 08:04:35 +0000
+++ src/mcs/miracastcontroller.h	2016-01-27 13:00:21 +0000
@@ -21,6 +21,7 @@
 #include <chrono>
 #include <memory>
 
+#include "networkmanager.h"
 #include "networkdevice.h"
 #include "non_copyable.h"
 #include "types.h"
@@ -54,7 +55,7 @@
     virtual void Scan(const std::chrono::seconds &timeout = std::chrono::seconds{30}) = 0;
 
     virtual NetworkDeviceState State() const = 0;
-    virtual std::vector<NetworkDeviceRole> SupportedRoles() const = 0;
+    virtual std::vector<NetworkManager::Capability> Capabilities() const = 0;
     virtual bool Scanning() const = 0;
 
 protected:

=== modified file 'src/mcs/miracastcontrollerskeleton.cpp'
--- src/mcs/miracastcontrollerskeleton.cpp	2015-12-21 15:20:11 +0000
+++ src/mcs/miracastcontrollerskeleton.cpp	2016-01-27 13:00:21 +0000
@@ -55,10 +55,7 @@
     aethercast_interface_manager_set_state(manager_obj_.get(),
                                            NetworkDevice::StateToStr(State()).c_str());
 
-    // Capabilities are a collection of different things our local adapter
-    // supports. The supported roles are just one part of this.
-    auto roles = SupportedRoles();
-    auto capabilities = DBusHelpers::GenerateCapabilities(roles);
+    auto capabilities = DBusHelpers::GenerateCapabilities(Capabilities());
 
     aethercast_interface_manager_set_capabilities(manager_obj_.get(), capabilities);
 

=== modified file 'src/mcs/miracastservice.cpp'
--- src/mcs/miracastservice.cpp	2015-12-18 19:48:09 +0000
+++ src/mcs/miracastservice.cpp	2016-01-27 13:00:21 +0000
@@ -27,8 +27,12 @@
 
 #include <chrono>
 
+#include <boost/filesystem.hpp>
+
 #include <wds/logging.h>
 
+#include "initgstreameronce.h"
+#include "config.h"
 #include "keep_alive.h"
 #include "logger.h"
 #include "miracastservice.h"
@@ -37,12 +41,11 @@
 #include "types.h"
 #include "logging.h"
 
-#include <w11t/wfddeviceinfo.h>
-
 namespace {
 // TODO(morphis, tvoss): Expose the port as a construction-time parameter.
 const std::uint16_t kMiracastDefaultRtspCtrlPort{7236};
 const std::chrono::milliseconds kStateIdleTimeout{5000};
+const std::chrono::seconds kShutdownGracePreriod{1};
 
 // SafeLog serves as integration point to the wds::LogSystem world.
 template <mcs::Logger::Severity severity>
@@ -93,11 +96,24 @@
     }
 
     struct Runtime {
-        static int OnSignalRaised(gpointer user_data) {
+        static gboolean OnSignalRaised(gpointer user_data) {
             auto thiz = static_cast<Runtime*>(user_data);
-            g_main_loop_quit(thiz->ml);
-
-            return 0;
+
+            // This will bring down everything and the timeout below will give
+            // things a small amount of time to perform their shutdown jobs.
+            thiz->service->Shutdown();
+
+            MCS_DEBUG("Exiting");
+
+            g_timeout_add_seconds(kShutdownGracePreriod.count(), [](gpointer user_data) {
+                auto thiz = static_cast<Runtime*>(user_data);
+                g_main_loop_quit(thiz->ml);
+                return FALSE;
+            }, thiz);
+
+            // A second SIGTERM should really terminate us and also overlay
+            // the grace period for a proper shutdown we're performing.
+            return FALSE;
         }
 
         Runtime() {
@@ -107,6 +123,9 @@
             g_unix_signal_add(SIGINT, OnSignalRaised, this);
             g_unix_signal_add(SIGTERM, OnSignalRaised, this);
 
+            // Initialize gstreamer.
+            mcs::InitGstreamerOnceOrThrow();
+
             // Redirect all wds logging to our own.
             wds::LogSystem::set_vlog_func(SafeLog<mcs::Logger::Severity::kTrace>);
             wds::LogSystem::set_log_func(SafeLog<mcs::Logger::Severity::kInfo>);
@@ -140,11 +159,14 @@
             // Become a reaper of all our children
             if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0)
                 g_warning("Failed to make us a subreaper of our children");
+
+            network_manager = mcs::NetworkManagerFactory::Create();
+            service = mcs::MiracastService::Create(network_manager);
+            mcsa = mcs::MiracastControllerSkeleton::create(service);
         }
 
         ~Runtime() {
             g_main_loop_unref(ml);
-            gst_deinit();
         }
 
         void Run() {
@@ -153,12 +175,11 @@
 
         GMainLoop *ml = g_main_loop_new(nullptr, FALSE);
         bool is_gst_initialized = gst_init_check(nullptr, nullptr, nullptr);
+        mcs::NetworkManager::Ptr network_manager;
+        mcs::MiracastService::Ptr service;
+        mcs::MiracastControllerSkeleton::Ptr mcsa;
     } rt;
 
-    auto network_manager = mcs::NetworkManagerFactory::Create();
-    auto service = mcs::MiracastService::Create(network_manager);
-    auto mcsa = mcs::MiracastControllerSkeleton::create(service);
-
     rt.Run();
 
     return 0;
@@ -173,6 +194,8 @@
     current_state_(kIdle),
     scan_timeout_source_(0),
     supported_roles_({kSource}) {
+
+    CreateRuntimeDirectory();
 }
 
 std::shared_ptr<MiracastService> MiracastService::FinalizeConstruction(const NetworkManager::Ptr &network_manager) {
@@ -191,6 +214,15 @@
         g_source_remove(scan_timeout_source_);
 }
 
+void MiracastService::CreateRuntimeDirectory() {
+    boost::filesystem::path runtime_dir(mcs::kRuntimePath);
+
+    if (boost::filesystem::is_directory(runtime_dir))
+        boost::filesystem::remove_all(runtime_dir);
+
+    boost::filesystem::create_directory(runtime_dir);
+}
+
 void MiracastService::SetDelegate(const std::weak_ptr<MiracastController::Delegate> &delegate) {
     delegate_ = delegate;
 }
@@ -203,8 +235,8 @@
     return current_state_;
 }
 
-std::vector<NetworkDeviceRole> MiracastService::SupportedRoles() const {
-    return supported_roles_;
+std::vector<NetworkManager::Capability> MiracastService::Capabilities() const {
+    return network_manager_->Capabilities();
 }
 
 bool MiracastService::Scanning() const {
@@ -273,6 +305,9 @@
         return;
 
     AdvanceState(device->State());
+
+    if (auto sp = delegate_.lock())
+        sp->OnDeviceChanged(device);
 }
 
 void MiracastService::OnDeviceChanged(const NetworkDevice::Ptr &device) {
@@ -297,7 +332,8 @@
 }
 
 void MiracastService::StartIdleTimer() {
-    g_timeout_add(kStateIdleTimeout.count(), &MiracastService::OnIdleTimer, new SharedKeepAlive<MiracastService>{shared_from_this()});
+    g_timeout_add(kStateIdleTimeout.count(), &MiracastService::OnIdleTimer,
+                  new SharedKeepAlive<MiracastService>{shared_from_this()});
 }
 
 void MiracastService::FinishConnectAttempt(mcs::Error error) {
@@ -309,6 +345,7 @@
 
 void MiracastService::Connect(const NetworkDevice::Ptr &device, ResultCallback callback) {
     if (current_device_) {
+        MCS_DEBUG("Tried to connect again while we're already trying to connect a device");
         callback(Error::kAlready);
         return;
     }
@@ -318,10 +355,10 @@
         return;
     }
 
-    DEBUG("Connecting remote device %s", device->Address());
+    DEBUG("address %s", device->Address());
 
     if (!network_manager_->Connect(device)) {
-         DEBUG("FAiled to connect remote device");
+        DEBUG("Failed to connect remote device");
         callback(Error::kFailed);
         return;
     }
@@ -347,4 +384,12 @@
 void MiracastService::Scan(const std::chrono::seconds &timeout) {
     network_manager_->Scan(timeout);
 }
+
+void MiracastService::Shutdown() {
+    if (current_device_)
+        network_manager_->Disconnect(current_device_);
+
+    network_manager_->Release();
+}
+
 } // namespace miracast

=== modified file 'src/mcs/miracastservice.h'
--- src/mcs/miracastservice.h	2015-12-11 21:10:24 +0000
+++ src/mcs/miracastservice.h	2016-01-27 13:00:21 +0000
@@ -67,7 +67,7 @@
     void Scan(const std::chrono::seconds &timeout = std::chrono::seconds{30});
 
     NetworkDeviceState State() const;
-    std::vector<NetworkDeviceRole> SupportedRoles() const;
+    std::vector<NetworkManager::Capability> Capabilities() const;
     bool Scanning() const;
 
     void OnClientDisconnected();
@@ -91,6 +91,9 @@
     void StartIdleTimer();
     void LoadWiFiFirmware();
 
+    void Shutdown();
+    void CreateRuntimeDirectory();
+
 private:
     std::weak_ptr<MiracastController::Delegate> delegate_;
     std::shared_ptr<NetworkManager> network_manager_;

=== modified file 'src/mcs/miracastsourceclient.cpp'
--- src/mcs/miracastsourceclient.cpp	2015-12-09 16:07:13 +0000
+++ src/mcs/miracastsourceclient.cpp	2016-01-27 13:00:21 +0000
@@ -25,7 +25,7 @@
 #include "keep_alive.h"
 #include "logger.h"
 #include "miracastsourceclient.h"
-#include "mirsourcemediamanager.h"
+#include "mcs/mir/sourcemediamanager.h"
 #include "testsourcemediamanager.h"
 #include "mediamanagerfactory.h"
 

=== modified file 'src/mcs/miracastsourcemanager.cpp'
--- src/mcs/miracastsourcemanager.cpp	2015-12-09 16:07:13 +0000
+++ src/mcs/miracastsourcemanager.cpp	2016-01-27 13:00:21 +0000
@@ -24,9 +24,7 @@
 namespace mcs {
 std::shared_ptr<MiracastSourceManager> MiracastSourceManager::Create(const IpV4Address &address, unsigned short port) {
     auto sp = std::shared_ptr<MiracastSourceManager>{new MiracastSourceManager{}};
-    DEBUG("Before setup");
     sp->Setup(address, port);
-    DEBUG("After setup");
     return sp;
 }
 
@@ -52,7 +50,7 @@
 }
 
 bool MiracastSourceManager::Setup(const IpV4Address &address, unsigned short port) {
-    GError *error;
+    GError *error = nullptr;
 
     if (socket_)
         return false;
@@ -110,6 +108,8 @@
 gboolean MiracastSourceManager::OnNewConnection(GSocket *socket, GIOCondition  cond, gpointer user_data) {
     auto inst = static_cast<WeakKeepAlive<MiracastSourceManager>*>(user_data)->GetInstance().lock();
 
+    MCS_DEBUG("");
+
     // The callback context was deleted while the wait for connection was active.
     // Hardly anything we can do about it except for returning early.
     if (not inst)

=== modified file 'src/mcs/networkdevice.cpp'
--- src/mcs/networkdevice.cpp	2015-12-18 17:15:31 +0000
+++ src/mcs/networkdevice.cpp	2016-01-27 13:00:21 +0000
@@ -17,8 +17,6 @@
 
 #include "networkdevice.h"
 
-#include <w11t/wfddeviceinfo.h>
-
 namespace mcs {
 std::string NetworkDevice::StateToStr(NetworkDeviceState state) {
     switch (state) {
@@ -27,7 +25,9 @@
     case kFailure:
         return "failure";
     case kAssociation:
-        return "connecting";
+        return "association";
+    case kConfiguration:
+        return "configuration";
     case kConnected:
         return "connected";
     case kDisconnected:

=== added file 'src/mcs/networkdeviceskeleton.cpp'
--- src/mcs/networkdeviceskeleton.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/networkdeviceskeleton.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <algorithm>
+#include <boost/concept_check.hpp>
+
+#include "networkdeviceskeleton.h"
+#include "utils.h"
+#include "keep_alive.h"
+#include "logger.h"
+#include "dbushelpers.h"
+
+namespace mcs {
+
+NetworkDeviceSkeleton::Ptr NetworkDeviceSkeleton::Create(const SharedGObject<GDBusConnection> &connection, const std::string &path, const NetworkDevice::Ptr &device, const MiracastController::Ptr &controller) {
+    return std::shared_ptr<NetworkDeviceSkeleton>(new NetworkDeviceSkeleton(connection, path, device, controller))->FinalizeConstruction();
+}
+
+NetworkDeviceSkeleton::NetworkDeviceSkeleton(const SharedGObject<GDBusConnection> &connection, const std::string &path, const NetworkDevice::Ptr &device, const MiracastController::Ptr &controller) :
+    ForwardingNetworkDevice(device),
+    connection_(connection),
+    object_(make_shared_gobject(aethercast_interface_object_skeleton_new(path.c_str()))),
+    path_(path),
+    controller_(controller),
+    device_iface_(aethercast_interface_device_skeleton_new()) {
+}
+
+std::shared_ptr<NetworkDeviceSkeleton> NetworkDeviceSkeleton::FinalizeConstruction() {
+    auto sp = shared_from_this();
+
+    g_signal_connect(device_iface_.get(), "handle-connect",
+                     G_CALLBACK(&NetworkDeviceSkeleton::OnHandleConnect),
+                     new WeakKeepAlive<NetworkDeviceSkeleton>{sp});
+    g_signal_connect(device_iface_.get(), "handle-disconnect",
+                     G_CALLBACK(&NetworkDeviceSkeleton::OnHandleDisconnect),
+                     new WeakKeepAlive<NetworkDeviceSkeleton>{sp});
+
+    SyncProperties();
+
+    if (!object_)
+        ERROR("Failed to create object for device %s", Address());
+    else
+        aethercast_interface_object_skeleton_set_device(object_.get(), device_iface_.get());
+
+    return sp;
+}
+
+void NetworkDeviceSkeleton::SyncProperties() {
+    aethercast_interface_device_set_address(device_iface_.get(), Address().c_str());
+    aethercast_interface_device_set_name(device_iface_.get(), Name().c_str());
+    aethercast_interface_device_set_state(device_iface_.get(), NetworkDevice::StateToStr(State()).c_str());
+
+    auto capabilities = DBusHelpers::GenerateDeviceCapabilities(SupportedRoles());
+    aethercast_interface_device_set_capabilities(device_iface_.get(), capabilities);
+    g_strfreev(capabilities);
+}
+
+GDBusObjectSkeleton* NetworkDeviceSkeleton::DBusObject() const {
+    return G_DBUS_OBJECT_SKELETON(object_.get());
+}
+
+std::string NetworkDeviceSkeleton::Path() const {
+    return path_;
+}
+
+// TODO(tvoss,morphis): Refactor mcs::NetworkDevice to have Connect/Disconnect defined on its interfaces.
+// It feels quite dirty to require both an instance of mcs::NetworkDevice and mcs::MiracastController to
+// implement the connect/disconnect calls coming in via the bus. The complication then is the async handling of
+// the invocation, as we will likely have to reach out to WPASupplicant for example (which is dispatched via the same
+// event loop as we are). In addition, we should not start littering our public interfaces by handing down callbacks.
+gboolean NetworkDeviceSkeleton::OnHandleConnect(AethercastInterfaceDevice *skeleton, GDBusMethodInvocation *invocation,
+                                           const gchar *role, gpointer user_data)
+{
+    boost::ignore_unused_variable_warning(skeleton);
+    boost::ignore_unused_variable_warning(role);
+
+    auto inst = static_cast<WeakKeepAlive<NetworkDeviceSkeleton>*>(user_data)->GetInstance().lock();
+
+    if (not inst) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
+        return TRUE;
+    }
+
+    g_object_ref(invocation);
+    auto inv = make_shared_gobject(invocation);
+
+    inst->controller_->Connect(inst->Fwd(), [inv](mcs::Error error) {
+        if (error != Error::kNone) {
+            g_dbus_method_invocation_return_error(inv.get(), G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
+                                                  "%s", mcs::ErrorToString(error).c_str());
+            return;
+        }
+
+        g_dbus_method_invocation_return_value(inv.get(), nullptr);
+    });
+
+    return TRUE;
+}
+
+gboolean NetworkDeviceSkeleton::OnHandleDisconnect(AethercastInterfaceDevice *skeleton, GDBusMethodInvocation *invocation,
+                                                   gpointer user_data)
+{
+    boost::ignore_unused_variable_warning(skeleton);
+
+    auto inst = static_cast<WeakKeepAlive<NetworkDeviceSkeleton>*>(user_data)->GetInstance().lock();
+
+    if (not inst) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
+        return TRUE;
+    }
+
+    g_object_ref(invocation);
+    auto inv = make_shared_gobject(invocation);
+
+    inst->controller_->Disconnect(inst->Fwd(), [inv](mcs::Error error) {
+        if (error != Error::kNone) {
+            g_dbus_method_invocation_return_error(inv.get(), G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
+                                                  "%s", mcs::ErrorToString(error).c_str());
+            return;
+        }
+
+        g_dbus_method_invocation_return_value(inv.get(), nullptr);
+    });
+
+    return TRUE;
+}
+
+} // namespace mcs

=== removed file 'src/mcs/networkdeviceskeleton.cpp'
--- src/mcs/networkdeviceskeleton.cpp	2015-12-21 15:20:11 +0000
+++ src/mcs/networkdeviceskeleton.cpp	1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <algorithm>
-#include <boost/concept_check.hpp>
-
-#include "networkdeviceskeleton.h"
-#include "utils.h"
-#include "keep_alive.h"
-#include "logger.h"
-#include "dbushelpers.h"
-
-namespace mcs {
-
-NetworkDeviceSkeleton::Ptr NetworkDeviceSkeleton::Create(const SharedGObject<GDBusConnection> &connection, const std::string &path, const NetworkDevice::Ptr &device, const MiracastController::Ptr &controller) {
-    return std::shared_ptr<NetworkDeviceSkeleton>(new NetworkDeviceSkeleton(connection, path, device, controller))->FinalizeConstruction();
-}
-
-NetworkDeviceSkeleton::NetworkDeviceSkeleton(const SharedGObject<GDBusConnection> &connection, const std::string &path, const NetworkDevice::Ptr &device, const MiracastController::Ptr &controller) :
-    ForwardingNetworkDevice(device),
-    connection_(connection),
-    object_(make_shared_gobject(aethercast_interface_object_skeleton_new(path.c_str()))),
-    path_(path),
-    controller_(controller),
-    device_iface_(aethercast_interface_device_skeleton_new()) {
-}
-
-std::shared_ptr<NetworkDeviceSkeleton> NetworkDeviceSkeleton::FinalizeConstruction() {
-    auto sp = shared_from_this();
-
-    g_signal_connect(device_iface_.get(), "handle-connect",
-                     G_CALLBACK(&NetworkDeviceSkeleton::OnHandleConnect),
-                     new WeakKeepAlive<NetworkDeviceSkeleton>{sp});
-    g_signal_connect(device_iface_.get(), "handle-disconnect",
-                     G_CALLBACK(&NetworkDeviceSkeleton::OnHandleDisconnect),
-                     new WeakKeepAlive<NetworkDeviceSkeleton>{sp});
-
-    SyncProperties();
-
-    if (!object_)
-        ERROR("Failed to create object for device %s", Address());
-    else
-        aethercast_interface_object_skeleton_set_device(object_.get(), device_iface_.get());
-
-    return sp;
-}
-
-void NetworkDeviceSkeleton::SyncProperties() {
-    aethercast_interface_device_set_address(device_iface_.get(), Address().c_str());
-    aethercast_interface_device_set_name(device_iface_.get(), Name().c_str());
-    aethercast_interface_device_set_state(device_iface_.get(), NetworkDevice::StateToStr(State()).c_str());
-
-    auto capabilities = DBusHelpers::GenerateCapabilities(SupportedRoles());
-    aethercast_interface_device_set_capabilities(device_iface_.get(), capabilities);
-    g_strfreev(capabilities);
-}
-
-GDBusObjectSkeleton* NetworkDeviceSkeleton::DBusObject() const {
-    return G_DBUS_OBJECT_SKELETON(object_.get());
-}
-
-std::string NetworkDeviceSkeleton::Path() const {
-    return path_;
-}
-
-// TODO(tvoss,morphis): Refactor mcs::NetworkDevice to have Connect/Disconnect defined on its interfaces.
-// It feels quite dirty to require both an instance of mcs::NetworkDevice and mcs::MiracastController to
-// implement the connect/disconnect calls coming in via the bus. The complication then is the async handling of
-// the invocation, as we will likely have to reach out to WPASupplicant for example (which is dispatched via the same
-// event loop as we are). In addition, we should not start littering our public interfaces by handing down callbacks.
-gboolean NetworkDeviceSkeleton::OnHandleConnect(AethercastInterfaceDevice *skeleton, GDBusMethodInvocation *invocation,
-                                           const gchar *role, gpointer user_data)
-{
-    boost::ignore_unused_variable_warning(skeleton);
-    boost::ignore_unused_variable_warning(role);
-
-    auto inst = static_cast<WeakKeepAlive<NetworkDeviceSkeleton>*>(user_data)->GetInstance().lock();
-
-    if (not inst) {
-        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
-        return TRUE;
-    }
-
-    g_object_ref(invocation);
-    auto inv = make_shared_gobject(invocation);
-
-    inst->controller_->Connect(inst->Fwd(), [inv](mcs::Error error) {
-        if (error != Error::kNone) {
-            g_dbus_method_invocation_return_error(inv.get(), G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
-                                                  "%s", mcs::ErrorToString(error).c_str());
-            return;
-        }
-
-        g_dbus_method_invocation_return_value(inv.get(), nullptr);
-    });
-
-    return TRUE;
-}
-
-gboolean NetworkDeviceSkeleton::OnHandleDisconnect(AethercastInterfaceDevice *skeleton, GDBusMethodInvocation *invocation,
-                                                   gpointer user_data)
-{
-    boost::ignore_unused_variable_warning(skeleton);
-
-    auto inst = static_cast<WeakKeepAlive<NetworkDeviceSkeleton>*>(user_data)->GetInstance().lock();
-
-    if (not inst) {
-        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
-        return TRUE;
-    }
-
-    g_object_ref(invocation);
-    auto inv = make_shared_gobject(invocation);
-
-    inst->controller_->Disconnect(inst->Fwd(), [inv](mcs::Error error) {
-        if (error != Error::kNone) {
-            g_dbus_method_invocation_return_error(inv.get(), G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
-                                                  "%s", mcs::ErrorToString(error).c_str());
-            return;
-        }
-
-        g_dbus_method_invocation_return_value(inv.get(), nullptr);
-    });
-
-    return TRUE;
-}
-
-} // namespace mcs

=== modified file 'src/mcs/networkmanager.cpp'
--- src/mcs/networkmanager.cpp	2015-11-26 16:27:30 +0000
+++ src/mcs/networkmanager.cpp	2016-01-27 13:00:21 +0000
@@ -16,3 +16,13 @@
  */
 
 #include "networkmanager.h"
+
+namespace mcs {
+std::string NetworkManager::CapabilityToStr(Capability capability) {
+    if (capability == Capability::kSink)
+        return "sink";
+    else if (capability == Capability::kSource)
+        return "source";
+    return "";
+}
+} // namespace mcs

=== modified file 'src/mcs/networkmanager.h'
--- src/mcs/networkmanager.h	2015-12-09 16:07:13 +0000
+++ src/mcs/networkmanager.h	2016-01-27 13:00:21 +0000
@@ -45,15 +45,25 @@
         Delegate() = default;
     };
 
+    enum class Capability {
+        kSource,
+        kSink
+    };
+
+    static std::string CapabilityToStr(Capability capability);
+
     virtual void SetDelegate(Delegate * delegate) = 0;
 
+    virtual void SetCapabilities(const std::vector<Capability> &capabilities) = 0;
+    virtual std::vector<Capability> Capabilities() const = 0;
+
     virtual bool Setup() = 0;
+    virtual void Release() = 0;
+
     virtual void Scan(const std::chrono::seconds &timeout) = 0;
     virtual bool Connect(const NetworkDevice::Ptr &device) = 0;
     virtual bool Disconnect(const NetworkDevice::Ptr &device) = 0;
 
-    virtual void SetWfdSubElements(const std::list<std::string> &elements) = 0;
-
     virtual std::vector<NetworkDevice::Ptr> Devices() const = 0;
     virtual IpV4Address LocalAddress() const = 0;
     virtual bool Running() const = 0;

=== modified file 'src/mcs/networkmanagerfactory.cpp'
--- src/mcs/networkmanagerfactory.cpp	2015-12-18 17:15:31 +0000
+++ src/mcs/networkmanagerfactory.cpp	2016-01-27 13:00:21 +0000
@@ -17,18 +17,81 @@
 
 #include <boost/concept_check.hpp>
 
+#include <w11tng/networkmanager.h>
+
 #include "networkmanagerfactory.h"
 
-#include <w11t/networkmanager.h>
+#include "logger.h"
+#include "utils.h"
 
 namespace mcs {
 
+void NullNetworkManager::SetDelegate(Delegate * delegate) {
+    ERROR("Not implemented");
+}
+
+bool NullNetworkManager::Setup() {
+    ERROR("Not implemented");
+    return false;
+}
+
+void NullNetworkManager::Release() {
+    ERROR("Not implemented");
+}
+
+void NullNetworkManager::Scan(const std::chrono::seconds &timeout) {
+    ERROR("Not implemented");
+}
+
+bool NullNetworkManager::Connect(const NetworkDevice::Ptr &device) {
+    ERROR("Not implemented");
+    return false;
+}
+
+bool NullNetworkManager::Disconnect(const NetworkDevice::Ptr &device) {
+    ERROR("Not implemented");
+    return false;
+}
+
+std::vector<NetworkDevice::Ptr> NullNetworkManager::Devices() const {
+    ERROR("Not implemented");
+    return std::vector<NetworkDevice::Ptr>();
+}
+
+IpV4Address NullNetworkManager::LocalAddress() const {
+    ERROR("Not implemented");
+    return IpV4Address();
+}
+
+bool NullNetworkManager::Running() const {
+    ERROR("Not implemented");
+    return false;
+}
+
+bool NullNetworkManager::Scanning() const {
+    ERROR("Not implemented");
+    return false;
+}
+
+void NullNetworkManager::SetCapabilities(const std::vector<Capability> &capabilities) {
+    ERROR("Not implemented");
+}
+
+std::vector<NetworkManager::Capability> NullNetworkManager::Capabilities() const {
+    return std::vector<NetworkManager::Capability>{};
+}
+
 NetworkManager::Ptr NetworkManagerFactory::Create(const std::string &type) {
-    boost::ignore_unused_variable_warning(type);
-
-    // FIXME for now we only can create the wpa one but this will be extended
-    // with further types.
-    return std::make_shared<w11t::NetworkManager>();
+    auto final_type = type.length() > 0 ? type : Utils::GetEnvValue("AETHERCAST_NETWORK_MANAGER");
+
+    DEBUG("Creating network manager of type %s", final_type.length() > 0 ? final_type : "w11tng");
+
+    // We will always default to the w11t implementation if no invalid
+    // type is specified.
+    if (final_type == "w11tng" || final_type.length() == 0)
+        return w11tng::NetworkManager::Create();
+
+    return std::make_shared<NullNetworkManager>();
 }
 
 } // namespace mcs

=== modified file 'src/mcs/networkmanagerfactory.h'
--- src/mcs/networkmanagerfactory.h	2015-12-09 16:07:13 +0000
+++ src/mcs/networkmanagerfactory.h	2016-01-27 13:00:21 +0000
@@ -22,6 +22,27 @@
 
 namespace mcs {
 
+// Only here to make unit testing easier for the factory class
+class NullNetworkManager : public mcs::NetworkManager {
+public:
+    void SetDelegate(Delegate * delegate) override;
+
+    bool Setup() override;
+    void Release() override;
+
+    void Scan(const std::chrono::seconds &timeout) override;
+    bool Connect(const NetworkDevice::Ptr &device) override;
+    bool Disconnect(const NetworkDevice::Ptr &device) override;
+
+    std::vector<NetworkDevice::Ptr> Devices() const override;
+    IpV4Address LocalAddress() const override;
+    bool Running() const override;
+    bool Scanning() const override;
+
+    void SetCapabilities(const std::vector<Capability> &capabilities) override;
+    std::vector<Capability> Capabilities() const override;
+};
+
 class NetworkManagerFactory {
 public:
     static NetworkManager::Ptr Create(const std::string &type = "");

=== modified file 'src/mcs/networkutils.cpp'
--- src/mcs/networkutils.cpp	2015-12-07 16:02:43 +0000
+++ src/mcs/networkutils.cpp	2016-01-27 13:00:21 +0000
@@ -194,6 +194,27 @@
     return ifr.ifr_ifindex;;
 }
 
+std::string NetworkUtils::RetrieveInterfaceName(int index) {
+    if (index < 0)
+        return "";
+
+    auto sock = ::socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    if (sock < 0)
+        return "";
+
+    struct ifreq ifr = { };
+    ifr.ifr_ifindex = index;
+
+    auto err = ::ioctl(sock, SIOCGIFNAME, &ifr);
+
+    ::close(sock);
+
+    if (err < 0)
+        return "";
+
+    return std::string(ifr.ifr_name);
+}
+
 int NetworkUtils::ResetInterface(int index)
 {
     struct ifreq ifr, addr_ifr;

=== modified file 'src/mcs/networkutils.h'
--- src/mcs/networkutils.h	2015-11-26 16:48:53 +0000
+++ src/mcs/networkutils.h	2016-01-27 13:00:21 +0000
@@ -23,6 +23,7 @@
 {
 public:
     static int RetrieveInterfaceIndex(const char *name);
+    static std::string RetrieveInterfaceName(int index);
     static int ModifyInterfaceAddress(int cmd, int flags, int index, int family,
                              const char *address, const char *peer,
                              unsigned char prefixlen, const char *broadcast);

=== modified file 'src/mcs/testsourcemediamanager.cpp'
--- src/mcs/testsourcemediamanager.cpp	2015-12-07 16:02:43 +0000
+++ src/mcs/testsourcemediamanager.cpp	2016-01-27 13:00:21 +0000
@@ -15,6 +15,8 @@
  *
  */
 
+#include <sstream>
+
 #include <gst/gst.h>
 
 #include "logger.h"
@@ -22,6 +24,8 @@
 #include "utils.h"
 #include "logging.h"
 
+#include "videoformat.h"
+
 namespace mcs {
 std::shared_ptr<TestSourceMediaManager> TestSourceMediaManager::create(const std::string &remote_address) {
     return std::shared_ptr<TestSourceMediaManager>{new TestSourceMediaManager{remote_address}};
@@ -35,13 +39,34 @@
 }
 
 SharedGObject<GstElement> TestSourceMediaManager::ConstructPipeline(const wds::H264VideoFormat &format) {
-    auto config = Utils::Sprintf("videotestsrc ! videoconvert ! video/x-raw,format=I420 ! x264enc ! mpegtsmux ! rtpmp2tpay ! udpsink name=sink host=%s port=%d",
-                                     remote_address_.c_str(), sink_port1_);
+    auto profile = mcs::video::ExtractH264Profile(format);
+    auto rr = mcs::video::ExtractRateAndResolution(format);
+
+#if 0
+    std::stringstream ss;
+    ss << Utils::Sprintf("videotestsrc ! video/x-raw,format=I420,framerate=%d/1,width=%d,height=%d,pixel-aspect-ratio=1/1 ! ", rr.framerate, rr.width, rr.height);
+    ss << "x264enc tune=zerolatency byte-stream=true ! ";
+    ss << Utils::Sprintf("video/x-h264,profile=%s ! ", profile.c_str());
+    ss << "mpegtsmux ! rtpmp2tpay ! ";
+    ss << Utils::Sprintf("udpsink name=sink host=%s port=%d", remote_address_.c_str(), sink_port1_);
+#else
+    std::stringstream ss;
+    ss << "ximagesrc ";
+    ss << Utils::Sprintf("videoconvert ! video/x-raw,format=I420,framerate=%d/1,pixel-aspect-ratio=1/1 ! ", rr.framerate);
+    ss << Utils::Sprintf("videoscale ! video/x-raw,width=%d,height=%d ! ", rr.width, rr.height);
+    ss << "queue2 ! ";
+    ss << "x264enc byte-stream=true tune=zerolatency interlaced=false ! ";
+    ss << Utils::Sprintf("video/x-h264,profile=%s !", profile.c_str());
+    ss << "mpegtsmux ! rtpmp2tpay ! ";
+    ss << Utils::Sprintf("udpsink name=sink host=%s port=%d", remote_address_.c_str(), sink_port1_);
+#endif
+
+    DEBUG("pipeline: %s", ss.str());
 
     GError *error = nullptr;
-    GstElement *pipeline = gst_parse_launch(config.c_str(), &error);
+    GstElement *pipeline = gst_parse_launch(ss.str().c_str(), &error);
     if (error) {
-        WARNING("Failed to setup GStreamer pipeline: %s", error->message);
+        ERROR("Failed to setup GStreamer pipeline: %s", error->message);
         g_error_free(error);
         return nullptr;
     }

=== modified file 'src/mcs/utils.cpp'
--- src/mcs/utils.cpp	2015-12-03 07:43:27 +0000
+++ src/mcs/utils.cpp	2016-01-27 13:00:21 +0000
@@ -15,9 +15,11 @@
  *
  */
 
+#include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <memory>
+#include <fstream>
 
 #include <cstring>
 #include <cstdarg>
@@ -46,4 +48,16 @@
         return std::string("");
     return std::string(value);
 }
+
+bool Utils::CreateFile(const std::string &file_path) {
+    boost::filesystem::path p(file_path);
+    if (boost::filesystem::exists(p))
+        return false;
+
+    std::ofstream of;
+    of.open(file_path, std::ofstream::out);
+    of << "";
+    of.close();
+    return true;
+}
 } // namespace mcs

=== modified file 'src/mcs/utils.h'
--- src/mcs/utils.h	2015-12-03 07:43:27 +0000
+++ src/mcs/utils.h	2016-01-27 13:00:21 +0000
@@ -40,6 +40,14 @@
     static std::string Sprintf(const std::string& fmt_str, Types&&... args);
     // GetEnv - returns a variable value from the environment
     static std::string GetEnvValue(const std::string &name);
+    // CreateFile - create an empty file at the specified path
+    static bool CreateFile(const std::string &file_path);
+
+    // CreateScopedPtrWithDeleterFor - create a std::unique_ptr with a custom deleter
+    template <typename Owned, typename Deleter>
+    inline std::unique_ptr<Owned, Deleter> CreateScopedPtrWithDeleterFor(Owned* owned, Deleter&& deleter) {
+        return {owned, deleter};
+    }
 };
 
 namespace impl {

=== added file 'src/mcs/videoformat.cpp'
--- src/mcs/videoformat.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/videoformat.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,383 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "videoformat.h"
+#include "logger.h"
+
+namespace mcs {
+namespace video {
+
+std::string ResolutionTypeToString(wds::ResolutionType type) {
+    switch (type) {
+    case wds::CEA:
+        return "CEA";
+    case wds::VESA:
+        return "VESA";
+    case wds::HH:
+        return "HH";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+std::string CEARatesAndResolutionsToString(wds::CEARatesAndResolutions type) {
+    switch (type) {
+    case wds::CEA640x480p60:
+        return "640x480p60";
+    case wds::CEA720x480p60:
+        return "720x480p60";
+    case wds::CEA720x480i60:
+        return "720x480i60";
+    case wds::CEA720x576p50:
+        return "720x576p50";
+    case wds::CEA720x576i50:
+        return "720x576i50";
+    case wds::CEA1280x720p30:
+        return "1280x720p30";
+    case wds::CEA1280x720p60:
+        return "1280x720p60";
+    case wds::CEA1920x1080p30:
+        return "1920x1080p30";
+    case wds::CEA1920x1080p60:
+        return "1920x1080p60";
+    case wds::CEA1920x1080i60:
+        return "1920x1080i60";
+    case wds::CEA1280x720p25:
+        return "1280x720p25";
+    case wds::CEA1280x720p50:
+        return "1280x720p50";
+    case wds::CEA1920x1080p25:
+        return "1920x1080p25";
+    case wds::CEA1920x1080p50:
+        return "1920x1080p50";
+    case wds::CEA1920x1080i50:
+        return "1920x1080i50";
+    case wds::CEA1280x720p24:
+        return "1280x720p24";
+    case wds::CEA1920x1080p24:
+        return "1920x1080p24";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+std::string VESARatesAndResolutionsToString(wds::VESARatesAndResolutions type) {
+    switch (type) {
+    case wds::VESA800x600p30:
+        return "800x600p30";
+    case wds::VESA800x600p60:
+        return "800x600p60";
+    case wds::VESA1024x768p30:
+        return "1024x768p30";
+    case wds::VESA1024x768p60:
+        return "1024x768p60";
+    case wds::VESA1152x864p30:
+        return "1152x864p30";
+    case wds::VESA1152x864p60:
+        return "1152x864p60";
+    case wds::VESA1280x768p30:
+        return "1280x768p30";
+    case wds::VESA1280x768p60:
+        return "1280x768p60";
+    case wds::VESA1280x800p30:
+        return "1280x800p30";
+    case wds::VESA1280x800p60:
+        return "1280x800p60";
+    case wds::VESA1360x768p30:
+        return "1360x768p30";
+    case wds::VESA1360x768p60:
+        return "1360x768p60";
+    case wds::VESA1366x768p30:
+        return "1366x768p30";
+    case wds::VESA1366x768p60:
+        return "1366x768p60";
+    case wds::VESA1280x1024p30:
+        return "1280x1024p30";
+    case wds::VESA1280x1024p60:
+        return "1280x1024p60";
+    case wds::VESA1400x1050p30:
+        return "1400x1050p30";
+    case wds::VESA1400x1050p60:
+        return "1400x1050p60";
+    case wds::VESA1440x900p30:
+        return "1440x900p30";
+    case wds::VESA1440x900p60:
+        return "1440x900p60";
+    case wds::VESA1600x900p30:
+        return "1600x900p30";
+    case wds::VESA1600x900p60:
+        return "1600x900p60";
+    case wds::VESA1600x1200p30:
+        return "1600x1200p30";
+    case wds::VESA1600x1200p60:
+        return "1600x1200p60";
+    case wds::VESA1680x1024p30:
+        return "1680x1024p30";
+    case wds::VESA1680x1024p60:
+        return "1680x1024p60";
+    case wds::VESA1680x1050p30:
+        return "1680x1050p30";
+    case wds::VESA1680x1050p60:
+        return "1680x1050p60";
+    case wds::VESA1920x1200p30:
+        return "1920x1200p30";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+std::string HHRatesAndResolutionsToString(wds::HHRatesAndResolutions type) {
+    switch (type) {
+    case wds::HH800x480p30:
+      return "800x480p30";
+    case wds::HH800x480p60:
+      return "800x480p60";
+    case wds::HH854x480p30:
+      return "854x480p30";
+    case wds::HH854x480p60:
+      return "854x480p60";
+    case wds::HH864x480p30:
+      return "864x480p30";
+    case wds::HH864x480p60:
+      return "864x480p60";
+    case wds::HH640x360p30:
+      return "640x360p30";
+    case wds::HH640x360p60:
+      return "640x360p60";
+    case wds::HH960x540p30:
+      return "960x540p30";
+    case wds::HH960x540p60:
+      return "960x540p60";
+    case wds::HH848x480p30:
+      return "848x480p30";
+    case wds::HH848x480p60:
+      return "848x480p60";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+std::string LevelToString(wds::H264Level level) {
+    switch (level) {
+    case wds::k3_1:
+        return "3.1";
+    case wds::k3_2:
+        return "3.2";
+    case wds::k4:
+        return "4";
+    case wds::k4_1:
+        return "4.1";
+    case wds::k4_2:
+        return "4.2";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+std::string ProfileToString(wds::H264Profile profile) {
+    switch (profile) {
+    case wds::CBP:
+        return "cbp";
+    case wds::CHP:
+        return "chp";
+    default:
+        break;
+    }
+    return "unknown";
+}
+
+void DumpVideoCodec(const wds::H264VideoCodec &codec) {
+    int i = 0;
+
+    DEBUG(" profile: %s", ProfileToString(codec.profile));
+    DEBUG(" level: %s", LevelToString(codec.level));
+
+    DEBUG(" CEA resolutions: ");
+    for (i = wds::CEA640x480p60; i <= wds::CEA1920x1080p24; ++i)
+        if (codec.cea_rr.test(i))
+            DEBUG("  %s", CEARatesAndResolutionsToString((wds::CEARatesAndResolutions) i).c_str());
+
+    DEBUG(" VESA resolutions: ");
+    for (i = wds::VESA800x600p30; i <= wds::VESA1920x1200p30; ++i)
+        if (codec.vesa_rr.test(i))
+            DEBUG("  %s", VESARatesAndResolutionsToString((wds::VESARatesAndResolutions) i).c_str());
+
+    DEBUG(" HH resolutions: ");
+    for (i = wds::HH800x480p30; i <= wds::HH848x480p60; ++i)
+        if (codec.hh_rr.test(i))
+            DEBUG("  %s", HHRatesAndResolutionsToString((wds::HHRatesAndResolutions) i).c_str());
+}
+
+void DumpVideoFormat(const wds::H264VideoFormat &format) {
+    DEBUG(" profile: %s", ProfileToString(format.profile));
+    DEBUG(" level: %s", LevelToString(format.level));
+    DEBUG(" resolution type: %s", ResolutionTypeToString(format.type));
+
+    if (format.type == wds::CEA)
+        DEBUG("resolution: %s", CEARatesAndResolutionsToString((wds::CEARatesAndResolutions) format.rate_resolution));
+    if (format.type == wds::VESA)
+        DEBUG("resolution: %s", VESARatesAndResolutionsToString((wds::VESARatesAndResolutions) format.rate_resolution));
+    if (format.type == wds::HH)
+        DEBUG("resolution: %s", HHRatesAndResolutionsToString((wds::HHRatesAndResolutions) format.rate_resolution));
+}
+
+void DumpNativeFormat(const wds::NativeVideoFormat &format) {
+    DEBUG(" resolution type: %s", ResolutionTypeToString(format.type));
+
+    if (format.type == wds::CEA)
+        DEBUG("resolution: %s", CEARatesAndResolutionsToString((wds::CEARatesAndResolutions) format.rate_resolution));
+    if (format.type == wds::VESA)
+        DEBUG("resolution: %s", VESARatesAndResolutionsToString((wds::VESARatesAndResolutions) format.rate_resolution));
+    if (format.type == wds::HH)
+        DEBUG("resolution: %s", HHRatesAndResolutionsToString((wds::HHRatesAndResolutions) format.rate_resolution));
+}
+
+std::string ExtractH264Profile(const wds::H264VideoFormat &format) {
+    std::string profile;
+    switch (format.profile) {
+    case wds::CBP:
+        profile = "constrained-baseline";
+        break;
+    case wds::CHP:
+        profile = "high";
+        break;
+    default:
+        break;
+    }
+    return profile;
+}
+
+std::string ExtractH264Level(const wds::H264VideoFormat &format) {
+    std::string level;
+    switch (format.level) {
+    case wds::k3_1:
+        level = "3.1";
+        break;
+    case wds::k3_2:
+        level = "3.2";
+        break;
+    case wds::k4:
+        level = "4";
+        break;
+    case wds::k4_1:
+        level = "4.1";
+        break;
+    case wds::k4_2:
+        level = "4.2";
+        break;
+    default:
+        break;
+    }
+    return level;
+}
+
+RateAndResolution ExtractRateAndResolution(const wds::H264VideoFormat &format) {
+    RateAndResolution rr;
+    switch (format.type) {
+    case wds::CEA:
+        switch (format.rate_resolution) {
+        case wds::CEA640x480p60:
+            rr.width = 640;
+            rr.height = 480;
+            rr.framerate = 60;
+            break;
+        case wds::CEA720x480p60:
+        case wds::CEA720x480i60:
+            rr.width = 720;
+            rr.height = 480;
+            rr.framerate = 60;
+            break;
+        case wds::CEA720x576p50:
+        case wds::CEA720x576i50:
+            rr.width = 720;
+            rr.height = 576;
+            rr.framerate = 50;
+            break;
+        case wds::CEA1280x720p30:
+            rr.width = 1280;
+            rr.height = 720;
+            rr.framerate = 30;
+            break;
+        case wds::CEA1280x720p60:
+            rr.width = 1280;
+            rr.height = 720;
+            rr.framerate = 60;
+            break;
+        case wds::CEA1920x1080p30:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 30;
+            break;
+        case wds::CEA1920x1080p60:
+        case wds::CEA1920x1080i60:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 60;
+            break;
+        case wds::CEA1280x720p25:
+            rr.width = 1280;
+            rr.height = 720;
+            rr.framerate = 25;
+            break;
+        case wds::CEA1280x720p50:
+            rr.width = 1280;
+            rr.height = 720;
+            rr.framerate = 50;
+            break;
+        case wds::CEA1280x720p24:
+            rr.width = 1280;
+            rr.height = 720;
+            rr.framerate = 24;
+            break;
+        case wds::CEA1920x1080p25:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 25;
+            break;
+        case wds::CEA1920x1080p50:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 50;
+            break;
+        case wds::CEA1920x1080i50:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 50;
+            break;
+        case wds::CEA1920x1080p24:
+            rr.width = 1920;
+            rr.height = 1080;
+            rr.framerate = 24;
+            break;
+        default:
+            break;
+        }
+        break;
+    // FIXME Add support for VESA and HH
+    default:
+        break;
+    }
+    return rr;
+}
+
+} // namespace video
+} // namespace mcs

=== added file 'src/mcs/videoformat.h'
--- src/mcs/videoformat.h	1970-01-01 00:00:00 +0000
+++ src/mcs/videoformat.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MCS_VIDEOFORMAT_H_
+#define MCS_VIDEOFORMAT_H_
+
+#include <wds/video_format.h>
+
+namespace mcs {
+namespace video {
+
+void DumpVideoCodec(const wds::H264VideoCodec &codec);
+void DumpVideoFormat(const wds::H264VideoFormat &format);
+void DumpNativeFormat(const wds::NativeVideoFormat &format);
+
+struct RateAndResolution {
+    unsigned int width;
+    unsigned int height;
+    unsigned int framerate;
+};
+
+RateAndResolution ExtractRateAndResolution(const wds::H264VideoFormat &format);
+std::string ExtractH264Profile(const wds::H264VideoFormat &format);
+std::string ExtractH264Level(const wds::H264VideoFormat &format);
+
+} // namespace video
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/x11sourcemediamanager.cpp'
--- src/mcs/x11sourcemediamanager.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/x11sourcemediamanager.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <gst/gst.h>
+
+#include "logger.h"
+#include "x11sourcemediamanager.h"
+#include "utils.h"
+#include "logging.h"
+
+namespace mcs {
+std::shared_ptr<X11SourceMediaManager> X11SourceMediaManager::create(const std::string &remote_address) {
+    return std::shared_ptr<X11SourceMediaManager>{new X11SourceMediaManager{remote_address}};
+}
+
+X11SourceMediaManager::X11SourceMediaManager(const std::string &remote_address) :
+    remote_address_(remote_address) {
+}
+
+X11SourceMediaManager::~X11SourceMediaManager() {
+}
+
+SharedGObject<GstElement> X11SourceMediaManager::ConstructPipeline(const wds::H264VideoFormat &format) {
+    auto config = Utils::Sprintf("ximagesrc ! videoconvert ! video/x-raw,format=I420 ! x264enc ! mpegtsmux ! rtpmp2tpay ! udpsink name=sink host=%s port=%d",
+                                     remote_address_.c_str(), sink_port1_);
+
+    GError *error = nullptr;
+    GstElement *pipeline = gst_parse_launch(config.c_str(), &error);
+    if (error) {
+        WARNING("Failed to setup GStreamer pipeline: %s", error->message);
+        g_error_free(error);
+        return nullptr;
+    }
+
+    return make_shared_gobject(pipeline);
+}
+} // namespace mcs

=== added file 'src/mcs/x11sourcemediamanager.h'
--- src/mcs/x11sourcemediamanager.h	1970-01-01 00:00:00 +0000
+++ src/mcs/x11sourcemediamanager.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef X11SOURCEMEDIAMANAGER_H_
+#define X11SOURCEMEDIAMANAGER_H_
+
+#include "gstsourcemediamanager.h"
+
+namespace mcs {
+class X11SourceMediaManager : public GstSourceMediaManager {
+public:
+    static std::shared_ptr<X11SourceMediaManager> create(const std::string &remote_address);
+    ~X11SourceMediaManager();
+
+protected:
+    SharedGObject<GstElement> ConstructPipeline(const wds::H264VideoFormat &format) override;
+
+private:
+    explicit X11SourceMediaManager(const std::string &remote_address);
+    std::string remote_address_;
+};
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/x264.cpp'
--- src/mcs/x264.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/x264.cpp	2016-01-27 13:00:21 +0000
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <atomic>
+
+#include "logger.h"
+#include "x264.h"
+
+namespace {
+
+static std::function<mcs::x264::Encoder::Ptr()>& MutableEncoderFactory() {
+    static std::function<mcs::x264::Encoder::Ptr()> factory = []() { return mcs::x264::Encoder::Ptr{}; };
+    return factory;
+}
+
+static const std::function<mcs::x264::Encoder::Ptr()>& EncoderFactory() {
+    return MutableEncoderFactory();
+}
+
+struct McsH264EncoderClass {
+    static GstStaticPadTemplate* SinkFactory() {
+        static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE (
+                    "sink",
+                    GST_PAD_SINK,
+                    GST_PAD_ALWAYS,
+                    GST_STATIC_CAPS ("ANY"));
+        return &sink_factory;
+    }
+
+    static GstStaticPadTemplate* SrcFactory() {
+        static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE (
+                    "src",
+                    GST_PAD_SRC,
+                    GST_PAD_ALWAYS,
+                    GST_STATIC_CAPS ("ANY"));
+
+        return &src_factory;
+    }
+
+    static void Init(McsH264EncoderClass *klass);
+
+    GstElementClass parent_class;
+};
+
+struct McsH264Encoder {
+    // Data ensures that we can 'new' the object, actually calling
+    // the ctors of contained objects (mcs::SharedGObject<T>).
+    struct Data {
+        mcs::SharedGObject<GstPad> sink;
+        mcs::SharedGObject<GstPad> source;
+        mcs::x264::GstEncoder::Ptr impl;
+    };
+
+    static GType Type();
+
+    static McsH264Encoder* CastInstanceFrom(GObject *obj) {
+        return G_TYPE_CHECK_INSTANCE_CAST(obj,McsH264Encoder::Type(),McsH264Encoder);
+    }
+
+    static McsH264EncoderClass* CastClassFrom(GObjectClass *klass) {
+        return G_TYPE_CHECK_CLASS_CAST((klass),McsH264Encoder::Type(),McsH264EncoderClass);
+    }
+
+    static bool IsInstanceOf(GObject *obj) {
+        return G_TYPE_CHECK_INSTANCE_TYPE((obj),McsH264Encoder::Type());
+    }
+
+    static bool IsClassOf(GObjectClass *klass) {
+        return G_TYPE_CHECK_CLASS_TYPE((klass),McsH264Encoder::Type());
+    }
+
+    static void Init(McsH264Encoder *self) {
+        MCS_TRACE("self %p", self);
+        self->d = new McsH264Encoder::Data{
+                mcs::make_shared_gobject(gst_pad_new_from_static_template (McsH264EncoderClass::SinkFactory(), "sink")),
+                mcs::make_shared_gobject(gst_pad_new_from_static_template (McsH264EncoderClass::SrcFactory(), "src")),
+                std::make_shared<mcs::x264::GstEncoder>(EncoderFactory()())
+        };
+
+        //gst_pad_set_event_function (filter->sinkpad, GST_DEBUG_FUNCPTR(gst_plugin_template_sink_event));
+        gst_pad_set_chain_function (self->d->sink.get(), McsH264Encoder::Chain);
+
+        gst_element_add_pad (GST_ELEMENT (self), self->d->sink.get());
+        gst_element_add_pad (GST_ELEMENT (self), self->d->source.get());
+    }
+
+    static void Finalize(GObject *obj) {
+        MCS_TRACE("obj %p", obj);
+        if (auto thiz = CastInstanceFrom(obj)) {
+            delete thiz->d;
+        }
+    }
+
+    static GstFlowReturn Chain(GstPad *pad, GstObject *parent, GstBuffer *buffer) {
+        MCS_TRACE("Chain(%p, %p, %p)", pad, parent, buffer);
+
+        struct Scope {
+            ~Scope() { if (buffer) gst_buffer_unref(buffer); }
+            GstBuffer *buffer;
+        } scope {buffer};
+
+        auto result = GST_FLOW_ERROR;
+
+        if (auto thiz = CastInstanceFrom(G_OBJECT(parent))) {
+            // TODO(tvoss): We should catch exceptions here, return
+            // appropriate error codes and signal errors to the gst bus.
+            result = gst_pad_push(thiz->d->source.get(), thiz->d->impl->Encode(buffer));
+        }
+
+        return result;
+    }
+
+    GstElement element;
+    Data *d;
+};
+
+#define GST_TYPE_MCS_H264_ENCODER() (gst_mcs_h264_encoder_get_type())
+#define GST_MCS_H264_ENCODER(obj) McsH264Encoder::CastInstanceFrom(obj)
+#define GST_MCS_H264_ENCODER_CLASS(klass) McsH264Encoder::CastClassFrom(klass)
+#define GST_IS_MCS_H264_ENCODER(obj) McsH264Encoder::IsInstanceOf(obj)
+#define GST_IS_MCS_H264_ENCODER_CLASS(klass) McsH264Encoder::IsClassOf(klass)
+
+GType mcs_h264_encoder_get_type (void);
+
+G_DEFINE_TYPE(McsH264Encoder, mcs_h264_encoder, GST_TYPE_ELEMENT)
+
+void McsH264EncoderClass::Init(McsH264EncoderClass *klass) {
+    MCS_TRACE("klass %p", klass);
+
+    auto gobject_class = reinterpret_cast<GObjectClass*>(klass);
+    auto gst_element_class = reinterpret_cast<GstElementClass*>(klass);
+
+    gobject_class->finalize = McsH264Encoder::Finalize;
+
+    gst_element_class_set_details_simple(gst_element_class, "ah264", "FIXME(classification)", "FIXME(description)", "Thomas Voß ([e-mail])");
+    gst_element_class_add_pad_template(gst_element_class, gst_static_pad_template_get(McsH264EncoderClass::SinkFactory()));
+    gst_element_class_add_pad_template(gst_element_class, gst_static_pad_template_get(McsH264EncoderClass::SrcFactory()));
+}
+
+void mcs_h264_encoder_class_init(McsH264EncoderClass *klass) {
+    McsH264EncoderClass::Init(klass);
+}
+
+void mcs_h264_encoder_init(McsH264Encoder *self) {
+    McsH264Encoder::Init(self);
+}
+
+GType McsH264Encoder::Type() {
+    return mcs_h264_encoder_get_type();
+}
+
+gboolean InitPlugin(GstPlugin* plugin) {
+    return gst_element_register(plugin, "ah264", 0, McsH264Encoder::Type());
+}
+}
+
+namespace mcs {
+namespace x264 {
+
+bool GstEncoder::Plugin::RegisterWithEncoderFactory(const std::function<Encoder::Ptr()>& factory) {
+    static bool registered(false);
+    static std::atomic<bool> once(false);
+
+    if (once.exchange(true)) {
+        return registered;
+    }
+
+    MutableEncoderFactory() = factory;
+
+    const auto result = gst_plugin_register_static(
+                GST_VERSION_MAJOR,
+                GST_VERSION_MINOR,
+                mcs::x264::GstEncoder::Plugin::name,
+                mcs::x264::GstEncoder::Plugin::description,
+                InitPlugin,
+                mcs::x264::GstEncoder::Plugin::version,
+                mcs::x264::GstEncoder::Plugin::license,
+                mcs::x264::GstEncoder::Plugin::source,
+                mcs::x264::GstEncoder::Plugin::package,
+                mcs::x264::GstEncoder::Plugin::origin);
+
+    return registered = result == TRUE;
+}
+
+GstEncoder::GstEncoder(const Encoder::Ptr &encoder) : encoder_(encoder) {
+}
+
+GstBuffer* mcs::x264::GstEncoder::Encode(GstBuffer *buffer) {
+    return encoder_->Encode(buffer);
+}
+}
+}

=== added file 'src/mcs/x264.h'
--- src/mcs/x264.h	1970-01-01 00:00:00 +0000
+++ src/mcs/x264.h	2016-01-27 13:00:21 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GSTH264HWENCODER_H_
+#define GSTH264HWENCODER_H_
+
+#include <cstdint>
+#include <memory>
+
+#include <gst/gst.h>
+
+#include "non_copyable.h"
+#include "shared_gobject.h"
+
+namespace mcs {
+namespace x264 {
+// An Encoder abstracts encoding of MirNativeBuffer
+class Encoder : public mcs::NonCopyable {
+public:
+    typedef std::shared_ptr<Encoder> Ptr;
+
+    // Encode takes the nativeBuffer and encodes it, returning
+    // a Frame instance describing the raw memory segment containing
+    // the encoded frame.
+    virtual GstBuffer*Encode(GstBuffer *) = 0;
+
+protected:
+    Encoder() = default;
+};
+
+// A GstEncoder exposes an h264::Encoder to the gstreamer world,
+// implemenating an element, that encodes incoming GstBuffer instances.
+class GstEncoder {
+public:
+    typedef std::shared_ptr<GstEncoder> Ptr;
+
+    struct Plugin {
+        static bool RegisterWithEncoderFactory(const std::function<Encoder::Ptr()> &factory);
+
+        static constexpr const char *name = "mcs::h264::Encoder";
+        static constexpr const char *description = "h264 encoder leveraging hw-accelerated codecs provided by Android";
+        static constexpr const char *version = "0.0";
+        static constexpr const char *license = "LGPL";
+        static constexpr const char *source = "aethercast";
+        static constexpr const char *package = "aethercast";
+        static constexpr const char *origin = "https://launchpad.net/aethercast";    
+    };
+
+    // GstEncoder creates a new instance, leveraging encoder for carrying out the actual
+    // encoding.
+    GstEncoder(const Encoder::Ptr &encoder);
+
+    // SinkPad returns the GstPad describing the sink pad of the element.
+    SharedGObject<GstPad*> SinkPad() const;
+    // SourcePad returns the GstPad describing the source pad of the element.
+    SharedGObject<GstPad*> SourcePad() const;
+
+    // Encode extracts a MirNativeBuffer from the given GstBuffer and hands it on
+    // to the actual Encoder instance.
+    GstBuffer* Encode(GstBuffer *buffer);
+
+private:
+    Encoder::Ptr encoder_;
+};
+}
+}
+
+#endif

=== removed directory 'src/w11t'
=== removed file 'src/w11t/commandqueue.cpp'
--- src/w11t/commandqueue.cpp	2015-12-18 17:15:31 +0000
+++ src/w11t/commandqueue.cpp	1970-01-01 00:00:00 +0000
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <glib.h>
-
-#include "commandqueue.h"
-
-namespace w11t {
-CommandQueue::CommandQueue(Delegate *delegate) :
-    delegate_(delegate),
-    current_(nullptr),
-    idle_source_(0) {
-}
-
-CommandQueue::~CommandQueue() {
-    if (idle_source_ > 0)
-        g_source_remove(idle_source_);
-}
-
-void CommandQueue::EnqueueCommand(const Message &message, Command::ResponseCallback callback) {
-    queue_.push(new Command(message, callback));
-    RestartQueue();
-}
-
-void CommandQueue::HandleMessage(Message message) {
-    if (message.ItsType() == Message::Type::kInvalid)
-        return;
-
-    if (message.ItsType() == Message::Type::kEvent) {
-        if (delegate_)
-            delegate_->OnUnsolicitedResponse(message);
-        return;
-    }
-
-    if (!current_)
-        return;
-
-    if (current_->callback)
-        current_->callback(message);
-
-    delete current_;
-    // This will unblock the queue and will allow us to send the next command
-    current_ = nullptr;
-
-    RestartQueue();
-}
-
-gboolean CommandQueue::OnRestartQueue(gpointer user_data) {
-    auto inst = static_cast<CommandQueue*>(user_data);
-    inst->idle_source_ = 0;
-    inst->CheckRestartingQueue();
-    return FALSE;
-}
-
-void CommandQueue::RestartQueue() {
-    if (idle_source_ > 0)
-        return;
-
-    idle_source_ = g_idle_add(&CommandQueue::OnRestartQueue, this);
-}
-
-void CommandQueue::CheckRestartingQueue() {
-    if (current_ != nullptr || queue_.size() == 0)
-        return;
-
-    WriteNextCommand();
-    RestartQueue();
-}
-
-void CommandQueue::WriteNextCommand() {
-    current_ = queue_.front();
-    queue_.pop();
-
-    if (!delegate_)
-        return;
-
-    if (!current_)
-        return;
-
-    current_->message.Seal();
-
-    delegate_->OnWriteMessage(current_->message);
-
-    if (!current_->callback) {
-        delete current_;
-        current_ = nullptr;
-    }
-}
-}

=== removed file 'src/w11t/commandqueue.h'
--- src/w11t/commandqueue.h	2015-12-18 17:15:31 +0000
+++ src/w11t/commandqueue.h	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef WPASUPPLICANTCOMMANDQUEUE_H_
-#define WPASUPPLICANTCOMMANDQUEUE_H_
-
-#include <boost/noncopyable.hpp>
-
-#include <string>
-#include <queue>
-
-#include <mcs/non_copyable.h>
-
-#include "command.h"
-
-namespace w11t {
-class CommandQueue {
-public:
-    class Delegate : private mcs::NonCopyable {
-    public:
-        virtual void OnUnsolicitedResponse(Message message) = 0;
-        virtual void OnWriteMessage(Message message) = 0;
-
-    protected:
-        Delegate() = default;
-    };
-
-    CommandQueue(Delegate *delegate);
-    ~CommandQueue();
-
-    void EnqueueCommand(const Message &message, Command::ResponseCallback callback = nullptr);
-    void HandleMessage(Message message);
-
-private:
-    void RestartQueue();
-    void CheckRestartingQueue();
-    void WriteNextCommand();
-
-private:
-    static gboolean OnRestartQueue(gpointer user_data);
-
-private:
-    Delegate *delegate_;
-    Command *current_;
-    std::queue<Command*> queue_;
-    unsigned int idle_source_;
-};
-}
-#endif

=== removed file 'src/w11t/dhcpclient.cpp'
--- src/w11t/dhcpclient.cpp	2015-12-18 17:15:31 +0000
+++ src/w11t/dhcpclient.cpp	1970-01-01 00:00:00 +0000
@@ -1,102 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <asm/types.h>
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-#include <sys/socket.h>
-
-#include <mcs/logger.h>
-#include <mcs/networkutils.h>
-
-#include "dhcpclient.h"
-#include "gdhcp.h"
-
-namespace w11t {
-DhcpClient::DhcpClient(Delegate *delegate, const std::string &interface_name) :
-    delegate_(delegate),
-    interface_name_(interface_name) {
-    interface_index_ = mcs::NetworkUtils::RetrieveInterfaceIndex(interface_name_.c_str());
-    if (interface_index_ < 0)
-        MCS_WARNING("Failed to determine index of network interface %s", interface_name_.c_str());
-}
-
-DhcpClient::~DhcpClient() {
-}
-
-void DhcpClient::OnLeaseAvailable(GDHCPClient *client, gpointer user_data) {
-    auto inst = static_cast<DhcpClient*>(user_data);
-
-    char *address = g_dhcp_client_get_address(inst->client_);
-    char *netmask = g_dhcp_client_get_netmask(inst->client_);
-
-    if (!address) {
-        MCS_WARNING("Received invalid IP configuration over DHCP");
-        return;
-    }
-
-    if (mcs::NetworkUtils::ModifyInterfaceAddress(RTM_NEWADDR, NLM_F_REPLACE | NLM_F_ACK, inst->interface_index_,
-                                    AF_INET, address,
-                                    NULL, 24, NULL) < 0) {
-        MCS_WARNING("Failed to assign network address for %s", inst->interface_name_.c_str());
-        return;
-    }
-
-    inst->local_address_ = mcs::IpV4Address::from_string(address);
-
-    if (netmask)
-        inst->netmask_.assign(netmask);
-
-    inst->delegate_->OnAddressAssigned(inst->local_address_);
-}
-
-void DhcpClient::OnClientDebug(const char *str, gpointer user_data) {
-    MCS_DEBUG("DHCP: %s", str);
-}
-
-mcs::IpV4Address DhcpClient::LocalAddress() const {
-    return local_address_;
-}
-
-bool DhcpClient::Start() {
-    GDHCPClientError error;
-    client_ = g_dhcp_client_new(G_DHCP_IPV4, interface_index_, &error);
-    if (!client_) {
-        MCS_ERROR("Failed to setup DHCP client: %s", g_dhcp_client_error_to_string(error));
-        return false;
-    }
-
-    g_dhcp_client_set_debug(client_, &DhcpClient::OnClientDebug, this);
-    g_dhcp_client_register_event(client_, G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE, &DhcpClient::OnLeaseAvailable, this);
-    g_dhcp_client_start(client_, NULL);
-
-    return true;
-}
-
-void DhcpClient::Stop() {
-    if (!client_)
-        return;
-
-    g_dhcp_client_stop(client_);
-    g_dhcp_client_unref(client_);
-
-    local_address_ = mcs::IpV4Address{};
-    netmask_ = "";
-
-    mcs::NetworkUtils::ResetInterface(interface_index_);
-}
-}

=== removed file 'src/w11t/dhcpserver.cpp'
--- src/w11t/dhcpserver.cpp	2015-12-18 17:15:31 +0000
+++ src/w11t/dhcpserver.cpp	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <asm/types.h>
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-#include <sys/socket.h>
-
-#include <mcs/logger.h>
-#include <mcs/networkutils.h>
-
-#include "dhcpserver.h"
-
-namespace w11t {
-DhcpServer::DhcpServer(Delegate *delegate, const std::string &interface_name) :
-    interface_name_(interface_name) {
-    interface_index_ = mcs::NetworkUtils::RetrieveInterfaceIndex(interface_name_.c_str());
-    if (interface_index_ < 0)
-        MCS_ERROR("Failed to determine index of network interface: %s", interface_name_);
-}
-
-DhcpServer::~DhcpServer() {
-    if (server_)
-        g_dhcp_server_unref(server_);
-}
-
-mcs::IpV4Address DhcpServer::LocalAddress() const {
-    // FIXME this should be stored somewhere else
-    return mcs::IpV4Address::from_string("192.168.7.1");
-}
-
-void DhcpServer::OnDebug(const char *str, gpointer user_data) {
-    MCS_DEBUG("DHCP: %s", str);
-}
-
-bool DhcpServer::Start() {
-    MCS_DEBUG("Starting up DHCP server");
-
-    // FIXME store those defaults somewhere else
-    const char *address = "192.168.7.1";
-    const char *subnet = "255.255.255.0";
-    const char *broadcast = "192.168.7.255";
-    unsigned char prefixlen = 24;
-
-    if (mcs::NetworkUtils::ModifyInterfaceAddress(RTM_NEWADDR, NLM_F_REPLACE | NLM_F_ACK, interface_index_,
-                                    AF_INET, address,
-                                    NULL, prefixlen, broadcast) < 0) {
-        MCS_ERROR("Failed to assign network address for %s", interface_name_);
-        return false;
-    }
-
-    GDHCPServerError error;
-    server_ = g_dhcp_server_new(G_DHCP_IPV4, interface_index_, &error);
-    if (!server_) {
-        MCS_ERROR("Failed to setup DHCP server: %s", g_dhcp_server_error_to_string(error));
-        return false;
-    }
-
-    g_dhcp_server_set_lease_time(server_, 3600);
-    g_dhcp_server_set_option(server_, G_DHCP_SUBNET, subnet);
-    g_dhcp_server_set_option(server_, G_DHCP_ROUTER, LocalAddress().to_string().c_str());
-    g_dhcp_server_set_option(server_, G_DHCP_DNS_SERVER, NULL);
-    g_dhcp_server_set_ip_range(server_, "192.168.7.5", "192.168.7.100");
-
-    g_dhcp_server_set_debug(server_, &DhcpServer::OnDebug, this);
-
-    if(g_dhcp_server_start(server_) < 0) {
-        MCS_ERROR("Failed to start DHCP server");
-        g_dhcp_server_unref(server_);
-        return false;
-    }
-
-    return true;
-}
-
-void DhcpServer::Stop() {
-    if (!server_)
-        return;
-
-    g_dhcp_server_stop(server_);
-    g_dhcp_server_unref(server_);
-
-    mcs::NetworkUtils::ResetInterface(interface_index_);
-}
-}

=== removed directory 'src/w11t/gdhcp'
=== removed file 'src/w11t/gdhcp/client.c'
--- src/w11t/gdhcp/client.c	2015-12-09 16:07:13 +0000
+++ src/w11t/gdhcp/client.c	1970-01-01 00:00:00 +0000
@@ -1,3282 +0,0 @@
-/*
- *
- *  DHCP client library with GLib integration
- *
- *  Copyright (C) 2009-2014  Intel Corporation. All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#include <resolv.h>
-
-#include <netpacket/packet.h>
-#include <netinet/if_ether.h>
-#include <net/ethernet.h>
-
-#include <linux/if.h>
-#include <linux/filter.h>
-
-#include <glib.h>
-
-#include "gdhcp.h"
-#include "common.h"
-#include "ipv4ll.h"
-
-#define DISCOVER_TIMEOUT 5
-#define DISCOVER_RETRIES 6
-
-#define REQUEST_TIMEOUT 5
-#define REQUEST_RETRIES 3
-
-typedef enum _listen_mode {
-	L_NONE,
-	L2,
-	L3,
-	L_ARP,
-} ListenMode;
-
-typedef enum _dhcp_client_state {
-	INIT_SELECTING,
-	REBOOTING,
-	REQUESTING,
-	BOUND,
-	RENEWING,
-	REBINDING,
-	RELEASED,
-	IPV4LL_PROBE,
-	IPV4LL_ANNOUNCE,
-	IPV4LL_MONITOR,
-	IPV4LL_DEFEND,
-	INFORMATION_REQ,
-	SOLICITATION,
-	REQUEST,
-	CONFIRM,
-	RENEW,
-	REBIND,
-	RELEASE,
-	DECLINE,
-} ClientState;
-
-struct _GDHCPClient {
-	int ref_count;
-	GDHCPType type;
-	ClientState state;
-	int ifindex;
-	char *interface;
-	uint8_t mac_address[6];
-	uint32_t xid;
-	uint32_t server_ip;
-	uint32_t requested_ip;
-	char *assigned_ip;
-	time_t start;
-	uint32_t lease_seconds;
-	ListenMode listen_mode;
-	int listener_sockfd;
-	uint8_t retry_times;
-	uint8_t ack_retry_times;
-	uint8_t conflicts;
-	guint timeout;
-	guint t1_timeout;
-	guint t2_timeout;
-	guint lease_timeout;
-	guint listener_watch;
-	GList *require_list;
-	GList *request_list;
-	GHashTable *code_value_hash;
-	GHashTable *send_value_hash;
-	GDHCPClientEventFunc lease_available_cb;
-	gpointer lease_available_data;
-	GDHCPClientEventFunc ipv4ll_available_cb;
-	gpointer ipv4ll_available_data;
-	GDHCPClientEventFunc no_lease_cb;
-	gpointer no_lease_data;
-	GDHCPClientEventFunc lease_lost_cb;
-	gpointer lease_lost_data;
-	GDHCPClientEventFunc ipv4ll_lost_cb;
-	gpointer ipv4ll_lost_data;
-	GDHCPClientEventFunc address_conflict_cb;
-	gpointer address_conflict_data;
-	GDHCPDebugFunc debug_func;
-	gpointer debug_data;
-	GDHCPClientEventFunc information_req_cb;
-	gpointer information_req_data;
-	GDHCPClientEventFunc solicitation_cb;
-	gpointer solicitation_data;
-	GDHCPClientEventFunc advertise_cb;
-	gpointer advertise_data;
-	GDHCPClientEventFunc request_cb;
-	gpointer request_data;
-	GDHCPClientEventFunc renew_cb;
-	gpointer renew_data;
-	GDHCPClientEventFunc rebind_cb;
-	gpointer rebind_data;
-	GDHCPClientEventFunc release_cb;
-	gpointer release_data;
-	GDHCPClientEventFunc confirm_cb;
-	gpointer confirm_data;
-	GDHCPClientEventFunc decline_cb;
-	gpointer decline_data;
-	char *last_address;
-	unsigned char *duid;
-	int duid_len;
-	unsigned char *server_duid;
-	int server_duid_len;
-	uint16_t status_code;
-	uint32_t iaid;
-	uint32_t T1, T2;
-	struct in6_addr ia_na;
-	struct in6_addr ia_ta;
-	time_t last_request;
-	uint32_t expire;
-	bool retransmit;
-	struct timeval start_time;
-	bool request_bcast;
-};
-
-const char *g_dhcp_client_error_to_string(GDHCPClientError error) {
-    switch (error) {
-    case G_DHCP_CLIENT_ERROR_NONE:
-        return "None";
-    case G_DHCP_CLIENT_ERROR_INTERFACE_UNAVAILABLE:
-        return "Interface unavailable";
-    case G_DHCP_CLIENT_ERROR_INTERFACE_IN_USE:
-        return "Interface in use";
-    case G_DHCP_CLIENT_ERROR_INTERFACE_DOWN:
-        return "Interface down";
-    case G_DHCP_CLIENT_ERROR_NOMEM:
-        return "No memory";
-    case G_DHCP_CLIENT_ERROR_INVALID_INDEX:
-        return "Invalid index";
-    case G_DHCP_CLIENT_ERROR_INVALID_OPTION:
-        return "Invalid option";
-    default:
-        break;
-    }
-
-    return "";
-}
-
-static inline void debug(GDHCPClient *client, const char *format, ...)
-{
-	char str[256];
-	va_list ap;
-
-	if (!client->debug_func)
-		return;
-
-	va_start(ap, format);
-
-	if (vsnprintf(str, sizeof(str), format, ap) > 0)
-		client->debug_func(str, client->debug_data);
-
-	va_end(ap);
-}
-
-/* Initialize the packet with the proper defaults */
-static void init_packet(GDHCPClient *dhcp_client, gpointer pkt, char type)
-{
-	if (dhcp_client->type == G_DHCP_IPV6)
-		dhcpv6_init_header(pkt, type);
-	else {
-		struct dhcp_packet *packet = pkt;
-
-		dhcp_init_header(packet, type);
-		memcpy(packet->chaddr, dhcp_client->mac_address, 6);
-	}
-}
-
-static void add_request_options(GDHCPClient *dhcp_client,
-				struct dhcp_packet *packet)
-{
-	int len = 0;
-	GList *list;
-	uint8_t code;
-	int end = dhcp_end_option(packet->options);
-
-	for (list = dhcp_client->request_list; list; list = list->next) {
-		code = (uint8_t) GPOINTER_TO_INT(list->data);
-
-		packet->options[end + OPT_DATA + len] = code;
-		len++;
-	}
-
-	if (len) {
-		packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
-		packet->options[end + OPT_LEN] = len;
-		packet->options[end + OPT_DATA + len] = DHCP_END;
-	}
-}
-
-struct hash_params {
-	unsigned char *buf;
-	int max_buf;
-	unsigned char **ptr_buf;
-};
-
-static void add_dhcpv6_binary_option(gpointer key, gpointer value,
-					gpointer user_data)
-{
-	uint8_t *option = value;
-	uint16_t len;
-	struct hash_params *params = user_data;
-
-	/* option[0][1] contains option code */
-	len = option[2] << 8 | option[3];
-
-	if ((*params->ptr_buf + len + 2 + 2) > (params->buf + params->max_buf))
-		return;
-
-	memcpy(*params->ptr_buf, option, len + 2 + 2);
-	(*params->ptr_buf) += len + 2 + 2;
-}
-
-static void add_dhcpv6_send_options(GDHCPClient *dhcp_client,
-				unsigned char *buf, int max_buf,
-				unsigned char **ptr_buf)
-{
-	struct hash_params params = {
-		.buf = buf,
-		.max_buf = max_buf,
-		.ptr_buf = ptr_buf
-	};
-
-	if (dhcp_client->type != G_DHCP_IPV6)
-		return;
-
-	g_hash_table_foreach(dhcp_client->send_value_hash,
-				add_dhcpv6_binary_option, &params);
-
-	*ptr_buf = *params.ptr_buf;
-}
-
-static void copy_option(uint8_t *buf, uint16_t code, uint16_t len,
-			uint8_t *msg)
-{
-	buf[0] = code >> 8;
-	buf[1] = code & 0xff;
-	buf[2] = len >> 8;
-	buf[3] = len & 0xff;
-	if (len > 0 && msg)
-		memcpy(&buf[4], msg, len);
-}
-
-static int32_t get_time_diff(struct timeval *tv)
-{
-	struct timeval now;
-	int32_t hsec;
-
-	gettimeofday(&now, NULL);
-
-	hsec = (now.tv_sec - tv->tv_sec) * 100;
-	hsec += (now.tv_usec - tv->tv_usec) / 10000;
-
-	return hsec;
-}
-
-static void remove_timeouts(GDHCPClient *dhcp_client)
-{
-
-	if (dhcp_client->timeout > 0)
-		g_source_remove(dhcp_client->timeout);
-	if (dhcp_client->t1_timeout > 0)
-		g_source_remove(dhcp_client->t1_timeout);
-	if (dhcp_client->t2_timeout > 0)
-		g_source_remove(dhcp_client->t2_timeout);
-	if (dhcp_client->lease_timeout > 0)
-		g_source_remove(dhcp_client->lease_timeout);
-
-	dhcp_client->timeout = 0;
-	dhcp_client->t1_timeout = 0;
-	dhcp_client->t2_timeout = 0;
-	dhcp_client->lease_timeout = 0;
-
-}
-
-static void add_dhcpv6_request_options(GDHCPClient *dhcp_client,
-				struct dhcpv6_packet *packet,
-				unsigned char *buf, int max_buf,
-				unsigned char **ptr_buf)
-{
-	GList *list;
-	uint16_t code, value;
-	bool added;
-	int32_t diff;
-	int len;
-
-	if (dhcp_client->type != G_DHCP_IPV6)
-		return;
-
-	for (list = dhcp_client->request_list; list; list = list->next) {
-		code = (uint16_t) GPOINTER_TO_INT(list->data);
-		added = false;
-
-		switch (code) {
-		case G_DHCPV6_CLIENTID:
-			if (!dhcp_client->duid)
-				return;
-
-			len = 2 + 2 + dhcp_client->duid_len;
-			if ((*ptr_buf + len) > (buf + max_buf)) {
-				debug(dhcp_client, "Too long dhcpv6 message "
-					"when writing client id option");
-				return;
-			}
-
-			copy_option(*ptr_buf, G_DHCPV6_CLIENTID,
-				dhcp_client->duid_len, dhcp_client->duid);
-			(*ptr_buf) += len;
-			added = true;
-			break;
-
-		case G_DHCPV6_SERVERID:
-			if (!dhcp_client->server_duid)
-				break;
-
-			len = 2 + 2 + dhcp_client->server_duid_len;
-			if ((*ptr_buf + len) > (buf + max_buf)) {
-				debug(dhcp_client, "Too long dhcpv6 message "
-					"when writing server id option");
-				return;
-			}
-
-			copy_option(*ptr_buf, G_DHCPV6_SERVERID,
-				dhcp_client->server_duid_len,
-				dhcp_client->server_duid);
-			(*ptr_buf) += len;
-			added = true;
-			break;
-
-		case G_DHCPV6_RAPID_COMMIT:
-			len = 2 + 2;
-			if ((*ptr_buf + len) > (buf + max_buf)) {
-				debug(dhcp_client, "Too long dhcpv6 message "
-					"when writing rapid commit option");
-				return;
-			}
-
-			copy_option(*ptr_buf, G_DHCPV6_RAPID_COMMIT, 0, 0);
-			(*ptr_buf) += len;
-			added = true;
-			break;
-
-		case G_DHCPV6_ORO:
-			break;
-
-		case G_DHCPV6_ELAPSED_TIME:
-			if (!dhcp_client->retransmit) {
-				/*
-				 * Initial message, elapsed time is 0.
-				 */
-				diff = 0;
-			} else {
-				diff = get_time_diff(&dhcp_client->start_time);
-				if (diff < 0 || diff > 0xffff)
-					diff = 0xffff;
-			}
-
-			len = 2 + 2 + 2;
-			if ((*ptr_buf + len) > (buf + max_buf)) {
-				debug(dhcp_client, "Too long dhcpv6 message "
-					"when writing elapsed time option");
-				return;
-			}
-
-			value = htons((uint16_t)diff);
-			copy_option(*ptr_buf, G_DHCPV6_ELAPSED_TIME,
-				2, (uint8_t *)&value);
-			(*ptr_buf) += len;
-			added = true;
-			break;
-
-		case G_DHCPV6_DNS_SERVERS:
-			break;
-
-		case G_DHCPV6_DOMAIN_LIST:
-			break;
-
-		case G_DHCPV6_SNTP_SERVERS:
-			break;
-
-		default:
-			break;
-		}
-
-		if (added)
-			debug(dhcp_client, "option %d len %d added", code, len);
-	}
-}
-
-static void add_binary_option(gpointer key, gpointer value, gpointer user_data)
-{
-	uint8_t *option = value;
-	struct dhcp_packet *packet = user_data;
-
-	dhcp_add_binary_option(packet, option);
-}
-
-static void add_send_options(GDHCPClient *dhcp_client,
-				struct dhcp_packet *packet)
-{
-	g_hash_table_foreach(dhcp_client->send_value_hash,
-				add_binary_option, packet);
-}
-
-/*
- * Return an RFC 951- and 2131-complaint BOOTP 'secs' value that
- * represents the number of seconds elapsed from the start of
- * attempting DHCP to satisfy some DHCP servers that allow for an
- * "authoritative" reply before responding.
- */
-static uint16_t dhcp_attempt_secs(GDHCPClient *dhcp_client)
-{
-	return htons(MIN(time(NULL) - dhcp_client->start, UINT16_MAX));
-}
-
-static int send_discover(GDHCPClient *dhcp_client, uint32_t requested)
-{
-	struct dhcp_packet packet;
-
-	debug(dhcp_client, "sending DHCP discover request");
-
-	init_packet(dhcp_client, &packet, DHCPDISCOVER);
-
-	packet.xid = dhcp_client->xid;
-	packet.secs = dhcp_attempt_secs(dhcp_client);
-
-	if (requested)
-		dhcp_add_option_uint32(&packet, DHCP_REQUESTED_IP, requested);
-
-	/* Explicitly saying that we want RFC-compliant packets helps
-	 * some buggy DHCP servers to NOT send bigger packets */
-	dhcp_add_option_uint16(&packet, DHCP_MAX_SIZE, 576);
-
-	add_request_options(dhcp_client, &packet);
-
-	add_send_options(dhcp_client, &packet);
-
-	/*
-	 * If we do not get a reply to DISCOVER packet, then we try with
-	 * broadcast flag set. So first packet is sent without broadcast flag,
-	 * first retry is with broadcast flag, second retry is without it etc.
-	 * Reason is various buggy routers/AP that either eat the other or vice
-	 * versa. In the receiving side we then find out what kind of packet
-	 * the server can send.
-	 */
-	return dhcp_send_raw_packet(&packet, INADDR_ANY, CLIENT_PORT,
-				INADDR_BROADCAST, SERVER_PORT,
-				MAC_BCAST_ADDR, dhcp_client->ifindex,
-				dhcp_client->retry_times % 2);
-}
-
-static int send_request(GDHCPClient *dhcp_client)
-{
-	struct dhcp_packet packet;
-
-	debug(dhcp_client, "sending DHCP request (state %d)",
-		dhcp_client->state);
-
-	init_packet(dhcp_client, &packet, DHCPREQUEST);
-
-	packet.xid = dhcp_client->xid;
-	packet.secs = dhcp_attempt_secs(dhcp_client);
-
-	if (dhcp_client->state == REQUESTING || dhcp_client->state == REBOOTING)
-		dhcp_add_option_uint32(&packet, DHCP_REQUESTED_IP,
-				dhcp_client->requested_ip);
-
-	if (dhcp_client->state == REQUESTING)
-		dhcp_add_option_uint32(&packet, DHCP_SERVER_ID,
-				dhcp_client->server_ip);
-
-	dhcp_add_option_uint16(&packet, DHCP_MAX_SIZE, 576);
-
-	add_request_options(dhcp_client, &packet);
-
-	add_send_options(dhcp_client, &packet);
-
-	if (dhcp_client->state == RENEWING || dhcp_client->state == REBINDING)
-		packet.ciaddr = htonl(dhcp_client->requested_ip);
-
-	if (dhcp_client->state == RENEWING)
-		return dhcp_send_kernel_packet(&packet,
-				dhcp_client->requested_ip, CLIENT_PORT,
-				dhcp_client->server_ip, SERVER_PORT);
-
-	return dhcp_send_raw_packet(&packet, INADDR_ANY, CLIENT_PORT,
-				INADDR_BROADCAST, SERVER_PORT,
-				MAC_BCAST_ADDR, dhcp_client->ifindex,
-				dhcp_client->request_bcast);
-}
-
-static int send_release(GDHCPClient *dhcp_client,
-			uint32_t server, uint32_t ciaddr)
-{
-	struct dhcp_packet packet;
-	uint64_t rand;
-
-	debug(dhcp_client, "sending DHCP release request");
-
-	init_packet(dhcp_client, &packet, DHCPRELEASE);
-	dhcp_get_random(&rand);
-	packet.xid = rand;
-	packet.ciaddr = htonl(ciaddr);
-
-	dhcp_add_option_uint32(&packet, DHCP_SERVER_ID, server);
-
-	return dhcp_send_kernel_packet(&packet, ciaddr, CLIENT_PORT,
-						server, SERVER_PORT);
-}
-
-static gboolean ipv4ll_probe_timeout(gpointer dhcp_data);
-static int switch_listening_mode(GDHCPClient *dhcp_client,
-					ListenMode listen_mode);
-
-static gboolean send_probe_packet(gpointer dhcp_data)
-{
-	GDHCPClient *dhcp_client;
-	guint timeout;
-
-	dhcp_client = dhcp_data;
-	/* if requested_ip is not valid, pick a new address*/
-	if (dhcp_client->requested_ip == 0) {
-		debug(dhcp_client, "pick a new random address");
-		dhcp_client->requested_ip = ipv4ll_random_ip();
-	}
-
-	debug(dhcp_client, "sending IPV4LL probe request");
-
-	if (dhcp_client->retry_times == 1) {
-		dhcp_client->state = IPV4LL_PROBE;
-		switch_listening_mode(dhcp_client, L_ARP);
-	}
-	ipv4ll_send_arp_packet(dhcp_client->mac_address, 0,
-			dhcp_client->requested_ip, dhcp_client->ifindex);
-
-	if (dhcp_client->retry_times < PROBE_NUM) {
-		/*add a random timeout in range of PROBE_MIN to PROBE_MAX*/
-		timeout = ipv4ll_random_delay_ms(PROBE_MAX-PROBE_MIN);
-		timeout += PROBE_MIN*1000;
-	} else
-		timeout = (ANNOUNCE_WAIT * 1000);
-
-	dhcp_client->timeout = g_timeout_add_full(G_PRIORITY_HIGH,
-						 timeout,
-						 ipv4ll_probe_timeout,
-						 dhcp_client,
-						 NULL);
-	return FALSE;
-}
-
-static gboolean ipv4ll_announce_timeout(gpointer dhcp_data);
-static gboolean ipv4ll_defend_timeout(gpointer dhcp_data);
-
-static gboolean send_announce_packet(gpointer dhcp_data)
-{
-	GDHCPClient *dhcp_client;
-
-	dhcp_client = dhcp_data;
-
-	debug(dhcp_client, "sending IPV4LL announce request");
-
-	ipv4ll_send_arp_packet(dhcp_client->mac_address,
-				dhcp_client->requested_ip,
-				dhcp_client->requested_ip,
-				dhcp_client->ifindex);
-
-	remove_timeouts(dhcp_client);
-
-	if (dhcp_client->state == IPV4LL_DEFEND) {
-		dhcp_client->timeout =
-			g_timeout_add_seconds_full(G_PRIORITY_HIGH,
-						DEFEND_INTERVAL,
-						ipv4ll_defend_timeout,
-						dhcp_client,
-						NULL);
-		return TRUE;
-	} else
-		dhcp_client->timeout =
-			g_timeout_add_seconds_full(G_PRIORITY_HIGH,
-						ANNOUNCE_INTERVAL,
-						ipv4ll_announce_timeout,
-						dhcp_client,
-						NULL);
-	return TRUE;
-}
-
-static void get_interface_mac_address(int index, uint8_t *mac_address)
-{
-	struct ifreq ifr;
-	int sk, err;
-
-	sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
-	if (sk < 0) {
-		perror("Open socket error");
-		return;
-	}
-
-	memset(&ifr, 0, sizeof(ifr));
-	ifr.ifr_ifindex = index;
-
-	err = ioctl(sk, SIOCGIFNAME, &ifr);
-	if (err < 0) {
-		perror("Get interface name error");
-		goto done;
-	}
-
-	err = ioctl(sk, SIOCGIFHWADDR, &ifr);
-	if (err < 0) {
-		perror("Get mac address error");
-		goto done;
-	}
-
-	memcpy(mac_address, ifr.ifr_hwaddr.sa_data, 6);
-
-done:
-	close(sk);
-}
-
-void g_dhcpv6_client_set_retransmit(GDHCPClient *dhcp_client)
-{
-	if (!dhcp_client)
-		return;
-
-	dhcp_client->retransmit = true;
-}
-
-void g_dhcpv6_client_clear_retransmit(GDHCPClient *dhcp_client)
-{
-	if (!dhcp_client)
-		return;
-
-	dhcp_client->retransmit = false;
-}
-
-int g_dhcpv6_create_duid(GDHCPDuidType duid_type, int index, int type,
-			unsigned char **duid, int *duid_len)
-{
-	time_t duid_time;
-
-	switch (duid_type) {
-	case G_DHCPV6_DUID_LLT:
-		*duid_len = 2 + 2 + 4 + ETH_ALEN;
-		*duid = g_try_malloc(*duid_len);
-		if (!*duid)
-			return -ENOMEM;
-
-		(*duid)[0] = 0;
-		(*duid)[1] = 1;
-		get_interface_mac_address(index, &(*duid)[2 + 2 + 4]);
-		(*duid)[2] = 0;
-		(*duid)[3] = type;
-		duid_time = time(NULL) - DUID_TIME_EPOCH;
-		(*duid)[4] = duid_time >> 24;
-		(*duid)[5] = duid_time >> 16;
-		(*duid)[6] = duid_time >> 8;
-		(*duid)[7] = duid_time & 0xff;
-		break;
-	case G_DHCPV6_DUID_EN:
-		return -EINVAL;
-	case G_DHCPV6_DUID_LL:
-		*duid_len = 2 + 2 + ETH_ALEN;
-		*duid = g_try_malloc(*duid_len);
-		if (!*duid)
-			return -ENOMEM;
-
-		(*duid)[0] = 0;
-		(*duid)[1] = 3;
-		get_interface_mac_address(index, &(*duid)[2 + 2]);
-		(*duid)[2] = 0;
-		(*duid)[3] = type;
-		break;
-	}
-
-	return 0;
-}
-
-static gchar *convert_to_hex(unsigned char *buf, int len)
-{
-	gchar *ret = g_try_malloc(len * 2 + 1);
-	int i;
-
-	for (i = 0; ret && i < len; i++)
-		g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
-
-	return ret;
-}
-
-int g_dhcpv6_client_set_duid(GDHCPClient *dhcp_client, unsigned char *duid,
-			int duid_len)
-{
-	if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
-		return -EINVAL;
-
-	g_free(dhcp_client->duid);
-
-	dhcp_client->duid = duid;
-	dhcp_client->duid_len = duid_len;
-
-	if (dhcp_client->debug_func) {
-		gchar *hex = convert_to_hex(duid, duid_len);
-		debug(dhcp_client, "DUID(%d) %s", duid_len, hex);
-		g_free(hex);
-	}
-
-	return 0;
-}
-
-int g_dhcpv6_client_set_pd(GDHCPClient *dhcp_client, uint32_t *T1,
-			uint32_t *T2, GSList *prefixes)
-{
-	uint8_t options[1452];
-	unsigned int max_buf = sizeof(options);
-	int len, count = g_slist_length(prefixes);
-
-	if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
-		return -EINVAL;
-
-	g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_PD);
-
-	memset(options, 0, sizeof(options));
-
-	options[0] = dhcp_client->iaid >> 24;
-	options[1] = dhcp_client->iaid >> 16;
-	options[2] = dhcp_client->iaid >> 8;
-	options[3] = dhcp_client->iaid;
-
-	if (T1) {
-		uint32_t t = htonl(*T1);
-		memcpy(&options[4], &t, 4);
-	}
-
-	if (T2) {
-		uint32_t t = htonl(*T2);
-		memcpy(&options[8], &t, 4);
-	}
-
-	len = 12;
-
-	if (count > 0) {
-		GSList *list;
-
-		for (list = prefixes; list; list = list->next) {
-			GDHCPIAPrefix *prefix = list->data;
-			uint8_t sub_option[4+4+1+16];
-
-			if ((len + 2 + 2 + sizeof(sub_option)) >= max_buf) {
-				debug(dhcp_client,
-					"Too long dhcpv6 message "
-					"when writing IA prefix option");
-				return -EINVAL;
-			}
-
-			memset(&sub_option, 0, sizeof(sub_option));
-
-			/* preferred and validity time are left zero */
-
-			sub_option[8] = prefix->prefixlen;
-			memcpy(&sub_option[9], &prefix->prefix, 16);
-
-			copy_option(&options[len], G_DHCPV6_IA_PREFIX,
-				sizeof(sub_option), sub_option);
-			len += 2 + 2 + sizeof(sub_option);
-		}
-	}
-
-	g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_PD,
-				options, len);
-
-	return 0;
-}
-
-uint32_t g_dhcpv6_client_get_iaid(GDHCPClient *dhcp_client)
-{
-	if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
-		return 0;
-
-	return dhcp_client->iaid;
-}
-
-void g_dhcpv6_client_set_iaid(GDHCPClient *dhcp_client, uint32_t iaid)
-{
-	if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
-		return;
-
-	dhcp_client->iaid = iaid;
-}
-
-void g_dhcpv6_client_create_iaid(GDHCPClient *dhcp_client, int index,
-				unsigned char *iaid)
-{
-    uint8_t buf[6] = { };
-
-	get_interface_mac_address(index, buf);
-
-	memcpy(iaid, &buf[2], 4);
-	dhcp_client->iaid = iaid[0] << 24 |
-			iaid[1] << 16 | iaid[2] << 8 | iaid[3];
-}
-
-int g_dhcpv6_client_get_timeouts(GDHCPClient *dhcp_client,
-				uint32_t *T1, uint32_t *T2,
-				time_t *started,
-				time_t *expire)
-{
-	if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
-		return -EINVAL;
-
-	if (T1)
-		*T1 = dhcp_client->T1;
-
-	if (T2)
-		*T2 = dhcp_client->T2;
-
-	if (started)
-		*started = dhcp_client->last_request;
-
-	if (expire)
-		*expire = dhcp_client->last_request + dhcp_client->expire;
-
-	return 0;
-}
-
-static uint8_t *create_iaaddr(GDHCPClient *dhcp_client, uint8_t *buf,
-				uint16_t len)
-{
-	buf[0] = 0;
-	buf[1] = G_DHCPV6_IAADDR;
-	buf[2] = 0;
-	buf[3] = len;
-	memcpy(&buf[4], &dhcp_client->ia_na, 16);
-	memset(&buf[20], 0, 4); /* preferred */
-	memset(&buf[24], 0, 4); /* valid */
-	return buf;
-}
-
-static uint8_t *append_iaaddr(GDHCPClient *dhcp_client, uint8_t *buf,
-			const char *address)
-{
-	struct in6_addr addr;
-
-	if (inet_pton(AF_INET6, address, &addr) != 1)
-		return NULL;
-
-	buf[0] = 0;
-	buf[1] = G_DHCPV6_IAADDR;
-	buf[2] = 0;
-	buf[3] = 24;
-	memcpy(&buf[4], &addr, 16);
-	memset(&buf[20], 0, 4); /* preferred */
-	memset(&buf[24], 0, 4); /* valid */
-	return &buf[28];
-}
-
-static void put_iaid(GDHCPClient *dhcp_client, int index, uint8_t *buf)
-{
-	uint32_t iaid;
-
-	iaid = g_dhcpv6_client_get_iaid(dhcp_client);
-	if (iaid == 0) {
-		g_dhcpv6_client_create_iaid(dhcp_client, index, buf);
-		return;
-	}
-
-	buf[0] = iaid >> 24;
-	buf[1] = iaid >> 16;
-	buf[2] = iaid >> 8;
-	buf[3] = iaid;
-}
-
-int g_dhcpv6_client_set_ia(GDHCPClient *dhcp_client, int index,
-			int code, uint32_t *T1, uint32_t *T2,
-			bool add_iaaddr, const char *ia_na)
-{
-	if (code == G_DHCPV6_IA_TA) {
-		uint8_t ia_options[4];
-
-		put_iaid(dhcp_client, index, ia_options);
-
-		g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_TA);
-		g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_TA,
-					ia_options, sizeof(ia_options));
-
-	} else if (code == G_DHCPV6_IA_NA) {
-		struct in6_addr addr;
-
-		g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_NA);
-
-		/*
-		 * If caller has specified the IPv6 address it wishes to
-		 * to use (ia_na != NULL and address is valid), then send
-		 * the address to server.
-		 * If caller did not specify the address (ia_na == NULL) and
-		 * if the current address is not set, then we should not send
-		 * the address sub-option.
-		 */
-		if (add_iaaddr && ((!ia_na &&
-			!IN6_IS_ADDR_UNSPECIFIED(&dhcp_client->ia_na))
-			|| (ia_na &&
-				inet_pton(AF_INET6, ia_na, &addr) == 1))) {
-#define IAADDR_LEN (16+4+4)
-			uint8_t ia_options[4+4+4+2+2+IAADDR_LEN];
-
-			if (ia_na)
-				memcpy(&dhcp_client->ia_na, &addr,
-						sizeof(struct in6_addr));
-
-			put_iaid(dhcp_client, index, ia_options);
-
-			if (T1) {
-				ia_options[4] = *T1 >> 24;
-				ia_options[5] = *T1 >> 16;
-				ia_options[6] = *T1 >> 8;
-				ia_options[7] = *T1;
-			} else
-				memset(&ia_options[4], 0x00, 4);
-
-			if (T2) {
-				ia_options[8] = *T2 >> 24;
-				ia_options[9] = *T2 >> 16;
-				ia_options[10] = *T2 >> 8;
-				ia_options[11] = *T2;
-			} else
-				memset(&ia_options[8], 0x00, 4);
-
-			create_iaaddr(dhcp_client, &ia_options[12],
-					IAADDR_LEN);
-
-			g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_NA,
-					ia_options, sizeof(ia_options));
-		} else {
-			uint8_t ia_options[4+4+4];
-
-			put_iaid(dhcp_client, index, ia_options);
-
-			memset(&ia_options[4], 0x00, 4); /* T1 (4 bytes) */
-			memset(&ia_options[8], 0x00, 4); /* T2 (4 bytes) */
-
-			g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_NA,
-					ia_options, sizeof(ia_options));
-		}
-
-	} else
-		return -EINVAL;
-
-	return 0;
-}
-
-int g_dhcpv6_client_set_ias(GDHCPClient *dhcp_client, int index,
-			int code, uint32_t *T1, uint32_t *T2,
-			GSList *addresses)
-{
-	GSList *list;
-	uint8_t *ia_options, *pos;
-	int len, count, total_len;
-
-	count = g_slist_length(addresses);
-	if (count == 0)
-		return -EINVAL;
-
-	g_dhcp_client_set_request(dhcp_client, code);
-
-	if (code == G_DHCPV6_IA_TA)
-		len = 4;         /* IAID */
-	else if (code == G_DHCPV6_IA_NA)
-		len = 4 + 4 + 4; /* IAID + T1 + T2 */
-	else
-		return -EINVAL;
-
-	total_len = len + count * (2 + 2 + 16 + 4 + 4);
-	ia_options = g_try_malloc0(total_len);
-	if (!ia_options)
-		return -ENOMEM;
-
-	put_iaid(dhcp_client, index, ia_options);
-
-	pos = &ia_options[len]; /* skip the IA_NA or IA_TA */
-
-	for (list = addresses; list; list = list->next) {
-		pos = append_iaaddr(dhcp_client, pos, list->data);
-		if (!pos)
-			break;
-	}
-
-	if (code == G_DHCPV6_IA_NA) {
-		if (T1) {
-			ia_options[4] = *T1 >> 24;
-			ia_options[5] = *T1 >> 16;
-			ia_options[6] = *T1 >> 8;
-			ia_options[7] = *T1;
-		} else
-			memset(&ia_options[4], 0x00, 4);
-
-		if (T2) {
-			ia_options[8] = *T2 >> 24;
-			ia_options[9] = *T2 >> 16;
-			ia_options[10] = *T2 >> 8;
-			ia_options[11] = *T2;
-		} else
-			memset(&ia_options[8], 0x00, 4);
-	}
-
-	g_dhcpv6_client_set_send(dhcp_client, code, ia_options, total_len);
-
-	g_free(ia_options);
-
-	return 0;
-}
-
-int g_dhcpv6_client_set_oro(GDHCPClient *dhcp_client, int args, ...)
-{
-	va_list va;
-	int i, j, len = sizeof(uint16_t) * args;
-	uint8_t *values;
-
-	values = g_try_malloc(len);
-	if (!values)
-		return -ENOMEM;
-
-	va_start(va, args);
-	for (i = 0, j = 0; i < args; i++) {
-		uint16_t value = va_arg(va, int);
-		values[j++] = value >> 8;
-		values[j++] = value & 0xff;
-	}
-	va_end(va);
-
-	g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_ORO, values, len);
-
-	g_free(values);
-
-	return 0;
-}
-
-static int send_dhcpv6_msg(GDHCPClient *dhcp_client, int type, char *msg)
-{
-	struct dhcpv6_packet *packet;
-	uint8_t buf[MAX_DHCPV6_PKT_SIZE];
-	unsigned char *ptr;
-	int ret, max_buf;
-
-	memset(buf, 0, sizeof(buf));
-	packet = (struct dhcpv6_packet *)&buf[0];
-	ptr = buf + sizeof(struct dhcpv6_packet);
-
-	init_packet(dhcp_client, packet, type);
-
-	if (!dhcp_client->retransmit) {
-		dhcp_client->xid = packet->transaction_id[0] << 16 |
-				packet->transaction_id[1] << 8 |
-				packet->transaction_id[2];
-		gettimeofday(&dhcp_client->start_time, NULL);
-	} else {
-		packet->transaction_id[0] = dhcp_client->xid >> 16;
-		packet->transaction_id[1] = dhcp_client->xid >> 8 ;
-		packet->transaction_id[2] = dhcp_client->xid;
-	}
-
-	g_dhcp_client_set_request(dhcp_client, G_DHCPV6_ELAPSED_TIME);