[deb_ffmpeg.git] / ffmpeg / libavdevice / decklink_enc.cpp

/*
 * Blackmagic DeckLink output
 * Copyright (c) 2013-2014 Ramiro Polla
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <DeckLinkAPI.h>

#include <pthread.h>
#include <semaphore.h>

extern "C" {
#include "libavformat/avformat.h"
#include "libavformat/internal.h"
#include "libavutil/imgutils.h"
}

#include "decklink_common.h"
#include "decklink_enc.h"


/* DeckLink callback class declaration */
class decklink_frame : public IDeckLinkVideoFrame
{
public:
    decklink_frame(struct decklink_ctx *ctx, AVFrame *avframe, long width,
                   long height, void *buffer) :
                   _ctx(ctx), _avframe(avframe), _width(width),
                   _height(height), _buffer(buffer), _refs(0) { }

    virtual long           STDMETHODCALLTYPE GetWidth      (void)          { return _width; }
    virtual long           STDMETHODCALLTYPE GetHeight     (void)          { return _height; }
    virtual long           STDMETHODCALLTYPE GetRowBytes   (void)          { return _width<<1; }
    virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void)          { return bmdFormat8BitYUV; }
    virtual BMDFrameFlags  STDMETHODCALLTYPE GetFlags      (void)          { return bmdVideoOutputFlagDefault; }
    virtual HRESULT        STDMETHODCALLTYPE GetBytes      (void **buffer) { *buffer = _buffer; return S_OK; }

    virtual HRESULT STDMETHODCALLTYPE GetTimecode     (BMDTimecodeFormat format, IDeckLinkTimecode **timecode) { return S_FALSE; }
    virtual HRESULT STDMETHODCALLTYPE GetAncillaryData(IDeckLinkVideoFrameAncillary **ancillary)               { return S_FALSE; }

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
    virtual ULONG   STDMETHODCALLTYPE AddRef(void)                            { return ++_refs; }
    virtual ULONG   STDMETHODCALLTYPE Release(void)                           { if (!--_refs) delete this; return _refs; }

    struct decklink_ctx *_ctx;
    AVFrame *_avframe;

private:
    long  _width;
    long  _height;
    void *_buffer;
    int   _refs;
};

class decklink_output_callback : public IDeckLinkVideoOutputCallback
{
public:
    virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted(IDeckLinkVideoFrame *_frame, BMDOutputFrameCompletionResult result)
    {
        decklink_frame *frame = static_cast<decklink_frame *>(_frame);
        struct decklink_ctx *ctx = frame->_ctx;
        AVFrame *avframe = frame->_avframe;

        av_frame_free(&avframe);

        sem_post(&ctx->semaphore);

        return S_OK;
    }
    virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped(void)       { return S_OK; }
    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
    virtual ULONG   STDMETHODCALLTYPE AddRef(void)                            { return 1; }
    virtual ULONG   STDMETHODCALLTYPE Release(void)                           { return 1; }
};

static int decklink_setup_video(AVFormatContext *avctx, AVStream *st)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
    AVCodecContext *c = st->codec;

    if (ctx->video) {
        av_log(avctx, AV_LOG_ERROR, "Only one video stream is supported!\n");
        return -1;
    }

    if (c->pix_fmt != AV_PIX_FMT_UYVY422) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
               " Only AV_PIX_FMT_UYVY422 is supported.\n");
        return -1;
    }
    if (ff_decklink_set_format(avctx, c->width, c->height,
                            c->time_base.num, c->time_base.den)) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported video size or framerate!"
               " Check available formats with -list_formats 1.\n");
        return -1;
    }
    if (ctx->dlo->EnableVideoOutput(ctx->bmd_mode,
                                    bmdVideoOutputFlagDefault) != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not enable video output!\n");
        return -1;
    }

    /* Set callback. */
    ctx->output_callback = new decklink_output_callback();
    ctx->dlo->SetScheduledFrameCompletionCallback(ctx->output_callback);

    /* Start video semaphore. */
    ctx->frames_preroll = c->time_base.den * ctx->preroll;
    if (c->time_base.den > 1000)
        ctx->frames_preroll /= 1000;

    /* Buffer twice as many frames as the preroll. */
    ctx->frames_buffer = ctx->frames_preroll * 2;
    ctx->frames_buffer = FFMIN(ctx->frames_buffer, 60);
    sem_init(&ctx->semaphore, 0, ctx->frames_buffer);

    /* The device expects the framerate to be fixed. */
    avpriv_set_pts_info(st, 64, c->time_base.num, c->time_base.den);

    ctx->video = 1;

    return 0;
}

