git.sesse.net Git - ffmpeg/blob - libavdevice/decklink_dec.cpp

   1 /*
   2  * Blackmagic DeckLink input
   3  * Copyright (c) 2013-2014 Luca Barbato, Deti Fliegl
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <DeckLinkAPI.h>
  23
  24 #include <pthread.h>
  25 #include <semaphore.h>
  26
  27 extern "C" {
  28 #include "config.h"
  29 #include "libavformat/avformat.h"
  30 #include "libavformat/internal.h"
  31 #include "libavutil/avutil.h"
  32 #include "libavutil/common.h"
  33 #include "libavutil/imgutils.h"
  34 #include "libavutil/time.h"
  35 #include "libavutil/mathematics.h"
  36 #if CONFIG_LIBZVBI
  37 #include <libzvbi.h>
  38 #endif
  39 }
  40
  41 #include "decklink_common.h"
  42 #include "decklink_dec.h"
  43
  44 #if CONFIG_LIBZVBI
  45 static uint8_t calc_parity_and_line_offset(int line)
  46 {
  47     uint8_t ret = (line < 313) << 5;
  48     if (line >= 7 && line <= 22)
  49         ret += line;
  50     if (line >= 320 && line <= 335)
  51         ret += (line - 313);
  52     return ret;
  53 }
  54
  55 int teletext_data_unit_from_vbi_data(int line, uint8_t *src, uint8_t *tgt)
  56 {
  57     vbi_bit_slicer slicer;
  58
  59     vbi_bit_slicer_init(&slicer, 720, 13500000, 6937500, 6937500, 0x00aaaae4, 0xffff, 18, 6, 42 * 8, VBI_MODULATION_NRZ_MSB, VBI_PIXFMT_UYVY);
  60
  61     if (vbi_bit_slice(&slicer, src, tgt + 4) == FALSE)
  62         return -1;
  63
  64     tgt[0] = 0x02; // data_unit_id
  65     tgt[1] = 0x2c; // data_unit_length
  66     tgt[2] = calc_parity_and_line_offset(line); // field_parity, line_offset
  67     tgt[3] = 0xe4; // framing code
  68
  69     return 0;
  70 }
  71 #endif
  72
  73 static void avpacket_queue_init(AVFormatContext *avctx, AVPacketQueue *q)
  74 {
  75     memset(q, 0, sizeof(AVPacketQueue));
  76     pthread_mutex_init(&q->mutex, NULL);
  77     pthread_cond_init(&q->cond, NULL);
  78     q->avctx = avctx;
  79 }
  80
  81 static void avpacket_queue_flush(AVPacketQueue *q)
  82 {
  83     AVPacketList *pkt, *pkt1;
  84
  85     pthread_mutex_lock(&q->mutex);
  86     for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
  87         pkt1 = pkt->next;
  88         av_packet_unref(&pkt->pkt);
  89         av_freep(&pkt);
  90     }
  91     q->last_pkt   = NULL;
  92     q->first_pkt  = NULL;
  93     q->nb_packets = 0;
  94     q->size       = 0;
  95     pthread_mutex_unlock(&q->mutex);
  96 }
  97
  98 static void avpacket_queue_end(AVPacketQueue *q)
  99 {
 100     avpacket_queue_flush(q);
 101     pthread_mutex_destroy(&q->mutex);
 102     pthread_cond_destroy(&q->cond);
 103 }
 104
 105 static unsigned long long avpacket_queue_size(AVPacketQueue *q)
 106 {
 107     unsigned long long size;
 108     pthread_mutex_lock(&q->mutex);
 109     size = q->size;
 110     pthread_mutex_unlock(&q->mutex);
 111     return size;
 112 }
 113
 114 static int avpacket_queue_put(AVPacketQueue *q, AVPacket *pkt)
 115 {
 116     AVPacketList *pkt1;
 117
 118     // Drop Packet if queue size is > 1GB
 119     if (avpacket_queue_size(q) >  1024 * 1024 * 1024 ) {
 120         av_log(q->avctx, AV_LOG_WARNING,  "Decklink input buffer overrun!\n");
 121         return -1;
 122     }
 123     /* duplicate the packet */
 124     if (av_dup_packet(pkt) < 0) {
 125         return -1;
 126     }
 127
 128     pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));
 129     if (!pkt1) {
 130         return -1;
 131     }
 132     pkt1->pkt  = *pkt;
 133     pkt1->next = NULL;
 134
 135     pthread_mutex_lock(&q->mutex);
 136
 137     if (!q->last_pkt) {
 138         q->first_pkt = pkt1;
 139     } else {
 140         q->last_pkt->next = pkt1;
 141     }
 142
 143     q->last_pkt = pkt1;
 144     q->nb_packets++;
 145     q->size += pkt1->pkt.size + sizeof(*pkt1);
 146
 147     pthread_cond_signal(&q->cond);
 148
 149     pthread_mutex_unlock(&q->mutex);
 150     return 0;
 151 }
 152
 153 static int avpacket_queue_get(AVPacketQueue *q, AVPacket *pkt, int block)
 154 {
 155     AVPacketList *pkt1;
 156     int ret;
 157
 158     pthread_mutex_lock(&q->mutex);
 159
 160     for (;; ) {
 161         pkt1 = q->first_pkt;
 162         if (pkt1) {
 163             q->first_pkt = pkt1->next;
 164             if (!q->first_pkt) {
 165                 q->last_pkt = NULL;
 166             }
 167             q->nb_packets--;
 168             q->size -= pkt1->pkt.size + sizeof(*pkt1);
 169             *pkt     = pkt1->pkt;
 170             av_free(pkt1);
 171             ret = 1;
 172             break;
 173         } else if (!block) {
 174             ret = 0;
 175             break;
 176         } else {
 177             pthread_cond_wait(&q->cond, &q->mutex);
 178         }
 179     }
 180     pthread_mutex_unlock(&q->mutex);
 181     return ret;
 182 }
 183
 184 class decklink_input_callback : public IDeckLinkInputCallback
 185 {
 186 public:
 187         decklink_input_callback(AVFormatContext *_avctx);
 188         ~decklink_input_callback();
 189
 190         virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
 191         virtual ULONG STDMETHODCALLTYPE AddRef(void);
 192         virtual ULONG STDMETHODCALLTYPE  Release(void);
 193         virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents, IDeckLinkDisplayMode*, BMDDetectedVideoInputFormatFlags);
 194         virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(IDeckLinkVideoInputFrame*, IDeckLinkAudioInputPacket*);
 195
 196 private:
 197         ULONG           m_refCount;
 198         pthread_mutex_t m_mutex;
 199         AVFormatContext *avctx;
 200         decklink_ctx    *ctx;
 201         int no_video;
 202         int64_t initial_video_pts;
 203         int64_t initial_audio_pts;
 204 };
 205
 206 decklink_input_callback::decklink_input_callback(AVFormatContext *_avctx) : m_refCount(0)
 207 {
 208     avctx = _avctx;
 209     decklink_cctx       *cctx = (struct decklink_cctx *)avctx->priv_data;
 210     ctx = (struct decklink_ctx *)cctx->ctx;
 211     no_video = 0;
 212     initial_audio_pts = initial_video_pts = AV_NOPTS_VALUE;
 213     pthread_mutex_init(&m_mutex, NULL);
 214 }
 215
 216 decklink_input_callback::~decklink_input_callback()
 217 {
 218     pthread_mutex_destroy(&m_mutex);
 219 }
 220
 221 ULONG decklink_input_callback::AddRef(void)
 222 {
 223     pthread_mutex_lock(&m_mutex);
 224     m_refCount++;
 225     pthread_mutex_unlock(&m_mutex);
 226
 227     return (ULONG)m_refCount;
 228 }
 229
 230 ULONG decklink_input_callback::Release(void)
 231 {
 232     pthread_mutex_lock(&m_mutex);
 233     m_refCount--;
 234     pthread_mutex_unlock(&m_mutex);
 235
 236     if (m_refCount == 0) {
 237         delete this;
 238         return 0;
 239     }
 240
 241     return (ULONG)m_refCount;
 242 }
 243
 244 static int64_t get_pkt_pts(IDeckLinkVideoInputFrame *videoFrame,
 245                            IDeckLinkAudioInputPacket *audioFrame,
 246                            int64_t wallclock,
 247                            DecklinkPtsSource pts_src,
 248                            AVRational time_base, int64_t *initial_pts)
 249 {
 250     int64_t pts = AV_NOPTS_VALUE;
 251     BMDTimeValue bmd_pts;
 252     BMDTimeValue bmd_duration;
 253     HRESULT res = E_INVALIDARG;
 254     switch (pts_src) {
 255         case PTS_SRC_AUDIO:
 256             if (audioFrame)
 257                 res = audioFrame->GetPacketTime(&bmd_pts, time_base.den);
 258             break;
 259         case PTS_SRC_VIDEO:
 260             if (videoFrame)
 261                 res = videoFrame->GetStreamTime(&bmd_pts, &bmd_duration, time_base.den);
 262             break;
 263         case PTS_SRC_REFERENCE:
 264             if (videoFrame)
 265                 res = videoFrame->GetHardwareReferenceTimestamp(time_base.den, &bmd_pts, &bmd_duration);
 266             break;
 267         case PTS_SRC_WALLCLOCK:
 268             pts = av_rescale_q(wallclock, AV_TIME_BASE_Q, time_base);
 269             break;
 270     }
 271     if (res == S_OK)
 272         pts = bmd_pts / time_base.num;
 273
 274     if (pts != AV_NOPTS_VALUE && *initial_pts == AV_NOPTS_VALUE)
 275         *initial_pts = pts;
 276     if (*initial_pts != AV_NOPTS_VALUE)
 277         pts -= *initial_pts;
 278
 279     return pts;
 280 }
 281
 282 HRESULT decklink_input_callback::VideoInputFrameArrived(
 283     IDeckLinkVideoInputFrame *videoFrame, IDeckLinkAudioInputPacket *audioFrame)
 284 {
 285     void *frameBytes;
 286     void *audioFrameBytes;
 287     BMDTimeValue frameTime;
 288     BMDTimeValue frameDuration;
 289     int64_t wallclock = 0;
 290
 291     ctx->frameCount++;
 292     if (ctx->audio_pts_source == PTS_SRC_WALLCLOCK || ctx->video_pts_source == PTS_SRC_WALLCLOCK)
 293         wallclock = av_gettime_relative();
 294
 295     // Handle Video Frame
 296     if (videoFrame) {
 297         AVPacket pkt;
 298         av_init_packet(&pkt);
 299         if (ctx->frameCount % 25 == 0) {
 300             unsigned long long qsize = avpacket_queue_size(&ctx->queue);
 301             av_log(avctx, AV_LOG_DEBUG,
 302                     "Frame received (#%lu) - Valid (%liB) - QSize %fMB\n",
 303                     ctx->frameCount,
 304                     videoFrame->GetRowBytes() * videoFrame->GetHeight(),
 305                     (double)qsize / 1024 / 1024);
 306         }
 307
 308         videoFrame->GetBytes(&frameBytes);
 309         videoFrame->GetStreamTime(&frameTime, &frameDuration,
 310                                   ctx->video_st->time_base.den);
 311
 312         if (videoFrame->GetFlags() & bmdFrameHasNoInputSource) {
 313             if (ctx->draw_bars && videoFrame->GetPixelFormat() == bmdFormat8BitYUV) {
 314                 unsigned bars[8] = {
 315                     0xEA80EA80, 0xD292D210, 0xA910A9A5, 0x90229035,
 316                     0x6ADD6ACA, 0x51EF515A, 0x286D28EF, 0x10801080 };
 317                 int width  = videoFrame->GetWidth();
 318                 int height = videoFrame->GetHeight();
 319                 unsigned *p = (unsigned *)frameBytes;
 320
 321                 for (int y = 0; y < height; y++) {
 322                     for (int x = 0; x < width; x += 2)
 323                         *p++ = bars[(x * 8) / width];
 324                 }
 325             }
 326
 327             if (!no_video) {
 328                 av_log(avctx, AV_LOG_WARNING, "Frame received (#%lu) - No input signal detected "
 329                         "- Frames dropped %u\n", ctx->frameCount, ++ctx->dropped);
 330             }
 331             no_video = 1;
 332         } else {
 333             if (no_video) {
 334                 av_log(avctx, AV_LOG_WARNING, "Frame received (#%lu) - Input returned "
 335                         "- Frames dropped %u\n", ctx->frameCount, ++ctx->dropped);
 336             }
 337             no_video = 0;
 338         }
 339
 340         pkt.pts = get_pkt_pts(videoFrame, audioFrame, wallclock, ctx->video_pts_source, ctx->video_st->time_base, &initial_video_pts);
 341         pkt.dts = pkt.pts;
 342
 343         pkt.duration = frameDuration;
 344         //To be made sure it still applies
 345         pkt.flags       |= AV_PKT_FLAG_KEY;
 346         pkt.stream_index = ctx->video_st->index;
 347         pkt.data         = (uint8_t *)frameBytes;
 348         pkt.size         = videoFrame->GetRowBytes() *
 349                            videoFrame->GetHeight();
 350         //fprintf(stderr,"Video Frame size %d ts %d\n", pkt.size, pkt.pts);
 351
 352 #if CONFIG_LIBZVBI
 353         if (!no_video && ctx->teletext_lines && videoFrame->GetPixelFormat() == bmdFormat8BitYUV && videoFrame->GetWidth() == 720) {
 354             IDeckLinkVideoFrameAncillary *vanc;
 355             AVPacket txt_pkt;
 356             uint8_t txt_buf0[1611]; // max 35 * 46 bytes decoded teletext lines + 1 byte data_identifier
 357             uint8_t *txt_buf = txt_buf0;
 358
 359             if (videoFrame->GetAncillaryData(&vanc) == S_OK) {
 360                 int i;
 361                 int64_t line_mask = 1;
 362                 txt_buf[0] = 0x10;    // data_identifier - EBU_data
 363                 txt_buf++;
 364                 for (i = 6; i < 336; i++, line_mask <<= 1) {
 365                     uint8_t *buf;
 366                     if ((ctx->teletext_lines & line_mask) && vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
 367                         if (teletext_data_unit_from_vbi_data(i, buf, txt_buf) >= 0)
 368                             txt_buf += 46;
 369                     }
 370                     if (i == 22)
 371                         i = 317;
 372                 }
 373                 vanc->Release();
 374                 if (txt_buf - txt_buf0 > 1) {
 375                     int stuffing_units = (4 - ((45 + txt_buf - txt_buf0) / 46) % 4) % 4;
 376                     while (stuffing_units--) {
 377                         memset(txt_buf, 0xff, 46);
 378                         txt_buf[1] = 0x2c; // data_unit_length
 379                         txt_buf += 46;
 380                     }
 381                     av_init_packet(&txt_pkt);
 382                     txt_pkt.pts = pkt.pts;
 383                     txt_pkt.dts = pkt.dts;
 384                     txt_pkt.stream_index = ctx->teletext_st->index;
 385                     txt_pkt.data = txt_buf0;
 386                     txt_pkt.size = txt_buf - txt_buf0;
 387                     if (avpacket_queue_put(&ctx->queue, &txt_pkt) < 0) {
 388                         ++ctx->dropped;
 389                     }
 390                 }
 391             }
 392         }
 393 #endif
 394
 395         if (avpacket_queue_put(&ctx->queue, &pkt) < 0) {
 396             ++ctx->dropped;
 397         }
 398     }
 399
 400     // Handle Audio Frame
 401     if (audioFrame) {
 402         AVPacket pkt;
 403         BMDTimeValue audio_pts;
 404         av_init_packet(&pkt);
 405
 406         //hack among hacks
 407         pkt.size = audioFrame->GetSampleFrameCount() * ctx->audio_st->codecpar->channels * (16 / 8);
 408         audioFrame->GetBytes(&audioFrameBytes);
 409         audioFrame->GetPacketTime(&audio_pts, ctx->audio_st->time_base.den);
 410         pkt.pts = get_pkt_pts(videoFrame, audioFrame, wallclock, ctx->audio_pts_source, ctx->audio_st->time_base, &initial_audio_pts);
 411         pkt.dts = pkt.pts;
 412
 413         //fprintf(stderr,"Audio Frame size %d ts %d\n", pkt.size, pkt.pts);
 414         pkt.flags       |= AV_PKT_FLAG_KEY;
 415         pkt.stream_index = ctx->audio_st->index;
 416         pkt.data         = (uint8_t *)audioFrameBytes;
 417
 418         if (avpacket_queue_put(&ctx->queue, &pkt) < 0) {
 419             ++ctx->dropped;
 420         }
 421     }
 422
 423     return S_OK;
 424 }
 425
 426 HRESULT decklink_input_callback::VideoInputFormatChanged(
 427     BMDVideoInputFormatChangedEvents events, IDeckLinkDisplayMode *mode,
 428     BMDDetectedVideoInputFormatFlags)
 429 {
 430     return S_OK;
 431 }
 432
 433 static HRESULT decklink_start_input(AVFormatContext *avctx)
 434 {
 435     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
 436     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
 437
 438     ctx->input_callback = new decklink_input_callback(avctx);
 439     ctx->dli->SetCallback(ctx->input_callback);
 440     return ctx->dli->StartStreams();
 441 }
 442
 443 extern "C" {
 444
 445 av_cold int ff_decklink_read_close(AVFormatContext *avctx)
 446 {
 447     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
 448     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
 449
 450     if (ctx->capture_started) {
 451         ctx->dli->StopStreams();
 452         ctx->dli->DisableVideoInput();
 453         ctx->dli->DisableAudioInput();
 454     }
 455
 456     ff_decklink_cleanup(avctx);
 457     avpacket_queue_end(&ctx->queue);
 458
 459     av_freep(&cctx->ctx);
 460
 461     return 0;
 462 }
 463
 464 av_cold int ff_decklink_read_header(AVFormatContext *avctx)
 465 {
 466     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
 467     struct decklink_ctx *ctx;
 468     AVStream *st;
 469     HRESULT result;
 470     char fname[1024];
 471     char *tmp;
 472     int mode_num = 0;
 473     int ret;
 474
 475     ctx = (struct decklink_ctx *) av_mallocz(sizeof(struct decklink_ctx));
 476     if (!ctx)
 477         return AVERROR(ENOMEM);
 478     ctx->list_devices = cctx->list_devices;
 479     ctx->list_formats = cctx->list_formats;
 480     ctx->teletext_lines = cctx->teletext_lines;
 481     ctx->preroll      = cctx->preroll;
 482     ctx->duplex_mode  = cctx->duplex_mode;
 483     if (cctx->video_input > 0 && (unsigned int)cctx->video_input < FF_ARRAY_ELEMS(decklink_video_connection_map))
 484         ctx->video_input = decklink_video_connection_map[cctx->video_input];
 485     if (cctx->audio_input > 0 && (unsigned int)cctx->audio_input < FF_ARRAY_ELEMS(decklink_audio_connection_map))
 486         ctx->audio_input = decklink_audio_connection_map[cctx->audio_input];
 487     ctx->audio_pts_source = cctx->audio_pts_source;
 488     ctx->video_pts_source = cctx->video_pts_source;
 489     ctx->draw_bars = cctx->draw_bars;
 490     cctx->ctx = ctx;
 491
 492 #if !CONFIG_LIBZVBI
 493     if (ctx->teletext_lines) {
 494         av_log(avctx, AV_LOG_ERROR, "Libzvbi support is needed for capturing teletext, please recompile FFmpeg.\n");
 495         return AVERROR(ENOSYS);
 496     }
 497 #endif
 498
 499     /* Check audio channel option for valid values: 2, 8 or 16 */
 500     switch (cctx->audio_channels) {
 501         case 2:
 502         case 8:
 503         case 16:
 504             break;
 505         default:
 506             av_log(avctx, AV_LOG_ERROR, "Value of channels option must be one of 2, 8 or 16\n");
 507             return AVERROR(EINVAL);
 508     }
 509
 510     /* List available devices. */
 511     if (ctx->list_devices) {
 512         ff_decklink_list_devices(avctx);
 513         return AVERROR_EXIT;
 514     }
 515
 516     strcpy (fname, avctx->filename);
 517     tmp=strchr (fname, '@');
 518     if (tmp != NULL) {
 519         mode_num = atoi (tmp+1);
 520         *tmp = 0;
 521     }
 522
 523     ret = ff_decklink_init_device(avctx, fname);
 524     if (ret < 0)
 525         return ret;
 526
 527     /* Get input device. */
 528     if (ctx->dl->QueryInterface(IID_IDeckLinkInput, (void **) &ctx->dli) != S_OK) {
 529         av_log(avctx, AV_LOG_ERROR, "Could not open input device from '%s'\n",
 530                avctx->filename);
 531         ret = AVERROR(EIO);
 532         goto error;
 533     }
 534
 535     /* List supported formats. */
 536     if (ctx->list_formats) {
 537         ff_decklink_list_formats(avctx, DIRECTION_IN);
 538         ret = AVERROR_EXIT;
 539         goto error;
 540     }
 541
 542     if (mode_num > 0) {
 543         if (ff_decklink_set_format(avctx, DIRECTION_IN, mode_num) < 0) {
 544             av_log(avctx, AV_LOG_ERROR, "Could not set mode %d for %s\n", mode_num, fname);
 545             ret = AVERROR(EIO);
 546             goto error;
 547         }
 548     }
 549
 550     /* Setup streams. */
 551     st = avformat_new_stream(avctx, NULL);
 552     if (!st) {
 553         av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
 554         ret = AVERROR(ENOMEM);
 555         goto error;
 556     }
 557     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
 558     st->codecpar->codec_id    = AV_CODEC_ID_PCM_S16LE;
 559     st->codecpar->sample_rate = bmdAudioSampleRate48kHz;
 560     st->codecpar->channels    = cctx->audio_channels;
 561     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
 562     ctx->audio_st=st;
 563
 564     st = avformat_new_stream(avctx, NULL);
 565     if (!st) {
 566         av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
 567         ret = AVERROR(ENOMEM);
 568         goto error;
 569     }
 570     st->codecpar->codec_type  = AVMEDIA_TYPE_VIDEO;
 571     st->codecpar->width       = ctx->bmd_width;
 572     st->codecpar->height      = ctx->bmd_height;
 573
 574     st->time_base.den      = ctx->bmd_tb_den;
 575     st->time_base.num      = ctx->bmd_tb_num;
 576     av_stream_set_r_frame_rate(st, av_make_q(st->time_base.den, st->time_base.num));
 577
 578     if (cctx->v210) {
 579         st->codecpar->codec_id    = AV_CODEC_ID_V210;
 580         st->codecpar->codec_tag   = MKTAG('V', '2', '1', '0');
 581         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 64, st->time_base.den, st->time_base.num * 3);
 582     } else {
 583         st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
 584         st->codecpar->format      = AV_PIX_FMT_UYVY422;
 585         st->codecpar->codec_tag   = MKTAG('U', 'Y', 'V', 'Y');
 586         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 16, st->time_base.den, st->time_base.num);
 587     }
 588
 589     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
 590
 591     ctx->video_st=st;
 592
 593     if (ctx->teletext_lines) {
 594         st = avformat_new_stream(avctx, NULL);
 595         if (!st) {
 596             av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
 597             ret = AVERROR(ENOMEM);
 598             goto error;
 599         }
 600         st->codecpar->codec_type  = AVMEDIA_TYPE_SUBTITLE;
 601         st->time_base.den         = ctx->bmd_tb_den;
 602         st->time_base.num         = ctx->bmd_tb_num;
 603         st->codecpar->codec_id    = AV_CODEC_ID_DVB_TELETEXT;
 604         avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
 605         ctx->teletext_st = st;
 606     }
 607
 608     av_log(avctx, AV_LOG_VERBOSE, "Using %d input audio channels\n", ctx->audio_st->codecpar->channels);
 609     result = ctx->dli->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType16bitInteger, ctx->audio_st->codecpar->channels);
 610
 611     if (result != S_OK) {
 612         av_log(avctx, AV_LOG_ERROR, "Cannot enable audio input\n");
 613         ret = AVERROR(EIO);
 614         goto error;
 615     }
 616
 617     result = ctx->dli->EnableVideoInput(ctx->bmd_mode,
 618                                         cctx->v210 ? bmdFormat10BitYUV : bmdFormat8BitYUV,
 619                                         bmdVideoInputFlagDefault);
 620
 621     if (result != S_OK) {
 622         av_log(avctx, AV_LOG_ERROR, "Cannot enable video input\n");
 623         ret = AVERROR(EIO);
 624         goto error;
 625     }
 626
 627     avpacket_queue_init (avctx, &ctx->queue);
 628
 629     if (decklink_start_input (avctx) != S_OK) {
 630         av_log(avctx, AV_LOG_ERROR, "Cannot start input stream\n");
 631         ret = AVERROR(EIO);
 632         goto error;
 633     }
 634
 635     return 0;
 636
 637 error:
 638     ff_decklink_cleanup(avctx);
 639     return ret;
 640 }
 641
 642 int ff_decklink_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 643 {
 644     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
 645     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
 646     AVFrame *frame = ctx->video_st->codec->coded_frame;
 647
 648     avpacket_queue_get(&ctx->queue, pkt, 1);
 649     if (frame && (ctx->bmd_field_dominance == bmdUpperFieldFirst || ctx->bmd_field_dominance == bmdLowerFieldFirst)) {
 650         frame->interlaced_frame = 1;
 651         if (ctx->bmd_field_dominance == bmdUpperFieldFirst) {
 652             frame->top_field_first = 1;
 653         }
 654     }
 655
 656     return 0;
 657 }
 658
 659 } /* extern "C" */