access: dtv: add en50221_capmt
[vlc.git] / modules / access / dv.c
1 /*****************************************************************************
2  * dv.c: Digital video/Firewire input (file: access plug-in)
3  *****************************************************************************
4  * Copyright (C) 2005 M2X
5  * $Id$
6  *
7  * Authors: Jean-Paul Saman <jpsaman at m2x dot nl>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (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 License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <assert.h>
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_access.h>
36
37 #include <errno.h>
38 #include <sys/types.h>
39 #include <unistd.h>
40 #include <sys/poll.h>
41
42 #include <libraw1394/raw1394.h>
43 #include <libraw1394/csr.h>
44 #include <libavc1394/avc1394.h>
45 #include <libavc1394/avc1394_vcr.h>
46 #include <libavc1394/rom1394.h>
47
48 /*****************************************************************************
49  * Module descriptor
50  *****************************************************************************/
51 static int  Open ( vlc_object_t * );
52 static void Close( vlc_object_t * );
53 static block_t *Block( access_t * );
54 static int Control( access_t *, int, va_list );
55
56 vlc_module_begin ()
57     set_description( N_("Digital Video (Firewire/ieee1394) input") )
58     set_shortname( N_("DV") )
59     set_category( CAT_INPUT )
60     set_subcategory( SUBCAT_INPUT_ACCESS )
61     set_capability( "access", 0 )
62     add_shortcut( "dv", "raw1394" )
63     set_callbacks( Open, Close )
64 vlc_module_end ()
65
66 typedef struct
67 {
68     vlc_thread_t    thread;
69     access_t        *p_access;
70     vlc_mutex_t     lock;
71     block_t         *p_frame;
72     block_t         **pp_last;
73
74 } event_thread_t;
75
76 static void* Raw1394EventThread( void * );
77 static enum raw1394_iso_disposition
78 Raw1394Handler(raw1394handle_t, unsigned char *,
79         unsigned int, unsigned char,
80         unsigned char, unsigned char, unsigned int,
81         unsigned int);
82
83 static int Raw1394GetNumPorts( access_t *p_access );
84 static raw1394handle_t Raw1394Open( access_t *, int );
85 static void Raw1394Close( raw1394handle_t );
86
87 static int DiscoverAVC( access_t *, int *, uint64_t );
88 static raw1394handle_t AVCOpen( access_t *, int );
89 static void AVCClose( access_t * );
90 static int AVCResetHandler( raw1394handle_t, unsigned int );
91 static int AVCPlay( access_t *, int );
92 static int AVCPause( access_t *, int );
93 static int AVCStop( access_t *, int );
94
95 struct access_sys_t
96 {
97     raw1394handle_t p_avc1394;
98     raw1394handle_t p_raw1394;
99     struct pollfd   raw1394_poll;
100
101     int i_cards;
102     int i_node;
103     int i_port;
104     int i_channel;
105     uint64_t i_guid;
106
107     /* event */
108     event_thread_t *p_ev;
109     vlc_mutex_t lock;
110     block_t *p_frame;
111 };
112
113 #define ISOCHRONOUS_QUEUE_LENGTH 1000
114 #define ISOCHRONOUS_MAX_PACKET_SIZE 4096
115
116 /*****************************************************************************
117  * Open: open the file
118  *****************************************************************************/
119 static int Open( vlc_object_t *p_this )
120 {
121     access_t     *p_access = (access_t*)p_this;
122     access_sys_t *p_sys;
123
124     struct raw1394_portinfo port_inf[ 16 ];
125
126     msg_Dbg( p_access, "opening device" );
127
128     /* Set up p_access */
129     access_InitFields( p_access );
130     ACCESS_SET_CALLBACKS( NULL, Block, Control, NULL );
131
132     p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
133     if( !p_sys )
134         return VLC_EGENERIC;
135
136     p_sys->i_cards = 0;
137     p_sys->i_node = 0;
138     p_sys->i_port = 0;
139     p_sys->i_guid = 0;
140     p_sys->i_channel = 63;
141     p_sys->p_raw1394 = NULL;
142     p_sys->p_avc1394 = NULL;
143     p_sys->p_frame = NULL;
144     p_sys->p_ev = NULL;
145
146     vlc_mutex_init( &p_sys->lock );
147
148     p_sys->i_node = DiscoverAVC( p_access, &p_sys->i_port, p_sys->i_guid );
149     if( p_sys->i_node < 0 )
150     {
151         msg_Err( p_access, "failed to open a Firewire (IEEE1394) connection" );
152         Close( p_this );
153         return VLC_EGENERIC;
154     }
155
156     p_sys->p_avc1394 = AVCOpen( p_access, p_sys->i_port );
157     if( !p_sys->p_avc1394 )
158     {
159         msg_Err( p_access, "no Digital Video Control device found" );
160         Close( p_this );
161         return VLC_EGENERIC;
162     }
163
164     p_sys->p_raw1394 = raw1394_new_handle();
165     if( !p_sys->p_raw1394 )
166     {
167         msg_Err( p_access, "no Digital Video device found" );
168         Close( p_this );
169         return VLC_EGENERIC;
170     }
171
172     p_sys->i_cards = raw1394_get_port_info( p_sys->p_raw1394, port_inf, 16 );
173     if( p_sys->i_cards < 0 )
174     {
175         msg_Err( p_access, "failed to get port info" );
176         Close( p_this );
177         return VLC_EGENERIC;
178     }
179
180     if( raw1394_set_port( p_sys->p_raw1394, p_sys->i_port ) < 0 )
181     {
182         msg_Err( p_access, "failed to set port info" );
183         Close( p_this );
184         return VLC_EGENERIC;
185     }
186
187     if ( raw1394_iso_recv_init( p_sys->p_raw1394, Raw1394Handler,
188                 ISOCHRONOUS_QUEUE_LENGTH, ISOCHRONOUS_MAX_PACKET_SIZE,
189                 p_sys->i_channel, RAW1394_DMA_PACKET_PER_BUFFER, -1 ) < 0 )
190     {
191         msg_Err( p_access, "failed to init isochronous recv" );
192         Close( p_this );
193         return VLC_EGENERIC;
194     }
195
196     raw1394_set_userdata( p_sys->p_raw1394, p_access );
197     raw1394_iso_recv_start( p_sys->p_raw1394, -1, -1, 0 );
198
199     p_sys->raw1394_poll.fd = raw1394_get_fd( p_sys->p_raw1394 );
200     p_sys->raw1394_poll.events = POLLIN | POLLPRI;
201
202     /* Now create our event thread catcher */
203     p_sys->p_ev = calloc( 1, sizeof( *p_sys->p_ev ) );
204     if( !p_sys->p_ev )
205     {
206         msg_Err( p_access, "failed to create event thread struct" );
207         Close( p_this );
208         return VLC_ENOMEM;
209     }
210
211     p_sys->p_ev->p_frame = NULL;
212     p_sys->p_ev->pp_last = &p_sys->p_ev->p_frame;
213     p_sys->p_ev->p_access = p_access;
214     vlc_mutex_init( &p_sys->p_ev->lock );
215     if( vlc_clone( &p_sys->p_ev->thread, Raw1394EventThread,
216                p_sys->p_ev, VLC_THREAD_PRIORITY_OUTPUT ) )
217     {
218         msg_Err( p_access, "failed to clone event thread" );
219         Close( p_this );
220         return VLC_EGENERIC;
221     }
222
223     return VLC_SUCCESS;
224 }
225
226 /*****************************************************************************
227  * Close: free unused data structures
228  *****************************************************************************/
229 static void Close( vlc_object_t *p_this )
230 {
231     access_t     *p_access = (access_t*)p_this;
232     access_sys_t *p_sys = p_access->p_sys;
233
234     if( p_sys->p_ev )
235     {
236         /* stop the event handler */
237         vlc_cancel( p_sys->p_ev->thread );
238
239         if( p_sys->p_raw1394 )
240             raw1394_iso_shutdown( p_sys->p_raw1394 );
241
242         vlc_join( p_sys->p_ev->thread, NULL );
243         vlc_mutex_destroy( &p_sys->p_ev->lock );
244
245         /* Cleanup frame data */
246         if( p_sys->p_ev->p_frame )
247         {
248             block_ChainRelease( p_sys->p_ev->p_frame );
249             p_sys->p_ev->p_frame = NULL;
250             p_sys->p_ev->pp_last = &p_sys->p_frame;
251         }
252         free( p_sys->p_ev );
253     }
254
255     if( p_sys->p_frame )
256         block_ChainRelease( p_sys->p_frame );
257     if( p_sys->p_raw1394 )
258         raw1394_destroy_handle( p_sys->p_raw1394 );
259
260     AVCClose( p_access );
261
262     vlc_mutex_destroy( &p_sys->lock );
263     free( p_sys );
264 }
265
266 /*****************************************************************************
267  * Control:
268  *****************************************************************************/
269 static int Control( access_t *p_access, int i_query, va_list args )
270 {
271     switch( i_query )
272     {
273         /* */
274         case ACCESS_CAN_PAUSE:
275             *va_arg( args, bool* ) = true;
276             break;
277
278        case ACCESS_CAN_SEEK:
279        case ACCESS_CAN_FASTSEEK:
280        case ACCESS_CAN_CONTROL_PACE:
281             *va_arg( args, bool* ) = false;
282             break;
283
284         case ACCESS_GET_PTS_DELAY:
285             *va_arg( args, int64_t * ) =
286                 INT64_C(1000) * var_InheritInteger( p_access, "live-caching" );
287             break;
288
289         /* */
290         case ACCESS_SET_PAUSE_STATE:
291             AVCPause( p_access, p_access->p_sys->i_node );
292             break;
293
294         default:
295             return VLC_EGENERIC;
296
297     }
298     return VLC_SUCCESS;
299 }
300
301 static block_t *Block( access_t *p_access )
302 {
303     access_sys_t *p_sys = p_access->p_sys;
304     block_t *p_block = NULL;
305
306     vlc_mutex_lock( &p_sys->lock );
307     p_block = p_sys->p_frame;
308     //msg_Dbg( p_access, "sending frame %p", (void *)p_block );
309     p_sys->p_frame = NULL;
310     vlc_mutex_unlock( &p_sys->lock );
311
312     return p_block;
313 }
314
315 static void Raw1394EventThreadCleanup( void *obj )
316 {
317     event_thread_t *p_ev = (event_thread_t *)obj;
318
319     AVCStop( p_ev->p_access, p_ev->p_access->p_sys->i_node );
320 }
321
322 static void* Raw1394EventThread( void *obj )
323 {
324     event_thread_t *p_ev = (event_thread_t *)obj;
325     access_t *p_access = (access_t *) p_ev->p_access;
326     access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
327     int result = 0;
328     int canc = vlc_savecancel();
329
330     AVCPlay( p_access, p_sys->i_node );
331     vlc_cleanup_push( Raw1394EventThreadCleanup, p_ev );
332     vlc_restorecancel( canc );
333
334     for( ;; )
335     {
336         while( ( result = poll( &p_sys->raw1394_poll, 1, -1 ) ) < 0 )
337         {
338             if( errno != EINTR )
339                 msg_Err( p_access, "poll error: %s", vlc_strerror_c(errno) );
340         }
341
342         if( result > 0 && ( ( p_sys->raw1394_poll.revents & POLLIN )
343                          || ( p_sys->raw1394_poll.revents & POLLPRI ) ) )
344         {
345             canc = vlc_savecancel();
346             result = raw1394_loop_iterate( p_sys->p_raw1394 );
347             vlc_restorecancel( canc );
348         }
349     }
350
351     vlc_cleanup_pop();
352     vlc_assert_unreachable();
353 }
354
355 static enum raw1394_iso_disposition
356 Raw1394Handler(raw1394handle_t handle, unsigned char *data,
357         unsigned int length, unsigned char channel,
358         unsigned char tag, unsigned char sy, unsigned int cycle,
359         unsigned int dropped)
360 {
361     access_t *p_access = NULL;
362     access_sys_t *p_sys = NULL;
363     block_t *p_block = NULL;
364     VLC_UNUSED(channel); VLC_UNUSED(tag);
365     VLC_UNUSED(sy); VLC_UNUSED(cycle); VLC_UNUSED(dropped);
366
367     p_access = (access_t *) raw1394_get_userdata( handle );
368     if( !p_access ) return 0;
369
370     p_sys = p_access->p_sys;
371
372     /* skip empty packets */
373     if( length > 16 )
374     {
375         unsigned char * p = data + 8;
376         int section_type = p[ 0 ] >> 5;           /* section type is in bits 5 - 7 */
377         int dif_sequence = p[ 1 ] >> 4;           /* dif sequence number is in bits 4 - 7 */
378         int dif_block = p[ 2 ];
379
380         vlc_mutex_lock( &p_sys->p_ev->lock );
381
382         /* if we are at the beginning of a frame, we put the previous
383            frame in our output_queue. */
384         if( (section_type == 0) && (dif_sequence == 0) )
385         {
386             vlc_mutex_lock( &p_sys->lock );
387             if( p_sys->p_ev->p_frame )
388             {
389                 /* Push current frame to p_access thread. */
390                 //p_sys->p_ev->p_frame->i_pts = mdate();
391                 block_ChainAppend( &p_sys->p_frame, p_sys->p_ev->p_frame );
392             }
393             /* reset list */
394             p_sys->p_ev->p_frame = block_Alloc( 144000 );
395             p_sys->p_ev->pp_last = &p_sys->p_frame;
396             vlc_mutex_unlock( &p_sys->lock );
397         }
398
399         p_block = p_sys->p_ev->p_frame;
400         if( p_block )
401         {
402             switch ( section_type )
403             {
404             case 0:    /* 1 Header block */
405                 /* p[3] |= 0x80; // hack to force PAL data */
406                 memcpy( p_block->p_buffer + dif_sequence * 150 * 80, p, 480 );
407                 break;
408
409             case 1:    /* 2 Subcode blocks */
410                 memcpy( p_block->p_buffer + dif_sequence * 150 * 80 + ( 1 + dif_block ) * 80, p, 480 );
411                 break;
412
413             case 2:    /* 3 VAUX blocks */
414                 memcpy( p_block->p_buffer + dif_sequence * 150 * 80 + ( 3 + dif_block ) * 80, p, 480 );
415                 break;
416
417             case 3:    /* 9 Audio blocks interleaved with video */
418                 memcpy( p_block->p_buffer + dif_sequence * 150 * 80 + ( 6 + dif_block * 16 ) * 80, p, 480 );
419                 break;
420
421             case 4:    /* 135 Video blocks interleaved with audio */
422                 memcpy( p_block->p_buffer + dif_sequence * 150 * 80 + ( 7 + ( dif_block / 15 ) + dif_block ) * 80, p, 480 );
423                 break;
424
425             default:    /* we canĀ“t handle any other data */
426                 block_Release( p_block );
427                 p_block = NULL;
428                 break;
429             }
430         }
431
432         vlc_mutex_unlock( &p_sys->p_ev->lock );
433     }
434     return 0;
435 }
436
437 /*
438  * Routing borrowed from dvgrab-1.8
439  * Copyright by Arne Schirmacher <dvgrab@schirmacher.de>
440  * Dan Dennedy <dan@dennedy.org> and others
441  */
442 static int Raw1394GetNumPorts( access_t *p_access )
443 {
444     int n_ports;
445     struct raw1394_portinfo pinf[ 16 ];
446     raw1394handle_t handle;
447
448     /* get a raw1394 handle */
449     if( !( handle = raw1394_new_handle() ) )
450     {
451         msg_Err( p_access, "raw1394 - failed to get handle: %s",
452                  vlc_strerror_c(errno) );
453         return VLC_EGENERIC;
454     }
455
456     if( ( n_ports = raw1394_get_port_info( handle, pinf, 16 ) ) < 0 )
457     {
458         msg_Err( p_access, "raw1394 - failed to get port info: %s",
459                  vlc_strerror_c(errno) );
460         raw1394_destroy_handle( handle );
461         return VLC_EGENERIC;
462     }
463     raw1394_destroy_handle( handle );
464
465     return n_ports;
466 }
467
468 static raw1394handle_t Raw1394Open( access_t *p_access, int port )
469 {
470     int n_ports;
471     struct raw1394_portinfo pinf[ 16 ];
472     raw1394handle_t handle;
473
474     /* get a raw1394 handle */
475     handle = raw1394_new_handle();
476     if( !handle )
477     {
478         msg_Err( p_access, "raw1394 - failed to get handle: %s",
479                  vlc_strerror_c(errno) );
480         return NULL;
481     }
482
483     if( ( n_ports = raw1394_get_port_info( handle, pinf, 16 ) ) < 0 )
484     {
485         msg_Err( p_access, "raw1394 - failed to get port info: %s",
486                  vlc_strerror_c(errno) );
487         raw1394_destroy_handle( handle );
488         return NULL;
489     }
490
491     /* tell raw1394 which host adapter to use */
492     if( raw1394_set_port( handle, port ) < 0 )
493     {
494         msg_Err( p_access, "raw1394 - failed to set set port: %s",
495                  vlc_strerror_c(errno) );
496         return NULL;
497     }
498
499     return handle;
500 }
501
502 static void Raw1394Close( raw1394handle_t handle )
503 {
504     raw1394_destroy_handle( handle );
505 }
506
507 static int DiscoverAVC( access_t *p_access, int* port, uint64_t guid )
508 {
509     rom1394_directory rom_dir;
510     raw1394handle_t handle = NULL;
511     int device = -1;
512     int i, j = 0;
513     int m = Raw1394GetNumPorts( p_access );
514
515     if( *port >= 0 )
516     {
517         /* search on explicit port */
518         j = *port;
519         m = *port + 1;
520     }
521
522     for( ; j < m && device == -1; j++ )
523     {
524         handle = Raw1394Open( p_access, j );
525         if( !handle )
526             return -1;
527
528         for( i = 0; i < raw1394_get_nodecount( handle ); ++i )
529         {
530             if( guid != 0 )
531             {
532                 /* select explicitly by GUID */
533                 if( guid == rom1394_get_guid( handle, i ) )
534                 {
535                     device = i;
536                     *port = j;
537                     break;
538                 }
539             }
540             else
541             {
542                 /* select first AV/C Tape Reccorder Player node */
543                 if( rom1394_get_directory( handle, i, &rom_dir ) < 0 )
544                 {
545                     msg_Err( p_access, "error reading config rom directory for node %d", i );
546                     continue;
547                 }
548                 if( ( rom1394_get_node_type( &rom_dir ) == ROM1394_NODE_TYPE_AVC ) &&
549                         avc1394_check_subunit_type( handle, i, AVC1394_SUBUNIT_TYPE_VCR ) )
550                 {
551                     device = i;
552                     *port = j;
553                     break;
554                 }
555             }
556         }
557         Raw1394Close( handle );
558     }
559
560     return device;
561 }
562
563 /*
564  * Handle AVC commands
565  */
566 static raw1394handle_t AVCOpen( access_t *p_access, int port )
567 {
568     access_sys_t *p_sys = p_access->p_sys;
569     struct raw1394_portinfo pinf[ 16 ];
570     int numcards;
571
572     p_sys->p_avc1394 = raw1394_new_handle();
573     if( !p_sys->p_avc1394 )
574         return NULL;
575
576     numcards = raw1394_get_port_info( p_sys->p_avc1394, pinf, 16 );
577     if( numcards < -1 )
578         return NULL;
579     if( raw1394_set_port( p_sys->p_avc1394, port ) < 0 )
580         return NULL;
581
582     raw1394_set_bus_reset_handler( p_sys->p_avc1394, AVCResetHandler );
583
584     return  p_sys->p_avc1394;
585 }
586
587 static void AVCClose( access_t *p_access )
588 {
589     access_sys_t *p_sys = p_access->p_sys;
590
591     if( p_sys->p_avc1394 )
592     {
593         raw1394_destroy_handle( p_sys->p_avc1394 );
594         p_sys->p_avc1394 = NULL;
595     }
596 }
597
598 static int AVCResetHandler( raw1394handle_t handle, unsigned int generation )
599 {
600     raw1394_update_generation( handle, generation );
601     return 0;
602 }
603
604 static int AVCPlay( access_t *p_access, int phyID )
605 {
606     access_sys_t *p_sys = p_access->p_sys;
607
608     msg_Dbg( p_access, "send play command over Digital Video control channel" );
609
610     if( p_sys->p_avc1394 && phyID >= 0 )
611     {
612         if( !avc1394_vcr_is_recording( p_sys->p_avc1394, phyID ) &&
613             avc1394_vcr_is_playing( p_sys->p_avc1394, phyID ) != AVC1394_VCR_OPERAND_PLAY_FORWARD )
614                 avc1394_vcr_play( p_sys->p_avc1394, phyID );
615     }
616     return 0;
617 }
618
619 static int AVCPause( access_t *p_access, int phyID )
620 {
621     access_sys_t *p_sys = p_access->p_sys;
622
623     if( p_sys->p_avc1394 && phyID >= 0 )
624     {
625         if( !avc1394_vcr_is_recording( p_sys->p_avc1394, phyID ) &&
626             ( avc1394_vcr_is_playing( p_sys->p_avc1394, phyID ) != AVC1394_VCR_OPERAND_PLAY_FORWARD_PAUSE ) )
627                 avc1394_vcr_pause( p_sys->p_avc1394, phyID );
628     }
629     return 0;
630 }
631
632
633 static int AVCStop( access_t *p_access, int phyID )
634 {
635     access_sys_t *p_sys = p_access->p_sys;
636
637     msg_Dbg( p_access, "closing Digital Video control channel" );
638
639     if ( p_sys->p_avc1394 && phyID >= 0 )
640         avc1394_vcr_stop( p_sys->p_avc1394, phyID );
641
642     return 0;
643 }