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