libavdevice/decklink: add support for -sources and -sinks arguments
[ffmpeg.git] / libavdevice / decklink_enc.cpp
1 /*
2  * Blackmagic DeckLink output
3  * Copyright (c) 2013-2014 Ramiro Polla
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 <atomic>
23 using std::atomic;
24
25 /* Include internal.h first to avoid conflict between winsock.h (used by
26  * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
27 extern "C" {
28 #include "libavformat/internal.h"
29 }
30
31 #include <DeckLinkAPI.h>
32
33 extern "C" {
34 #include "libavformat/avformat.h"
35 #include "libavutil/imgutils.h"
36 #include "avdevice.h"
37 }
38
39 #include "decklink_common.h"
40 #include "decklink_enc.h"
41
42
43 /* DeckLink callback class declaration */
44 class decklink_frame : public IDeckLinkVideoFrame
45 {
46 public:
47     decklink_frame(struct decklink_ctx *ctx, AVFrame *avframe) :
48                    _ctx(ctx), _avframe(avframe),  _refs(1) { }
49
50     virtual long           STDMETHODCALLTYPE GetWidth      (void)          { return _avframe->width; }
51     virtual long           STDMETHODCALLTYPE GetHeight     (void)          { return _avframe->height; }
52     virtual long           STDMETHODCALLTYPE GetRowBytes   (void)          { return _avframe->linesize[0] < 0 ? -_avframe->linesize[0] : _avframe->linesize[0]; }
53     virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void)          { return bmdFormat8BitYUV; }
54     virtual BMDFrameFlags  STDMETHODCALLTYPE GetFlags      (void)          { return _avframe->linesize[0] < 0 ? bmdFrameFlagFlipVertical : bmdFrameFlagDefault; }
55     virtual HRESULT        STDMETHODCALLTYPE GetBytes      (void **buffer)
56     {
57         if (_avframe->linesize[0] < 0)
58             *buffer = (void *)(_avframe->data[0] + _avframe->linesize[0] * (_avframe->height - 1));
59         else
60             *buffer = (void *)(_avframe->data[0]);
61         return S_OK;
62     }
63
64     virtual HRESULT STDMETHODCALLTYPE GetTimecode     (BMDTimecodeFormat format, IDeckLinkTimecode **timecode) { return S_FALSE; }
65     virtual HRESULT STDMETHODCALLTYPE GetAncillaryData(IDeckLinkVideoFrameAncillary **ancillary)               { return S_FALSE; }
66
67     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
68     virtual ULONG   STDMETHODCALLTYPE AddRef(void)                            { return ++_refs; }
69     virtual ULONG   STDMETHODCALLTYPE Release(void)
70     {
71         int ret = --_refs;
72         if (!ret) {
73             av_frame_free(&_avframe);
74             delete this;
75         }
76         return ret;
77     }
78
79     struct decklink_ctx *_ctx;
80     AVFrame *_avframe;
81
82 private:
83     std::atomic<int>  _refs;
84 };
85
86 class decklink_output_callback : public IDeckLinkVideoOutputCallback
87 {
88 public:
89     virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted(IDeckLinkVideoFrame *_frame, BMDOutputFrameCompletionResult result)
90     {
91         decklink_frame *frame = static_cast<decklink_frame *>(_frame);
92         struct decklink_ctx *ctx = frame->_ctx;
93         AVFrame *avframe = frame->_avframe;
94
95         av_frame_unref(avframe);
96
97         pthread_mutex_lock(&ctx->mutex);
98         ctx->frames_buffer_available_spots++;
99         pthread_cond_broadcast(&ctx->cond);
100         pthread_mutex_unlock(&ctx->mutex);
101
102         return S_OK;
103     }
104     virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped(void)       { return S_OK; }
105     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
106     virtual ULONG   STDMETHODCALLTYPE AddRef(void)                            { return 1; }
107     virtual ULONG   STDMETHODCALLTYPE Release(void)                           { return 1; }
108 };
109
110 static int decklink_setup_video(AVFormatContext *avctx, AVStream *st)
111 {
112     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
113     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
114     AVCodecParameters *c = st->codecpar;
115
116     if (ctx->video) {
117         av_log(avctx, AV_LOG_ERROR, "Only one video stream is supported!\n");
118         return -1;
119     }
120
121     if (c->format != AV_PIX_FMT_UYVY422) {
122         av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
123                " Only AV_PIX_FMT_UYVY422 is supported.\n");
124         return -1;
125     }
126     if (ff_decklink_set_format(avctx, c->width, c->height,
127                             st->time_base.num, st->time_base.den, c->field_order)) {
128         av_log(avctx, AV_LOG_ERROR, "Unsupported video size, framerate or field order!"
129                " Check available formats with -list_formats 1.\n");
130         return -1;
131     }
132     if (ctx->dlo->EnableVideoOutput(ctx->bmd_mode,
133                                     bmdVideoOutputFlagDefault) != S_OK) {
134         av_log(avctx, AV_LOG_ERROR, "Could not enable video output!\n");
135         return -1;
136     }
137
138     /* Set callback. */
139     ctx->output_callback = new decklink_output_callback();
140     ctx->dlo->SetScheduledFrameCompletionCallback(ctx->output_callback);
141
142     ctx->frames_preroll = st->time_base.den * ctx->preroll;
143     if (st->time_base.den > 1000)
144         ctx->frames_preroll /= 1000;
145
146     /* Buffer twice as many frames as the preroll. */
147     ctx->frames_buffer = ctx->frames_preroll * 2;
148     ctx->frames_buffer = FFMIN(ctx->frames_buffer, 60);
149     pthread_mutex_init(&ctx->mutex, NULL);
150     pthread_cond_init(&ctx->cond, NULL);
151     ctx->frames_buffer_available_spots = ctx->frames_buffer;
152
153     /* The device expects the framerate to be fixed. */
154     avpriv_set_pts_info(st, 64, st->time_base.num, st->time_base.den);
155
156     ctx->video = 1;
157
158     return 0;
159 }
160
161 static int decklink_setup_audio(AVFormatContext *avctx, AVStream *st)
162 {
163     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
164     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
165     AVCodecParameters *c = st->codecpar;
166
167     if (ctx->audio) {
168         av_log(avctx, AV_LOG_ERROR, "Only one audio stream is supported!\n");
169         return -1;
170     }
171     if (c->sample_rate != 48000) {
172         av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate!"
173                " Only 48kHz is supported.\n");
174         return -1;
175     }
176     if (c->channels != 2 && c->channels != 8 && c->channels != 16) {
177         av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels!"
178                " Only 2, 8 or 16 channels are supported.\n");
179         return -1;
180     }
181     if (ctx->dlo->EnableAudioOutput(bmdAudioSampleRate48kHz,
182                                     bmdAudioSampleType16bitInteger,
183                                     c->channels,
184                                     bmdAudioOutputStreamTimestamped) != S_OK) {
185         av_log(avctx, AV_LOG_ERROR, "Could not enable audio output!\n");
186         return -1;
187     }
188     if (ctx->dlo->BeginAudioPreroll() != S_OK) {
189         av_log(avctx, AV_LOG_ERROR, "Could not begin audio preroll!\n");
190         return -1;
191     }
192
193     /* The device expects the sample rate to be fixed. */
194     avpriv_set_pts_info(st, 64, 1, c->sample_rate);
195     ctx->channels = c->channels;
196
197     ctx->audio = 1;
198
199     return 0;
200 }
201
202 av_cold int ff_decklink_write_trailer(AVFormatContext *avctx)
203 {
204     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
205     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
206
207     if (ctx->playback_started) {
208         BMDTimeValue actual;
209         ctx->dlo->StopScheduledPlayback(ctx->last_pts * ctx->bmd_tb_num,
210                                         &actual, ctx->bmd_tb_den);
211         ctx->dlo->DisableVideoOutput();
212         if (ctx->audio)
213             ctx->dlo->DisableAudioOutput();
214     }
215
216     ff_decklink_cleanup(avctx);
217
218     if (ctx->output_callback)
219         delete ctx->output_callback;
220
221     pthread_mutex_destroy(&ctx->mutex);
222     pthread_cond_destroy(&ctx->cond);
223
224     av_freep(&cctx->ctx);
225
226     return 0;
227 }
228
229 static int decklink_write_video_packet(AVFormatContext *avctx, AVPacket *pkt)
230 {
231     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
232     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
233     AVFrame *avframe, *tmp = (AVFrame *)pkt->data;
234     decklink_frame *frame;
235     buffercount_type buffered;
236     HRESULT hr;
237
238     if (tmp->format != AV_PIX_FMT_UYVY422 ||
239         tmp->width  != ctx->bmd_width ||
240         tmp->height != ctx->bmd_height) {
241         av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid pixel format or dimension.\n");
242         return AVERROR(EINVAL);
243     }
244     avframe = av_frame_clone(tmp);
245     if (!avframe) {
246         av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
247         return AVERROR(EIO);
248     }
249
250     frame = new decklink_frame(ctx, avframe);
251     if (!frame) {
252         av_log(avctx, AV_LOG_ERROR, "Could not create new frame.\n");
253         av_frame_free(&avframe);
254         return AVERROR(EIO);
255     }
256
257     /* Always keep at most one second of frames buffered. */
258     pthread_mutex_lock(&ctx->mutex);
259     while (ctx->frames_buffer_available_spots == 0) {
260         pthread_cond_wait(&ctx->cond, &ctx->mutex);
261     }
262     ctx->frames_buffer_available_spots--;
263     pthread_mutex_unlock(&ctx->mutex);
264
265     /* Schedule frame for playback. */
266     hr = ctx->dlo->ScheduleVideoFrame((struct IDeckLinkVideoFrame *) frame,
267                                       pkt->pts * ctx->bmd_tb_num,
268                                       ctx->bmd_tb_num, ctx->bmd_tb_den);
269     /* Pass ownership to DeckLink, or release on failure */
270     frame->Release();
271     if (hr != S_OK) {
272         av_log(avctx, AV_LOG_ERROR, "Could not schedule video frame."
273                 " error %08x.\n", (uint32_t) hr);
274         return AVERROR(EIO);
275     }
276
277     ctx->dlo->GetBufferedVideoFrameCount(&buffered);
278     av_log(avctx, AV_LOG_DEBUG, "Buffered video frames: %d.\n", (int) buffered);
279     if (pkt->pts > 2 && buffered <= 2)
280         av_log(avctx, AV_LOG_WARNING, "There are not enough buffered video frames."
281                " Video may misbehave!\n");
282
283     /* Preroll video frames. */
284     if (!ctx->playback_started && pkt->pts > ctx->frames_preroll) {
285         av_log(avctx, AV_LOG_DEBUG, "Ending audio preroll.\n");
286         if (ctx->audio && ctx->dlo->EndAudioPreroll() != S_OK) {
287             av_log(avctx, AV_LOG_ERROR, "Could not end audio preroll!\n");
288             return AVERROR(EIO);
289         }
290         av_log(avctx, AV_LOG_DEBUG, "Starting scheduled playback.\n");
291         if (ctx->dlo->StartScheduledPlayback(0, ctx->bmd_tb_den, 1.0) != S_OK) {
292             av_log(avctx, AV_LOG_ERROR, "Could not start scheduled playback!\n");
293             return AVERROR(EIO);
294         }
295         ctx->playback_started = 1;
296     }
297
298     return 0;
299 }
300
301 static int decklink_write_audio_packet(AVFormatContext *avctx, AVPacket *pkt)
302 {
303     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
304     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
305     int sample_count = pkt->size / (ctx->channels << 1);
306     buffercount_type buffered;
307
308     ctx->dlo->GetBufferedAudioSampleFrameCount(&buffered);
309     if (pkt->pts > 1 && !buffered)
310         av_log(avctx, AV_LOG_WARNING, "There's no buffered audio."
311                " Audio will misbehave!\n");
312
313     if (ctx->dlo->ScheduleAudioSamples(pkt->data, sample_count, pkt->pts,
314                                        bmdAudioSampleRate48kHz, NULL) != S_OK) {
315         av_log(avctx, AV_LOG_ERROR, "Could not schedule audio samples.\n");
316         return AVERROR(EIO);
317     }
318
319     return 0;
320 }
321
322 extern "C" {
323
324 av_cold int ff_decklink_write_header(AVFormatContext *avctx)
325 {
326     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
327     struct decklink_ctx *ctx;
328     unsigned int n;
329     int ret;
330
331     ctx = (struct decklink_ctx *) av_mallocz(sizeof(struct decklink_ctx));
332     if (!ctx)
333         return AVERROR(ENOMEM);
334     ctx->list_devices = cctx->list_devices;
335     ctx->list_formats = cctx->list_formats;
336     ctx->preroll      = cctx->preroll;
337     cctx->ctx = ctx;
338
339     /* List available devices and exit. */
340     if (ctx->list_devices) {
341         ff_decklink_list_devices_legacy(avctx, 0, 1);
342         return AVERROR_EXIT;
343     }
344
345     ret = ff_decklink_init_device(avctx, avctx->filename);
346     if (ret < 0)
347         return ret;
348
349     /* Get output device. */
350     if (ctx->dl->QueryInterface(IID_IDeckLinkOutput, (void **) &ctx->dlo) != S_OK) {
351         av_log(avctx, AV_LOG_ERROR, "Could not open output device from '%s'\n",
352                avctx->filename);
353         ret = AVERROR(EIO);
354         goto error;
355     }
356
357     /* List supported formats. */
358     if (ctx->list_formats) {
359         ff_decklink_list_formats(avctx);
360         ret = AVERROR_EXIT;
361         goto error;
362     }
363
364     /* Setup streams. */
365     ret = AVERROR(EIO);
366     for (n = 0; n < avctx->nb_streams; n++) {
367         AVStream *st = avctx->streams[n];
368         AVCodecParameters *c = st->codecpar;
369         if        (c->codec_type == AVMEDIA_TYPE_AUDIO) {
370             if (decklink_setup_audio(avctx, st))
371                 goto error;
372         } else if (c->codec_type == AVMEDIA_TYPE_VIDEO) {
373             if (decklink_setup_video(avctx, st))
374                 goto error;
375         } else {
376             av_log(avctx, AV_LOG_ERROR, "Unsupported stream type.\n");
377             goto error;
378         }
379     }
380
381     return 0;
382
383 error:
384     ff_decklink_cleanup(avctx);
385     return ret;
386 }
387
388 int ff_decklink_write_packet(AVFormatContext *avctx, AVPacket *pkt)
389 {
390     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
391     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
392     AVStream *st = avctx->streams[pkt->stream_index];
393
394     ctx->last_pts = FFMAX(ctx->last_pts, pkt->pts);
395
396     if      (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
397         return decklink_write_video_packet(avctx, pkt);
398     else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
399         return decklink_write_audio_packet(avctx, pkt);
400
401     return AVERROR(EIO);
402 }
403
404 int ff_decklink_list_output_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list)
405 {
406     return ff_decklink_list_devices(avctx, device_list, 0, 1);
407 }
408
409 } /* extern "C" */