root/rat/trunk/pdb.c @ 3106

Revision 3106, 5.3 KB (checked in by ucacoxh, 14 years ago)

- Added common/ntp.h common/ntp.c which do basic ntp timestamp get, conversion,

and differencing.

- Changed rtp library to use ntp.h ntp.c.
- Add rtt calculation to rat on reception of sr with lsr != 0.
- Add fields in pdb.h for last_rtt and avg_rtt.

Still have to add field to ui and probably decide an mbus message
name, for moment it's rtp.source.rtt.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:    pdb.c
3 * PROGRAM: RAT
4 * AUTHOR:  O.Hodson
5 *
6 * Copyright (c) 1999-2000 University College London
7 * All rights reserved.
8 *
9 * These functions provide a means of maintaining persistent
10 * information on conference participants that is not contained in the
11 * RTCP database.  Entries are stored in a binary tree, identified
12 * with a unique 32 bit unsigned identifer (probably the same as
13 * SSRC).
14 */
15 
16#ifndef HIDE_SOURCE_STRINGS
17static const char cvsid[] =
18        "$Id$";
19#endif /* HIDE_SOURCE_STRINGS */
20
21#include "config_unix.h"
22#include "config_win32.h"
23#include "debug.h"
24#include "memory.h"
25#include "btree.h"
26#include "channel_types.h"
27#include "audio_types.h"
28#include "codec_types.h"
29#include "timers.h"
30#include "session.h"
31#include "pdb.h"
32
33struct s_pdb {
34        btree_t *db;
35        uint32_t  nelem;
36};
37
38int 
39pdb_create(pdb_t **pp)
40{
41        pdb_t *p;
42
43        p = (pdb_t*)xmalloc(sizeof(pdb_t));
44        if (p == NULL) {
45                *pp = NULL;
46                return FALSE;
47        }
48
49        if (btree_create(&p->db) == FALSE) {
50                xfree(p);
51                *pp = NULL;
52                return FALSE;
53        }
54
55        p->nelem = 0;
56        *pp = p;
57        return TRUE;
58}
59
60int 
61pdb_destroy(pdb_t **pp)
62{
63        pdb_t   *p = *pp;
64        uint32_t id;
65       
66        while(pdb_get_first_id(p, &id)) {
67                if (pdb_item_destroy(p, id) == FALSE) {
68                        debug_msg("Failed to destroy item\n");
69                        return FALSE;
70                }
71        }
72
73        if (btree_destroy(&p->db) == FALSE) {
74                debug_msg("Failed to destroy tree\n");
75                return FALSE;
76        }
77
78        xfree(p);
79        *pp = NULL;
80        return TRUE;
81}
82
83uint32_t
84pdb_item_count(pdb_t *p)
85{
86        return p->nelem;
87}
88
89int
90pdb_get_first_id(pdb_t *p, uint32_t *id)
91{
92        return btree_get_min_key(p->db, id);
93}
94
95int
96pdb_get_next_id(pdb_t *p, uint32_t cur, uint32_t *next)
97{
98        return btree_get_next_key(p->db, cur, next);
99}
100
101int
102pdb_item_get(pdb_t *p, uint32_t id, pdb_entry_t **item)
103{
104        void *v;
105        if (btree_find(p->db, id, &v) == FALSE) {
106                *item = NULL;
107                return FALSE;
108        }
109        assert(v != NULL);
110        *item = (pdb_entry_t*)v;
111        pdb_item_validate(*item);
112        return TRUE;
113}
114
115int
116pdb_item_create(pdb_t *p, struct s_fast_time *clock, uint16_t freq, uint32_t id)
117{
118        pdb_entry_t *item;
119        ts_t         zero_ts;
120
121        if (btree_find(p->db, id, (void**)&item)) {
122                debug_msg("Item already exists\n");
123                return FALSE;
124        }
125
126        item = (pdb_entry_t*)xmalloc(sizeof(pdb_entry_t));
127        if (item == NULL) {
128                return FALSE;
129        }
130
131        /* Initialize elements of item here as necesary **********************/
132
133        item->magic           = 0xc001babe;
134        item->ssrc            = id;
135        item->render_3D_data  = NULL;
136        item->enc             = -1;
137        item->enc_fmt_len     = 2 * (CODEC_LONG_NAME_LEN + 1);
138        item->enc_fmt         = xmalloc(item->enc_fmt_len);
139        item->gain            = 1.0;
140        item->mute            = 0;
141        item->clock           = new_time(clock, freq);
142        zero_ts               = ts_map32(8000, 0);
143        item->last_ui_update  = zero_ts;
144
145        /* Initial jitter estimate (30ms)                                    */
146        item->jitter            = ts_map32(8000, 240);
147        item->transit           = zero_ts;
148        item->last_transit      = zero_ts;
149        item->last_last_transit = zero_ts;
150        item->avg_transit       = zero_ts;
151        item->playout           = zero_ts;
152        item->last_arr          = zero_ts;
153        item->last_rtt          = 0.0;
154        item->avg_rtt           = 0.0;
155        /* Packet stats initialization                                       */
156        item->received        = 0;
157        item->duplicates      = 0;
158        item->misordered      = 0;
159        item->jit_toged       = 0;
160        item->spike_toged     = 0;
161        item->spike_events    = 0;
162
163        pdb_item_validate(item);
164        /*********************************************************************/
165
166        if (btree_add(p->db, id, (void*)item) == FALSE) {
167                debug_msg("failed to add item to persistent database!\n");
168                return FALSE;
169        }
170
171        p->nelem++;
172        return TRUE;
173}
174
175int
176pdb_item_destroy(pdb_t *p, uint32_t id)
177{
178        pdb_entry_t *item;
179
180        if (btree_remove(p->db, id, (void**)&item) == FALSE) {
181                debug_msg("Cannot delete item because it does not exist!\n");
182                return FALSE;
183        }
184
185        pdb_item_validate(item);
186        assert(id == item->ssrc);
187
188        /* clean up elements of item here ************************************/
189
190        if (item->render_3D_data != NULL) {
191                render_3D_free(&item->render_3D_data);
192        }
193
194        if (item->clock) {
195                free_time(item->clock);
196        }
197
198        if (item->enc_fmt != NULL) {
199                xfree(item->enc_fmt);
200                item->enc_fmt = NULL;
201        }
202
203        /*********************************************************************/
204
205        debug_msg("Removing persistent database entry for SSRC 0x%08lx\n",
206                  item->ssrc);
207        xfree(item);
208        p->nelem--;
209        return TRUE;
210}
211
212void
213pdb_item_validate(pdb_entry_t *item)
214{
215        assert(item != NULL);
216        assert(item->magic == 0xc001babe);
217}
Note: See TracBrowser for help on using the browser.