Google Summer of Code 2016

Welcome to P2PSP Google Summer of Code (GSoC) 2018 project ideas page. We will use this page to develop possible project ideas. Please note that anyone who is interested can participate in this process. You do not have to be a GSoC student or mentor to suggest possible project ideas. If you want to suggest an idea, please, send an email with the subject "GSoC 18 Ideas" to info [at] p2psp.org. You can also join the team at GitHub, chat on Gitter.

Potential mentors:Vicente González RuizCristóbal Medina López, Leocadio González CasadoJuan Álvaro Muñoz NaranjoThis email address is being protected from spambots. You need JavaScript enabled to view it.Jose Manuel García SalmerónMax Mertens Juan José Moreno Riado, and Yuansong Qiao.

The current list of ideas for the GSoC 2018 is:

  1. Statistics module to measure the audience and other interesting data.
    1. Explanation: This project addresses the implementation of a statistics module for P2PSP that records information related to the stream, number of peers (audience) per minute, in/out of peers, total peers, etc. That set of data must be displayed a convenient graphical interface. A very interesting extension is to consider also the use of social sign-in (Facebook, Twitter, Google+).
    2. Expected deliverables: An application that displays graphs of all data recovered. 
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Python and JavaScript.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/core/Statistics-module.

  2. WebRTC implementation of a NAT traversal procedure based on port prediction.
    1. Explanation:  To implement NTS using STUN servers. Using the tools provided by ICE, users behind a symmetric NAT cannot participate in a team in a collaborative way by themselves, because the current solution using TURN servers does not follow the distributed communication scheme of P2P networks. Several STUN servers or a STUN server with several IP addresses can be used to implement a similar port prediction algorithm as the one in NTS.
    2. Expected deliverables: A JS + WebRTC code implementing the procedure.
    3. Knowledge prerequisites: Basic skills on computer networks, sockets, JS and WebRTC.
    4. Skill level:  Easy.
    5. Mentor: 
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/Virtual-Room. 

  3. Chromecast support for P2PSP.
    1. Explanation: Chromecast is a digital media player developed by Google which can be connected to a TV. This idea consist in adding the option "send to chromecast" to the P2PSP GUI (See 11). This option should send the stream from a desktop application to Chromecast. Note that the player controls are held in the desktop version.
    2. Expected deliverables: A new module for the GUI with Chromecast support.
    3. Knowledge prerequisites: Python and API Chomecast programming skills.
    4. Skill level: Easy.
    5. Mentor:  
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/core/Chromecast-support

  4. Implementation of the P2PSP as a JS library: P2PSP-JS.
    1. Explanation: A WebRTC implementation providing a comprehensive, configurable, and easy to use P2PSP API.
    2. Expected deliverables: A P2PSP API.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Python, JavaScript, HTML5 and WebRTC.
    4. Skill level: Experienced.
    5. Mentor:  
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/core/Chromecast-DBS.

  5. Implementation of the Data Broadcasting Set of Rules 2 (DBS2) using P2PSP-JS as a Chromecast application.
    1. Explanation: A Chromecast device can run a P2PSP peer and a player using the WebRTC framework. This idea depends on the success of idea number 2, but after that, a minor programming effort should be performed.
    2. Expected deliverables: A peer implementation for Chromecast.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Bash, Python, JavaScript, HTML5 and WebRTC.
    4. Skill level: Experienced.
    5. Mentor:  
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/core/Chromecast-DBS.

  6. Improving data security with the DPS layer.
    1. Explanation: In some context, data privacy could be necessary. This functionality can be provide by data encryption and some kind of keys sharing between peers.
    2. Expected deliverables: A new implementation of the DPS (Data Privacy Set of rules) layer.
    3. Knowledge prerequisites: Basic skills on computer networks, security and Python.
    4. Skill level: Intermediate.
    5. Mentor:
    6. Priority: Medium
    7. Room: https://gitter.im/P2PSP/core/DPS.

  7. Automatization of the deployment of a P2PSP team (or a part of it) over the PlanetLab infrastructure.
    1. Explanation: The PlanetLab is a network of public (Linux) hosts exclusively dedicated to the development and performance measurement of communication protocols. The idea of this project is to automatize as much as possible this task, enabling the deployment and evaluation of hundreds peers.
    2. Expected deliverables: A script deploying a P2PSP team over PlanetLab.
    3. Knowledge prerequisites: Shell scripting, Unix.
    4. Skill level: Intermediate.
    5. Mentor: 
    6. Priority: Low.
    7. Room: https://gitter.im/P2PSP/PlanetLab.

  8. Development of a tracker of splitters.
    1. Explanation: A channel is associated to one or more splitters that stream the same content, in a synchronized way. In order to achieve a good load balancing among the splitters of the same channel, a tracker could determine (depending on the number of peers, for example, in each team) the a free splitter (team) and redirect the incomming peer to it. See https://github.com/P2PSP/core/tree/master/doc/TCS.
    2. Expected deliverables: A standalone application (written in a portable language such as Python or C++) which implements the previously described behaviour.
    3. Knowledge prerequisites: Socket programming and a good understanding of P2PSP.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/Splitters-Tracker.

  9. Implementation of a media-aware splitter.
    1. Explanation: The current splitter divides the code-stream into blocks (chunks) of the same size and that size usually does not match with the native block of the video (for example, in H.264 exist NAL units, in Theora there are pages, etc). Therefore, if a chunk is lost (in the current implementation), even if it is two bytes long, two blocks of video could be affected. To solve this drawback, this idea proposes to modify the implementation of the splitter available at: https://github.com/P2PSP/p2psp, in order to use a chunk size suitable for the media transmitted. The incorporation of such functionality should be provided as a "pluging".
    2. Expected deliverables: A new version of the splitter.
    3. Knowledge prerequisites: C++, video formats.
    4. Skill level: Experienced.
    5. Mentor: 
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/core/MediaAware-Splitter

  10. Improve GoPro project.
    1. Explanation: This idea is an extension of implemented idea 7 (see below). Add support for other cameras like SJCAM (the more the merrier). Maybe would be possible to add more streaming platforms like twitch or Twitter.
    2. Expected deliverables: An improved GoPro Gateway app.
    3. Knowledge prerequisites: Java, Android and socket programming.
    4. Skill level: Easy.
    5. Mentor: 
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/GoPro-Gateway.

  11. Testing the reliability of P2PSP teams.
    1. Explanation: It not easy to test if a modification in P2PSP has the expected impact. For this reason, we propose to write a Bash script which is able to create a team on a single host, run it and provide statistics about its performance (lost chunk ratio, for example). 
    2. Expected deliverables: A tester for the P2PSP protocol.
    3. Knowledge prerequisites: P2PSP and Bash.
    4. Skill level: Easy.
    5. Mentor: 
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/ProtocolTest

  12. Automatic peer clustering using several teams.
    1. Explanation: The synchronizer entity can be used by peers to receive (the same) media from two or more team, simultaneously. In this idea, we propose to extend the functionality of the synchronizer to allow a peer to move between teams in a seamless manner.
    2. Expected deliverables: An extended synchronizer.
    3. Knowledge prerequisites: C++ and socket programming.
    4. Skill level: Experienced.
    5. Mentor: 
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/DBS-Min-Latency

  13. Using Internet Sockets instead of Unix sockets.
    1. Explanation: Currently, we use Unix domain sockets to communicate between processes in the same host system. So, our simulator uses files as "address" instead of a (host, port) pair. If we turn AF_UNIX into AF_INET the translation between the simulator and the production code would be almost the same. We could apply all changes tested in the simulator to the production code in a faster way. Additionally, the code which gathers statistics should be implemented using socket.
    2. Expected deliverables: An improved P2PSP simulation version.
    3. Knowledge prerequisites: Socket programming, Python.
    4. Skill level: Intermediate.
    5. Mentor: 
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/Simulator

  14. Measure the latency of the chunks transmission.
    1. Explanation: This idea consist in measuring the time the chunks take to travel from the splitter to the peers.
    2. Expected deliverables: An improved P2PSP simulation version.
    3. Knowledge prerequisites: Socket programming, Python.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/Simulator

  15. Implement a lost-chunks recovery system based on Reed-Solomon codes.
    1. Explanation: This idea consist in implement a recovery system based on Reed-Solomon error correction codes.
    2. Expected deliverables: An improved P2PSP simulation version.
    3. Knowledge prerequisites: Socket programming, Python.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/Simulator

  16. Implement IMS layer.
    1. Explanation: Take advantage of IP multicast facility when available. See https://github.com/P2PSP/core/tree/master/doc/IMS.
    2. Expected deliverables: An improved P2PSP simulation version.
    3. Knowledge prerequisites: Socket programming, Python.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/Simulator

  17. Reimplement splitter_dbs.py to replace threading.Thread by multiprocessing processes.
    1. Explanation: Python GIL has some limitations for CPU intensive applications. Processes could help to resolve that problem.
    2. Expected deliverables: An improved P2PSP simulation version.
    3. Knowledge prerequisites: Socket programming, Python.
    4. Skill level: Easy.
    5. Mentor:
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/Simulator

 

