Debian Codegraph @

src/dv.c

raw
1 /*
2 * libiec61883 - Linux IEEE 1394 streaming media library.
3 * Copyright (C) 2004 Kristian Hogsberg, Dan Dennedy, and Dan Maas.
4 * This file written by Dan Dennedy.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include "iec61883.h"
26 #include "iec61883-private.h"
27
28 #include <stdio.h>
29 #include <errno.h>
30 #include <stdlib.h>
31 #include <netinet/in.h>
32 #include <string.h>
33 #include <assert.h>
34
35 #define DIF_BLOCK_SIZE 480
36 #define DV_CUSTOM_CIP /* packetizer and syt generation code from Dan Maas */
37
38 iec61883_dv_t
39 iec61883_dv_xmit_init (raw1394handle_t handle,
40 int is_pal,
41 iec61883_dv_xmit_t get_data,
42 void *callback_data)
43 {
44 /* DV is composed of DIF blocks, each 480 bytes */
45 int dbs = DIF_BLOCK_SIZE / sizeof (quadlet_t);
46 int fdf = is_pal ? 0x80 : 0x00;
47 int syt_interval = is_pal ? 300 : 250;
48 int rate = syt_interval * (is_pal ? 25 : 30000.0/1001.0);
49 struct iec61883_dv *dv;
50
51 assert (handle != NULL);
52 dv = malloc (sizeof (struct iec61883_dv));
53 if (!dv) {
54 errno = ENOMEM;
55 return NULL;
56 }
57
58 dv->channel = -1;
59 dv->handle = handle;
60 dv->put_data = NULL;
61 dv->get_data = get_data;
62 dv->callback_data = callback_data;
63 dv->buffer_packets = 1000;
64 dv->prebuffer_packets = 1000;
65 dv->irq_interval = 250;
66 dv->synch = 0;
67 dv->speed = RAW1394_ISO_SPEED_100;
68
69 iec61883_cip_init (&dv->cip, IEC61883_FMT_DV, fdf, rate, dbs, syt_interval);
70
71 iec61883_cip_set_transmission_mode (&dv->cip, IEC61883_MODE_NON_BLOCKING);
72
73 raw1394_set_userdata (handle, dv);
74
75 return dv;
76 }
77
78 iec61883_dv_t
79 iec61883_dv_recv_init (raw1394handle_t handle,
80 iec61883_dv_recv_t put_data,
81 void *callback_data)
82 {
83 struct iec61883_dv *dv;
84
85 assert (handle != NULL);
86 dv = malloc (sizeof (struct iec61883_dv));
87 if (!dv) {
88 errno = ENOMEM;
89 return NULL;
90 }
91
92 dv->channel = -1;
93 dv->handle = handle;
94 dv->put_data = put_data;
95 dv->get_data = NULL;
96 dv->callback_data = callback_data;
97 dv->buffer_packets = 1000;
98 dv->irq_interval = 250;
99 dv->synch = 0;
100 dv->speed = RAW1394_ISO_SPEED_100;
101
102 raw1394_set_userdata (handle, dv);
103
104 return dv;
105 }
106
107 static enum raw1394_iso_disposition
108 dv_xmit_handler (raw1394handle_t handle,
109 unsigned char *data,
110 unsigned int *len,
111 unsigned char *tag,
112 unsigned char *sy,
113 int cycle,
114 unsigned int dropped)
115 {
116 struct iec61883_dv *dv = raw1394_get_userdata (handle);
117 struct iec61883_packet *packet;
118 int n_dif_blocks;
119 int result = RAW1394_ISO_OK;
120
121 assert (dv != NULL);
122 packet = (struct iec61883_packet *) data;
123 n_dif_blocks = iec61883_cip_fill_header (handle, &dv->cip, packet);
124
125 #ifdef DV_CUSTOM_CIP
126 static const int syt_offset = 3;
127
128 static int packet_num = 0;
129 static int cip_accum = 0;
130 static int continuity_counter = 0;
131
132 unsigned int ts;
133 int cip_n = 1; /* PAL defaults */
134 int cip_d = 16;
135
136 if (dv->cip.syt_interval == 250) { /* NTSC */
137 cip_n = 68;
138 cip_d = 1068;
139 }
140 /* generate syt */
141 if (packet_num == 0) {
142 ts = cycle + syt_offset;
143 if (ts > 8000)
144 ts -= 8000;
145 ts = (ts & 0xF) << 12;
146 } else {
147 ts = 0xFFFF;
148 }
149 packet->syt = htons(ts);
150 packet->dbc = continuity_counter;
151 /* num/denom algorithm to determine empty packet rate */
152 if (cip_accum > (cip_d - cip_n)) {
153 n_dif_blocks = 0;
154 cip_accum -= (cip_d - cip_n);
155 } else {
156 n_dif_blocks = 1;
157 cip_accum += cip_n;
158 continuity_counter++;
159 if (++packet_num >= dv->cip.syt_interval) {
160 packet_num = 0;
161 }
162 }
163 #endif
164
165 dv->total_dropped += dropped;
166
167 *len = n_dif_blocks * DIF_BLOCK_SIZE + 8;
168 *tag = IEC61883_TAG_WITH_CIP;
169 *sy = 0;
170
171 if (dv->get_data != NULL &&
172 dv->get_data (packet->data, n_dif_blocks, dropped, dv->callback_data) < 0)
173 result = RAW1394_ISO_ERROR;
174
175 return result;
176 }
177
178 int
179 iec61883_dv_xmit_start (struct iec61883_dv *dv, int channel)
180 {
181 int result = 0;
182 assert (dv != NULL);
183 unsigned int max_packet_size = iec61883_cip_get_max_packet_size (&dv->cip);
184
185 result = raw1394_iso_xmit_init (dv->handle,
186 dv_xmit_handler,
187 dv->buffer_packets,
188 max_packet_size,
189 channel,
190 dv->speed,
191 dv->irq_interval);
192
193 if ( result == 0 )
194 {
195 dv->total_dropped = 0;
196 dv->channel = channel;
197 result = raw1394_iso_xmit_start (dv->handle, -1, dv->prebuffer_packets);
198 }
199
200 return result;
201 }
202
203 static enum raw1394_iso_disposition
204 dv_recv_handler (raw1394handle_t handle,
205 unsigned char *data,
206 unsigned int len,
207 unsigned char channel,
208 unsigned char tag,
209 unsigned char sy,
210 unsigned int cycle,
211 unsigned int dropped)
212 {
213 struct iec61883_dv *dv = raw1394_get_userdata (handle);
214 enum raw1394_iso_disposition result = RAW1394_ISO_OK;
215
216 assert (dv != NULL);
217 dv->total_dropped += dropped;
218
219 if (dv->put_data != NULL && /* only if callback registered */
220 channel == dv->channel && /* only for selected channel */
221 len == DIF_BLOCK_SIZE + 8) /* not empty packets */
222 {
223 if (dv->put_data (data + 8, DIF_BLOCK_SIZE, dropped, dv->callback_data) < 0)
224 result = RAW1394_ISO_ERROR;
225 }
226 if (result == RAW1394_ISO_OK && dropped)
227 result = RAW1394_ISO_DEFER;
228
229 return result;
230 }
231
232 int
233 iec61883_dv_recv_start (struct iec61883_dv *dv, int channel)
234 {
235 int result = 0;
236
237 assert (dv != NULL);
238 result = raw1394_iso_recv_init (dv->handle,
239 dv_recv_handler,
240 dv->buffer_packets,
241 DIF_BLOCK_SIZE + 8,
242 channel,
243 RAW1394_DMA_PACKET_PER_BUFFER,
244 dv->irq_interval);
245
246 if (result == 0) {
247 dv->total_dropped = 0;
248 dv->channel = channel;
249 result = raw1394_iso_recv_start (dv->handle, -1, -1, 0);
250 }
251 return result;
252 }
253
254 void
255 iec61883_dv_recv_stop (iec61883_dv_t dv)
256 {
257 assert (dv != NULL);
258 if (dv->synch)
259 raw1394_iso_recv_flush (dv->handle);
260 raw1394_iso_shutdown (dv->handle);
261 }
262
263 void
264 iec61883_dv_xmit_stop (iec61883_dv_t dv)
265 {
266 assert (dv != NULL);
267 if (dv->synch)
268 raw1394_iso_xmit_sync (dv->handle);
269 raw1394_iso_shutdown (dv->handle);
270 }
271
272 void
273 iec61883_dv_close (iec61883_dv_t dv)
274 {
275 assert (dv != NULL);
276 if (dv->put_data)
277 iec61883_dv_recv_stop (dv);
278 if (dv->get_data)
279 iec61883_dv_xmit_stop (dv);
280 free (dv);
281 }
282
283 static int
284 dv_fb_recv (unsigned char *data, int len, unsigned int dropped, void *callback_data)
285 {
286 int result = 0;
287 if (len != 480) return result;
288 struct iec61883_dv_fb *fb = (struct iec61883_dv_fb *)callback_data;
289 int section_type = data[0] >> 5; /* section type is in bits 5 - 7 */
290 int dif_sequence = data[1] >> 4; /* dif sequence number is in bits 4 - 7 */
291 int dif_block = data[2];
292
293 assert (fb != NULL);
294 /* test for start of frame */
295 if (section_type == 0 && dif_sequence == 0) {
296 /* if not waiting for the first frame */
297 if (fb->ff == 0) {
298 int total = ((fb->data[3] & 0x80) == 0 ? 250 : 300) * 480;
299 if (fb->len != total)
300 fb->total_incomplete++;
301 result = fb->put_data (fb->data, total, fb->len == total,
302 fb->callback_data);
303 fb->len = 0;
304 } else {
305 /* no longer waiting for first frame */
306 fb->ff = 0;
307 }
308 }
309 /* if not the first frame */
310 if (fb->ff == 0 && dif_sequence < 12) {
311 unsigned char *p = fb->data + dif_sequence * 150 * 80;
312 fb->len += len;
313 switch ( section_type ) {
314 case 0: /* 1 Header block */
315 memcpy( p, data, len );
316 break;
317 case 1: /* 2 Subcode blocks */
318 if (dif_block < 2)
319 memcpy( p + ( 1 + dif_block ) * 80, data, len );
320 break;
321 case 2: /* 3 VAUX blocks */
322 if (dif_block < 3)
323 memcpy( p + ( 3 + dif_block ) * 80, data, len );
324 break;
325 case 3: /* 9 Audio blocks interleaved with video */
326 if (dif_block < 9)
327 memcpy( p + ( 6 + dif_block * 16 ) * 80, data, len );
328 break;
329 case 4: /* 135 Video blocks interleaved with audio */
330 if (dif_block < 135)
331 memcpy( p + ( 7 + ( dif_block / 15 ) + dif_block ) * 80, data, len );
332 break;
333 default:
334 break;
335 }
336 }
337
338 return result;
339 }
340
341 iec61883_dv_fb_t
342 iec61883_dv_fb_init (raw1394handle_t handle,
343 iec61883_dv_fb_recv_t put_data,
344 void *callback_data)
345 {
346 struct iec61883_dv_fb *fb;
347
348 fb = malloc (sizeof( struct iec61883_dv_fb));
349 if (!fb) {
350 errno = ENOMEM;
351 return NULL;
352 }
353
354 memset (fb->data, 0, sizeof (fb->data));
355 fb->len = 0; /* tracks the bytes collected to determine if frame complete */
356 fb->ff = 1; /* indicates waiting for the start of frame */
357 fb->put_data = put_data;
358 fb->callback_data = callback_data;
359 fb->dv = iec61883_dv_recv_init (handle, dv_fb_recv, (void *)fb );
360 if (!fb->dv) {
361 free (fb);
362 return NULL;
363 }
364
365 return fb;
366 }
367
368 iec61883_dv_t
369 iec61883_dv_fb_get_dv(iec61883_dv_fb_t fb)
370 {
371 return (fb != NULL ) ? fb->dv : NULL;
372 }
373
374 int
375 iec61883_dv_fb_start (iec61883_dv_fb_t fb, int channel)
376 {
377 assert (fb != NULL);
378 return iec61883_dv_recv_start (fb->dv, channel);
379 }
380
381 void
382 iec61883_dv_fb_stop (iec61883_dv_fb_t fb)
383 {
384 assert (fb != NULL);
385 iec61883_dv_recv_stop (fb->dv);
386 }
387
388 void
389 iec61883_dv_fb_close (iec61883_dv_fb_t fb)
390 {
391 assert (fb != NULL);
392 iec61883_dv_close (fb->dv);
393 free (fb);
394 }
395
396 unsigned int
397 iec61883_dv_get_buffers (iec61883_dv_t dv)
398 {
399 assert (dv != NULL);
400 return dv->buffer_packets;
401 }
402
403 void
404 iec61883_dv_set_buffers (iec61883_dv_t dv, unsigned int packets)
405 {
406 assert (dv != NULL);
407 dv->buffer_packets = packets;
408 }
409
410 unsigned int
411 iec61883_dv_get_prebuffers (iec61883_dv_t dv)
412 {
413 assert (dv != NULL);
414 return dv->prebuffer_packets;
415 }
416
417 void
418 iec61883_dv_set_prebuffers (iec61883_dv_t dv, unsigned int packets)
419 {
420 assert (dv != NULL);
421 dv->prebuffer_packets = packets;
422 }
423
424 unsigned int
425 iec61883_dv_get_irq_interval (iec61883_dv_t dv)
426 {
427 assert (dv != NULL);
428 return dv->irq_interval;
429 }
430
431 void
432 iec61883_dv_set_irq_interval (iec61883_dv_t dv, unsigned int packets)
433 {
434 assert (dv != NULL);
435 dv->irq_interval = packets;
436 }
437
438 int
439 iec61883_dv_get_synch (iec61883_dv_t dv)
440 {
441 assert (dv != NULL);
442 return dv->synch;
443 }
444
445 void
446 iec61883_dv_set_synch (iec61883_dv_t dv, int synch)
447 {
448 assert (dv != NULL);
449 dv->synch = synch;
450 }
451
452 int
453 iec61883_dv_get_speed (iec61883_dv_t dv)
454 {
455 assert (dv != NULL);
456 return dv->speed;
457 }
458
459 void
460 iec61883_dv_set_speed (iec61883_dv_t dv, int speed)
461 {
462 assert (dv != NULL);
463 dv->speed = speed;
464 }
465
466 unsigned int
467 iec61883_dv_get_dropped (iec61883_dv_t dv)
468 {
469 assert (dv != NULL);
470 return dv->total_dropped;
471 }
472
473 void *
474 iec61883_dv_get_callback_data (iec61883_dv_t dv)
475 {
476 assert (dv != NULL);
477 return dv->callback_data;
478 }
479
480 unsigned int
481 iec61883_dv_fb_get_incomplete (iec61883_dv_fb_t fb)
482 {
483 assert (fb != NULL);
484 return fb->total_incomplete;
485 }
486
487 void *
488 iec61883_dv_fb_get_callback_data (iec61883_dv_fb_t fb)
489 {
490 assert (fb != NULL);
491 return fb->callback_data;
492 }