[deb_ffmpeg.git] / ffmpeg / libavdevice / iec61883.c

/*
 * 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

    char *device_guid;                  ///< to select one of multiple DV devices

    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;

#if THREADS
    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) {
        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:
#if THREADS
    pthread_cond_broadcast(&dv->cond);
    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;

#if THREADS
    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");
#if THREADS
            pthread_mutex_lock(&dv->mutex);
            dv->eof = 1;
            pthread_cond_broadcast(&dv->cond);
            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);
    pkt->destruct = av_destruct_packet;
    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;
        size = avpriv_mpegts_parse_packet(dv->mpeg_demux, pkt, packet->buf,
                                          packet->len);
        dv->queue_first = packet->next;
        av_free(packet->buf);
        av_free(packet);
        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;
    uint64_t guid = 0;

    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;
    }

    inport = strtol(context->filename, &endptr, 10);
    if (endptr != context->filename && *endptr == '\0') {
        av_log(context, AV_LOG_INFO, "Selecting IEEE1394 port: %d\n", inport);
        j = inport;
        nb_ports = inport + 1;
    } else if (strcmp(context->filename, "auto")) {
        av_log(context, AV_LOG_ERROR, "Invalid input \"%s\", you should specify "
               "\"auto\" for auto-detection, or the port number.\n", context->filename);
        goto fail;
    }

    if (dv->device_guid) {
        if (sscanf(dv->device_guid, "%llx", (long long unsigned int *)&guid) != 1) {
            av_log(context, AV_LOG_INFO, "Invalid dvguid parameter: %s\n",
                   dv->device_guid);
            goto fail;
        }
    }

    for (; j < nb_ports && port==-1; ++j) {
        raw1394_destroy_handle(dv->raw1394);

        if (!(dv->raw1394 = raw1394_new_handle_on_port(j))) {
            av_log(context, AV_LOG_ERROR, "Failed setting IEEE1394 port.\n");
            goto fail;
        }

        for (i=0; i<raw1394_get_nodecount(dv->raw1394); ++i) {

            /* 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;
                }
                rom1394_free_directory(&rom_dir);
            }
        }
    }

    if (port == -1) {
        av_log(context, AV_LOG_ERROR, "No AV/C devices found.\n");
        goto fail;
    }

    /* Provide bus sanity for multiple connections */

    iec61883_cmp_normalize_output(dv->raw1394, 0xffc0 | dv->node);

    /* 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;

    if (dv->type == IEC61883_HDV) {

        /* Init HDV receive */

        avformat_new_stream(context, NULL);

        dv->mpeg_demux = avpriv_mpegts_parse_open(context);
        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;
    pthread_mutex_init(&dv->mutex, NULL);
    pthread_cond_init(&dv->cond, NULL);
    pthread_create(&dv->receive_task_thread, NULL, iec61883_receive_task, dv);
#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
     */

