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 "config_components.h" 27 28#include <poll.h> 29#include <libraw1394/raw1394.h> 30#include <libavc1394/avc1394.h> 31#include <libavc1394/rom1394.h> 32#include <libiec61883/iec61883.h> 33#include "libavformat/dv.h" 34#include "libavformat/mpegts.h" 35#include "libavutil/opt.h" 36#include "avdevice.h" 37 38#define THREADS HAVE_PTHREADS 39 40#if THREADS 41#include <pthread.h> 42#endif 43 44#define MOTDCT_SPEC_ID 0x00005068 45#define IEC61883_AUTO 0 46#define IEC61883_DV 1 47#define IEC61883_HDV 2 48 49/** 50 * For DV, one packet corresponds exactly to one frame. 51 * For HDV, these are MPEG2 transport stream packets. 52 * The queue is implemented as linked list. 53 */ 54typedef struct DVPacket { 55 uint8_t *buf; ///< actual buffer data 56 int len; ///< size of buffer allocated 57 struct DVPacket *next; ///< next DVPacket 58} DVPacket; 59 60struct iec61883_data { 61 AVClass *class; 62 raw1394handle_t raw1394; ///< handle for libraw1394 63 iec61883_dv_fb_t iec61883_dv; ///< handle for libiec61883 when used with DV 64 iec61883_mpeg2_t iec61883_mpeg2; ///< handle for libiec61883 when used with HDV 65 66 DVDemuxContext *dv_demux; ///< generic DV muxing/demuxing context 67 MpegTSContext *mpeg_demux; ///< generic HDV muxing/demuxing context 68 69 DVPacket *queue_first; ///< first element of packet queue 70 DVPacket *queue_last; ///< last element of packet queue 71 72 char *device_guid; ///< to select one of multiple DV devices 73 74 int packets; ///< Number of packets queued 75 int max_packets; ///< Max. number of packets in queue 76 77 int bandwidth; ///< returned by libiec61883 78 int channel; ///< returned by libiec61883 79 int input_port; ///< returned by libiec61883 80 int type; ///< Stream type, to distinguish DV/HDV 81 int node; ///< returned by libiec61883 82 int output_port; ///< returned by libiec61883 83 int thread_loop; ///< Condition for thread while-loop 84 int receiving; ///< True as soon data from device available 85 int receive_error; ///< Set in receive task in case of error 86 int eof; ///< True as soon as no more data available 87 88 struct pollfd raw1394_poll; ///< to poll for new data from libraw1394 89 90 /** Parse function for DV/HDV differs, so this is set before packets arrive */ 91 int (*parse_queue)(struct iec61883_data *dv, AVPacket *pkt); 92 93#if THREADS 94 pthread_t receive_task_thread; 95 pthread_mutex_t mutex; 96 pthread_cond_t cond; 97#endif 98}; 99 100static int iec61883_callback(unsigned char *data, int length, 101 int complete, void *callback_data) 102{ 103 struct iec61883_data *dv = callback_data; 104 DVPacket *packet; 105 int ret; 106 107#if THREADS 108 pthread_mutex_lock(&dv->mutex); 109#endif 110 111 if (dv->packets >= dv->max_packets) { 112 av_log(NULL, AV_LOG_ERROR, "DV packet queue overrun, dropping.\n"); 113 ret = 0; 114 goto exit; 115 } 116 117 packet = av_mallocz(sizeof(*packet)); 118 if (!packet) { 119 ret = -1; 120 goto exit; 121 } 122 123 packet->buf = av_malloc(length + AV_INPUT_BUFFER_PADDING_SIZE); 124 if (!packet->buf) { 125 av_free(packet); 126 ret = -1; 127 goto exit; 128 } 129 packet->len = length; 130 131 memcpy(packet->buf, data, length); 132 memset(packet->buf + length, 0, AV_INPUT_BUFFER_PADDING_SIZE); 133 134 if (dv->queue_first) { 135 dv->queue_last->next = packet; 136 dv->queue_last = packet; 137 } else { 138 dv->queue_first = packet; 139 dv->queue_last = packet; 140 } 141 dv->packets++; 142 143 ret = 0; 144 145exit: 146#if THREADS 147 pthread_cond_broadcast(&dv->cond); 148 pthread_mutex_unlock(&dv->mutex); 149#endif 150 return ret; 151} 152 153static void *iec61883_receive_task(void *opaque) 154{ 155 struct iec61883_data *dv = (struct iec61883_data *)opaque; 156 int result; 157 158#if THREADS 159 while (dv->thread_loop) 160#endif 161 { 162 while ((result = poll(&dv->raw1394_poll, 1, 200)) < 0) { 163 if (!(errno == EAGAIN || errno == EINTR)) { 164 av_log(NULL, AV_LOG_ERROR, "Raw1394 poll error occurred.\n"); 165 dv->receive_error = AVERROR(EIO); 166 return NULL; 167 } 168 } 169 if (result > 0 && ((dv->raw1394_poll.revents & POLLIN) 170 || (dv->raw1394_poll.revents & POLLPRI))) { 171 dv->receiving = 1; 172 raw1394_loop_iterate(dv->raw1394); 173 } else if (dv->receiving) { 174 av_log(NULL, AV_LOG_ERROR, "No more input data available\n"); 175#if THREADS 176 pthread_mutex_lock(&dv->mutex); 177 dv->eof = 1; 178 pthread_cond_broadcast(&dv->cond); 179 pthread_mutex_unlock(&dv->mutex); 180#else 181 dv->eof = 1; 182#endif 183 return NULL; 184 } 185 } 186 187 return NULL; 188} 189 190static int iec61883_parse_queue_dv(struct iec61883_data *dv, AVPacket *pkt) 191{ 192 DVPacket *packet; 193 int size; 194 195 size = avpriv_dv_get_packet(dv->dv_demux, pkt); 196 if (size > 0) 197 return size; 198 199 packet = dv->queue_first; 200 if (!packet) 201 return -1; 202 203 size = avpriv_dv_produce_packet(dv->dv_demux, pkt, 204 packet->buf, packet->len, -1); 205 dv->queue_first = packet->next; 206 if (size < 0) 207 av_free(packet->buf); 208 av_free(packet); 209 dv->packets--; 210 211 if (size < 0) 212 return -1; 213 214 if (av_packet_from_data(pkt, pkt->data, pkt->size) < 0) { 215 av_freep(&pkt->data); 216 av_packet_unref(pkt); 217 return -1; 218 } 219 220 return size; 221} 222 223static int iec61883_parse_queue_hdv(struct iec61883_data *dv, AVPacket *pkt) 224{ 225#if CONFIG_MPEGTS_DEMUXER 226 DVPacket *packet; 227 int size; 228 229 while (dv->queue_first) { 230 packet = dv->queue_first; 231 size = avpriv_mpegts_parse_packet(dv->mpeg_demux, pkt, packet->buf, 232 packet->len); 233 dv->queue_first = packet->next; 234 av_freep(&packet->buf); 235 av_freep(&packet); 236 dv->packets--; 237 238 if (size > 0) 239 return size; 240 } 241#endif 242 return -1; 243} 244 245static int iec61883_read_header(AVFormatContext *context) 246{ 247 struct iec61883_data *dv = context->priv_data; 248 struct raw1394_portinfo pinf[16]; 249 rom1394_directory rom_dir; 250 char *endptr; 251 int inport; 252 int nb_ports; 253 int port = -1; 254 int response; 255 int i, j = 0; 256 uint64_t guid = 0; 257 258 dv->input_port = -1; 259 dv->output_port = -1; 260 dv->channel = -1; 261 262 dv->raw1394 = raw1394_new_handle(); 263 264 if (!dv->raw1394) { 265 av_log(context, AV_LOG_ERROR, "Failed to open IEEE1394 interface.\n"); 266 return AVERROR(EIO); 267 } 268 269 if ((nb_ports = raw1394_get_port_info(dv->raw1394, pinf, 16)) < 0) { 270 av_log(context, AV_LOG_ERROR, "Failed to get number of IEEE1394 ports.\n"); 271 goto fail; 272 } 273 274 inport = strtol(context->url, &endptr, 10); 275 if (endptr != context->url && *endptr == '\0') { 276 av_log(context, AV_LOG_INFO, "Selecting IEEE1394 port: %d\n", inport); 277 j = inport; 278 nb_ports = inport + 1; 279 } else if (strcmp(context->url, "auto")) { 280 av_log(context, AV_LOG_ERROR, "Invalid input \"%s\", you should specify " 281 "\"auto\" for auto-detection, or the port number.\n", context->url); 282 goto fail; 283 } 284 285 if (dv->device_guid) { 286 if (sscanf(dv->device_guid, "%"SCNu64, &guid) != 1) { 287 av_log(context, AV_LOG_INFO, "Invalid dvguid parameter: %s\n", 288 dv->device_guid); 289 goto fail; 290 } 291 } 292 293 for (; j < nb_ports && port==-1; ++j) { 294 raw1394_destroy_handle(dv->raw1394); 295 296 if (!(dv->raw1394 = raw1394_new_handle_on_port(j))) { 297 av_log(context, AV_LOG_ERROR, "Failed setting IEEE1394 port.\n"); 298 goto fail; 299 } 300 301 for (i=0; i<raw1394_get_nodecount(dv->raw1394); ++i) { 302 303 /* Select device explicitly by GUID */ 304 305 if (guid > 1) { 306 if (guid == rom1394_get_guid(dv->raw1394, i)) { 307 dv->node = i; 308 port = j; 309 break; 310 } 311 } else { 312 313 /* Select first AV/C tape recorder player node */ 314 315 if (rom1394_get_directory(dv->raw1394, i, &rom_dir) < 0) 316 continue; 317 if (((rom1394_get_node_type(&rom_dir) == ROM1394_NODE_TYPE_AVC) && 318 avc1394_check_subunit_type(dv->raw1394, i, AVC1394_SUBUNIT_TYPE_VCR)) || 319 (rom_dir.unit_spec_id == MOTDCT_SPEC_ID)) { 320 rom1394_free_directory(&rom_dir); 321 dv->node = i; 322 port = j; 323 break; 324 } 325 rom1394_free_directory(&rom_dir); 326 } 327 } 328 } 329 330 if (port == -1) { 331 av_log(context, AV_LOG_ERROR, "No AV/C devices found.\n"); 332 goto fail; 333 } 334 335 /* Provide bus sanity for multiple connections */ 336 337 iec61883_cmp_normalize_output(dv->raw1394, 0xffc0 | dv->node); 338 339 /* Find out if device is DV or HDV */ 340 341 if (dv->type == IEC61883_AUTO) { 342 response = avc1394_transaction(dv->raw1394, dv->node, 343 AVC1394_CTYPE_STATUS | 344 AVC1394_SUBUNIT_TYPE_TAPE_RECORDER | 345 AVC1394_SUBUNIT_ID_0 | 346 AVC1394_VCR_COMMAND_OUTPUT_SIGNAL_MODE | 347 0xFF, 2); 348 response = AVC1394_GET_OPERAND0(response); 349 dv->type = (response == 0x10 || response == 0x90 || response == 0x1A || response == 0x9A) ? 350 IEC61883_HDV : IEC61883_DV; 351 } 352 353 /* Connect to device, and do initialization */ 354 355 dv->channel = iec61883_cmp_connect(dv->raw1394, dv->node, &dv->output_port, 356 raw1394_get_local_id(dv->raw1394), 357 &dv->input_port, &dv->bandwidth); 358 359 if (dv->channel < 0) 360 dv->channel = 63; 361 362 if (!dv->max_packets) 363 dv->max_packets = 100; 364 365 if (CONFIG_MPEGTS_DEMUXER && dv->type == IEC61883_HDV) { 366 367 /* Init HDV receive */ 368 369 avformat_new_stream(context, NULL); 370 371 dv->mpeg_demux = avpriv_mpegts_parse_open(context); 372 if (!dv->mpeg_demux) 373 goto fail; 374 375 dv->parse_queue = iec61883_parse_queue_hdv; 376 377 dv->iec61883_mpeg2 = iec61883_mpeg2_recv_init(dv->raw1394, 378 (iec61883_mpeg2_recv_t)iec61883_callback, 379 dv); 380 381 dv->max_packets *= 766; 382 } else { 383 384 /* Init DV receive */ 385 386 dv->dv_demux = avpriv_dv_init_demux(context); 387 if (!dv->dv_demux) 388 goto fail; 389 390 dv->parse_queue = iec61883_parse_queue_dv; 391 392 dv->iec61883_dv = iec61883_dv_fb_init(dv->raw1394, iec61883_callback, dv); 393 } 394 395 dv->raw1394_poll.fd = raw1394_get_fd(dv->raw1394); 396 dv->raw1394_poll.events = POLLIN | POLLERR | POLLHUP | POLLPRI; 397 398 /* Actually start receiving */ 399 400 if (dv->type == IEC61883_HDV) 401 iec61883_mpeg2_recv_start(dv->iec61883_mpeg2, dv->channel); 402 else 403 iec61883_dv_fb_start(dv->iec61883_dv, dv->channel); 404 405#if THREADS 406 dv->thread_loop = 1; 407 if (pthread_mutex_init(&dv->mutex, NULL)) 408 goto fail; 409 if (pthread_cond_init(&dv->cond, NULL)) 410 goto fail; 411 if (pthread_create(&dv->receive_task_thread, NULL, iec61883_receive_task, dv)) 412 goto fail; 413#endif 414 415 return 0; 416 417fail: 418 raw1394_destroy_handle(dv->raw1394); 419 return AVERROR(EIO); 420} 421 422static int iec61883_read_packet(AVFormatContext *context, AVPacket *pkt) 423{ 424 struct iec61883_data *dv = context->priv_data; 425 int size; 426 427 /** 428 * Try to parse frames from queue 429 */ 430 431#if THREADS 432 pthread_mutex_lock(&dv->mutex); 433 while ((size = dv->parse_queue(dv, pkt)) == -1) 434 if (!dv->eof) 435 pthread_cond_wait(&dv->cond, &dv->mutex); 436 else 437 break; 438 pthread_mutex_unlock(&dv->mutex); 439#else 440 int result; 441 while ((size = dv->parse_queue(dv, pkt)) == -1) { 442 iec61883_receive_task((void *)dv); 443 if (dv->receive_error) 444 return dv->receive_error; 445 } 446#endif 447 448 return size; 449} 450 451static int iec61883_close(AVFormatContext *context) 452{ 453 struct iec61883_data *dv = context->priv_data; 454 455#if THREADS 456 dv->thread_loop = 0; 457 pthread_join(dv->receive_task_thread, NULL); 458 pthread_cond_destroy(&dv->cond); 459 pthread_mutex_destroy(&dv->mutex); 460#endif 461 462 if (CONFIG_MPEGTS_DEMUXER && dv->type == IEC61883_HDV) { 463 iec61883_mpeg2_recv_stop(dv->iec61883_mpeg2); 464 iec61883_mpeg2_close(dv->iec61883_mpeg2); 465 avpriv_mpegts_parse_close(dv->mpeg_demux); 466 } else { 467 iec61883_dv_fb_stop(dv->iec61883_dv); 468 iec61883_dv_fb_close(dv->iec61883_dv); 469 av_freep(&dv->dv_demux); 470 } 471 while (dv->queue_first) { 472 DVPacket *packet = dv->queue_first; 473 dv->queue_first = packet->next; 474 av_freep(&packet->buf); 475 av_freep(&packet); 476 } 477 478 iec61883_cmp_disconnect(dv->raw1394, dv->node, dv->output_port, 479 raw1394_get_local_id(dv->raw1394), 480 dv->input_port, dv->channel, dv->bandwidth); 481 482 raw1394_destroy_handle(dv->raw1394); 483 484 return 0; 485} 486 487static const AVOption options[] = { 488 { "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" }, 489 { "auto", "auto detect DV/HDV", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_AUTO}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" }, 490 { "dv", "force device being treated as DV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_DV}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" }, 491 { "hdv" , "force device being treated as HDV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_HDV}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" }, 492 { "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 }, 493 { "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 }, 494 { NULL }, 495}; 496 497static const AVClass iec61883_class = { 498 .class_name = "iec61883 indev", 499 .item_name = av_default_item_name, 500 .option = options, 501 .version = LIBAVUTIL_VERSION_INT, 502 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT, 503}; 504 505const AVInputFormat ff_iec61883_demuxer = { 506 .name = "iec61883", 507 .long_name = NULL_IF_CONFIG_SMALL("libiec61883 (new DV1394) A/V input device"), 508 .priv_data_size = sizeof(struct iec61883_data), 509 .read_header = iec61883_read_header, 510 .read_packet = iec61883_read_packet, 511 .read_close = iec61883_close, 512 .flags = AVFMT_NOFILE, 513 .priv_class = &iec61883_class, 514}; 515