Statistics
| Branch: | Revision:

grapes / doc / grapes.doxy @ 2b424777

History | View | Annotate | Download (3.1 KB)

1
/** @mainpage
2

    
3
   @section intro Introduction
4

    
5
   GRAPES (Generic Resource-Aware P2P Environment for Streaming) is a
6
   library of functionalities providing some ``building blocks'' for P2P
7
   streaming applications. Each application is decomposed in a set of
8
   <i>modules</i> (or <i>\em components</i>), and the library contain
9
   various alternative implementations of the modules, exported through
10
   the public GRAPES API (see the list of .h files).
11

    
12
   Ideally, a P2P streaming application can be built by linking such
13
   functionalities with a minimum amount of C code (in the best of the possible
14
   worlds, we would have some kind of GUI - like a graph editor - allowing
15
   to combine the various modules in different ways and to automatically
16
   generate the glue code for building the P2P program).
17

    
18
   One of the design goals of the GRAPES library is not to force
19
   any particular structure in the applications using it, and it should be
20
   possible to use its APIs in either multi-threaded programs, multi-process
21
   applications, single-threaded (event based) architectures, etc...
22
   Moreover, there should not be any dependency on external libraries, and
23
   the code should be fairly portable.
24

    
25
@section structure GRAPES Structure
26

    
27
   The following Components/Modules can be identified:
28
	- a Scheduler
29
	- a @link peersampler.h Peer Sampling @endlink mechanism
30
        - a @link peerset.h Peer Set @endlink data type
31
        - a @link chunkbuffer.h Chunk Buffer @endlink
32
        - a @link chunkidset.h Chunk ID Set @endlink data type
33
	- a @ref trade_sig Module
34
	- a @ref trade_msg module (send \& receive chunks)
35
	- a @link chunkiser.h "chunkiser"@endlink, which builds chunks from an input
36
                  media stream, and the corresponding "dechunkiser", which
37
                  reconstructs the encoded stream based on the received chunks
38

    
39
   Each module is separated into a sub-directory within the source tree,
40
   is described by a well-defined interface, and can have different
41
   implementations and/or bindings to different programming languages
42
   (for the moment, only C bindings are provided wrapper for other
43
   programming languages can be implemented based on the C library).
44
   The public Application Programming Interfaces (APIs) of the various
45
   modules are located in the <i>include/</i> sub-directory.
46

    
47
@section trade_msg Chunk Transport
48
   Chunk Transport is a module of the GRAPES libary which is responsible for
49
   sending and receiving chunks (described by the struct chunk from chunk.h).
50

    
51
   As for other modules, chunk transport is provided through two kinds
52
   of APIs: the @link trade_msg_ha.h <i>high abstraction</i> @endlink and
53
   the @link trade_msg_la.h <i>low abstraction</i> @endlink API.
54

    
55
   By design, the chunk trading API should be generic
56
   enough to support both push and pull styles of streaming.
57

    
58
@section trade_sig Signalling
59
  The Signalling functionalities allow the caller to offer/request chunks, or
60
  to send buffermaps (Chunk ID Sets) between peers.
61

    
62
  The signalling API is divided in @link trade_sig_ha.h <i>high
63
  abstraction</i> @endlink and @link trade_sig_la.h <i>low
64
  abstraction</i> @endlink
65
*/