static int decklink_setup_audio(AVFormatContext *avctx, AVStream *st)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
    AVCodecContext *c = st->codec;

    if (ctx->audio) {
        av_log(avctx, AV_LOG_ERROR, "Only one audio stream is supported!\n");
        return -1;
    }
    if (c->sample_rate != 48000) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate!"
               " Only 48kHz is supported.\n");
        return -1;
    }
    if (c->channels != 2 && c->channels != 8) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels!"
               " Only stereo and 7.1 are supported.\n");
        return -1;
    }
    if (ctx->dlo->EnableAudioOutput(bmdAudioSampleRate48kHz,
                                    bmdAudioSampleType16bitInteger,
                                    c->channels,
                                    bmdAudioOutputStreamTimestamped) != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not enable audio output!\n");
        return -1;
    }
    if (ctx->dlo->BeginAudioPreroll() != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not begin audio preroll!\n");
        return -1;
    }

    /* The device expects the sample rate to be fixed. */
    avpriv_set_pts_info(st, 64, 1, c->sample_rate);
    ctx->channels = c->channels;

    ctx->audio = 1;

    return 0;
}

av_cold int ff_decklink_write_trailer(AVFormatContext *avctx)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;

    if (ctx->playback_started) {
        BMDTimeValue actual;
        ctx->dlo->StopScheduledPlayback(ctx->last_pts * ctx->bmd_tb_num,
                                        &actual, ctx->bmd_tb_den);
        ctx->dlo->DisableVideoOutput();
        if (ctx->audio)
            ctx->dlo->DisableAudioOutput();
    }

    if (ctx->dlo)
        ctx->dlo->Release();
    if (ctx->dl)
        ctx->dl->Release();

    if (ctx->output_callback)
        delete ctx->output_callback;

    sem_destroy(&ctx->semaphore);

    av_freep(&cctx->ctx);

    return 0;
}

static int decklink_write_video_packet(AVFormatContext *avctx, AVPacket *pkt)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
    AVPicture *avpicture = (AVPicture *) pkt->data;
    AVFrame *avframe, *tmp;
    decklink_frame *frame;
    buffercount_type buffered;
    HRESULT hr;

    /* HACK while av_uncoded_frame() isn't implemented */
    int ret;

    tmp = av_frame_alloc();
    if (!tmp)
        return AVERROR(ENOMEM);
    tmp->format = AV_PIX_FMT_UYVY422;
    tmp->width  = ctx->bmd_width;
    tmp->height = ctx->bmd_height;
    ret = av_frame_get_buffer(tmp, 32);
    if (ret < 0) {
        av_frame_free(&tmp);
        return ret;
    }
    av_image_copy(tmp->data, tmp->linesize, (const uint8_t **) avpicture->data,
                  avpicture->linesize, (AVPixelFormat) tmp->format, tmp->width,
                  tmp->height);
    avframe = av_frame_clone(tmp);
    av_frame_free(&tmp);
    if (!avframe) {
        av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
        return AVERROR(EIO);
    }
    /* end HACK */

    frame = new decklink_frame(ctx, avframe, ctx->bmd_width, ctx->bmd_height,
                               (void *) avframe->data[0]);
    if (!frame) {
        av_log(avctx, AV_LOG_ERROR, "Could not create new frame.\n");
        return AVERROR(EIO);
    }

    /* Always keep at most one second of frames buffered. */
    sem_wait(&ctx->semaphore);

    /* Schedule frame for playback. */
    hr = ctx->dlo->ScheduleVideoFrame((struct IDeckLinkVideoFrame *) frame,
                                      pkt->pts * ctx->bmd_tb_num,
                                      ctx->bmd_tb_num, ctx->bmd_tb_den);
    if (hr != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not schedule video frame."
                " error %08x.\n", (uint32_t) hr);
        frame->Release();
        return AVERROR(EIO);
    }

    ctx->dlo->GetBufferedVideoFrameCount(&buffered);
    av_log(avctx, AV_LOG_DEBUG, "Buffered video frames: %d.\n", (int) buffered);
    if (pkt->pts > 2 && buffered <= 2)
        av_log(avctx, AV_LOG_WARNING, "There are not enough buffered video frames."
               " Video may misbehave!\n");

    /* Preroll video frames. */
    if (!ctx->playback_started && pkt->pts > ctx->frames_preroll) {
        av_log(avctx, AV_LOG_DEBUG, "Ending audio preroll.\n");
        if (ctx->audio && ctx->dlo->EndAudioPreroll() != S_OK) {
            av_log(avctx, AV_LOG_ERROR, "Could not end audio preroll!\n");
            return AVERROR(EIO);
        }
        av_log(avctx, AV_LOG_DEBUG, "Starting scheduled playback.\n");
        if (ctx->dlo->StartScheduledPlayback(0, ctx->bmd_tb_den, 1.0) != S_OK) {
            av_log(avctx, AV_LOG_ERROR, "Could not start scheduled playback!\n");
            return AVERROR(EIO);
        }
        ctx->playback_started = 1;
    }

    return 0;
}

