← Back to branch summary

~ubuntu-branches/ubuntu/precise/me-tv/precise-proposed

« back to all changes in this revision

Viewing changes to src/libdvben50221/en50221_app_dvb.c

  • Committer: Bazaar Package Importer
  • Author(s): Philipp Kern
  • Date: 2008-07-23 14:03:56 UTC
  • mfrom: (1.1.3 upstream) (3.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080723140356-m6ze7fbkydes42c7
Tags: 0.5.33-3
Fix xine-lib ffmpeg dependency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libdvben50221/en50221_app_dvb.c
1
 
/*
2
 
    en50221 encoder An implementation for libdvb
3
 
    an implementation for the en50221 transport layer
4
 
 
5
 
    Copyright (C) 2004, 2005 Manu Abraham <abraham.manu@gmail.com>
6
 
    Copyright (C) 2005 Julian Scheel (julian at jusst dot de)
7
 
    Copyright (C) 2006 Andrew de Quincey (adq_dvb@lidskialf.net)
8
 
 
9
 
    This library is free software; you can redistribute it and/or modify
10
 
    it under the terms of the GNU Lesser General Public License as
11
 
    published by the Free Software Foundation; either version 2.1 of
12
 
    the License, or (at your option) any later version.
13
 
 
14
 
    This program is distributed in the hope that it will be useful,
15
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
    GNU Lesser General Public License for more details.
18
 
 
19
 
    You should have received a copy of the GNU Lesser General Public
20
 
    License along with this library; if not, write to the Free Software
21
 
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22
 
*/
23
 
 
24
 
#include <string.h>
25
 
#include <libdvbmisc/dvbmisc.h>
26
 
#include <pthread.h>
27
 
#include "en50221_app_dvb.h"
28
 
#include "en50221_app_tags.h"
29
 
#include "asn_1.h"
30
 
 
31
 
struct en50221_app_dvb {
32
 
        struct en50221_app_send_functions *funcs;
33
 
 
34
 
        en50221_app_dvb_tune_callback tune_callback;
35
 
        void *tune_callback_arg;
36
 
 
37
 
        en50221_app_dvb_replace_callback replace_callback;
38
 
        void *replace_callback_arg;
39
 
 
40
 
        en50221_app_dvb_clear_replace_callback clear_replace_callback;
41
 
        void *clear_replace_callback_arg;
42
 
 
43
 
        pthread_mutex_t lock;
44
 
};
45
 
 
46
 
static int en50221_app_dvb_parse_tune(struct en50221_app_dvb *dvb,
47
 
                                      uint8_t slot_id,
48
 
                                      uint16_t session_number,
49
 
                                      uint8_t * data,
50
 
                                      uint32_t data_length);
51
 
 
52
 
static int en50221_app_dvb_parse_replace(struct en50221_app_dvb *dvb,
53
 
                                         uint8_t slot_id,
54
 
                                         uint16_t session_number,
55
 
                                         uint8_t * data,
56
 
                                         uint32_t data_length);
57
 
 
58
 
static int en50221_app_dvb_parse_clear_replace(struct en50221_app_dvb *dvb,
59
 
                                               uint8_t slot_id,
60
 
                                               uint16_t session_number,
61
 
                                               uint8_t * data,
62
 
                                               uint32_t data_length);
63
 
 
64
 
 
65
 
 
66
 
struct en50221_app_dvb *en50221_app_dvb_create(struct en50221_app_send_functions *funcs)
67
 
{
68
 
        struct en50221_app_dvb *dvb = NULL;
69
 
 
70
 
        // create structure and set it up
71
 
        dvb = malloc(sizeof(struct en50221_app_dvb));
72
 
        if (dvb == NULL) {
73
 
                return NULL;
74
 
        }
75
 
        dvb->funcs = funcs;
76
 
        dvb->tune_callback = NULL;
77
 
        dvb->replace_callback = NULL;
78
 
        dvb->clear_replace_callback = NULL;
79
 
 
80
 
        pthread_mutex_init(&dvb->lock, NULL);
81
 
 
82
 
        // done
83
 
        return dvb;
84
 
}
85
 
 
86
 
void en50221_app_dvb_destroy(struct en50221_app_dvb *dvb)
87
 
{
88
 
        pthread_mutex_destroy(&dvb->lock);
89
 
        free(dvb);
90
 
}
91
 
 
92
 
void en50221_app_dvb_register_tune_callback(struct en50221_app_dvb *dvb,
93
 
                                            en50221_app_dvb_tune_callback callback,
94
 
                                            void *arg)
95
 
{
96
 
        pthread_mutex_lock(&dvb->lock);
97
 
        dvb->tune_callback = callback;
98
 
        dvb->tune_callback_arg = arg;
99
 
        pthread_mutex_unlock(&dvb->lock);
100
 
}
101
 
 
102
 
void en50221_app_dvb_register_replace_callback(struct en50221_app_dvb *dvb,
103
 
                                               en50221_app_dvb_replace_callback callback,
104
 
                                               void *arg)
105
 
{
106
 
        pthread_mutex_lock(&dvb->lock);
107
 
        dvb->replace_callback = callback;
108
 
        dvb->replace_callback_arg = arg;
109
 
        pthread_mutex_unlock(&dvb->lock);
110
 
}
111
 
 
112
 
void en50221_app_dvb_register_clear_replace_callback(struct en50221_app_dvb *dvb,
113
 
                                                     en50221_app_dvb_clear_replace_callback callback,
114
 
                                                     void *arg)
115
 
{
116
 
        pthread_mutex_lock(&dvb->lock);
117
 
        dvb->clear_replace_callback = callback;
118
 
        dvb->clear_replace_callback_arg = arg;
119
 
        pthread_mutex_unlock(&dvb->lock);
120
 
}
121
 
 
122
 
int en50221_app_dvb_ask_release(struct en50221_app_dvb *dvb,
123
 
                                uint16_t session_number)
124
 
{
125
 
        uint8_t data[4];
126
 
 
127
 
        data[0] = (TAG_ASK_RELEASE >> 16) & 0xFF;
128
 
        data[1] = (TAG_ASK_RELEASE >> 8) & 0xFF;
129
 
        data[2] = TAG_ASK_RELEASE & 0xFF;
130
 
        data[3] = 0;
131
 
 
132
 
        return dvb->funcs->send_data(dvb->funcs->arg, session_number, data, 4);
133
 
}
134
 
 
135
 
int en50221_app_dvb_message(struct en50221_app_dvb *dvb,
136
 
                            uint8_t slot_id,
137
 
                            uint16_t session_number,
138
 
                            uint32_t resource_id,
139
 
                            uint8_t * data, uint32_t data_length)
140
 
{
141
 
        (void) resource_id;
142
 
 
143
 
        // get the tag
144
 
        if (data_length < 3) {
145
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
146
 
                return -1;
147
 
        }
148
 
        uint32_t tag = (data[0] << 16) | (data[1] << 8) | data[2];
149
 
 
150
 
        switch (tag) {
151
 
        case TAG_TUNE:
152
 
                return en50221_app_dvb_parse_tune(dvb, slot_id,
153
 
                                                  session_number, data + 3,
154
 
                                                  data_length - 3);
155
 
        case TAG_REPLACE:
156
 
                return en50221_app_dvb_parse_replace(dvb, slot_id,
157
 
                                                     session_number,
158
 
                                                     data + 3,
159
 
                                                     data_length - 3);
160
 
        case TAG_CLEAR_REPLACE:
161
 
                return en50221_app_dvb_parse_clear_replace(dvb, slot_id,
162
 
                                                           session_number,
163
 
                                                           data + 3,
164
 
                                                           data_length - 3);
165
 
        }
166
 
 
167
 
        print(LOG_LEVEL, ERROR, 1, "Received unexpected tag %x\n", tag);
168
 
        return -1;
169
 
}
170
 
 
171
 
 
172
 
 
173
 
 
174
 
 
175
 
 
176
 
 
177
 
 
178
 
 
179
 
 
180
 
static int en50221_app_dvb_parse_tune(struct en50221_app_dvb *dvb,
181
 
                                      uint8_t slot_id,
182
 
                                      uint16_t session_number,
183
 
                                      uint8_t * data, uint32_t data_length)
184
 
{
185
 
        // validate data
186
 
        if (data_length < 9) {
187
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
188
 
                return -1;
189
 
        }
190
 
        if (data[0] != 8) {
191
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
192
 
                return -1;
193
 
        }
194
 
        uint8_t *tune_data = data + 1;
195
 
 
196
 
        // parse it
197
 
        uint16_t network_id = (tune_data[0] << 8) | tune_data[1];
198
 
        uint16_t original_network_id = (tune_data[2] << 8) | tune_data[3];
199
 
        uint16_t transport_stream_id = (tune_data[4] << 8) | tune_data[5];
200
 
        uint16_t service_id = (tune_data[6] << 8) | tune_data[7];
201
 
 
202
 
        // tell the app
203
 
        pthread_mutex_lock(&dvb->lock);
204
 
        en50221_app_dvb_tune_callback cb = dvb->tune_callback;
205
 
        void *cb_arg = dvb->tune_callback_arg;
206
 
        pthread_mutex_unlock(&dvb->lock);
207
 
        if (cb) {
208
 
                return cb(cb_arg, slot_id, session_number, network_id,
209
 
                          original_network_id, transport_stream_id,
210
 
                          service_id);
211
 
        }
212
 
        return 0;
213
 
}
214
 
 
215
 
static int en50221_app_dvb_parse_replace(struct en50221_app_dvb *dvb,
216
 
                                         uint8_t slot_id,
217
 
                                         uint16_t session_number,
218
 
                                         uint8_t * data,
219
 
                                         uint32_t data_length)
220
 
{
221
 
        // validate data
222
 
        if (data_length < 6) {
223
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
224
 
                return -1;
225
 
        }
226
 
        if (data[0] != 5) {
227
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
228
 
                return -1;
229
 
        }
230
 
        uint8_t *replace_data = data + 1;
231
 
 
232
 
        // parse it
233
 
        uint8_t replacement_ref = replace_data[0];
234
 
        uint16_t replace_pid =
235
 
            ((replace_data[1] & 0x1f) << 8) | replace_data[2];
236
 
        uint16_t replacement_pid =
237
 
            ((replace_data[3] & 0x1f) << 8) | replace_data[4];
238
 
 
239
 
        // tell the app
240
 
        pthread_mutex_lock(&dvb->lock);
241
 
        en50221_app_dvb_replace_callback cb = dvb->replace_callback;
242
 
        void *cb_arg = dvb->replace_callback_arg;
243
 
        pthread_mutex_unlock(&dvb->lock);
244
 
        if (cb) {
245
 
                return cb(cb_arg, slot_id, session_number, replacement_ref,
246
 
                          replace_pid, replacement_pid);
247
 
        }
248
 
        return 0;
249
 
}
250
 
 
251
 
static int en50221_app_dvb_parse_clear_replace(struct en50221_app_dvb *dvb,
252
 
                                               uint8_t slot_id,
253
 
                                               uint16_t session_number,
254
 
                                               uint8_t * data,
255
 
                                               uint32_t data_length)
256
 
{
257
 
        // validate data
258
 
        if (data_length < 2) {
259
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
260
 
                return -1;
261
 
        }
262
 
        if (data[0] != 1) {
263
 
                print(LOG_LEVEL, ERROR, 1, "Received short data\n");
264
 
                return -1;
265
 
        }
266
 
        uint8_t *replace_data = data + 1;
267
 
 
268
 
        // parse it
269
 
        uint8_t replacement_ref = replace_data[0];
270
 
 
271
 
        // tell the app
272
 
        pthread_mutex_lock(&dvb->lock);
273
 
        en50221_app_dvb_clear_replace_callback cb =
274
 
            dvb->clear_replace_callback;
275
 
        void *cb_arg = dvb->clear_replace_callback_arg;
276
 
        pthread_mutex_unlock(&dvb->lock);
277
 
        if (cb) {
278
 
                return cb(cb_arg, slot_id, session_number,
279
 
                          replacement_ref);
280
 
        }
281
 
        return 0;
282
 
}