Note: the mentor assigned for each idea is not definitive.


 Ideas proposed in the past turned into reality:

  1. Design and Implementation of a new source video from mobile phone (Android)
    1. Explanation: Mobile phones are nowadays present in everyone's pocket, meaning that there is a camera at virtually any populated place in the world. Giving users the chance to share what they are watching live with the rest of the world seems to be a good idea and is a natural application of the phone+Internet combination. On the other hand, P2PSP is a minimal (easy to implement) protocol designed for the streaming of media (audio and video). At the present time, there is a working Python implementation available at Launchpad. We propose the development of an Android app that captures the video of the camera and sends it to a streaming server (possibly Icecast) on real time. From there, P2PSP distributes the stream to the rest of the world.
    2. Expected deliverables: An application for Android that captures the video of the camera and send it to a streaming server (icecast) in real time.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Android programming skill.
    4. Skill level: Experienced.
    5. Mentor: This email address is being protected from spambots. You need JavaScript enabled to view it.Vicente González Ruiz and Cristóbal Medina López
    6. Student: Jorge Martín Espinosa
    7. Results: GitHub - https://goo.gl/jMgZnE 
    8. Funded by Luxunda S.L. Thanks!!

  2. Translate core code in python to C++.
    1. Explanation: In order to create a common core for different devices implementations such as mobile phone, desktop, embedded devices, etc., we propose a translation of the core to C++.
    2. Expected deliverables: A new core code in C++.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, C++ programming skills.
    4. Skill level: Intermediate.
    5. Mentor: This email address is being protected from spambots. You need JavaScript enabled to view it. and Vicente González Ruiz
    6. Student: Jorge García Hinestrosa and Antonio Vicente Martín.
    7. Results: GitHub - http://code.p2psp.org 
    8. Funded by Luxunda S.L. Thanks!!

  3. Implementation of the NAT Traversal Set (NTS) of rules of the Peer-to-Peer Straightforward Protocol (P2PSP).
    1. Explanation: Another important aspect for improving P2PSP is that peers behind NATs can run with some form of restricted access from the outside. This set of rules defines how to provide this functionality.
    2. Expected deliverables: A Python class that inherits the Splitter_DBS class of splitter.py and a Python class that inherits the Peer_DBS class of peer.py, both implementing the techniques described in the NTS.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Bash and Python.
    4. Skill level: Intermediate.
    5. Mentor: Vicente González Ruiz and This email address is being protected from spambots. You need JavaScript enabled to view it.
    6. Student: Max Mertens
    7. Results: GSoC15 - https://goo.gl/VuTfP9 | GitHub - https://goo.gl/IJFQAb
    8. Funded by Google Summer of Code 2015. Thanks!!

  4. Prevention of Pollution Attacks - Model 1.
    1. Explanation: In the P2PSP system it is necessary  a method to avoid attacks consisting on the injection of fake information into the team. An attacker can do this by sending poisoned chunks. A way to tackle this problem is by inserting one o more “trusted-peers”. These peers are authenticated as trusted to the splitter, but not to the rest of peer (the behavior of a trusted-peer is identical to any other peer making impossible for a poisonous peer to know these special peers). The source sends to the trusted-peers a hash code for every chunk sent to the team, using a reliable transmission protocol. Alternatively, hash codes for randomly chosen chunks are sent to the trusted-peers (note that the poisonous peer is not aware of which chunks were selected). If a poisonous peer sends an altered chunk to a trusted-peer, it will detect the change using the hash code and will notify the source, which will eject the poisonous peer from the team. 
    2. Expected deliverables: A Python class that inherits the DBS class of splitter.py and a Python class that inherits the DBS class of peer.py, both implementing the techniques described in the DIS of rules.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Bash and Python.
    4. Skill level: Easy/ Intermediate.
    5. Mentor: Leocadio González Casado and Juan Álvaro Muñoz Naranjo.
    6. Student: Ilya Shakirov
    7. Results: GSoC15 - https://goo.gl/jaHQ83 | GitHub - https://goo.gl/bqTe9X 
    8. Funded by Google Summer of Code 2015. Thanks!!

  5. Design, implementation and integration of a graphical user interface for the Peer in the P2PSP python implementation.
    1. Explanation: There already is a working implementation in Python but it does not have any integrated GUI, so the user must run a player separately. The purpose of this work is to use LibVLC (a media framework that embeds the features of VLC into an application) to integrate a peer and a player into a single executable. However, any other suggestions about multimedia libraries are welcome. The P2PSP source code is available at https://launchpad.net/p2psp. You can find more information about LibVLC and Python in https://wiki.videolan.org/PythonBinding/. The code must be documented with Doxygen.
    2. Expected deliverables: A single executable integrating a GUI, a player and a P2PSP peer. 
    3. Knowledge prerequisites: Python programming skills.
    4. Skill level: Easy / Intermediate.
    5. Mentor: Cristóbal Medina López and Jose Juan Sánchez Hernández.
    6. Student: Prince Kumar
    7. Results: GSoC15 - https://goo.gl/oWxmnV | GitHub - https://goo.gl/y5zJUj 
    8. Funded by Google Summer of Code 2015. Thanks!!

  6. Implementation of the End-point Masquerading Set (EMS) of rules of the Peer-to-Peer Straightforward Protocol (P2PSP).
    1. Explanation: EMS handles those situations where two or more peers and behind a NAT device that performs IP masquerading (a framework commonly found when peers runs in private networks).
    2. Expected deliverables: A C++ SplitterEMS class that inherits the SplitterDBS class defined in splitter_dbs.h and a C++ PeerEMS class that inherits the PeerDBS class of peer_dbs.h.
    3. Knowledge prerequisites: Basic skills on computer networks, sockets and C++.
    4. Skill level:  Intermediate.
    5. Mentor: Vicente González Ruiz and Max Mertens.
    6. Room: https://gitter.im/P2PSP/p2psp/EMS.
    7. Student: Kevin Shi
    8. Results: GSoC16 - https://goo.gl/JsP92v | GitHub - https://goo.gl/my1XnO
    9. Funded by Google Summer of Code 2016. Thanks!!

  7. Implementation of a GoPro Gateway.
    1. Explanation: Action cameras are becoming popular. We think that create a gateway between the camera and Internet is a interesting thing. So, in this project we propose create an app for mobile devices that use the GoPro camera as a source and send the stream to the Internet. It could be sent to a P2PSP splitter, Youtube, Icecast, etc.
    2. Expected deliverables: A mobile phone application (Android or iOS) which implements the previously described behaviour.
    3. Knowledge prerequisites: Mobile programming (Android or iOS), basic skills on computer networks and sockets.
    4. Skill level: Intermediate.
    5. Mentor: Jose Manuel García Salmerón and Vicente González Ruiz
    6. Room: https://gitter.im/P2PSP/GoPro-Gateway.
    7. Student: Sravan Ravi
    8. Result: GSoC16 - https://goo.gl/QuYbPO | GitHub - https://goo.gl/jiDdlv
    9. Funded by Google Summer of Code 2016. Thanks!!

  8. The P2PSP virtual room application.
    1. Explanation: We want to offer an evolution of this experiment (https://youtu.be/R7035-XaZd4). A virtual room where friends share videos among them in real time directly over the web browser, with synchronized playback and a video chat at the same time. It is like to be in the same room watching a movie but in a virtual way. Browsers are connected each other over a P2P overlay (using WebRTC), this means that we have a private communication, without going through a server. It's a browser-to-browser connection. 
    2. Expected deliverables: A website where an user can share a video with his friends in real time, with synchronized playback and they can have a video chat at the same time. All of this over a P2P overlay.
    3. Knowledge prerequisites: Basic skills on computer networks and sockets, Python, JavaScript, HTML5 and WebRTC.
    4. Skill level: Intermediate.
    5. Mentor: Cristóbal Medina López and Jose Manuel García Salmerón 
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/Virtual-Room.
    8. Funded by Google Summer of Code 2017. Thanks!!

  9. Implementation of a REST WebService for the P2PSP media sources.
    1. Explanation: At its current state, the Splitter - which handles the team of peers - needs to be connected using an IP and Port which must be either fixed or previously agreed for both streaming video and peer connection. Which we want to accomplish here is to have a wrapper WebService that can receive the video through an HTTP request - or any other way that can easily get through NATs-, create an Splitter instance and redirect the video to it, assigning a 'friendly URL' to it that can be easily shared. When this URL is visited, it will reply with the IP and port that the peers need in order to connect to the Splitter.
    2. Expected deliverables: A REST web application that will dynamically create Splitters, receive the video and redirect it to the correct Splitter, assign URLs to them and reply to those URL with the IP and port needed to connect to the team that the Splitter runs.
    3. Knowledge prerequisites: Basic skill on computer networks, sockets, REST apis and the HTTP protocol.
    4. Skill level: Easy.
    5. Mentor: Vicente González Ruiz and This email address is being protected from spambots. You need JavaScript enabled to view it.
    6. Priority: High. 
    7. Room: https://gitter.im/P2PSP/MediaSources-server.
    8. Funded by Google Summer of Code 2017. Thanks!!

  10. A P2PSP simulator.
    1. Explanation: Create a simulator of the P2PSP protocol using Thread and message passing in order to do the prototyping of new strategies easier. If we use Python, we can use Queue class. It’ll be very useful!
    2. Expected deliverables: A complete stand-alone simulator of P2PSP.
    3. Knowledge prerequisites: Python.
    4. Skill level: Intermediate.
    5. Mentor:  Cristóbal Medina López
    6. Priority: High.
    7. Room: https://gitter.im/P2PSP/Simulator
    8. Funded by University of Almería and Ministry of Education Spain (MECD). Thanks!!

Ideas partially done:

  1. GUI-QT.
    1. Explanation: The purpose of this work is to integrate a peer and a player into a single executable GUI using QT and C++.
    2. Expected deliverables: A GUI for the P2PSP peer + player.
    3. Knowledge prerequisites: QT and C++.
    4. Skill level: Intermediate.
    5. Mentor: 
    6. Priority: Medium.
    7. Room: https://gitter.im/P2PSP/GUI-QT
    8. Funded by Google Summer of Code 2017. Thanks!!