2012-04-23 14:01:17 +00:00
/*
* Copyright ( c ) 2012 Georg Lippitsch < georg . lippitsch @ gmx . at >
*
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* FFmpeg is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
/**
* @ file
* libiec61883 interface
*/
# include <sys/poll.h>
# include <libraw1394/raw1394.h>
# include <libavc1394/avc1394.h>
# include <libavc1394/rom1394.h>
# include <libiec61883/iec61883.h>
# include "libavformat/dv.h"
# include "libavformat/mpegts.h"
# include "libavutil/opt.h"
# include "avdevice.h"
# define THREADS HAVE_PTHREADS
# if THREADS
# include <pthread.h>
# endif
# define MOTDCT_SPEC_ID 0x00005068
# define IEC61883_AUTO 0
# define IEC61883_DV 1
# define IEC61883_HDV 2
/**
* For DV , one packet corresponds exactly to one frame .
* For HDV , these are MPEG2 transport stream packets .
* The queue is implemented as linked list .
*/
typedef struct DVPacket {
uint8_t * buf ; ///< actual buffer data
int len ; ///< size of buffer allocated
struct DVPacket * next ; ///< next DVPacket
} DVPacket ;
struct iec61883_data {
AVClass * class ;
raw1394handle_t raw1394 ; ///< handle for libraw1394
iec61883_dv_fb_t iec61883_dv ; ///< handle for libiec61883 when used with DV
iec61883_mpeg2_t iec61883_mpeg2 ; ///< handle for libiec61883 when used with HDV
DVDemuxContext * dv_demux ; ///< generic DV muxing/demuxing context
MpegTSContext * mpeg_demux ; ///< generic HDV muxing/demuxing context
DVPacket * queue_first ; ///< first element of packet queue
DVPacket * queue_last ; ///< last element of packet queue
2012-07-12 21:36:05 +00:00
char * device_guid ; ///< to select one of multiple DV devices
2012-04-23 14:01:17 +00:00
int packets ; ///< Number of packets queued
int max_packets ; ///< Max. number of packets in queue
int bandwidth ; ///< returned by libiec61883
int channel ; ///< returned by libiec61883
int input_port ; ///< returned by libiec61883
int type ; ///< Stream type, to distinguish DV/HDV
int node ; ///< returned by libiec61883
int output_port ; ///< returned by libiec61883
int thread_loop ; ///< Condition for thread while-loop
int receiving ; ///< True as soon data from device available
int receive_error ; ///< Set in receive task in case of error
int eof ; ///< True as soon as no more data available
struct pollfd raw1394_poll ; ///< to poll for new data from libraw1394
/** Parse function for DV/HDV differs, so this is set before packets arrive */
int ( * parse_queue ) ( struct iec61883_data * dv , AVPacket * pkt ) ;
# if THREADS
pthread_t receive_task_thread ;
pthread_mutex_t mutex ;
pthread_cond_t cond ;
# endif
} ;
static int iec61883_callback ( unsigned char * data , int length ,
int complete , void * callback_data )
{
struct iec61883_data * dv = callback_data ;
DVPacket * packet ;
int ret ;
2014-03-05 16:21:07 +00:00
# if THREADS
2012-04-23 14:01:17 +00:00
pthread_mutex_lock ( & dv - > mutex ) ;
# endif
if ( dv - > packets > = dv - > max_packets ) {
av_log ( NULL , AV_LOG_ERROR , " DV packet queue overrun, dropping. \n " ) ;
ret = 0 ;
goto exit ;
}
packet = av_mallocz ( sizeof ( * packet ) ) ;
if ( ! packet ) {
ret = - 1 ;
goto exit ;
}
packet - > buf = av_malloc ( length ) ;
if ( ! packet - > buf ) {
2017-02-08 22:37:42 +00:00
av_free ( packet ) ;
2012-04-23 14:01:17 +00:00
ret = - 1 ;
goto exit ;
}
packet - > len = length ;
memcpy ( packet - > buf , data , length ) ;
if ( dv - > queue_first ) {
dv - > queue_last - > next = packet ;
dv - > queue_last = packet ;
} else {
dv - > queue_first = packet ;
dv - > queue_last = packet ;
}
dv - > packets + + ;
ret = 0 ;
exit :
2014-03-05 16:21:07 +00:00
# if THREADS
2012-07-12 21:36:05 +00:00
pthread_cond_broadcast ( & dv - > cond ) ;
2012-04-23 14:01:17 +00:00
pthread_mutex_unlock ( & dv - > mutex ) ;
# endif
return ret ;
}
static void * iec61883_receive_task ( void * opaque )
{
struct iec61883_data * dv = ( struct iec61883_data * ) opaque ;
int result ;
2014-03-05 16:21:07 +00:00
# if THREADS
2012-04-23 14:01:17 +00:00
while ( dv - > thread_loop )
# endif
{
while ( ( result = poll ( & dv - > raw1394_poll , 1 , 200 ) ) < 0 ) {
if ( ! ( errno = = EAGAIN | | errno = = EINTR ) ) {
av_log ( NULL , AV_LOG_ERROR , " Raw1394 poll error occurred. \n " ) ;
dv - > receive_error = AVERROR ( EIO ) ;
return NULL ;
}
}
if ( result > 0 & & ( ( dv - > raw1394_poll . revents & POLLIN )
| | ( dv - > raw1394_poll . revents & POLLPRI ) ) ) {
dv - > receiving = 1 ;
raw1394_loop_iterate ( dv - > raw1394 ) ;
} else if ( dv - > receiving ) {
av_log ( NULL , AV_LOG_ERROR , " No more input data available \n " ) ;
2014-03-05 16:21:07 +00:00
# if THREADS
2012-04-23 14:01:17 +00:00
pthread_mutex_lock ( & dv - > mutex ) ;
dv - > eof = 1 ;
2012-07-12 21:36:05 +00:00
pthread_cond_broadcast ( & dv - > cond ) ;
2012-04-23 14:01:17 +00:00
pthread_mutex_unlock ( & dv - > mutex ) ;
# else
dv - > eof = 1 ;
# endif
return NULL ;
}
}
return NULL ;
}
static int iec61883_parse_queue_dv ( struct iec61883_data * dv , AVPacket * pkt )
{
DVPacket * packet ;
int size ;
size = avpriv_dv_get_packet ( dv - > dv_demux , pkt ) ;
if ( size > 0 )
return size ;
packet = dv - > queue_first ;
if ( ! packet )
return - 1 ;
size = avpriv_dv_produce_packet ( dv - > dv_demux , pkt ,
packet - > buf , packet - > len , - 1 ) ;
dv - > queue_first = packet - > next ;
av_free ( packet ) ;
dv - > packets - - ;
if ( size > 0 )
return size ;
return - 1 ;
}
static int iec61883_parse_queue_hdv ( struct iec61883_data * dv , AVPacket * pkt )
{
DVPacket * packet ;
int size ;
while ( dv - > queue_first ) {
packet = dv - > queue_first ;
2014-08-06 23:59:56 +00:00
size = avpriv_mpegts_parse_packet ( dv - > mpeg_demux , pkt , packet - > buf ,
packet - > len ) ;
2012-04-23 14:01:17 +00:00
dv - > queue_first = packet - > next ;
2014-11-22 17:44:35 +00:00
av_freep ( & packet - > buf ) ;
av_freep ( & packet ) ;
2012-04-23 14:01:17 +00:00
dv - > packets - - ;
if ( size > 0 )
return size ;
}
return - 1 ;
}
static int iec61883_read_header ( AVFormatContext * context )
{
struct iec61883_data * dv = context - > priv_data ;
struct raw1394_portinfo pinf [ 16 ] ;
rom1394_directory rom_dir ;
char * endptr ;
int inport ;
int nb_ports ;
int port = - 1 ;
int response ;
int i , j = 0 ;
2012-07-12 21:36:05 +00:00
uint64_t guid = 0 ;
2012-04-23 14:01:17 +00:00
dv - > input_port = - 1 ;
dv - > output_port = - 1 ;
dv - > channel = - 1 ;
dv - > raw1394 = raw1394_new_handle ( ) ;
if ( ! dv - > raw1394 ) {
av_log ( context , AV_LOG_ERROR , " Failed to open IEEE1394 interface. \n " ) ;
return AVERROR ( EIO ) ;
}
if ( ( nb_ports = raw1394_get_port_info ( dv - > raw1394 , pinf , 16 ) ) < 0 ) {
av_log ( context , AV_LOG_ERROR , " Failed to get number of IEEE1394 ports. \n " ) ;
goto fail ;
}
2017-12-29 22:29:52 +00:00
inport = strtol ( context - > url , & endptr , 10 ) ;
if ( endptr ! = context - > url & & * endptr = = ' \0 ' ) {
2012-04-23 14:01:17 +00:00
av_log ( context , AV_LOG_INFO , " Selecting IEEE1394 port: %d \n " , inport ) ;
j = inport ;
nb_ports = inport + 1 ;
2017-12-29 22:29:52 +00:00
} else if ( strcmp ( context - > url , " auto " ) ) {
2012-04-23 14:01:17 +00:00
av_log ( context , AV_LOG_ERROR , " Invalid input \" %s \" , you should specify "
2017-12-29 22:29:52 +00:00
" \" auto \" for auto-detection, or the port number. \n " , context - > url ) ;
2012-04-23 14:01:17 +00:00
goto fail ;
}
2012-07-12 21:36:05 +00:00
if ( dv - > device_guid ) {
2015-06-13 07:28:41 +00:00
if ( sscanf ( dv - > device_guid , " % " SCNu64 , & guid ) ! = 1 ) {
2012-07-12 21:36:05 +00:00
av_log ( context , AV_LOG_INFO , " Invalid dvguid parameter: %s \n " ,
dv - > device_guid ) ;
goto fail ;
}
}
2012-04-23 14:01:17 +00:00
for ( ; j < nb_ports & & port = = - 1 ; + + j ) {
2012-07-12 21:36:05 +00:00
raw1394_destroy_handle ( dv - > raw1394 ) ;
if ( ! ( dv - > raw1394 = raw1394_new_handle_on_port ( j ) ) ) {
2012-04-23 14:01:17 +00:00
av_log ( context , AV_LOG_ERROR , " Failed setting IEEE1394 port. \n " ) ;
goto fail ;
}
2012-07-12 21:36:05 +00:00
2012-04-23 14:01:17 +00:00
for ( i = 0 ; i < raw1394_get_nodecount ( dv - > raw1394 ) ; + + i ) {
2012-07-12 21:36:05 +00:00
/* Select device explicitly by GUID */
if ( guid > 1 ) {
if ( guid = = rom1394_get_guid ( dv - > raw1394 , i ) ) {
dv - > node = i ;
port = j ;
break ;
}
} else {
/* Select first AV/C tape recorder player node */
if ( rom1394_get_directory ( dv - > raw1394 , i , & rom_dir ) < 0 )
continue ;
if ( ( ( rom1394_get_node_type ( & rom_dir ) = = ROM1394_NODE_TYPE_AVC ) & &
avc1394_check_subunit_type ( dv - > raw1394 , i , AVC1394_SUBUNIT_TYPE_VCR ) ) | |
( rom_dir . unit_spec_id = = MOTDCT_SPEC_ID ) ) {
rom1394_free_directory ( & rom_dir ) ;
dv - > node = i ;
port = j ;
break ;
}
2012-04-23 14:01:17 +00:00
rom1394_free_directory ( & rom_dir ) ;
}
}
}
if ( port = = - 1 ) {
av_log ( context , AV_LOG_ERROR , " No AV/C devices found. \n " ) ;
goto fail ;
}
2012-07-12 21:36:05 +00:00
/* Provide bus sanity for multiple connections */
iec61883_cmp_normalize_output ( dv - > raw1394 , 0xffc0 | dv - > node ) ;
2012-04-23 14:01:17 +00:00
/* Find out if device is DV or HDV */
if ( dv - > type = = IEC61883_AUTO ) {
response = avc1394_transaction ( dv - > raw1394 , dv - > node ,
AVC1394_CTYPE_STATUS |
AVC1394_SUBUNIT_TYPE_TAPE_RECORDER |
AVC1394_SUBUNIT_ID_0 |
AVC1394_VCR_COMMAND_OUTPUT_SIGNAL_MODE |
0xFF , 2 ) ;
response = AVC1394_GET_OPERAND0 ( response ) ;
dv - > type = ( response = = 0x10 | | response = = 0x90 | | response = = 0x1A | | response = = 0x9A ) ?
IEC61883_HDV : IEC61883_DV ;
}
/* Connect to device, and do initialization */
dv - > channel = iec61883_cmp_connect ( dv - > raw1394 , dv - > node , & dv - > output_port ,
raw1394_get_local_id ( dv - > raw1394 ) ,
& dv - > input_port , & dv - > bandwidth ) ;
if ( dv - > channel < 0 )
dv - > channel = 63 ;
if ( ! dv - > max_packets )
dv - > max_packets = 100 ;
2014-12-04 00:35:47 +00:00
if ( CONFIG_MPEGTS_DEMUXER & & dv - > type = = IEC61883_HDV ) {
2012-04-23 14:01:17 +00:00
/* Init HDV receive */
avformat_new_stream ( context , NULL ) ;
2014-08-06 23:59:56 +00:00
dv - > mpeg_demux = avpriv_mpegts_parse_open ( context ) ;
2012-04-23 14:01:17 +00:00
if ( ! dv - > mpeg_demux )
goto fail ;
dv - > parse_queue = iec61883_parse_queue_hdv ;
dv - > iec61883_mpeg2 = iec61883_mpeg2_recv_init ( dv - > raw1394 ,
( iec61883_mpeg2_recv_t ) iec61883_callback ,
dv ) ;
dv - > max_packets * = 766 ;
} else {
/* Init DV receive */
dv - > dv_demux = avpriv_dv_init_demux ( context ) ;
if ( ! dv - > dv_demux )
goto fail ;
dv - > parse_queue = iec61883_parse_queue_dv ;
dv - > iec61883_dv = iec61883_dv_fb_init ( dv - > raw1394 , iec61883_callback , dv ) ;
}
dv - > raw1394_poll . fd = raw1394_get_fd ( dv - > raw1394 ) ;
dv - > raw1394_poll . events = POLLIN | POLLERR | POLLHUP | POLLPRI ;
/* Actually start receiving */
if ( dv - > type = = IEC61883_HDV )
iec61883_mpeg2_recv_start ( dv - > iec61883_mpeg2 , dv - > channel ) ;
else
iec61883_dv_fb_start ( dv - > iec61883_dv , dv - > channel ) ;
# if THREADS
dv - > thread_loop = 1 ;
2015-06-07 16:57:55 +00:00
if ( pthread_mutex_init ( & dv - > mutex , NULL ) )
goto fail ;
if ( pthread_cond_init ( & dv - > cond , NULL ) )
goto fail ;
if ( pthread_create ( & dv - > receive_task_thread , NULL , iec61883_receive_task , dv ) )
goto fail ;
2012-04-23 14:01:17 +00:00
# endif
return 0 ;
fail :
raw1394_destroy_handle ( dv - > raw1394 ) ;
return AVERROR ( EIO ) ;
}
static int iec61883_read_packet ( AVFormatContext * context , AVPacket * pkt )
{
struct iec61883_data * dv = context - > priv_data ;
int size ;
/**
* Try to parse frames from queue
*/
2014-03-05 16:21:07 +00:00
# if THREADS
2012-04-23 14:01:17 +00:00
pthread_mutex_lock ( & dv - > mutex ) ;
while ( ( size = dv - > parse_queue ( dv , pkt ) ) = = - 1 )
if ( ! dv - > eof )
pthread_cond_wait ( & dv - > cond , & dv - > mutex ) ;
else
break ;
pthread_mutex_unlock ( & dv - > mutex ) ;
# else
int result ;
while ( ( size = dv - > parse_queue ( dv , pkt ) ) = = - 1 ) {
iec61883_receive_task ( ( void * ) dv ) ;
if ( dv - > receive_error )
return dv - > receive_error ;
}
# endif
return size ;
}
static int iec61883_close ( AVFormatContext * context )
{
struct iec61883_data * dv = context - > priv_data ;
# if THREADS
dv - > thread_loop = 0 ;
pthread_join ( dv - > receive_task_thread , NULL ) ;
pthread_cond_destroy ( & dv - > cond ) ;
pthread_mutex_destroy ( & dv - > mutex ) ;
# endif
2014-12-04 00:35:47 +00:00
if ( CONFIG_MPEGTS_DEMUXER & & dv - > type = = IEC61883_HDV ) {
2012-04-23 14:01:17 +00:00
iec61883_mpeg2_recv_stop ( dv - > iec61883_mpeg2 ) ;
iec61883_mpeg2_close ( dv - > iec61883_mpeg2 ) ;
2014-08-06 23:59:56 +00:00
avpriv_mpegts_parse_close ( dv - > mpeg_demux ) ;
2012-04-23 14:01:17 +00:00
} else {
iec61883_dv_fb_stop ( dv - > iec61883_dv ) ;
iec61883_dv_fb_close ( dv - > iec61883_dv ) ;
}
while ( dv - > queue_first ) {
DVPacket * packet = dv - > queue_first ;
dv - > queue_first = packet - > next ;
2014-11-22 17:44:35 +00:00
av_freep ( & packet - > buf ) ;
av_freep ( & packet ) ;
2012-04-23 14:01:17 +00:00
}
iec61883_cmp_disconnect ( dv - > raw1394 , dv - > node , dv - > output_port ,
raw1394_get_local_id ( dv - > raw1394 ) ,
dv - > input_port , dv - > channel , dv - > bandwidth ) ;
raw1394_destroy_handle ( dv - > raw1394 ) ;
return 0 ;
}
static const AVOption options [ ] = {
2012-09-05 12:26:01 +00:00
{ " dvtype " , " override autodetection of DV/HDV " , offsetof ( struct iec61883_data , type ) , AV_OPT_TYPE_INT , { . i64 = IEC61883_AUTO } , IEC61883_AUTO , IEC61883_HDV , AV_OPT_FLAG_DECODING_PARAM , " dvtype " } ,
2012-09-05 11:58:11 +00:00
{ " auto " , " auto detect DV/HDV " , 0 , AV_OPT_TYPE_CONST , { . i64 = IEC61883_AUTO } , 0 , 0 , AV_OPT_FLAG_DECODING_PARAM , " dvtype " } ,
{ " dv " , " force device being treated as DV device " , 0 , AV_OPT_TYPE_CONST , { . i64 = IEC61883_DV } , 0 , 0 , AV_OPT_FLAG_DECODING_PARAM , " dvtype " } ,
{ " hdv " , " force device being treated as HDV device " , 0 , AV_OPT_TYPE_CONST , { . i64 = IEC61883_HDV } , 0 , 0 , AV_OPT_FLAG_DECODING_PARAM , " dvtype " } ,
2012-09-05 12:26:01 +00:00
{ " dvbuffer " , " set queue buffer size (in packets) " , offsetof ( struct iec61883_data , max_packets ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_DECODING_PARAM } ,
2012-07-12 21:36:05 +00:00
{ " dvguid " , " select one of multiple DV devices by its GUID " , offsetof ( struct iec61883_data , device_guid ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , AV_OPT_FLAG_DECODING_PARAM } ,
2012-04-23 14:01:17 +00:00
{ NULL } ,
} ;
static const AVClass iec61883_class = {
. class_name = " iec61883 indev " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
2014-02-22 22:32:51 +00:00
. category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT ,
2012-04-23 14:01:17 +00:00
} ;
AVInputFormat ff_iec61883_demuxer = {
. name = " iec61883 " ,
. long_name = NULL_IF_CONFIG_SMALL ( " libiec61883 (new DV1394) A/V input device " ) ,
. priv_data_size = sizeof ( struct iec61883_data ) ,
. read_header = iec61883_read_header ,
. read_packet = iec61883_read_packet ,
. read_close = iec61883_close ,
. flags = AVFMT_NOFILE ,
. priv_class = & iec61883_class ,
} ;