static int decklink_write_audio_packet(AVFormatContext *avctx, AVPacket *pkt)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
    int sample_count = pkt->size / (ctx->channels << 1);
    buffercount_type buffered;

    ctx->dlo->GetBufferedAudioSampleFrameCount(&buffered);
    if (pkt->pts > 1 && !buffered)
        av_log(avctx, AV_LOG_WARNING, "There's no buffered audio."
               " Audio will misbehave!\n");

    if (ctx->dlo->ScheduleAudioSamples(pkt->data, sample_count, pkt->pts,
                                       bmdAudioSampleRate48kHz, NULL) != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not schedule audio samples.\n");
        return AVERROR(EIO);
    }

    return 0;
}

extern "C" {

av_cold int ff_decklink_write_header(AVFormatContext *avctx)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx;
    IDeckLinkDisplayModeIterator *itermode;
    IDeckLinkIterator *iter;
    IDeckLink *dl = NULL;
    unsigned int n;

    ctx = (struct decklink_ctx *) av_mallocz(sizeof(struct decklink_ctx));
    if (!ctx)
        return AVERROR(ENOMEM);
    ctx->list_devices = cctx->list_devices;
    ctx->list_formats = cctx->list_formats;
    ctx->preroll      = cctx->preroll;
    cctx->ctx = ctx;

    iter = CreateDeckLinkIteratorInstance();
    if (!iter) {
        av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
        return AVERROR(EIO);
    }

    /* List available devices. */
    if (ctx->list_devices) {
        ff_decklink_list_devices(avctx);
        return AVERROR_EXIT;
    }

    /* Open device. */
    while (iter->Next(&dl) == S_OK) {
        const char *displayName;
        ff_decklink_get_display_name(dl, &displayName);
        if (!strcmp(avctx->filename, displayName)) {
            av_free((void *) displayName);
            ctx->dl = dl;
            break;
        }
        av_free((void *) displayName);
        dl->Release();
    }
    iter->Release();
    if (!ctx->dl) {
        av_log(avctx, AV_LOG_ERROR, "Could not open '%s'\n", avctx->filename);
        return AVERROR(EIO);
    }

    /* Get output device. */
    if (ctx->dl->QueryInterface(IID_IDeckLinkOutput, (void **) &ctx->dlo) != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not open output device from '%s'\n",
               avctx->filename);
        ctx->dl->Release();
        return AVERROR(EIO);
    }

    /* List supported formats. */
    if (ctx->list_formats) {
        ff_decklink_list_formats(avctx);
        ctx->dlo->Release();
        ctx->dl->Release();
        return AVERROR_EXIT;
    }

    if (ctx->dlo->GetDisplayModeIterator(&itermode) != S_OK) {
        av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
        ctx->dl->Release();
        return AVERROR(EIO);
    }

    /* Setup streams. */
    for (n = 0; n < avctx->nb_streams; n++) {
        AVStream *st = avctx->streams[n];
        AVCodecContext *c = st->codec;
        if        (c->codec_type == AVMEDIA_TYPE_AUDIO) {
            if (decklink_setup_audio(avctx, st))
                goto error;
        } else if (c->codec_type == AVMEDIA_TYPE_VIDEO) {
            if (decklink_setup_video(avctx, st))
                goto error;
        } else {
            av_log(avctx, AV_LOG_ERROR, "Unsupported stream type.\n");
            goto error;
        }
    }
    itermode->Release();

    return 0;

error:

    ctx->dlo->Release();
    ctx->dl->Release();

    return AVERROR(EIO);
}

int ff_decklink_write_packet(AVFormatContext *avctx, AVPacket *pkt)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
    struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
    AVStream *st = avctx->streams[pkt->stream_index];

    ctx->last_pts = FFMAX(ctx->last_pts, pkt->pts);

    if      (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        return decklink_write_video_packet(avctx, pkt);
    else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
        return decklink_write_audio_packet(avctx, pkt);

    return AVERROR(EIO);
}

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