2 * Copyright (c) 2012 Georg Lippitsch <georg.lippitsch@gmx.at>
4 * This file is part of FFmpeg.
6 * FFmpeg 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.
11 * FFmpeg 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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * libiec61883 interface
27 #include <libraw1394/raw1394.h>
28 #include <libavc1394/avc1394.h>
29 #include <libavc1394/rom1394.h>
30 #include <libiec61883/iec61883.h>
31 #include "libavformat/dv.h"
32 #include "libavformat/mpegts.h"
33 #include "libavutil/opt.h"
36 #define THREADS HAVE_PTHREADS
42 #define MOTDCT_SPEC_ID 0x00005068
43 #define IEC61883_AUTO 0
45 #define IEC61883_HDV 2
48 * For DV, one packet corresponds exactly to one frame.
49 * For HDV, these are MPEG2 transport stream packets.
50 * The queue is implemented as linked list.
52 typedef struct DVPacket
{
53 uint8_t *buf
; ///< actual buffer data
54 int len
; ///< size of buffer allocated
55 struct DVPacket
*next
; ///< next DVPacket
58 struct iec61883_data
{
60 raw1394handle_t raw1394
; ///< handle for libraw1394
61 iec61883_dv_fb_t iec61883_dv
; ///< handle for libiec61883 when used with DV
62 iec61883_mpeg2_t iec61883_mpeg2
; ///< handle for libiec61883 when used with HDV
64 DVDemuxContext
*dv_demux
; ///< generic DV muxing/demuxing context
65 MpegTSContext
*mpeg_demux
; ///< generic HDV muxing/demuxing context
67 DVPacket
*queue_first
; ///< first element of packet queue
68 DVPacket
*queue_last
; ///< last element of packet queue
70 char *device_guid
; ///< to select one of multiple DV devices
72 int packets
; ///< Number of packets queued
73 int max_packets
; ///< Max. number of packets in queue
75 int bandwidth
; ///< returned by libiec61883
76 int channel
; ///< returned by libiec61883
77 int input_port
; ///< returned by libiec61883
78 int type
; ///< Stream type, to distinguish DV/HDV
79 int node
; ///< returned by libiec61883
80 int output_port
; ///< returned by libiec61883
81 int thread_loop
; ///< Condition for thread while-loop
82 int receiving
; ///< True as soon data from device available
83 int receive_error
; ///< Set in receive task in case of error
84 int eof
; ///< True as soon as no more data available
86 struct pollfd raw1394_poll
; ///< to poll for new data from libraw1394
88 /** Parse function for DV/HDV differs, so this is set before packets arrive */
89 int (*parse_queue
)(struct iec61883_data
*dv
, AVPacket
*pkt
);
92 pthread_t receive_task_thread
;
93 pthread_mutex_t mutex
;
98 static int iec61883_callback(unsigned char *data
, int length
,
99 int complete
, void *callback_data
)
101 struct iec61883_data
*dv
= callback_data
;
106 pthread_mutex_lock(&dv
->mutex
);
109 if (dv
->packets
>= dv
->max_packets
) {
110 av_log(NULL
, AV_LOG_ERROR
, "DV packet queue overrun, dropping.\n");
115 packet
= av_mallocz(sizeof(*packet
));
121 packet
->buf
= av_malloc(length
);
126 packet
->len
= length
;
128 memcpy(packet
->buf
, data
, length
);
130 if (dv
->queue_first
) {
131 dv
->queue_last
->next
= packet
;
132 dv
->queue_last
= packet
;
134 dv
->queue_first
= packet
;
135 dv
->queue_last
= packet
;
143 pthread_cond_broadcast(&dv
->cond
);
144 pthread_mutex_unlock(&dv
->mutex
);
149 static void *iec61883_receive_task(void *opaque
)
151 struct iec61883_data
*dv
= (struct iec61883_data
*)opaque
;
155 while (dv
->thread_loop
)
158 while ((result
= poll(&dv
->raw1394_poll
, 1, 200)) < 0) {
159 if (!(errno
== EAGAIN
|| errno
== EINTR
)) {
160 av_log(NULL
, AV_LOG_ERROR
, "Raw1394 poll error occurred.\n");
161 dv
->receive_error
= AVERROR(EIO
);
165 if (result
> 0 && ((dv
->raw1394_poll
.revents
& POLLIN
)
166 || (dv
->raw1394_poll
.revents
& POLLPRI
))) {
168 raw1394_loop_iterate(dv
->raw1394
);
169 } else if (dv
->receiving
) {
170 av_log(NULL
, AV_LOG_ERROR
, "No more input data available\n");
172 pthread_mutex_lock(&dv
->mutex
);
174 pthread_cond_broadcast(&dv
->cond
);
175 pthread_mutex_unlock(&dv
->mutex
);
186 static int iec61883_parse_queue_dv(struct iec61883_data
*dv
, AVPacket
*pkt
)
191 size
= avpriv_dv_get_packet(dv
->dv_demux
, pkt
);
195 packet
= dv
->queue_first
;
199 size
= avpriv_dv_produce_packet(dv
->dv_demux
, pkt
,
200 packet
->buf
, packet
->len
, -1);
201 pkt
->destruct
= av_destruct_packet
;
202 dv
->queue_first
= packet
->next
;
212 static int iec61883_parse_queue_hdv(struct iec61883_data
*dv
, AVPacket
*pkt
)
217 while (dv
->queue_first
) {
218 packet
= dv
->queue_first
;
219 size
= avpriv_mpegts_parse_packet(dv
->mpeg_demux
, pkt
, packet
->buf
,
221 dv
->queue_first
= packet
->next
;
222 av_freep(&packet
->buf
);
233 static int iec61883_read_header(AVFormatContext
*context
)
235 struct iec61883_data
*dv
= context
->priv_data
;
236 struct raw1394_portinfo pinf
[16];
237 rom1394_directory rom_dir
;
247 dv
->output_port
= -1;
250 dv
->raw1394
= raw1394_new_handle();
253 av_log(context
, AV_LOG_ERROR
, "Failed to open IEEE1394 interface.\n");
257 if ((nb_ports
= raw1394_get_port_info(dv
->raw1394
, pinf
, 16)) < 0) {
258 av_log(context
, AV_LOG_ERROR
, "Failed to get number of IEEE1394 ports.\n");
262 inport
= strtol(context
->filename
, &endptr
, 10);
263 if (endptr
!= context
->filename
&& *endptr
== '\0') {
264 av_log(context
, AV_LOG_INFO
, "Selecting IEEE1394 port: %d\n", inport
);
266 nb_ports
= inport
+ 1;
267 } else if (strcmp(context
->filename
, "auto")) {
268 av_log(context
, AV_LOG_ERROR
, "Invalid input \"%s\", you should specify "
269 "\"auto\" for auto-detection, or the port number.\n", context
->filename
);
273 if (dv
->device_guid
) {
274 if (sscanf(dv
->device_guid
, "%llx", (long long unsigned int *)&guid
) != 1) {
275 av_log(context
, AV_LOG_INFO
, "Invalid dvguid parameter: %s\n",
281 for (; j
< nb_ports
&& port
==-1; ++j
) {
282 raw1394_destroy_handle(dv
->raw1394
);
284 if (!(dv
->raw1394
= raw1394_new_handle_on_port(j
))) {
285 av_log(context
, AV_LOG_ERROR
, "Failed setting IEEE1394 port.\n");
289 for (i
=0; i
<raw1394_get_nodecount(dv
->raw1394
); ++i
) {
291 /* Select device explicitly by GUID */
294 if (guid
== rom1394_get_guid(dv
->raw1394
, i
)) {
301 /* Select first AV/C tape recorder player node */
303 if (rom1394_get_directory(dv
->raw1394
, i
, &rom_dir
) < 0)
305 if (((rom1394_get_node_type(&rom_dir
) == ROM1394_NODE_TYPE_AVC
) &&
306 avc1394_check_subunit_type(dv
->raw1394
, i
, AVC1394_SUBUNIT_TYPE_VCR
)) ||
307 (rom_dir
.unit_spec_id
== MOTDCT_SPEC_ID
)) {
308 rom1394_free_directory(&rom_dir
);
313 rom1394_free_directory(&rom_dir
);
319 av_log(context
, AV_LOG_ERROR
, "No AV/C devices found.\n");
323 /* Provide bus sanity for multiple connections */
325 iec61883_cmp_normalize_output(dv
->raw1394
, 0xffc0 | dv
->node
);
327 /* Find out if device is DV or HDV */
329 if (dv
->type
== IEC61883_AUTO
) {
330 response
= avc1394_transaction(dv
->raw1394
, dv
->node
,
331 AVC1394_CTYPE_STATUS
|
332 AVC1394_SUBUNIT_TYPE_TAPE_RECORDER
|
333 AVC1394_SUBUNIT_ID_0
|
334 AVC1394_VCR_COMMAND_OUTPUT_SIGNAL_MODE
|
336 response
= AVC1394_GET_OPERAND0(response
);
337 dv
->type
= (response
== 0x10 || response
== 0x90 || response
== 0x1A || response
== 0x9A) ?
338 IEC61883_HDV
: IEC61883_DV
;
341 /* Connect to device, and do initialization */
343 dv
->channel
= iec61883_cmp_connect(dv
->raw1394
, dv
->node
, &dv
->output_port
,
344 raw1394_get_local_id(dv
->raw1394
),
345 &dv
->input_port
, &dv
->bandwidth
);
350 if (!dv
->max_packets
)
351 dv
->max_packets
= 100;
353 if (CONFIG_MPEGTS_DEMUXER
&& dv
->type
== IEC61883_HDV
) {
355 /* Init HDV receive */
357 avformat_new_stream(context
, NULL
);
359 dv
->mpeg_demux
= avpriv_mpegts_parse_open(context
);
363 dv
->parse_queue
= iec61883_parse_queue_hdv
;
365 dv
->iec61883_mpeg2
= iec61883_mpeg2_recv_init(dv
->raw1394
,
366 (iec61883_mpeg2_recv_t
)iec61883_callback
,
369 dv
->max_packets
*= 766;
372 /* Init DV receive */
374 dv
->dv_demux
= avpriv_dv_init_demux(context
);
378 dv
->parse_queue
= iec61883_parse_queue_dv
;
380 dv
->iec61883_dv
= iec61883_dv_fb_init(dv
->raw1394
, iec61883_callback
, dv
);
383 dv
->raw1394_poll
.fd
= raw1394_get_fd(dv
->raw1394
);
384 dv
->raw1394_poll
.events
= POLLIN
| POLLERR
| POLLHUP
| POLLPRI
;
386 /* Actually start receiving */
388 if (dv
->type
== IEC61883_HDV
)
389 iec61883_mpeg2_recv_start(dv
->iec61883_mpeg2
, dv
->channel
);
391 iec61883_dv_fb_start(dv
->iec61883_dv
, dv
->channel
);
395 pthread_mutex_init(&dv
->mutex
, NULL
);
396 pthread_cond_init(&dv
->cond
, NULL
);
397 pthread_create(&dv
->receive_task_thread
, NULL
, iec61883_receive_task
, dv
);
403 raw1394_destroy_handle(dv
->raw1394
);
407 static int iec61883_read_packet(AVFormatContext
*context
, AVPacket
*pkt
)
409 struct iec61883_data
*dv
= context
->priv_data
;
413 * Try to parse frames from queue
417 pthread_mutex_lock(&dv
->mutex
);
418 while ((size
= dv
->parse_queue(dv
, pkt
)) == -1)
420 pthread_cond_wait(&dv
->cond
, &dv
->mutex
);
423 pthread_mutex_unlock(&dv
->mutex
);
426 while ((size
= dv
->parse_queue(dv
, pkt
)) == -1) {
427 iec61883_receive_task((void *)dv
);
428 if (dv
->receive_error
)
429 return dv
->receive_error
;
436 static int iec61883_close(AVFormatContext
*context
)
438 struct iec61883_data
*dv
= context
->priv_data
;
442 pthread_join(dv
->receive_task_thread
, NULL
);
443 pthread_cond_destroy(&dv
->cond
);
444 pthread_mutex_destroy(&dv
->mutex
);
447 if (CONFIG_MPEGTS_DEMUXER
&& dv
->type
== IEC61883_HDV
) {
448 iec61883_mpeg2_recv_stop(dv
->iec61883_mpeg2
);
449 iec61883_mpeg2_close(dv
->iec61883_mpeg2
);
450 avpriv_mpegts_parse_close(dv
->mpeg_demux
);
452 iec61883_dv_fb_stop(dv
->iec61883_dv
);
453 iec61883_dv_fb_close(dv
->iec61883_dv
);
455 while (dv
->queue_first
) {
456 DVPacket
*packet
= dv
->queue_first
;
457 dv
->queue_first
= packet
->next
;
458 av_freep(&packet
->buf
);
462 iec61883_cmp_disconnect(dv
->raw1394
, dv
->node
, dv
->output_port
,
463 raw1394_get_local_id(dv
->raw1394
),
464 dv
->input_port
, dv
->channel
, dv
->bandwidth
);
466 raw1394_destroy_handle(dv
->raw1394
);
471 static const AVOption options
[] = {
472 { "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" },
473 { "auto", "auto detect DV/HDV", 0, AV_OPT_TYPE_CONST
, {.i64
= IEC61883_AUTO
}, 0, 0, AV_OPT_FLAG_DECODING_PARAM
, "dvtype" },
474 { "dv", "force device being treated as DV device", 0, AV_OPT_TYPE_CONST
, {.i64
= IEC61883_DV
}, 0, 0, AV_OPT_FLAG_DECODING_PARAM
, "dvtype" },
475 { "hdv" , "force device being treated as HDV device", 0, AV_OPT_TYPE_CONST
, {.i64
= IEC61883_HDV
}, 0, 0, AV_OPT_FLAG_DECODING_PARAM
, "dvtype" },
476 { "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
},
477 { "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
},
481 static const AVClass iec61883_class
= {
482 .class_name
= "iec61883 indev",
483 .item_name
= av_default_item_name
,
485 .version
= LIBAVUTIL_VERSION_INT
,
486 .category
= AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
,
489 AVInputFormat ff_iec61883_demuxer
= {
491 .long_name
= NULL_IF_CONFIG_SMALL("libiec61883 (new DV1394) A/V input device"),
492 .priv_data_size
= sizeof(struct iec61883_data
),
493 .read_header
= iec61883_read_header
,
494 .read_packet
= iec61883_read_packet
,
495 .read_close
= iec61883_close
,
496 .flags
= AVFMT_NOFILE
,
497 .priv_class
= &iec61883_class
,