FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
iec61883.c
Go to the documentation of this file.
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;
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 
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);
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 
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_freep(&packet->buf);
223  av_freep(&packet);
224  dv->packets--;
225 
226  if (size > 0)
227  return size;
228  }
229 
230  return -1;
231 }
232 
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) ?
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 
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 
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 
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);
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_freep(&packet->buf);
459  av_freep(&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,
487 };
488 
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 };