614bda0924f773f3aedfb28582827c01b5f23e62
[ffmpeg.git] / libavdevice / decklink_dec.cpp
1 /*
2  * Blackmagic DeckLink input
3  * Copyright (c) 2013-2014 Luca Barbato, Deti Fliegl
4  * Copyright (c) 2017 Akamai Technologies, Inc.
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /* Include internal.h first to avoid conflict between winsock.h (used by
24  * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
25 extern "C" {
26 #include "libavformat/internal.h"
27 }
28
29 #include <DeckLinkAPI.h>
30
31 extern "C" {
32 #include "config.h"
33 #include "libavformat/avformat.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/common.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/time.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/reverse.h"
41 #if CONFIG_LIBZVBI
42 #include <libzvbi.h>
43 #endif
44 }
45
46 #include "decklink_common.h"
47 #include "decklink_dec.h"
48
49 #define MAX_WIDTH_VANC 1920
50
51 typedef struct VANCLineNumber {
52     BMDDisplayMode mode;
53     int vanc_start;
54     int field0_vanc_end;
55     int field1_vanc_start;
56     int vanc_end;
57 } VANCLineNumber;
58
59 /* These VANC line numbers need not be very accurate. In any case
60  * GetBufferForVerticalBlankingLine() will return an error when invalid
61  * ancillary line number was requested. We just need to make sure that the
62  * entire VANC region is covered, while making sure we don't decode VANC of
63  * another source during switching*/
64 static VANCLineNumber vanc_line_numbers[] = {
65     /* SD Modes */
66
67     {bmdModeNTSC, 11, 19, 274, 282},
68     {bmdModeNTSC2398, 11, 19, 274, 282},
69     {bmdModePAL, 7, 22, 320, 335},
70     {bmdModeNTSCp, 11, -1, -1, 39},
71     {bmdModePALp, 7, -1, -1, 45},
72
73     /* HD 1080 Modes */
74
75     {bmdModeHD1080p2398, 8, -1, -1, 42},
76     {bmdModeHD1080p24, 8, -1, -1, 42},
77     {bmdModeHD1080p25, 8, -1, -1, 42},
78     {bmdModeHD1080p2997, 8, -1, -1, 42},
79     {bmdModeHD1080p30, 8, -1, -1, 42},
80     {bmdModeHD1080i50, 8, 20, 570, 585},
81     {bmdModeHD1080i5994, 8, 20, 570, 585},
82     {bmdModeHD1080i6000, 8, 20, 570, 585},
83     {bmdModeHD1080p50, 8, -1, -1, 42},
84     {bmdModeHD1080p5994, 8, -1, -1, 42},
85     {bmdModeHD1080p6000, 8, -1, -1, 42},
86
87      /* HD 720 Modes */
88
89     {bmdModeHD720p50, 8, -1, -1, 26},
90     {bmdModeHD720p5994, 8, -1, -1, 26},
91     {bmdModeHD720p60, 8, -1, -1, 26},
92
93     /* For all other modes, for which we don't support VANC */
94     {bmdModeUnknown, 0, -1, -1, -1}
95 };
96
97 static int get_vanc_line_idx(BMDDisplayMode mode)
98 {
99     unsigned int i;
100     for (i = 0; i < FF_ARRAY_ELEMS(vanc_line_numbers); i++) {
101         if (mode == vanc_line_numbers[i].mode)
102             return i;
103     }
104     /* Return the VANC idx for Unknown mode */
105     return i - 1;
106 }
107
108 /* The 10-bit VANC data is packed in V210, we only need the luma component. */
109 static void extract_luma_from_v210(uint16_t *dst, const uint8_t *src, int width)
110 {
111     int i;
112     for (i = 0; i < width / 3; i += 3) {
113         *dst++ = (src[1] >> 2) + ((src[2] & 15) << 6);
114         *dst++ =  src[4]       + ((src[5] &  3) << 8);
115         *dst++ = (src[6] >> 4) + ((src[7] & 63) << 4);
116         src += 8;
117     }
118 }
119
120 static uint8_t calc_parity_and_line_offset(int line)
121 {
122     uint8_t ret = (line < 313) << 5;
123     if (line >= 7 && line <= 22)
124         ret += line;
125     if (line >= 320 && line <= 335)
126         ret += (line - 313);
127     return ret;
128 }
129
130 static void fill_data_unit_head(int line, uint8_t *tgt)
131 {
132     tgt[0] = 0x02; // data_unit_id
133     tgt[1] = 0x2c; // data_unit_length
134     tgt[2] = calc_parity_and_line_offset(line); // field_parity, line_offset
135     tgt[3] = 0xe4; // framing code
136 }
137
138 #if CONFIG_LIBZVBI
139 static uint8_t* teletext_data_unit_from_vbi_data(int line, uint8_t *src, uint8_t *tgt, vbi_pixfmt fmt)
140 {
141     vbi_bit_slicer slicer;
142
143     vbi_bit_slicer_init(&slicer, 720, 13500000, 6937500, 6937500, 0x00aaaae4, 0xffff, 18, 6, 42 * 8, VBI_MODULATION_NRZ_MSB, fmt);
144
145     if (vbi_bit_slice(&slicer, src, tgt + 4) == FALSE)
146         return tgt;
147
148     fill_data_unit_head(line, tgt);
149
150     return tgt + 46;
151 }
152
153 static uint8_t* teletext_data_unit_from_vbi_data_10bit(int line, uint8_t *src, uint8_t *tgt)
154 {
155     uint8_t y[720];
156     uint8_t *py = y;
157     uint8_t *pend = y + 720;
158     /* The 10-bit VBI data is packed in V210, but libzvbi only supports 8-bit,
159      * so we extract the 8 MSBs of the luma component, that is enough for
160      * teletext bit slicing. */
161     while (py < pend) {
162         *py++ = (src[1] >> 4) + ((src[2] & 15) << 4);
163         *py++ = (src[4] >> 2) + ((src[5] & 3 ) << 6);
164         *py++ = (src[6] >> 6) + ((src[7] & 63) << 2);
165         src += 8;
166     }
167     return teletext_data_unit_from_vbi_data(line, y, tgt, VBI_PIXFMT_YUV420);
168 }
169 #endif
170
171 static uint8_t* teletext_data_unit_from_op47_vbi_packet(int line, uint16_t *py, uint8_t *tgt)
172 {
173     int i;
174
175     if (py[0] != 0x255 || py[1] != 0x255 || py[2] != 0x227)
176         return tgt;
177
178     fill_data_unit_head(line, tgt);
179
180     py += 3;
181     tgt += 4;
182
183     for (i = 0; i < 42; i++)
184        *tgt++ = ff_reverse[py[i] & 255];
185
186     return tgt;
187 }
188
189 static int linemask_matches(int line, int64_t mask)
190 {
191     int shift = -1;
192     if (line >= 6 && line <= 22)
193         shift = line - 6;
194     if (line >= 318 && line <= 335)
195         shift = line - 318 + 17;
196     return shift >= 0 && ((1ULL << shift) & mask);
197 }
198
199 static uint8_t* teletext_data_unit_from_op47_data(uint16_t *py, uint16_t *pend, uint8_t *tgt, int64_t wanted_lines)
200 {
201     if (py < pend - 9) {
202         if (py[0] == 0x151 && py[1] == 0x115 && py[3] == 0x102) {       // identifier, identifier, format code for WST teletext
203             uint16_t *descriptors = py + 4;
204             int i;
205             py += 9;
206             for (i = 0; i < 5 && py < pend - 45; i++, py += 45) {
207                 int line = (descriptors[i] & 31) + (!(descriptors[i] & 128)) * 313;
208                 if (line && linemask_matches(line, wanted_lines))
209                     tgt = teletext_data_unit_from_op47_vbi_packet(line, py, tgt);
210             }
211         }
212     }
213     return tgt;
214 }
215
216 static uint8_t* teletext_data_unit_from_ancillary_packet(uint16_t *py, uint16_t *pend, uint8_t *tgt, int64_t wanted_lines, int allow_multipacket)
217 {
218     uint16_t did = py[0];                                               // data id
219     uint16_t sdid = py[1];                                              // secondary data id
220     uint16_t dc = py[2] & 255;                                          // data count
221     py += 3;
222     pend = FFMIN(pend, py + dc);
223     if (did == 0x143 && sdid == 0x102) {                                // subtitle distribution packet
224         tgt = teletext_data_unit_from_op47_data(py, pend, tgt, wanted_lines);
225     } else if (allow_multipacket && did == 0x143 && sdid == 0x203) {    // VANC multipacket
226         py += 2;                                                        // priority, line/field
227         while (py < pend - 3) {
228             tgt = teletext_data_unit_from_ancillary_packet(py, pend, tgt, wanted_lines, 0);
229             py += 4 + (py[2] & 255);                                    // ndid, nsdid, ndc, line/field
230         }
231     }
232     return tgt;
233 }
234
235 static uint8_t* teletext_data_unit_from_vanc_data(uint16_t *py, uint8_t *tgt, int64_t wanted_lines)
236 {
237     uint16_t *pend = py + 1920;
238
239     while (py < pend - 6) {
240         if (py[0] == 0 && py[1] == 0x3ff && py[2] == 0x3ff) {           // ancillary data flag
241             py += 3;
242             tgt = teletext_data_unit_from_ancillary_packet(py, pend, tgt, wanted_lines, 0);
243             py += py[2] & 255;
244         } else {
245             py++;
246         }
247     }
248     return tgt;
249 }
250
251 static void avpacket_queue_init(AVFormatContext *avctx, AVPacketQueue *q)
252 {
253     struct decklink_cctx *ctx = (struct decklink_cctx *)avctx->priv_data;
254     memset(q, 0, sizeof(AVPacketQueue));
255     pthread_mutex_init(&q->mutex, NULL);
256     pthread_cond_init(&q->cond, NULL);
257     q->avctx = avctx;
258     q->max_q_size = ctx->queue_size;
259 }
260
261 static void avpacket_queue_flush(AVPacketQueue *q)
262 {
263     AVPacketList *pkt, *pkt1;
264
265     pthread_mutex_lock(&q->mutex);
266     for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
267         pkt1 = pkt->next;
268         av_packet_unref(&pkt->pkt);
269         av_freep(&pkt);
270     }
271     q->last_pkt   = NULL;
272     q->first_pkt  = NULL;
273     q->nb_packets = 0;
274     q->size       = 0;
275     pthread_mutex_unlock(&q->mutex);
276 }
277
278 static void avpacket_queue_end(AVPacketQueue *q)
279 {
280     avpacket_queue_flush(q);
281     pthread_mutex_destroy(&q->mutex);
282     pthread_cond_destroy(&q->cond);
283 }
284
285 static unsigned long long avpacket_queue_size(AVPacketQueue *q)
286 {
287     unsigned long long size;
288     pthread_mutex_lock(&q->mutex);
289     size = q->size;
290     pthread_mutex_unlock(&q->mutex);
291     return size;
292 }
293
294 static int avpacket_queue_put(AVPacketQueue *q, AVPacket *pkt)
295 {
296     AVPacketList *pkt1;
297
298     // Drop Packet if queue size is > maximum queue size
299     if (avpacket_queue_size(q) > (uint64_t)q->max_q_size) {
300         av_log(q->avctx, AV_LOG_WARNING,  "Decklink input buffer overrun!\n");
301         return -1;
302     }
303     /* duplicate the packet */
304     if (av_dup_packet(pkt) < 0) {
305         return -1;
306     }
307
308     pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));
309     if (!pkt1) {
310         return -1;
311     }
312     pkt1->pkt  = *pkt;
313     pkt1->next = NULL;
314
315     pthread_mutex_lock(&q->mutex);
316
317     if (!q->last_pkt) {
318         q->first_pkt = pkt1;
319     } else {
320         q->last_pkt->next = pkt1;
321     }
322
323     q->last_pkt = pkt1;
324     q->nb_packets++;
325     q->size += pkt1->pkt.size + sizeof(*pkt1);
326
327     pthread_cond_signal(&q->cond);
328
329     pthread_mutex_unlock(&q->mutex);
330     return 0;
331 }
332
333 static int avpacket_queue_get(AVPacketQueue *q, AVPacket *pkt, int block)
334 {
335     AVPacketList *pkt1;
336     int ret;
337
338     pthread_mutex_lock(&q->mutex);
339
340     for (;; ) {
341         pkt1 = q->first_pkt;
342         if (pkt1) {
343             q->first_pkt = pkt1->next;
344             if (!q->first_pkt) {
345                 q->last_pkt = NULL;
346             }
347             q->nb_packets--;
348             q->size -= pkt1->pkt.size + sizeof(*pkt1);
349             *pkt     = pkt1->pkt;
350             av_free(pkt1);
351             ret = 1;
352             break;
353         } else if (!block) {
354             ret = 0;
355             break;
356         } else {
357             pthread_cond_wait(&q->cond, &q->mutex);
358         }
359     }
360     pthread_mutex_unlock(&q->mutex);
361     return ret;
362 }
363
364 class decklink_input_callback : public IDeckLinkInputCallback
365 {
366 public:
367         decklink_input_callback(AVFormatContext *_avctx);
368         ~decklink_input_callback();
369
370         virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
371         virtual ULONG STDMETHODCALLTYPE AddRef(void);
372         virtual ULONG STDMETHODCALLTYPE  Release(void);
373         virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(BMDVideoInputFormatChangedEvents, IDeckLinkDisplayMode*, BMDDetectedVideoInputFormatFlags);
374         virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(IDeckLinkVideoInputFrame*, IDeckLinkAudioInputPacket*);
375
376 private:
377         ULONG           m_refCount;
378         pthread_mutex_t m_mutex;
379         AVFormatContext *avctx;
380         decklink_ctx    *ctx;
381         int no_video;
382         int64_t initial_video_pts;
383         int64_t initial_audio_pts;
384 };
385
386 decklink_input_callback::decklink_input_callback(AVFormatContext *_avctx) : m_refCount(0)
387 {
388     avctx = _avctx;
389     decklink_cctx       *cctx = (struct decklink_cctx *)avctx->priv_data;
390     ctx = (struct decklink_ctx *)cctx->ctx;
391     no_video = 0;
392     initial_audio_pts = initial_video_pts = AV_NOPTS_VALUE;
393     pthread_mutex_init(&m_mutex, NULL);
394 }
395
396 decklink_input_callback::~decklink_input_callback()
397 {
398     pthread_mutex_destroy(&m_mutex);
399 }
400
401 ULONG decklink_input_callback::AddRef(void)
402 {
403     pthread_mutex_lock(&m_mutex);
404     m_refCount++;
405     pthread_mutex_unlock(&m_mutex);
406
407     return (ULONG)m_refCount;
408 }
409
410 ULONG decklink_input_callback::Release(void)
411 {
412     pthread_mutex_lock(&m_mutex);
413     m_refCount--;
414     pthread_mutex_unlock(&m_mutex);
415
416     if (m_refCount == 0) {
417         delete this;
418         return 0;
419     }
420
421     return (ULONG)m_refCount;
422 }
423
424 static int64_t get_pkt_pts(IDeckLinkVideoInputFrame *videoFrame,
425                            IDeckLinkAudioInputPacket *audioFrame,
426                            int64_t wallclock,
427                            DecklinkPtsSource pts_src,
428                            AVRational time_base, int64_t *initial_pts)
429 {
430     int64_t pts = AV_NOPTS_VALUE;
431     BMDTimeValue bmd_pts;
432     BMDTimeValue bmd_duration;
433     HRESULT res = E_INVALIDARG;
434     switch (pts_src) {
435         case PTS_SRC_AUDIO:
436             if (audioFrame)
437                 res = audioFrame->GetPacketTime(&bmd_pts, time_base.den);
438             break;
439         case PTS_SRC_VIDEO:
440             if (videoFrame)
441                 res = videoFrame->GetStreamTime(&bmd_pts, &bmd_duration, time_base.den);
442             break;
443         case PTS_SRC_REFERENCE:
444             if (videoFrame)
445                 res = videoFrame->GetHardwareReferenceTimestamp(time_base.den, &bmd_pts, &bmd_duration);
446             break;
447         case PTS_SRC_WALLCLOCK:
448         {
449             /* MSVC does not support compound literals like AV_TIME_BASE_Q
450              * in C++ code (compiler error C4576) */
451             AVRational timebase;
452             timebase.num = 1;
453             timebase.den = AV_TIME_BASE;
454             pts = av_rescale_q(wallclock, timebase, time_base);
455             break;
456         }
457     }
458     if (res == S_OK)
459         pts = bmd_pts / time_base.num;
460
461     if (pts != AV_NOPTS_VALUE && *initial_pts == AV_NOPTS_VALUE)
462         *initial_pts = pts;
463     if (*initial_pts != AV_NOPTS_VALUE)
464         pts -= *initial_pts;
465
466     return pts;
467 }
468
469 HRESULT decklink_input_callback::VideoInputFrameArrived(
470     IDeckLinkVideoInputFrame *videoFrame, IDeckLinkAudioInputPacket *audioFrame)
471 {
472     void *frameBytes;
473     void *audioFrameBytes;
474     BMDTimeValue frameTime;
475     BMDTimeValue frameDuration;
476     int64_t wallclock = 0;
477
478     ctx->frameCount++;
479     if (ctx->audio_pts_source == PTS_SRC_WALLCLOCK || ctx->video_pts_source == PTS_SRC_WALLCLOCK)
480         wallclock = av_gettime_relative();
481
482     // Handle Video Frame
483     if (videoFrame) {
484         AVPacket pkt;
485         av_init_packet(&pkt);
486         if (ctx->frameCount % 25 == 0) {
487             unsigned long long qsize = avpacket_queue_size(&ctx->queue);
488             av_log(avctx, AV_LOG_DEBUG,
489                     "Frame received (#%lu) - Valid (%liB) - QSize %fMB\n",
490                     ctx->frameCount,
491                     videoFrame->GetRowBytes() * videoFrame->GetHeight(),
492                     (double)qsize / 1024 / 1024);
493         }
494
495         videoFrame->GetBytes(&frameBytes);
496         videoFrame->GetStreamTime(&frameTime, &frameDuration,
497                                   ctx->video_st->time_base.den);
498
499         if (videoFrame->GetFlags() & bmdFrameHasNoInputSource) {
500             if (ctx->draw_bars && videoFrame->GetPixelFormat() == bmdFormat8BitYUV) {
501                 unsigned bars[8] = {
502                     0xEA80EA80, 0xD292D210, 0xA910A9A5, 0x90229035,
503                     0x6ADD6ACA, 0x51EF515A, 0x286D28EF, 0x10801080 };
504                 int width  = videoFrame->GetWidth();
505                 int height = videoFrame->GetHeight();
506                 unsigned *p = (unsigned *)frameBytes;
507
508                 for (int y = 0; y < height; y++) {
509                     for (int x = 0; x < width; x += 2)
510                         *p++ = bars[(x * 8) / width];
511                 }
512             }
513
514             if (!no_video) {
515                 av_log(avctx, AV_LOG_WARNING, "Frame received (#%lu) - No input signal detected "
516                         "- Frames dropped %u\n", ctx->frameCount, ++ctx->dropped);
517             }
518             no_video = 1;
519         } else {
520             if (no_video) {
521                 av_log(avctx, AV_LOG_WARNING, "Frame received (#%lu) - Input returned "
522                         "- Frames dropped %u\n", ctx->frameCount, ++ctx->dropped);
523             }
524             no_video = 0;
525         }
526
527         pkt.pts = get_pkt_pts(videoFrame, audioFrame, wallclock, ctx->video_pts_source, ctx->video_st->time_base, &initial_video_pts);
528         pkt.dts = pkt.pts;
529
530         pkt.duration = frameDuration;
531         //To be made sure it still applies
532         pkt.flags       |= AV_PKT_FLAG_KEY;
533         pkt.stream_index = ctx->video_st->index;
534         pkt.data         = (uint8_t *)frameBytes;
535         pkt.size         = videoFrame->GetRowBytes() *
536                            videoFrame->GetHeight();
537         //fprintf(stderr,"Video Frame size %d ts %d\n", pkt.size, pkt.pts);
538
539         if (!no_video && ctx->teletext_lines) {
540             IDeckLinkVideoFrameAncillary *vanc;
541             AVPacket txt_pkt;
542             uint8_t txt_buf0[3531]; // 35 * 46 bytes decoded teletext lines + 1 byte data_identifier + 1920 bytes OP47 decode buffer
543             uint8_t *txt_buf = txt_buf0;
544
545             if (videoFrame->GetAncillaryData(&vanc) == S_OK) {
546                 int i;
547                 int64_t line_mask = 1;
548                 BMDPixelFormat vanc_format = vanc->GetPixelFormat();
549                 txt_buf[0] = 0x10;    // data_identifier - EBU_data
550                 txt_buf++;
551 #if CONFIG_LIBZVBI
552                 if (ctx->bmd_mode == bmdModePAL && (vanc_format == bmdFormat8BitYUV || vanc_format == bmdFormat10BitYUV)) {
553                     av_assert0(videoFrame->GetWidth() == 720);
554                     for (i = 6; i < 336; i++, line_mask <<= 1) {
555                         uint8_t *buf;
556                         if ((ctx->teletext_lines & line_mask) && vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
557                             if (vanc_format == bmdFormat8BitYUV)
558                                 txt_buf = teletext_data_unit_from_vbi_data(i, buf, txt_buf, VBI_PIXFMT_UYVY);
559                             else
560                                 txt_buf = teletext_data_unit_from_vbi_data_10bit(i, buf, txt_buf);
561                         }
562                         if (i == 22)
563                             i = 317;
564                     }
565                 }
566 #endif
567                 if (vanc_format == bmdFormat10BitYUV && videoFrame->GetWidth() <= MAX_WIDTH_VANC) {
568                     int idx = get_vanc_line_idx(ctx->bmd_mode);
569                     for (i = vanc_line_numbers[idx].vanc_start; i <= vanc_line_numbers[idx].vanc_end; i++) {
570                         uint8_t *buf;
571                         if (vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
572                             uint16_t luma_vanc[MAX_WIDTH_VANC];
573                             extract_luma_from_v210(luma_vanc, buf, videoFrame->GetWidth());
574                             if (videoFrame->GetWidth() == 1920) {
575                                 txt_buf = teletext_data_unit_from_vanc_data(luma_vanc, txt_buf, ctx->teletext_lines);
576                                 if (txt_buf - txt_buf0 > 1611) {   // ensure we still have at least 1920 bytes free in the buffer
577                                     av_log(avctx, AV_LOG_ERROR, "Too many OP47 teletext packets.\n");
578                                     break;
579                                 }
580                             }
581                         }
582                         if (i == vanc_line_numbers[idx].field0_vanc_end)
583                             i = vanc_line_numbers[idx].field1_vanc_start - 1;
584                     }
585                 }
586                 vanc->Release();
587                 if (txt_buf - txt_buf0 > 1) {
588                     int stuffing_units = (4 - ((45 + txt_buf - txt_buf0) / 46) % 4) % 4;
589                     while (stuffing_units--) {
590                         memset(txt_buf, 0xff, 46);
591                         txt_buf[1] = 0x2c; // data_unit_length
592                         txt_buf += 46;
593                     }
594                     av_init_packet(&txt_pkt);
595                     txt_pkt.pts = pkt.pts;
596                     txt_pkt.dts = pkt.dts;
597                     txt_pkt.stream_index = ctx->teletext_st->index;
598                     txt_pkt.data = txt_buf0;
599                     txt_pkt.size = txt_buf - txt_buf0;
600                     if (avpacket_queue_put(&ctx->queue, &txt_pkt) < 0) {
601                         ++ctx->dropped;
602                     }
603                 }
604             }
605         }
606
607         if (avpacket_queue_put(&ctx->queue, &pkt) < 0) {
608             ++ctx->dropped;
609         }
610     }
611
612     // Handle Audio Frame
613     if (audioFrame) {
614         AVPacket pkt;
615         BMDTimeValue audio_pts;
616         av_init_packet(&pkt);
617
618         //hack among hacks
619         pkt.size = audioFrame->GetSampleFrameCount() * ctx->audio_st->codecpar->channels * (16 / 8);
620         audioFrame->GetBytes(&audioFrameBytes);
621         audioFrame->GetPacketTime(&audio_pts, ctx->audio_st->time_base.den);
622         pkt.pts = get_pkt_pts(videoFrame, audioFrame, wallclock, ctx->audio_pts_source, ctx->audio_st->time_base, &initial_audio_pts);
623         pkt.dts = pkt.pts;
624
625         //fprintf(stderr,"Audio Frame size %d ts %d\n", pkt.size, pkt.pts);
626         pkt.flags       |= AV_PKT_FLAG_KEY;
627         pkt.stream_index = ctx->audio_st->index;
628         pkt.data         = (uint8_t *)audioFrameBytes;
629
630         if (avpacket_queue_put(&ctx->queue, &pkt) < 0) {
631             ++ctx->dropped;
632         }
633     }
634
635     return S_OK;
636 }
637
638 HRESULT decklink_input_callback::VideoInputFormatChanged(
639     BMDVideoInputFormatChangedEvents events, IDeckLinkDisplayMode *mode,
640     BMDDetectedVideoInputFormatFlags)
641 {
642     return S_OK;
643 }
644
645 static HRESULT decklink_start_input(AVFormatContext *avctx)
646 {
647     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
648     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
649
650     ctx->input_callback = new decklink_input_callback(avctx);
651     ctx->dli->SetCallback(ctx->input_callback);
652     return ctx->dli->StartStreams();
653 }
654
655 extern "C" {
656
657 av_cold int ff_decklink_read_close(AVFormatContext *avctx)
658 {
659     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
660     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
661
662     if (ctx->capture_started) {
663         ctx->dli->StopStreams();
664         ctx->dli->DisableVideoInput();
665         ctx->dli->DisableAudioInput();
666     }
667
668     ff_decklink_cleanup(avctx);
669     avpacket_queue_end(&ctx->queue);
670
671     av_freep(&cctx->ctx);
672
673     return 0;
674 }
675
676 av_cold int ff_decklink_read_header(AVFormatContext *avctx)
677 {
678     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
679     struct decklink_ctx *ctx;
680     AVStream *st;
681     HRESULT result;
682     char fname[1024];
683     char *tmp;
684     int mode_num = 0;
685     int ret;
686
687     ctx = (struct decklink_ctx *) av_mallocz(sizeof(struct decklink_ctx));
688     if (!ctx)
689         return AVERROR(ENOMEM);
690     ctx->list_devices = cctx->list_devices;
691     ctx->list_formats = cctx->list_formats;
692     ctx->teletext_lines = cctx->teletext_lines;
693     ctx->preroll      = cctx->preroll;
694     ctx->duplex_mode  = cctx->duplex_mode;
695     if (cctx->video_input > 0 && (unsigned int)cctx->video_input < FF_ARRAY_ELEMS(decklink_video_connection_map))
696         ctx->video_input = decklink_video_connection_map[cctx->video_input];
697     if (cctx->audio_input > 0 && (unsigned int)cctx->audio_input < FF_ARRAY_ELEMS(decklink_audio_connection_map))
698         ctx->audio_input = decklink_audio_connection_map[cctx->audio_input];
699     ctx->audio_pts_source = cctx->audio_pts_source;
700     ctx->video_pts_source = cctx->video_pts_source;
701     ctx->draw_bars = cctx->draw_bars;
702     cctx->ctx = ctx;
703
704     /* Check audio channel option for valid values: 2, 8 or 16 */
705     switch (cctx->audio_channels) {
706         case 2:
707         case 8:
708         case 16:
709             break;
710         default:
711             av_log(avctx, AV_LOG_ERROR, "Value of channels option must be one of 2, 8 or 16\n");
712             return AVERROR(EINVAL);
713     }
714
715     /* List available devices. */
716     if (ctx->list_devices) {
717         ff_decklink_list_devices(avctx);
718         return AVERROR_EXIT;
719     }
720
721     if (cctx->v210) {
722         av_log(avctx, AV_LOG_WARNING, "The bm_v210 option is deprecated and will be removed. Please use the -raw_format yuv422p10.\n");
723         cctx->raw_format = MKBETAG('v','2','1','0');
724     }
725
726     strcpy (fname, avctx->filename);
727     tmp=strchr (fname, '@');
728     if (tmp != NULL) {
729         av_log(avctx, AV_LOG_WARNING, "The @mode syntax is deprecated and will be removed. Please use the -format_code option.\n");
730         mode_num = atoi (tmp+1);
731         *tmp = 0;
732     }
733
734     ret = ff_decklink_init_device(avctx, fname);
735     if (ret < 0)
736         return ret;
737
738     /* Get input device. */
739     if (ctx->dl->QueryInterface(IID_IDeckLinkInput, (void **) &ctx->dli) != S_OK) {
740         av_log(avctx, AV_LOG_ERROR, "Could not open input device from '%s'\n",
741                avctx->filename);
742         ret = AVERROR(EIO);
743         goto error;
744     }
745
746     /* List supported formats. */
747     if (ctx->list_formats) {
748         ff_decklink_list_formats(avctx, DIRECTION_IN);
749         ret = AVERROR_EXIT;
750         goto error;
751     }
752
753     if (mode_num > 0 || cctx->format_code) {
754         if (ff_decklink_set_format(avctx, DIRECTION_IN, mode_num) < 0) {
755             av_log(avctx, AV_LOG_ERROR, "Could not set mode number %d or format code %s for %s\n",
756                 mode_num, (cctx->format_code) ? cctx->format_code : "(unset)", fname);
757             ret = AVERROR(EIO);
758             goto error;
759         }
760     }
761
762 #if !CONFIG_LIBZVBI
763     if (ctx->teletext_lines && ctx->bmd_mode == bmdModePAL) {
764         av_log(avctx, AV_LOG_ERROR, "Libzvbi support is needed for capturing SD PAL teletext, please recompile FFmpeg.\n");
765         ret = AVERROR(ENOSYS);
766         goto error;
767     }
768 #endif
769
770     /* Setup streams. */
771     st = avformat_new_stream(avctx, NULL);
772     if (!st) {
773         av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
774         ret = AVERROR(ENOMEM);
775         goto error;
776     }
777     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
778     st->codecpar->codec_id    = AV_CODEC_ID_PCM_S16LE;
779     st->codecpar->sample_rate = bmdAudioSampleRate48kHz;
780     st->codecpar->channels    = cctx->audio_channels;
781     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
782     ctx->audio_st=st;
783
784     st = avformat_new_stream(avctx, NULL);
785     if (!st) {
786         av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
787         ret = AVERROR(ENOMEM);
788         goto error;
789     }
790     st->codecpar->codec_type  = AVMEDIA_TYPE_VIDEO;
791     st->codecpar->width       = ctx->bmd_width;
792     st->codecpar->height      = ctx->bmd_height;
793
794     st->time_base.den      = ctx->bmd_tb_den;
795     st->time_base.num      = ctx->bmd_tb_num;
796     av_stream_set_r_frame_rate(st, av_make_q(st->time_base.den, st->time_base.num));
797
798     switch((BMDPixelFormat)cctx->raw_format) {
799     case bmdFormat8BitYUV:
800         st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
801         st->codecpar->codec_tag   = MKTAG('U', 'Y', 'V', 'Y');
802         st->codecpar->format      = AV_PIX_FMT_UYVY422;
803         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 16, st->time_base.den, st->time_base.num);
804         break;
805     case bmdFormat10BitYUV:
806         st->codecpar->codec_id    = AV_CODEC_ID_V210;
807         st->codecpar->codec_tag   = MKTAG('V','2','1','0');
808         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 64, st->time_base.den, st->time_base.num * 3);
809         st->codecpar->bits_per_coded_sample = 10;
810         break;
811     case bmdFormat8BitARGB:
812         st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
813         st->codecpar->codec_tag   = avcodec_pix_fmt_to_codec_tag((enum AVPixelFormat)st->codecpar->format);;
814         st->codecpar->format      = AV_PIX_FMT_ARGB;
815         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 32, st->time_base.den, st->time_base.num);
816         break;
817     case bmdFormat8BitBGRA:
818         st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
819         st->codecpar->codec_tag   = avcodec_pix_fmt_to_codec_tag((enum AVPixelFormat)st->codecpar->format);
820         st->codecpar->format      = AV_PIX_FMT_BGRA;
821         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 32, st->time_base.den, st->time_base.num);
822         break;
823     case bmdFormat10BitRGB:
824         st->codecpar->codec_id    = AV_CODEC_ID_R210;
825         st->codecpar->codec_tag   = MKTAG('R','2','1','0');
826         st->codecpar->format      = AV_PIX_FMT_RGB48LE;
827         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 30, st->time_base.den, st->time_base.num);
828         st->codecpar->bits_per_coded_sample = 10;
829         break;
830     default:
831         av_log(avctx, AV_LOG_ERROR, "Raw Format %.4s not supported\n", (char*) &cctx->raw_format);
832         ret = AVERROR(EINVAL);
833         goto error;
834     }
835
836     switch (ctx->bmd_field_dominance) {
837     case bmdUpperFieldFirst:
838         st->codecpar->field_order = AV_FIELD_TT;
839         break;
840     case bmdLowerFieldFirst:
841         st->codecpar->field_order = AV_FIELD_BB;
842         break;
843     case bmdProgressiveFrame:
844     case bmdProgressiveSegmentedFrame:
845         st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
846         break;
847     }
848
849     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
850
851     ctx->video_st=st;
852
853     if (ctx->teletext_lines) {
854         st = avformat_new_stream(avctx, NULL);
855         if (!st) {
856             av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n");
857             ret = AVERROR(ENOMEM);
858             goto error;
859         }
860         st->codecpar->codec_type  = AVMEDIA_TYPE_SUBTITLE;
861         st->time_base.den         = ctx->bmd_tb_den;
862         st->time_base.num         = ctx->bmd_tb_num;
863         st->codecpar->codec_id    = AV_CODEC_ID_DVB_TELETEXT;
864         avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
865         ctx->teletext_st = st;
866     }
867
868     av_log(avctx, AV_LOG_VERBOSE, "Using %d input audio channels\n", ctx->audio_st->codecpar->channels);
869     result = ctx->dli->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType16bitInteger, ctx->audio_st->codecpar->channels);
870
871     if (result != S_OK) {
872         av_log(avctx, AV_LOG_ERROR, "Cannot enable audio input\n");
873         ret = AVERROR(EIO);
874         goto error;
875     }
876
877     result = ctx->dli->EnableVideoInput(ctx->bmd_mode,
878                                         (BMDPixelFormat) cctx->raw_format,
879                                         bmdVideoInputFlagDefault);
880
881     if (result != S_OK) {
882         av_log(avctx, AV_LOG_ERROR, "Cannot enable video input\n");
883         ret = AVERROR(EIO);
884         goto error;
885     }
886
887     avpacket_queue_init (avctx, &ctx->queue);
888
889     if (decklink_start_input (avctx) != S_OK) {
890         av_log(avctx, AV_LOG_ERROR, "Cannot start input stream\n");
891         ret = AVERROR(EIO);
892         goto error;
893     }
894
895     return 0;
896
897 error:
898     ff_decklink_cleanup(avctx);
899     return ret;
900 }
901
902 int ff_decklink_read_packet(AVFormatContext *avctx, AVPacket *pkt)
903 {
904     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
905     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
906
907     avpacket_queue_get(&ctx->queue, pkt, 1);
908
909     return 0;
910 }
911
912 } /* extern "C" */