#if THREADS
    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

    if (dv->type == IEC61883_HDV) {
        iec61883_mpeg2_recv_stop(dv->iec61883_mpeg2);
        iec61883_mpeg2_close(dv->iec61883_mpeg2);
        avpriv_mpegts_parse_close(dv->mpeg_demux);
    } 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;
        av_free(packet->buf);
        av_free(packet);
    }

    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[] = {
    { "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" },
    { "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" },
    { "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 },
    { "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 },
    { NULL },
};

static const AVClass iec61883_class = {
    .class_name = "iec61883 indev",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
};

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,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2012 Georg Lippitsch <georg.lippitsch@gmx.at>
	3	*
	4	* This file is part of FFmpeg.
	5	*
	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.
	10	*
	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.
	15	*
	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
	19	*/
	20
	21	/**
	22	* @file
	23	* libiec61883 interface
	24	*/
	25
	26	#include <sys/poll.h>
	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"
	34	#include "avdevice.h"
	35
	36	#define THREADS HAVE_PTHREADS
	37
	38	#if THREADS
	39	#include <pthread.h>
	40	#endif
	41
	42	#define MOTDCT_SPEC_ID 0x00005068
	43	#define IEC61883_AUTO 0
	44	#define IEC61883_DV 1
	45	#define IEC61883_HDV 2
	46
	47	/**
	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.
	51	*/
	52	typedef struct DVPacket {
	53	uint8_t *buf; ///< actual buffer data
	54	int len; ///< size of buffer allocated
	55	struct DVPacket *next; ///< next DVPacket
	56	} DVPacket;
	57
	58	struct iec61883_data {
	59	AVClass *class;
	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
	63
	64	DVDemuxContext *dv_demux; ///< generic DV muxing/demuxing context
65	MpegTSContext *mpeg_demux; ///< generic HDV muxing/demuxing context
66
67	DVPacket *queue_first; ///< first element of packet queue
68	DVPacket *queue_last; ///< last element of packet queue
69
70	char *device_guid; ///< to select one of multiple DV devices
71
72	int packets; ///< Number of packets queued
73	int max_packets; ///< Max. number of packets in queue
74
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
85
86	struct pollfd raw1394_poll; ///< to poll for new data from libraw1394
87
88	/** Parse function for DV/HDV differs, so this is set before packets arrive */
89	int (parse_queue)(struct iec61883_data dv, AVPacket *pkt);
90
91	#if THREADS
92	pthread_t receive_task_thread;
93	pthread_mutex_t mutex;
94	pthread_cond_t cond;
95	#endif
96	};
97
98	static int iec61883_callback(unsigned char *data, int length,
99	int complete, void *callback_data)
100	{
101	struct iec61883_data *dv = callback_data;
102	DVPacket *packet;
103	int ret;
104
105	#if THREADS
106	pthread_mutex_lock(&dv->mutex);
107	#endif
108
109	if (dv->packets >= dv->max_packets) {
110	av_log(NULL, AV_LOG_ERROR, "DV packet queue overrun, dropping.\n");
111	ret = 0;
112	goto exit;
113	}
114
115	packet = av_mallocz(sizeof(*packet));
116	if (!packet) {
117	ret = -1;
118	goto exit;
119	}
120
121	packet->buf = av_malloc(length);
122	if (!packet->buf) {
123	ret = -1;
124	goto exit;
125	}
126	packet->len = length;
127
128	memcpy(packet->buf, data, length);
129
130	if (dv->queue_first) {
131	dv->queue_last->next = packet;
132	dv->queue_last = packet;
133	} else {
134	dv->queue_first = packet;
135	dv->queue_last = packet;
136	}
137	dv->packets++;
138
139	ret = 0;
140
141	exit:
142	#if THREADS
143	pthread_cond_broadcast(&dv->cond);
144	pthread_mutex_unlock(&dv->mutex);
145	#endif
146	return ret;
147	}
148
149	static void iec61883_receive_task(void opaque)
150	{
151	struct iec61883_data dv = (struct iec61883_data )opaque;
152	int result;
153
154	#if THREADS
155	while (dv->thread_loop)
156	#endif
157	{
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);
162	return NULL;
163	}
164	}
165	if (result > 0 && ((dv->raw1394_poll.revents & POLLIN)
166	\|\| (dv->raw1394_poll.revents & POLLPRI))) {
167	dv->receiving = 1;
168	raw1394_loop_iterate(dv->raw1394);
169	} else if (dv->receiving) {
170	av_log(NULL, AV_LOG_ERROR, "No more input data available\n");
171	#if THREADS
172	pthread_mutex_lock(&dv->mutex);
173	dv->eof = 1;
174	pthread_cond_broadcast(&dv->cond);
175	pthread_mutex_unlock(&dv->mutex);
176	#else
177	dv->eof = 1;
178	#endif
179	return NULL;
180	}
181	}
182
183	return NULL;
184	}
185
186	static int iec61883_parse_queue_dv(struct iec61883_data dv, AVPacket pkt)
187	{
188	DVPacket *packet;
189	int size;
190
191	size = avpriv_dv_get_packet(dv->dv_demux, pkt);
192	if (size > 0)
193	return size;
194
195	packet = dv->queue_first;
196	if (!packet)
197	return -1;
198
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;
203	av_free(packet);
204	dv->packets--;
205
206	if (size > 0)
207	return size;
208
209	return -1;
210	}
211
212	static int iec61883_parse_queue_hdv(struct iec61883_data dv, AVPacket pkt)
213	{
214	DVPacket *packet;
215	int size;
216
217	while (dv->queue_first) {
218	packet = dv->queue_first;
219	size = avpriv_mpegts_parse_packet(dv->mpeg_demux, pkt, packet->buf,
220	packet->len);
221	dv->queue_first = packet->next;
222	av_free(packet->buf);
223	av_free(packet);
224	dv->packets--;
225
226	if (size > 0)
227	return size;
228	}
229
230	return -1;
231	}
232
233	static int iec61883_read_header(AVFormatContext *context)
234	{
235	struct iec61883_data *dv = context->priv_data;
236	struct raw1394_portinfo pinf[16];
237	rom1394_directory rom_dir;
238	char *endptr;
239	int inport;
240	int nb_ports;
241	int port = -1;
242	int response;
243	int i, j = 0;
244	uint64_t guid = 0;
245
246	dv->input_port = -1;
247	dv->output_port = -1;
248	dv->channel = -1;
249
250	dv->raw1394 = raw1394_new_handle();
251
252	if (!dv->raw1394) {
253	av_log(context, AV_LOG_ERROR, "Failed to open IEEE1394 interface.\n");
254	return AVERROR(EIO);
255	}
256
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");
259	goto fail;
260	}
261
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);
265	j = 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);
270	goto fail;
271	}
272
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",
276	dv->device_guid);
277	goto fail;
278	}
279	}
280
281	for (; j < nb_ports && port==-1; ++j) {
282	raw1394_destroy_handle(dv->raw1394);
283
284	if (!(dv->raw1394 = raw1394_new_handle_on_port(j))) {
285	av_log(context, AV_LOG_ERROR, "Failed setting IEEE1394 port.\n");
286	goto fail;
287	}
288
289	for (i=0; i<raw1394_get_nodecount(dv->raw1394); ++i) {
290
291	/* Select device explicitly by GUID */
292
293	if (guid > 1) {
294	if (guid == rom1394_get_guid(dv->raw1394, i)) {
295	dv->node = i;
296	port = j;
297	break;
298	}
299	} else {
300
301	/* Select first AV/C tape recorder player node */
302
303	if (rom1394_get_directory(dv->raw1394, i, &rom_dir) < 0)
304	continue;
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);
309	dv->node = i;
310	port = j;
311	break;
312	}
313	rom1394_free_directory(&rom_dir);
314	}
315	}
316	}
317
318	if (port == -1) {
319	av_log(context, AV_LOG_ERROR, "No AV/C devices found.\n");
320	goto fail;
321	}
322
323	/* Provide bus sanity for multiple connections */
324
325	iec61883_cmp_normalize_output(dv->raw1394, 0xffc0 \| dv->node);
326
327	/* Find out if device is DV or HDV */
328
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 \|
335	0xFF, 2);
336	response = AVC1394_GET_OPERAND0(response);
337	dv->type = (response == 0x10 \|\| response == 0x90 \|\| response == 0x1A \|\| response == 0x9A) ?
338	IEC61883_HDV : IEC61883_DV;
339	}
340
341	/* Connect to device, and do initialization */
342
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);
346
347	if (dv->channel < 0)
348	dv->channel = 63;
349
350	if (!dv->max_packets)
351	dv->max_packets = 100;
352
353	if (dv->type == IEC61883_HDV) {
354
355	/* Init HDV receive */
356
357	avformat_new_stream(context, NULL);
358
359	dv->mpeg_demux = avpriv_mpegts_parse_open(context);
360	if (!dv->mpeg_demux)
361	goto fail;
362
363	dv->parse_queue = iec61883_parse_queue_hdv;
364
365	dv->iec61883_mpeg2 = iec61883_mpeg2_recv_init(dv->raw1394,
366	(iec61883_mpeg2_recv_t)iec61883_callback,
367	dv);
368
369	dv->max_packets *= 766;
370	} else {
371
372	/* Init DV receive */
373
374	dv->dv_demux = avpriv_dv_init_demux(context);
375	if (!dv->dv_demux)
376	goto fail;
377
378	dv->parse_queue = iec61883_parse_queue_dv;
379
380	dv->iec61883_dv = iec61883_dv_fb_init(dv->raw1394, iec61883_callback, dv);
381	}
382
383	dv->raw1394_poll.fd = raw1394_get_fd(dv->raw1394);
384	dv->raw1394_poll.events = POLLIN \| POLLERR \| POLLHUP \| POLLPRI;
385
386	/* Actually start receiving */
387
388	if (dv->type == IEC61883_HDV)
389	iec61883_mpeg2_recv_start(dv->iec61883_mpeg2, dv->channel);
390	else
391	iec61883_dv_fb_start(dv->iec61883_dv, dv->channel);
392
393	#if THREADS
394	dv->thread_loop = 1;
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);
398	#endif
399
400	return 0;
401
402	fail:
403	raw1394_destroy_handle(dv->raw1394);
404	return AVERROR(EIO);
405	}
406
407	static int iec61883_read_packet(AVFormatContext context, AVPacket pkt)
408	{
409	struct iec61883_data *dv = context->priv_data;
410	int size;
411
412	/**
413	* Try to parse frames from queue
414	*/
415
416	#if THREADS
417	pthread_mutex_lock(&dv->mutex);
418	while ((size = dv->parse_queue(dv, pkt)) == -1)
419	if (!dv->eof)
420	pthread_cond_wait(&dv->cond, &dv->mutex);
421	else
422	break;
423	pthread_mutex_unlock(&dv->mutex);
424	#else
425	int result;
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;
430	}
431	#endif
432
433	return size;
434	}
435
436	static int iec61883_close(AVFormatContext *context)
437	{
438	struct iec61883_data *dv = context->priv_data;
439
440	#if THREADS
441	dv->thread_loop = 0;
442	pthread_join(dv->receive_task_thread, NULL);
443	pthread_cond_destroy(&dv->cond);
444	pthread_mutex_destroy(&dv->mutex);
445	#endif
446
447	if (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);
451	} else {
452	iec61883_dv_fb_stop(dv->iec61883_dv);
453	iec61883_dv_fb_close(dv->iec61883_dv);
454	}
455	while (dv->queue_first) {
456	DVPacket *packet = dv->queue_first;
457	dv->queue_first = packet->next;
458	av_free(packet->buf);
459	av_free(packet);
460	}
461
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);
465
466	raw1394_destroy_handle(dv->raw1394);
467
468	return 0;
469	}
470
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 },
478	{ NULL },
479	};
480
481	static const AVClass iec61883_class = {
482	.class_name = "iec61883 indev",
483	.item_name = av_default_item_name,
484	.option = options,
485	.version = LIBAVUTIL_VERSION_INT,
486	.category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
487	};
488
489	AVInputFormat ff_iec61883_demuxer = {
490	.name = "iec61883",
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,
498	};