Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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