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 */ 52typedef 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 58struct 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 98static 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 141exit: 142#if THREADS 143 pthread_cond_broadcast(&dv->cond); 144 pthread_mutex_unlock(&dv->mutex); 145#endif 146 return ret; 147} 148 149static 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 186static 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 212static 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 = ff_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 233static 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 = ff_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 402fail: 403 raw1394_destroy_handle(dv->raw1394); 404 return AVERROR(EIO); 405} 406 407static 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 436static 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 ff_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 471static 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 481static 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 489AVInputFormat 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}; 499