git.sesse.net Git - ffmpeg/blob - libavdevice/iec61883.c

   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 <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 + AV_INPUT_BUFFER_PADDING_SIZE);
 122     if (!packet->buf) {
 123         av_free(packet);
 124         ret = -1;
 125         goto exit;
 126     }
 127     packet->len = length;
 128
 129     memcpy(packet->buf, data, length);
 130     memset(packet->buf + length, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 131
 132     if (dv->queue_first) {
 133         dv->queue_last->next = packet;
 134         dv->queue_last = packet;
 135     } else {
 136         dv->queue_first = packet;
 137         dv->queue_last = packet;
 138     }
 139     dv->packets++;
 140
 141     ret = 0;
 142
 143 exit:
 144 #if THREADS
 145     pthread_cond_broadcast(&dv->cond);
 146     pthread_mutex_unlock(&dv->mutex);
 147 #endif
 148     return ret;
 149 }
 150
 151 static void *iec61883_receive_task(void *opaque)
 152 {
 153     struct iec61883_data *dv = (struct iec61883_data *)opaque;
 154     int result;
 155
 156 #if THREADS
 157     while (dv->thread_loop)
 158 #endif
 159     {
 160         while ((result = poll(&dv->raw1394_poll, 1, 200)) < 0) {
 161             if (!(errno == EAGAIN || errno == EINTR)) {
 162                 av_log(NULL, AV_LOG_ERROR, "Raw1394 poll error occurred.\n");
 163                 dv->receive_error = AVERROR(EIO);
 164                 return NULL;
 165             }
 166         }
 167         if (result > 0 && ((dv->raw1394_poll.revents & POLLIN)
 168                            || (dv->raw1394_poll.revents & POLLPRI))) {
 169             dv->receiving = 1;
 170             raw1394_loop_iterate(dv->raw1394);
 171         } else if (dv->receiving) {
 172             av_log(NULL, AV_LOG_ERROR, "No more input data available\n");
 173 #if THREADS
 174             pthread_mutex_lock(&dv->mutex);
 175             dv->eof = 1;
 176             pthread_cond_broadcast(&dv->cond);
 177             pthread_mutex_unlock(&dv->mutex);
 178 #else
 179             dv->eof = 1;
 180 #endif
 181             return NULL;
 182         }
 183     }
 184
 185     return NULL;
 186 }
 187
 188 static int iec61883_parse_queue_dv(struct iec61883_data *dv, AVPacket *pkt)
 189 {
 190     DVPacket *packet;
 191     int size;
 192
 193     size = avpriv_dv_get_packet(dv->dv_demux, pkt);
 194     if (size > 0)
 195         return size;
 196
 197     packet = dv->queue_first;
 198     if (!packet)
 199         return -1;
 200
 201     size = avpriv_dv_produce_packet(dv->dv_demux, pkt,
 202                                     packet->buf, packet->len, -1);
 203     dv->queue_first = packet->next;
 204     if (size < 0)
 205         av_free(packet->buf);
 206     av_free(packet);
 207     dv->packets--;
 208
 209     if (size < 0)
 210         return -1;
 211
 212     if (av_packet_from_data(pkt, pkt->data, pkt->size) < 0) {
 213         av_freep(&pkt->data);
 214         av_packet_unref(pkt);
 215         return -1;
 216     }
 217
 218     return size;
 219 }
 220
 221 static int iec61883_parse_queue_hdv(struct iec61883_data *dv, AVPacket *pkt)
 222 {
 223     DVPacket *packet;
 224     int size;
 225
 226     while (dv->queue_first) {
 227         packet = dv->queue_first;
 228         size = avpriv_mpegts_parse_packet(dv->mpeg_demux, pkt, packet->buf,
 229                                           packet->len);
 230         dv->queue_first = packet->next;
 231         av_freep(&packet->buf);
 232         av_freep(&packet);
 233         dv->packets--;
 234
 235         if (size > 0)
 236             return size;
 237     }
 238
 239     return -1;
 240 }
 241
 242 static int iec61883_read_header(AVFormatContext *context)
 243 {
 244     struct iec61883_data *dv = context->priv_data;
 245     struct raw1394_portinfo pinf[16];
 246     rom1394_directory rom_dir;
 247     char *endptr;
 248     int inport;
 249     int nb_ports;
 250     int port = -1;
 251     int response;
 252     int i, j = 0;
 253     uint64_t guid = 0;
 254
 255     dv->input_port = -1;
 256     dv->output_port = -1;
 257     dv->channel = -1;
 258
 259     dv->raw1394 = raw1394_new_handle();
 260
 261     if (!dv->raw1394) {
 262         av_log(context, AV_LOG_ERROR, "Failed to open IEEE1394 interface.\n");
 263         return AVERROR(EIO);
 264     }
 265
 266     if ((nb_ports = raw1394_get_port_info(dv->raw1394, pinf, 16)) < 0) {
 267         av_log(context, AV_LOG_ERROR, "Failed to get number of IEEE1394 ports.\n");
 268         goto fail;
 269     }
 270
 271     inport = strtol(context->url, &endptr, 10);
 272     if (endptr != context->url && *endptr == '\0') {
 273         av_log(context, AV_LOG_INFO, "Selecting IEEE1394 port: %d\n", inport);
 274         j = inport;
 275         nb_ports = inport + 1;
 276     } else if (strcmp(context->url, "auto")) {
 277         av_log(context, AV_LOG_ERROR, "Invalid input \"%s\", you should specify "
 278                "\"auto\" for auto-detection, or the port number.\n", context->url);
 279         goto fail;
 280     }
 281
 282     if (dv->device_guid) {
 283         if (sscanf(dv->device_guid, "%"SCNu64, &guid) != 1) {
 284             av_log(context, AV_LOG_INFO, "Invalid dvguid parameter: %s\n",
 285                    dv->device_guid);
 286             goto fail;
 287         }
 288     }
 289
 290     for (; j < nb_ports && port==-1; ++j) {
 291         raw1394_destroy_handle(dv->raw1394);
 292
 293         if (!(dv->raw1394 = raw1394_new_handle_on_port(j))) {
 294             av_log(context, AV_LOG_ERROR, "Failed setting IEEE1394 port.\n");
 295             goto fail;
 296         }
 297
 298         for (i=0; i<raw1394_get_nodecount(dv->raw1394); ++i) {
 299
 300             /* Select device explicitly by GUID */
 301
 302             if (guid > 1) {
 303                 if (guid == rom1394_get_guid(dv->raw1394, i)) {
 304                     dv->node = i;
 305                     port = j;
 306                     break;
 307                 }
 308             } else {
 309
 310                 /* Select first AV/C tape recorder player node */
 311
 312                 if (rom1394_get_directory(dv->raw1394, i, &rom_dir) < 0)
 313                     continue;
 314                 if (((rom1394_get_node_type(&rom_dir) == ROM1394_NODE_TYPE_AVC) &&
 315                      avc1394_check_subunit_type(dv->raw1394, i, AVC1394_SUBUNIT_TYPE_VCR)) ||
 316                     (rom_dir.unit_spec_id == MOTDCT_SPEC_ID)) {
 317                     rom1394_free_directory(&rom_dir);
 318                     dv->node = i;
 319                     port = j;
 320                     break;
 321                 }
 322                 rom1394_free_directory(&rom_dir);
 323             }
 324         }
 325     }
 326
 327     if (port == -1) {
 328         av_log(context, AV_LOG_ERROR, "No AV/C devices found.\n");
 329         goto fail;
 330     }
 331
 332     /* Provide bus sanity for multiple connections */
 333
 334     iec61883_cmp_normalize_output(dv->raw1394, 0xffc0 | dv->node);
 335
 336     /* Find out if device is DV or HDV */
 337
 338     if (dv->type == IEC61883_AUTO) {
 339         response = avc1394_transaction(dv->raw1394, dv->node,
 340                                        AVC1394_CTYPE_STATUS |
 341                                        AVC1394_SUBUNIT_TYPE_TAPE_RECORDER |
 342                                        AVC1394_SUBUNIT_ID_0 |
 343                                        AVC1394_VCR_COMMAND_OUTPUT_SIGNAL_MODE |
 344                                        0xFF, 2);
 345         response = AVC1394_GET_OPERAND0(response);
 346         dv->type = (response == 0x10 || response == 0x90 || response == 0x1A || response == 0x9A) ?
 347             IEC61883_HDV : IEC61883_DV;
 348     }
 349
 350     /* Connect to device, and do initialization */
 351
 352     dv->channel = iec61883_cmp_connect(dv->raw1394, dv->node, &dv->output_port,
 353                                        raw1394_get_local_id(dv->raw1394),
 354                                        &dv->input_port, &dv->bandwidth);
 355
 356     if (dv->channel < 0)
 357         dv->channel = 63;
 358
 359     if (!dv->max_packets)
 360         dv->max_packets = 100;
 361
 362     if (CONFIG_MPEGTS_DEMUXER && dv->type == IEC61883_HDV) {
 363
 364         /* Init HDV receive */
 365
 366         avformat_new_stream(context, NULL);
 367
 368         dv->mpeg_demux = avpriv_mpegts_parse_open(context);
 369         if (!dv->mpeg_demux)
 370             goto fail;
 371
 372         dv->parse_queue = iec61883_parse_queue_hdv;
 373
 374         dv->iec61883_mpeg2 = iec61883_mpeg2_recv_init(dv->raw1394,
 375                                                       (iec61883_mpeg2_recv_t)iec61883_callback,
 376                                                       dv);
 377
 378         dv->max_packets *= 766;
 379     } else {
 380
 381         /* Init DV receive */
 382
 383         dv->dv_demux = avpriv_dv_init_demux(context);
 384         if (!dv->dv_demux)
 385             goto fail;
 386
 387         dv->parse_queue = iec61883_parse_queue_dv;
 388
 389         dv->iec61883_dv = iec61883_dv_fb_init(dv->raw1394, iec61883_callback, dv);
 390     }
 391
 392     dv->raw1394_poll.fd = raw1394_get_fd(dv->raw1394);
 393     dv->raw1394_poll.events = POLLIN | POLLERR | POLLHUP | POLLPRI;
 394
 395     /* Actually start receiving */
 396
 397     if (dv->type == IEC61883_HDV)
 398         iec61883_mpeg2_recv_start(dv->iec61883_mpeg2, dv->channel);
 399     else
 400         iec61883_dv_fb_start(dv->iec61883_dv, dv->channel);
 401
 402 #if THREADS
 403     dv->thread_loop = 1;
 404     if (pthread_mutex_init(&dv->mutex, NULL))
 405         goto fail;
 406     if (pthread_cond_init(&dv->cond, NULL))
 407         goto fail;
 408     if (pthread_create(&dv->receive_task_thread, NULL, iec61883_receive_task, dv))
 409         goto fail;
 410 #endif
 411
 412     return 0;
 413
 414 fail:
 415     raw1394_destroy_handle(dv->raw1394);
 416     return AVERROR(EIO);
 417 }
 418
 419 static int iec61883_read_packet(AVFormatContext *context, AVPacket *pkt)
 420 {
 421     struct iec61883_data *dv = context->priv_data;
 422     int size;
 423
 424     /**
 425      * Try to parse frames from queue
 426      */
 427
 428 #if THREADS
 429     pthread_mutex_lock(&dv->mutex);
 430     while ((size = dv->parse_queue(dv, pkt)) == -1)
 431         if (!dv->eof)
 432             pthread_cond_wait(&dv->cond, &dv->mutex);
 433         else
 434             break;
 435     pthread_mutex_unlock(&dv->mutex);
 436 #else
 437     int result;
 438     while ((size = dv->parse_queue(dv, pkt)) == -1) {
 439         iec61883_receive_task((void *)dv);
 440         if (dv->receive_error)
 441             return dv->receive_error;
 442     }
 443 #endif
 444
 445     return size;
 446 }
 447
 448 static int iec61883_close(AVFormatContext *context)
 449 {
 450     struct iec61883_data *dv = context->priv_data;
 451
 452 #if THREADS
 453     dv->thread_loop = 0;
 454     pthread_join(dv->receive_task_thread, NULL);
 455     pthread_cond_destroy(&dv->cond);
 456     pthread_mutex_destroy(&dv->mutex);
 457 #endif
 458
 459     if (CONFIG_MPEGTS_DEMUXER && dv->type == IEC61883_HDV) {
 460         iec61883_mpeg2_recv_stop(dv->iec61883_mpeg2);
 461         iec61883_mpeg2_close(dv->iec61883_mpeg2);
 462         avpriv_mpegts_parse_close(dv->mpeg_demux);
 463     } else {
 464         iec61883_dv_fb_stop(dv->iec61883_dv);
 465         iec61883_dv_fb_close(dv->iec61883_dv);
 466         av_freep(&dv->dv_demux);
 467     }
 468     while (dv->queue_first) {
 469         DVPacket *packet = dv->queue_first;
 470         dv->queue_first = packet->next;
 471         av_freep(&packet->buf);
 472         av_freep(&packet);
 473     }
 474
 475     iec61883_cmp_disconnect(dv->raw1394, dv->node, dv->output_port,
 476                             raw1394_get_local_id(dv->raw1394),
 477                             dv->input_port, dv->channel, dv->bandwidth);
 478
 479     raw1394_destroy_handle(dv->raw1394);
 480
 481     return 0;
 482 }
 483
 484 static const AVOption options[] = {
 485     { "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" },
 486     { "auto",   "auto detect DV/HDV", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_AUTO}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
 487     { "dv",     "force device being treated as DV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_DV},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
 488     { "hdv" ,   "force device being treated as HDV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_HDV},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
 489     { "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 },
 490     { "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 },
 491     { NULL },
 492 };
 493
 494 static const AVClass iec61883_class = {
 495     .class_name = "iec61883 indev",
 496     .item_name  = av_default_item_name,
 497     .option     = options,
 498     .version    = LIBAVUTIL_VERSION_INT,
 499     .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
 500 };
 501
 502 const AVInputFormat ff_iec61883_demuxer = {
 503     .name           = "iec61883",
 504     .long_name      = NULL_IF_CONFIG_SMALL("libiec61883 (new DV1394) A/V input device"),
 505     .priv_data_size = sizeof(struct iec61883_data),
 506     .read_header    = iec61883_read_header,
 507     .read_packet    = iec61883_read_packet,
 508     .read_close     = iec61883_close,
 509     .flags          = AVFMT_NOFILE,
 510     .priv_class     = &iec61883_class,
 511 };