[FFmpeg-devel] Implement NewTek NDI support

Submitted by Maksym Veremeyenko on Aug. 3, 2017, 5:21 a.m.

Details

Message ID 9985864f-8828-6fcb-586c-648974eabc00@m1stereo.tv
State Superseded
Headers show

Commit Message

Maksym Veremeyenko Aug. 3, 2017, 5:21 a.m.
On 30.07.2017 17:19, Marton Balint wrote:
[...]
>> Subject: [PATCH] lavd: implement NewTek NDI muxer/demuxer support
>
> lavd: implement NewTek NDI input/output device support
>
fixed

[...]
>>  - Dolby E decoder and SMPTE 337M demuxer
>> +- NewTek NDI muxer/demuxer
>
> NewTek NDI input/output device
>
fixed

[...]
>> +@item wait_sources
>> +Override time to wait until the number of online sources have changed.
>> +Defaults to @option{500000}.
>
> Defaults to @option{0.5} sec.
>
> By the way, is this enough? SDK warns that it might take a few seconds
> to list all the sources. SDK example uses 5 second, shouldn't we us that
> as well as the default?
>
we can increase it after... but from my tests it is enough. moreover, i 
did some rework of /waiting process/

>> +@item max_frames_probe
>> +Maximum frames for probe input format.
>> +Defaults to @option{25}.
>
> This option is no longer needed/used.
>
fixed

[...]
>> +NDI is very picky about the formats it supports. Pixel format is always
>> +uyvy422. Audio sample rate is always 48 kHz.
>
> Is there a real limitation to 48 kHz? You might support anything unless
> there
> is a good reason to restrict it to 48 kHz.
>
no limitation:

[...]
sample_rate (int)
This is the current audio sample rate. For instance, this might be 
44100, 48000 or 96000. It can, however, be any value.
[...]

i will drop any checks of sample rate

>> +    int max_frames_probe;
>
> no longer needed.
>
done

[...]
>> +    const NDIlib_find_create_t find_create_desc = { true, NULL };
>
> for readability you should name your set fields, e.g. find_create_desc =
> { .show_local_sources = true };
>
done

[...]
>> +    NDIlib_find_destroy(ndi_find);
>
> Probably you should not destroy this here, only in ndi_read_close after
> freeing
> ctx->recv, because as far as I see the found NDIlib_source_t is might be
> freed
> here as well which you would also like to use after returning from this
> function.
>
i moved ndi_find to context and destroying it moved to ndi_read_close

[...]
>> +    const NDIlib_tally_t tally_state = { true, false };
>
> for readability you should name your set fields
>
done

[...]
>> +    st->time_base                   = NDI_TIME_BASE_Q;
>> +    av_stream_set_r_frame_rate(st, av_make_q(v->frame_rate_N,
>> v->frame_rate_D));
>> +
>> +    st->sample_aspect_ratio = st->codecpar->sample_aspect_ratio =
>> +        av_mul_q(av_d2q(v->picture_aspect_ratio, INT_MAX),
>> (AVRational){v->yres, v->xres});
>
> Since the source aspect ratio is float, and there are some very inaccurate
> representations of 16/9 in the include files and sdk (e.g. 16/9 = 1.778),
> I suggest we drop some precision here as well because we don't want to get
> 134217729:134217728 kind of sample aspect ratios.
>
> Something like:
>
> tmp = av_mul_q(av_d2q(v->picture_aspect_ratio, INT_MAX),
> (AVRational){v->yres, v->xres});
> av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den,
> tmp.num, tmp.den, 1000);
>
done

[...]
>> +
>> +    st->codecpar->codec_type        = AVMEDIA_TYPE_VIDEO;
>> +    st->codecpar->width             = v->xres;
>> +    st->codecpar->height            = v->yres;
>> +    st->codecpar->codec_id          = AV_CODEC_ID_RAWVIDEO;
>> +    st->codecpar->bit_rate          = av_rescale(v->xres * v->yres *
>> 16, st->time_base.den, st->time_base.num);
>
> Here you probably want to use frame rate instead of time base.
>
fixed


>> +//    avpriv_set_pts_info(st, 64, 1, a->sample_rate);
>
> stale line which can be removed
>
done

[...]
>> +    if (ctx->ndi_send) {
>> +        if (ctx->last_avframe) {
>> +            /* send NULL to flush equeued frame */
>> +            NDIlib_send_send_video_async(ctx->ndi_send, NULL);
>
> This line crashes for me under x86_64 linux, it seems to dereference the
> null
> pointer. SDK bug?
yes, it is SDK (libndi.so.1.0.1) bug. SDK provided by request (seems 
betta, libndi.so.3.0.1) has no this bug.

> Maybe you should simply do:
>
>          NDIlib_send_destroy(ctx->ndi_send);
>          av_frame_free(&ctx->last_avframe);
>
> Although I don't know if this flushes (sends) the last frame, or simply
> drops
> it... Anyhow, better than crashing, if you can't fix the crash.
>
done

[...]
>> +        : (void *)(avframe->data[0]);
>
> As NDI has no way of signalling a flipped image, I think it is best if you
> simply reject frames with negative linesize.
>
may be warning will be enough?

>> +    if (c->sample_rate != 48000) {
>> +        av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate!"
>> +               " Only 48kHz is supported.\n");
>> +        return AVERROR(EINVAL);
>> +    }
>
> As I mentioned earlier, you should consider supporting any sample rate.
>
done

>> +
>> +    ctx->audio =
>> av_mallocz(sizeof(NDIlib_audio_frame_interleaved_16s_t));
>> +    if (!ctx->audio)
>> +        return AVERROR(ENOMEM);
>> +
>> +    ctx->audio->sample_rate = c->sample_rate;
>> +    ctx->audio->no_channels = c->channels;
>> +    ctx->audio->reference_level = ctx->reference_level;
>> +
>> +    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE/*c->sample_rate*/);
>
> stale comment
>
cleaned

[...]
>> +    ctx->video->xres = c->width;
>> +    ctx->video->yres = c->height;
>> +    ctx->video->frame_rate_N = st->avg_frame_rate.num;
>> +    ctx->video->frame_rate_D = st->avg_frame_rate.den;
>> +    ctx->video->frame_format_type = c->field_order ==
>> AV_FIELD_PROGRESSIVE
>> +        ? NDIlib_frame_format_type_progressive
>> +        : NDIlib_frame_format_type_interleaved;
>
> You should reject bottom field first formats, as NDI explicitly
> disallows them.
>
even if it disallowed, why to drop? may be warning message would be enough?


[...]
>> +//    avpriv_set_pts_info(st, 64, st->time_base.num, st->time_base.den);
>
> please remove this stale line as well.
>
done

>> +    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
>> +
>> +    return 0;
>> +}
>> +
>> +static int ndi_write_header(AVFormatContext *avctx)
>> +{
>> +    int ret = 0;
>> +    unsigned int n;
>> +    struct NDIContext *ctx = avctx->priv_data;
>> +    const NDIlib_send_create_t ndi_send_desc = {avctx->filename,
>> NULL, true, false};
>
> for readability you should name your set fields here as well.
>
done


> You might consider adding connection metadata to identify libavdevice as
> sender
> and signal the version. You might use something like "Lavd
> libndi_newtek" for
> the product name and use LIBAVDEVICE_VERSION for the version number.
>
i planned to add this later with user's defined metadata.

> I tried receiving an NDI source I created with ffmpeg, but it was not
> listed.
> Is this expected? I thought local sources should appear as well.
>
it should... that is my current testing environment
i reworked *ndi_find_sources*, please do a tests

> Also, v3 of the SDK is to be released very soon. Maybe better to wait
> for it
> and use that? Hopefully less bugs in the SDK itself?
i hope they will release it till IBC... but it has very small difference 
against current patch to support this.

Comments

Steinar H. Gunderson Aug. 3, 2017, 7:15 a.m.
On Thu, Aug 03, 2017 at 08:21:09AM +0300, Maksym Veremeyenko wrote:
>> You should reject bottom field first formats, as NDI explicitly
>> disallows them.
> even if it disallowed, why to drop? may be warning message would be enough?

FWIW, the documentation may say that formats are always TFF, but on the wire,
it seems the bottom field actually goes first.

(I guess this is a bug that isn't noticed because there's actually no way
from the API to get at the individual fields)

> +NDI is very picky about the formats it supports. Pixel format is always
> +uyvy422.

Or bgra (internally, uyvya4224, I suppose).

> +    recv_create_desc.allow_video_fields = ctx->allow_video_fields;

I'm not convinced you ever want to set this to false, as what's happening if
you do is simply that the SDK applies a vertical blur to incoming interlaced
frames. FFmpeg has much better deinterlacers if that's what you want.

/* Steinar */
Steinar H. Gunderson Aug. 3, 2017, 7:41 a.m.
On Thu, Aug 03, 2017 at 08:21:09AM +0300, Maksym Veremeyenko wrote:
>> You should reject bottom field first formats, as NDI explicitly
>> disallows them.
> even if it disallowed, why to drop? may be warning message would be enough?

FWIW, the documentation may say that formats are always TFF, but on the wire,
it seems the bottom field actually goes first.

(I guess this is a bug that isn't noticed because there's actually no way
from the API to get at the individual fields)

> +NDI is very picky about the formats it supports. Pixel format is always
> +uyvy422.

Or bgra (internally, uyvya4224, I suppose).

> +    recv_create_desc.allow_video_fields = ctx->allow_video_fields;

I'm not convinced you ever want to set this to false, as what's happening if
you do is simply that the SDK applies a vertical blur to incoming interlaced
frames. FFmpeg has much better deinterlacers if that's what you want.

/* Steinar */
Marton Balint Aug. 5, 2017, 7:46 p.m.
On Thu, 3 Aug 2017, Maksym Veremeyenko wrote:

> On 30.07.2017 17:19, Marton Balint wrote:
> [...]
>>> Subject: [PATCH] lavd: implement NewTek NDI muxer/demuxer support

Hi,

About the warnings for the bottom field order and the negative linesize, I 
still think it is better to reject them (return an error), this way the 
user will be forced to fix the input, by changing the field order (e.g by 
using the fieldorder filter before passing video) or getting rid of the 
negative linesize.

To support negative linesizes, there is one more thing you might do: If the
source frame has a negative linesize, then instead of cloning, allocate a new
avframe with av_frame_alloc, set widht/height/format, use av_frame_get_buffer
to allocate a buffer, then use av_frame_copy to copy the data from the source
frame to the newly allocated one which should have a positive linesize.
A bit too much work for a rarely used feature, but if you are interested, it is
doable. You can generate a negative linesize source with the vflip filter.

I did some further tests, and I still cannot see my own ffmpeg generated
source, I am running this command:

./ffmpeg -nostdin -f libndi_newtek -wait_sources 10 -find_sources 1 -i none & ./ffmpeg -f lavfi -i mptestsrc,format=pix_fmts=uyvy422 -f libndi_newtek dummy

Even after 10 seconds, the first process finds 0 sources, the second process is
running happily. Does this work for you?

I also have some additional comments for the patch:

[..]

> +@subsection Examples
> +
> +@itemize
> +
> +@item
> +Play video clip:
> +@example
> +ffmpeg -i "udp://@239.1.1.1:10480?fifo_size=1000000&overrun_nonfatal=1" -vf "scale=720:576,fps=fps=25,setdar=dar=16/9,format=pix_fmts=uyvy422" -f libndi_newtek NEW_NDI1

@ needs escaping into @@

[..]

> +    while (1)
> +    {
> +        int f, t = ctx->wait_sources / 1000;
> +        av_log(avctx, AV_LOG_DEBUG, "Waiting for sources %d miliseconds\n", t);
> +        f = NDIlib_find_wait_for_sources(ctx->ndi_find, t);
> +        av_log(avctx, AV_LOG_DEBUG, "NDIlib_find_wait_for_sources returns %d\n", f);
> +        if (!f)
> +            break;
> +    };

You should not loop indefinitely, give up after a few tries.

[..]

> +static int ndi_write_video_packet(AVFormatContext *avctx, AVStream *st, AVPacket *pkt)
> +{
> +    struct NDIContext *ctx = avctx->priv_data;
> +    AVFrame *avframe, *tmp = (AVFrame *)pkt->data;
> +
> +    if (tmp->format != AV_PIX_FMT_UYVY422 ||
> +        tmp->width  != ctx->video->xres ||
> +        tmp->height != ctx->video->yres) {
> +        av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid pixel format or dimension.\n");
> +        av_log(avctx, AV_LOG_ERROR, "tmp->width=%d, tmp->height=%d, ctx->video->xres=%d, ctx->video->yres=%d\n", tmp->width, tmp->height, ctx->video->xres, ctx->video->yres);
> +        return AVERROR(EINVAL);
> +    }
> +    avframe = av_frame_clone(tmp);
> +    if (!avframe) {
> +        av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");

For ENOMEM we typically don't use an error message.

[..]


> +static int ndi_write_header(AVFormatContext *avctx)
> +{
> +    int ret = 0;
> +    unsigned int n;
> +    struct NDIContext *ctx = avctx->priv_data;
> +    const NDIlib_send_create_t ndi_send_desc = { .p_ndi_name = avctx->filename,
> +        .p_groups = NULL, .clock_video = false, .clock_audio = false };

Setting both clock_video and clock_audio to false is intentional? Maybe better
to clock based on the stream types you get? (E.g. clock to video if you have a
video stream, clock to audio otherwise?)

Regards,
Marton
Maksym Veremeyenko Aug. 8, 2017, 9:29 a.m.
On 03.08.2017 10:41, Steinar H. Gunderson wrote:
> On Thu, Aug 03, 2017 at 08:21:09AM +0300, Maksym Veremeyenko wrote:
>>> You should reject bottom field first formats, as NDI explicitly
>>> disallows them.
>> even if it disallowed, why to drop? may be warning message would be enough?
>
> FWIW, the documentation may say that formats are always TFF, but on the wire,
> it seems the bottom field actually goes first.
>
> (I guess this is a bug that isn't noticed because there's actually no way
> from the API to get at the individual fields)
>
i dropped bottom field order support.

>> +NDI is very picky about the formats it supports. Pixel format is always
>> +uyvy422.
>
> Or bgra (internally, uyvya4224, I suppose).
>
i extended supported pixel format, except uyvya4224 that is not 
supported by ffmpeg

>> +    recv_create_desc.allow_video_fields = ctx->allow_video_fields;
>
> I'm not convinced you ever want to set this to false, as what's happening if
> you do is simply that the SDK applies a vertical blur to incoming interlaced
> frames. FFmpeg has much better deinterlacers if that's what you want.
i dont know which method used by SDK to deinterlace, but if it provided, 
then it could be used for some reason.

Patch hide | download patch | download mbox

From 65a4b1de8989553db6d3a18256cd448bff7e3033 Mon Sep 17 00:00:00 2001
From: Maksym Veremeyenko <verem@m1.tv>
Date: Thu, 3 Aug 2017 04:52:04 -0400
Subject: [PATCH] lavd: implement NewTek NDI input/output device support

---
 Changelog                          |   1 +
 configure                          |   9 +
 doc/indevs.texi                    |  53 ++++++
 doc/outdevs.texi                   |  37 ++++
 libavdevice/Makefile               |   4 +
 libavdevice/alldevices.c           |   1 +
 libavdevice/libndi_newtek_common.h |  30 ++++
 libavdevice/libndi_newtek_dec.c    | 343 +++++++++++++++++++++++++++++++++++++
 libavdevice/libndi_newtek_enc.c    | 277 ++++++++++++++++++++++++++++++
 libavdevice/version.h              |   2 +-
 10 files changed, 756 insertions(+), 1 deletion(-)
 create mode 100644 libavdevice/libndi_newtek_common.h
 create mode 100644 libavdevice/libndi_newtek_dec.c
 create mode 100644 libavdevice/libndi_newtek_enc.c

diff --git a/Changelog b/Changelog
index 3074942..3bce00a 100644
--- a/Changelog
+++ b/Changelog
@@ -30,6 +30,7 @@  version <next>:
 - libvmaf video filter
 - Dolby E decoder and SMPTE 337M demuxer
 - unpremultiply video filter
+- NewTek NDI input/output device
 
 version 3.3:
 - CrystalHD decoder moved to new decode API
diff --git a/configure b/configure
index 66c7b94..32ee901 100755
--- a/configure
+++ b/configure
@@ -277,6 +277,7 @@  External library support:
   --enable-libzvbi         enable teletext support via libzvbi [no]
   --disable-lzma           disable lzma [autodetect]
   --enable-decklink        enable Blackmagic DeckLink I/O support [no]
+  --enable-libndi_newtek   enable Newteck NDI I/O support [no]
   --enable-mediacodec      enable Android MediaCodec support [no]
   --enable-libmysofa       enable libmysofa, needed for sofalizer filter [no]
   --enable-openal          enable OpenAL 1.1 capture support [no]
@@ -1508,6 +1509,7 @@  EXTERNAL_LIBRARY_GPL_LIST="
 
 EXTERNAL_LIBRARY_NONFREE_LIST="
     decklink
+    libndi_newtek
     libfdk_aac
     openssl
 "
@@ -3013,6 +3015,10 @@  decklink_indev_deps="decklink threads"
 decklink_indev_extralibs="-lstdc++"
 decklink_outdev_deps="decklink threads"
 decklink_outdev_extralibs="-lstdc++"
+libndi_newtek_indev_deps="libndi_newtek"
+libndi_newtek_indev_extralibs="-lndi"
+libndi_newtek_outdev_deps="libndi_newtek"
+libndi_newtek_outdev_extralibs="-lndi"
 dshow_indev_deps="IBaseFilter"
 dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid -loleaut32 -lshlwapi"
 dv1394_indev_deps="dv1394"
@@ -5566,6 +5572,8 @@  avisynth_demuxer_extralibs='$ldl'
 cuda_extralibs='$ldl'
 decklink_outdev_extralibs="$decklink_outdev_extralibs $ldl"
 decklink_indev_extralibs="$decklink_indev_extralibs $ldl"
+libndi_newtek_outdev_extralibs="$libndi_newtek_outdev_extralibs $ldl"
+libndi_newtek_indev_extralibs="$libndi_newtek_indev_extralibs $ldl"
 frei0r_filter_extralibs='$ldl'
 frei0r_src_filter_extralibs='$ldl'
 ladspa_filter_extralibs='$ldl'
@@ -5824,6 +5832,7 @@  enabled coreimage_filter  && { check_header_objcc QuartzCore/CoreImage.h || disa
 enabled coreimagesrc_filter && { check_header_objcc QuartzCore/CoreImage.h || disable coreimagesrc_filter; }
 enabled decklink          && { { check_header DeckLinkAPI.h || die "ERROR: DeckLinkAPI.h header not found"; } &&
                                { check_cpp_condition DeckLinkAPIVersion.h "BLACKMAGIC_DECKLINK_API_VERSION >= 0x0a060100" || die "ERROR: Decklink API version must be >= 10.6.1."; } }
+enabled libndi_newtek     && { check_header Processing.NDI.Lib.h || die "ERROR: Processing.NDI.Lib.h header not found"; }
 enabled frei0r            && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
 enabled gmp               && require gmp gmp.h mpz_export -lgmp
 enabled gnutls            && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
diff --git a/doc/indevs.texi b/doc/indevs.texi
index 09e3321..f6ad81e 100644
--- a/doc/indevs.texi
+++ b/doc/indevs.texi
@@ -327,6 +327,59 @@  ffmpeg -channels 16 -format_code Hi50 -f decklink -i 'UltraStudio Mini Recorder'
 
 @end itemize
 
+@section libndi_newtek
+
+The libndi_newtek input device provides capture capabilities for using NDI (Network
+Device Interface, standard created by NewTek).
+
+Input filename is a NDI source name that could be found by sending -find_sources 1
+to command line - it has no specific syntax but human-readable formatted.
+
+To enable this input device, you need the NDI SDK and you
+need to configure with the appropriate @code{--extra-cflags}
+and @code{--extra-ldflags}.
+
+@subsection Options
+
+@table @option
+
+@item find_sources
+If set to @option{true}, print a list of found/available NDI sources and exit.
+Defaults to @option{false}.
+
+@item wait_sources
+Override time to wait until the number of online sources have changed.
+Defaults to @option{0.5}.
+
+@item allow_video_fields
+When this flag is @option{false}, all video that you receive will be progressive.
+Defaults to @option{true}.
+
+@item reference_level
+The audio reference level in dB. This specifies how many dB above the
+reference level (+4dBU) is the full range of 16 bit audio.
+Defaults to @option{0}.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+List input devices:
+@example
+ffmpeg -f libndi_newtek -find_sources 1 -i dummy
+@end example
+
+@item
+Restream to NDI:
+@example
+ffmpeg -f libndi_newtek -i "DEV-5.INTERNAL.M1STEREO.TV (NDI_SOURCE_NAME_1)" -f libndi_newtek -y NDI_SOURCE_NAME_2
+@end example
+
+@end itemize
+
 @section dshow
 
 Windows DirectShow input device.
diff --git a/doc/outdevs.texi b/doc/outdevs.texi
index df41cc8..72e6776 100644
--- a/doc/outdevs.texi
+++ b/doc/outdevs.texi
@@ -182,6 +182,43 @@  ffmpeg -i test.avi -f decklink -pix_fmt uyvy422 -s 720x486 -r 24000/1001 'DeckLi
 
 @end itemize
 
+@section libndi_newtek
+
+The libndi_newtek output device provides playback capabilities for using NDI (Network
+Device Interface, standard created by NewTek).
+
+Output filename is a NDI name.
+
+To enable this output device, you need the NDI SDK and you
+need to configure with the appropriate @code{--extra-cflags}
+and @code{--extra-ldflags}.
+
+NDI is very picky about the formats it supports. Pixel format is always
+uyvy422.
+
+@subsection Options
+
+@table @option
+
+@item reference_level
+The audio reference level in dB. This specifies how many dB above the
+reference level (+4dBU) is the full range of 16 bit audio.
+Defaults to @option{0}.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+Play video clip:
+@example
+ffmpeg -i "udp://@239.1.1.1:10480?fifo_size=1000000&overrun_nonfatal=1" -vf "scale=720:576,fps=fps=25,setdar=dar=16/9,format=pix_fmts=uyvy422" -f libndi_newtek NEW_NDI1
+@end example
+
+@end itemize
+
 @section fbdev
 
 Linux framebuffer output device.
diff --git a/libavdevice/Makefile b/libavdevice/Makefile
index 1d4e9e6..80afa61 100644
--- a/libavdevice/Makefile
+++ b/libavdevice/Makefile
@@ -19,6 +19,8 @@  OBJS-$(CONFIG_BKTR_INDEV)                += bktr.o
 OBJS-$(CONFIG_CACA_OUTDEV)               += caca.o
 OBJS-$(CONFIG_DECKLINK_OUTDEV)           += decklink_enc.o decklink_enc_c.o decklink_common.o
 OBJS-$(CONFIG_DECKLINK_INDEV)            += decklink_dec.o decklink_dec_c.o decklink_common.o
+OBJS-$(CONFIG_LIBNDI_NEWTEK_OUTDEV)      += libndi_newtek_enc.o
+OBJS-$(CONFIG_LIBNDI_NEWTEK_INDEV)       += libndi_newtek_dec.o
 OBJS-$(CONFIG_DSHOW_INDEV)               += dshow_crossbar.o dshow.o dshow_enummediatypes.o \
                                             dshow_enumpins.o dshow_filter.o \
                                             dshow_pin.o dshow_common.o
@@ -60,6 +62,8 @@  SLIBOBJS-$(HAVE_GNU_WINDRES)             += avdeviceres.o
 SKIPHEADERS                              += decklink_common.h
 SKIPHEADERS-$(CONFIG_DECKLINK)           += decklink_enc.h decklink_dec.h \
                                             decklink_common_c.h
+SKIPHEADERS-$(CONFIG_LIBNDI_NEWTEK_INDEV) += libndi_newtek_common.h
+SKIPHEADERS-$(CONFIG_LIBNDI_NEWTEK_OUTDEV) += libndi_newtek_common.h
 SKIPHEADERS-$(CONFIG_DSHOW_INDEV)        += dshow_capture.h
 SKIPHEADERS-$(CONFIG_FBDEV_INDEV)        += fbdev_common.h
 SKIPHEADERS-$(CONFIG_FBDEV_OUTDEV)       += fbdev_common.h
diff --git a/libavdevice/alldevices.c b/libavdevice/alldevices.c
index a8ed53a..8d1cb86 100644
--- a/libavdevice/alldevices.c
+++ b/libavdevice/alldevices.c
@@ -46,6 +46,7 @@  static void register_all(void)
     REGISTER_INDEV   (BKTR,             bktr);
     REGISTER_OUTDEV  (CACA,             caca);
     REGISTER_INOUTDEV(DECKLINK,         decklink);
+    REGISTER_INOUTDEV(LIBNDI_NEWTEK,    libndi_newtek);
     REGISTER_INDEV   (DSHOW,            dshow);
     REGISTER_INDEV   (DV1394,           dv1394);
     REGISTER_INOUTDEV(FBDEV,            fbdev);
diff --git a/libavdevice/libndi_newtek_common.h b/libavdevice/libndi_newtek_common.h
new file mode 100644
index 0000000..8990317
--- /dev/null
+++ b/libavdevice/libndi_newtek_common.h
@@ -0,0 +1,30 @@ 
+/*
+ * NewTek NDI common code
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
+ * 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
+ */
+
+#ifndef AVDEVICE_LIBNDI_NEWTEK_COMMON_H
+#define AVDEVICE_LIBNDI_NEWTEK_COMMON_H
+
+#include <Processing.NDI.Lib.h>
+
+#define NDI_TIME_BASE 10000000
+#define NDI_TIME_BASE_Q (AVRational){1, NDI_TIME_BASE}
+
+#endif
diff --git a/libavdevice/libndi_newtek_dec.c b/libavdevice/libndi_newtek_dec.c
new file mode 100644
index 0000000..a635be5
--- /dev/null
+++ b/libavdevice/libndi_newtek_dec.c
@@ -0,0 +1,343 @@ 
+/*
+ * Newtek NDI input
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
+ * 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 "libavformat/avformat.h"
+#include "libavformat/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/imgutils.h"
+
+#include "libndi_newtek_common.h"
+
+struct NDIContext {
+    const AVClass *cclass;
+
+    /* Options */
+    int find_sources;
+    int64_t wait_sources;
+    int allow_video_fields;
+    int reference_level;
+
+    /* Runtime */
+    NDIlib_recv_create_t *recv;
+    NDIlib_find_instance_t ndi_find;
+
+    /* Streams */
+    AVStream *video_st, *audio_st;
+};
+
+static int ndi_set_video_packet(AVFormatContext *avctx, NDIlib_video_frame_t *v, AVPacket *pkt)
+{
+    int ret;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    ret = av_new_packet(pkt, v->yres * v->line_stride_in_bytes);
+    if (ret < 0)
+        return ret;
+
+    pkt->dts = pkt->pts = av_rescale_q(v->timecode, NDI_TIME_BASE_Q, ctx->video_st->time_base);
+    pkt->duration = av_rescale_q(1, (AVRational){v->frame_rate_D, v->frame_rate_N}, ctx->video_st->time_base);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->dts = pkt->pts = %"PRId64", duration=%"PRId64", timecode=%"PRId64"\n",
+        __func__, pkt->dts, pkt->duration, v->timecode);
+
+    pkt->flags         |= AV_PKT_FLAG_KEY;
+    pkt->stream_index   = ctx->video_st->index;
+
+    memcpy(pkt->data, v->p_data, pkt->size);
+
+    NDIlib_recv_free_video(ctx->recv, v);
+
+    return 0;
+}
+
+static int ndi_set_audio_packet(AVFormatContext *avctx, NDIlib_audio_frame_t *a, AVPacket *pkt)
+{
+    int ret;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    NDIlib_audio_frame_interleaved_16s_t dst;
+
+    ret = av_new_packet(pkt, 2 * a->no_samples * a->no_channels);
+    if (ret < 0)
+        return ret;
+
+    pkt->dts = pkt->pts = av_rescale_q(a->timecode, NDI_TIME_BASE_Q, ctx->audio_st->time_base);
+    pkt->duration = av_rescale_q(1, (AVRational){a->no_samples, a->sample_rate}, ctx->audio_st->time_base);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->dts = pkt->pts = %"PRId64", duration=%"PRId64", timecode=%"PRId64"\n",
+        __func__, pkt->dts, pkt->duration, a->timecode);
+
+    pkt->flags       |= AV_PKT_FLAG_KEY;
+    pkt->stream_index = ctx->audio_st->index;
+
+    dst.reference_level = 0;
+    dst.p_data = (short *)pkt->data;
+    NDIlib_util_audio_to_interleaved_16s(a, &dst);
+
+    NDIlib_recv_free_audio(ctx->recv, a);
+
+    return 0;
+}
+
+static int ndi_find_sources(AVFormatContext *avctx, const char *name, NDIlib_source_t *source_to_connect_to)
+{
+    int j = AVERROR(ENODEV);
+    unsigned int n, i;
+    struct NDIContext *ctx = avctx->priv_data;
+    const NDIlib_source_t *ndi_srcs = NULL;
+    const NDIlib_find_create_t find_create_desc = { .show_local_sources = true,
+        .p_groups = NULL, .p_extra_ips = NULL };
+
+    if (!ctx->ndi_find)
+        ctx->ndi_find = NDIlib_find_create2(&find_create_desc);
+    if (!ctx->ndi_find) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_find_create failed.\n");
+        return AVERROR(EIO);
+    }
+
+    while (1)
+    {
+        int f, t = ctx->wait_sources / 1000;
+        av_log(avctx, AV_LOG_DEBUG, "Waiting for sources %d miliseconds\n", t);
+        f = NDIlib_find_wait_for_sources(ctx->ndi_find, t);
+        av_log(avctx, AV_LOG_DEBUG, "NDIlib_find_wait_for_sources returns %d\n", f);
+        if (!f)
+            break;
+    };
+
+    ndi_srcs = NDIlib_find_get_current_sources(ctx->ndi_find, &n);
+
+    if (ctx->find_sources)
+        av_log(avctx, AV_LOG_INFO, "Found %d NDI sources:\n", n);
+
+    for (i = 0; i < n; i++) {
+        if (ctx->find_sources)
+            av_log(avctx, AV_LOG_INFO, "\t'%s'\t'%s'\n", ndi_srcs[i].p_ndi_name, ndi_srcs[i].p_ip_address);
+
+        if (!strcmp(name, ndi_srcs[i].p_ndi_name)) {
+            *source_to_connect_to = ndi_srcs[i];
+            j = i;
+        }
+    }
+
+    return j;
+}
+
+static int ndi_read_header(AVFormatContext *avctx)
+{
+    int ret;
+    NDIlib_recv_create_t recv_create_desc;
+    const NDIlib_tally_t tally_state = { .on_program = true, .on_preview = false };
+    struct NDIContext *ctx = avctx->priv_data;
+
+    if (!NDIlib_initialize()) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_initialize failed.\n");
+        return AVERROR_EXTERNAL;
+    }
+
+    /* Find available sources. */
+    ret = ndi_find_sources(avctx, avctx->filename, &recv_create_desc.source_to_connect_to);
+    if (ctx->find_sources) {
+        return AVERROR_EXIT;
+    }
+    if (ret < 0)
+        return ret;
+
+    /* Create receiver description */
+    recv_create_desc.color_format = NDIlib_recv_color_format_e_UYVY_RGBA;
+    recv_create_desc.bandwidth = NDIlib_recv_bandwidth_highest;
+    recv_create_desc.allow_video_fields = ctx->allow_video_fields;
+
+    /* Create the receiver */
+    ctx->recv = NDIlib_recv_create2(&recv_create_desc);
+    if (!ctx->recv) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_recv_create2 failed.\n");
+        return AVERROR(EIO);
+    }
+
+    /* Set tally */
+    NDIlib_recv_set_tally(ctx->recv, &tally_state);
+
+    avctx->ctx_flags |= AVFMTCTX_NOHEADER;
+
+    return 0;
+}
+
+static int ndi_create_video_stream(AVFormatContext *avctx, NDIlib_video_frame_t *v)
+{
+    AVStream *st;
+    AVRational tmp;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    st = avformat_new_stream(avctx, NULL);
+    if (!st) {
+        av_log(avctx, AV_LOG_ERROR, "Cannot add video stream\n");
+        return AVERROR(ENOMEM);
+    }
+
+    st->time_base                   = NDI_TIME_BASE_Q;
+    av_stream_set_r_frame_rate(st, av_make_q(v->frame_rate_N, v->frame_rate_D));
+
+    tmp = av_mul_q(av_d2q(v->picture_aspect_ratio, INT_MAX), (AVRational){v->yres, v->xres});
+    av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den, tmp.num, tmp.den, 1000);
+    st->codecpar->sample_aspect_ratio = st->sample_aspect_ratio;
+
+    st->codecpar->codec_type        = AVMEDIA_TYPE_VIDEO;
+    st->codecpar->width             = v->xres;
+    st->codecpar->height            = v->yres;
+    st->codecpar->codec_id          = AV_CODEC_ID_RAWVIDEO;
+    st->codecpar->bit_rate          = av_rescale(v->xres * v->yres * 16, v->frame_rate_N, v->frame_rate_D);
+    st->codecpar->field_order       = v->frame_format_type == NDIlib_frame_format_type_progressive
+        ? AV_FIELD_PROGRESSIVE : AV_FIELD_TT;
+
+    if (NDIlib_FourCC_type_UYVY == v->FourCC || NDIlib_FourCC_type_UYVA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_UYVY422;
+        st->codecpar->codec_tag     = MKTAG('U', 'Y', 'V', 'Y');
+    } else if (NDIlib_FourCC_type_BGRA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_BGRA;
+        st->codecpar->codec_tag     = MKTAG('B', 'G', 'R', 'A');
+    } else if (NDIlib_FourCC_type_BGRX == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_BGR0;
+        st->codecpar->codec_tag     = MKTAG('B', 'G', 'R', '0');
+    } else if (NDIlib_FourCC_type_RGBA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_RGBA;
+        st->codecpar->codec_tag     = MKTAG('R', 'G', 'B', 'A');
+    } else if (NDIlib_FourCC_type_RGBX == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_RGB0;
+        st->codecpar->codec_tag     = MKTAG('R', 'G', 'B', '0');
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported video stream format, v->FourCC=%d\n", v->FourCC);
+        return AVERROR(EINVAL);
+    }
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    ctx->video_st = st;
+
+    return 0;
+}
+
+static int ndi_create_audio_stream(AVFormatContext *avctx, NDIlib_audio_frame_t *a)
+{
+    AVStream *st;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    st = avformat_new_stream(avctx, NULL);
+    if (!st) {
+        av_log(avctx, AV_LOG_ERROR, "Cannot add audio stream\n");
+        return AVERROR(ENOMEM);
+    }
+
+    st->codecpar->codec_type        = AVMEDIA_TYPE_AUDIO;
+    st->codecpar->codec_id          = AV_CODEC_ID_PCM_S16LE;
+    st->codecpar->sample_rate       = a->sample_rate;
+    st->codecpar->channels          = a->no_channels;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    ctx->audio_st = st;
+
+    return 0;
+}
+
+static int ndi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
+{
+    int ret = 0;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    while (1) {
+        NDIlib_video_frame_t v;
+        NDIlib_audio_frame_t a;
+        NDIlib_metadata_frame_t m;
+        NDIlib_frame_type_e t;
+
+        t = NDIlib_recv_capture(ctx->recv, &v, &a, &m, 40);
+
+        if (NDIlib_frame_type_video == t) {
+            if (!ctx->video_st) {
+                ret = ndi_create_video_stream(avctx, &v);
+                if (ret < 0)
+                    return ret;
+            }
+            ret = ndi_set_video_packet(avctx, &v, pkt);
+            break;
+        }
+        else if (NDIlib_frame_type_audio == t) {
+            if (!ctx->audio_st) {
+                ret = ndi_create_audio_stream(avctx, &a);
+                if (ret < 0)
+                    return ret;
+            }
+            ret = ndi_set_audio_packet(avctx, &a, pkt);
+            break;
+        }
+        else if (NDIlib_frame_type_metadata == t)
+            NDIlib_recv_free_metadata(ctx->recv, &m);
+        else if (NDIlib_frame_type_none != t){
+            av_log(avctx, AV_LOG_ERROR, "NDIlib_recv_capture returns %d\n", t);
+        }
+    };
+
+    return ret;
+}
+
+static int ndi_read_close(AVFormatContext *avctx)
+{
+    struct NDIContext *ctx = (struct NDIContext *)avctx->priv_data;
+
+    if (ctx->recv)
+        NDIlib_recv_destroy(ctx->recv);
+
+    if (ctx->ndi_find)
+        NDIlib_find_destroy(ctx->ndi_find);
+
+    return 0;
+}
+
+#define OFFSET(x) offsetof(struct NDIContext, x)
+#define DEC AV_OPT_FLAG_DECODING_PARAM
+
+static const AVOption options[] = {
+    { "find_sources", "Find available sources"  , OFFSET(find_sources), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC },
+    { "wait_sources", "Time to wait until the number of online sources have changed"  , OFFSET(wait_sources), AV_OPT_TYPE_DURATION, { .i64 = 1000000 }, 100000, 20000000, DEC },
+    { "allow_video_fields", "When this flag is FALSE, all video that you receive will be progressive"  , OFFSET(allow_video_fields), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, DEC },
+    { "reference_level", "The audio reference level in dB"  , OFFSET(reference_level), AV_OPT_TYPE_INT, { .i64 = 0 }, -20, 20, DEC | AV_OPT_FLAG_AUDIO_PARAM},
+    { NULL },
+};
+
+static const AVClass libndi_newtek_demuxer_class = {
+    .class_name = "NDI demuxer",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
+};
+
+AVInputFormat ff_libndi_newtek_demuxer = {
+    .name           = "libndi_newtek",
+    .long_name      = NULL_IF_CONFIG_SMALL("Network Device Interface (NDI) input using NewTek library"),
+    .flags          = AVFMT_NOFILE,
+    .priv_class     = &libndi_newtek_demuxer_class,
+    .priv_data_size = sizeof(struct NDIContext),
+    .read_header   = ndi_read_header,
+    .read_packet   = ndi_read_packet,
+    .read_close    = ndi_read_close,
+};
diff --git a/libavdevice/libndi_newtek_enc.c b/libavdevice/libndi_newtek_enc.c
new file mode 100644
index 0000000..ffcf213
--- /dev/null
+++ b/libavdevice/libndi_newtek_enc.c
@@ -0,0 +1,277 @@ 
+/*
+ * NewTek NDI output
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
+ * 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 "libavformat/avformat.h"
+#include "libavformat/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/imgutils.h"
+
+#include "libndi_newtek_common.h"
+
+struct NDIContext {
+    const AVClass *cclass;
+
+    /* Options */
+    int reference_level;
+
+    NDIlib_video_frame_t *video;
+    NDIlib_audio_frame_interleaved_16s_t *audio;
+    NDIlib_send_instance_t ndi_send;
+    AVFrame *last_avframe;
+};
+
+static int ndi_write_trailer(AVFormatContext *avctx)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+
+    if (ctx->ndi_send) {
+        NDIlib_send_destroy(ctx->ndi_send);
+
+        if (ctx->last_avframe)
+            av_frame_free(&ctx->last_avframe);
+    }
+
+    if (ctx->video)
+        av_freep(&ctx->video);
+
+    if (ctx->audio)
+        av_freep(&ctx->audio);
+
+    return 0;
+}
+
+static int ndi_write_video_packet(AVFormatContext *avctx, AVStream *st, AVPacket *pkt)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVFrame *avframe, *tmp = (AVFrame *)pkt->data;
+
+    if (tmp->format != AV_PIX_FMT_UYVY422 ||
+        tmp->width  != ctx->video->xres ||
+        tmp->height != ctx->video->yres) {
+        av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid pixel format or dimension.\n");
+        av_log(avctx, AV_LOG_ERROR, "tmp->width=%d, tmp->height=%d, ctx->video->xres=%d, ctx->video->yres=%d\n", tmp->width, tmp->height, ctx->video->xres, ctx->video->yres);
+        return AVERROR(EINVAL);
+    }
+    avframe = av_frame_clone(tmp);
+    if (!avframe) {
+        av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
+        return AVERROR(ENOMEM);
+    }
+
+    ctx->video->timecode = av_rescale_q(pkt->pts, st->time_base, NDI_TIME_BASE_Q);
+
+    ctx->video->line_stride_in_bytes = avframe->linesize[0] < 0
+        ? -avframe->linesize[0]
+        : avframe->linesize[0];
+    ctx->video->p_data = (avframe->linesize[0] < 0)
+        ? (void *)(avframe->data[0] + avframe->linesize[0] * (avframe->height - 1))
+        : (void *)(avframe->data[0]);
+
+    if (avframe->linesize[0] < 0)
+        av_log(avctx, AV_LOG_WARNING, "Negative linesize deteted. Possibly flipped picture output");
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->pts=%"PRId64", timecode=%"PRId64", st->time_base=%d/%d\n",
+        __func__, pkt->pts, ctx->video->timecode, st->time_base.num, st->time_base.den);
+
+    /* asynchronous for one frame, but will block if a second frame
+        is given before the first one has been sent */
+    NDIlib_send_send_video_async(ctx->ndi_send, ctx->video);
+
+    if (ctx->last_avframe)
+        av_frame_free(&ctx->last_avframe);
+    ctx->last_avframe = avframe;
+
+    return 0;
+}
+
+static int ndi_write_audio_packet(AVFormatContext *avctx, AVStream *st, AVPacket *pkt)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+
+    ctx->audio->p_data = (short *)pkt->data;
+    ctx->audio->timecode = av_rescale_q(pkt->pts, st->time_base, NDI_TIME_BASE_Q);
+    ctx->audio->no_samples = pkt->size / (ctx->audio->no_channels << 1);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->pts=%"PRId64", timecode=%"PRId64", st->time_base=%d/%d\n",
+        __func__, pkt->pts, ctx->video->timecode, st->time_base.num, st->time_base.den);
+
+    NDIlib_util_send_send_audio_interleaved_16s(ctx->ndi_send, ctx->audio);
+
+    return 0;
+}
+
+static int ndi_write_packet(AVFormatContext *avctx, AVPacket *pkt)
+{
+    AVStream *st = avctx->streams[pkt->stream_index];
+
+    if      (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
+        return ndi_write_video_packet(avctx, st, pkt);
+    else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
+        return ndi_write_audio_packet(avctx, st, pkt);
+
+    return AVERROR_BUG;
+}
+
+static int ndi_setup_audio(AVFormatContext *avctx, AVStream *st)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVCodecParameters *c = st->codecpar;
+
+    if (ctx->audio) {
+        av_log(avctx, AV_LOG_ERROR, "Only one audio stream is supported!\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->audio = av_mallocz(sizeof(NDIlib_audio_frame_interleaved_16s_t));
+    if (!ctx->audio)
+        return AVERROR(ENOMEM);
+
+    ctx->audio->sample_rate = c->sample_rate;
+    ctx->audio->no_channels = c->channels;
+    ctx->audio->reference_level = ctx->reference_level;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    return 0;
+}
+
+static int ndi_setup_video(AVFormatContext *avctx, AVStream *st)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVCodecParameters *c = st->codecpar;
+
+    if (ctx->video) {
+        av_log(avctx, AV_LOG_ERROR, "Only one video stream is supported!\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (c->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported codec format!"
+               " Only AV_CODEC_ID_WRAPPED_AVFRAME is supported (-vcodec wrapped_avframe).\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (c->format != AV_PIX_FMT_UYVY422) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
+               " Only AV_PIX_FMT_UYVY422 is supported.\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->video = av_mallocz(sizeof(NDIlib_video_frame_t));
+    if (!ctx->video)
+        return AVERROR(ENOMEM);
+
+    ctx->video->FourCC = NDIlib_FourCC_type_UYVY;
+    ctx->video->xres = c->width;
+    ctx->video->yres = c->height;
+    ctx->video->frame_rate_N = st->avg_frame_rate.num;
+    ctx->video->frame_rate_D = st->avg_frame_rate.den;
+    ctx->video->frame_format_type = c->field_order == AV_FIELD_PROGRESSIVE
+        ? NDIlib_frame_format_type_progressive
+        : NDIlib_frame_format_type_interleaved;
+
+    if (c->field_order == AV_FIELD_BB || c->field_order == AV_FIELD_BT)
+        av_log(avctx, AV_LOG_WARNING, "Lower field-first disallowed");
+
+
+    if (st->sample_aspect_ratio.num) {
+        AVRational display_aspect_ratio;
+        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+                  st->codecpar->width  * (int64_t)st->sample_aspect_ratio.num,
+                  st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
+                  1024 * 1024);
+        ctx->video->picture_aspect_ratio = av_q2d(display_aspect_ratio);
+    }
+    else
+        ctx->video->picture_aspect_ratio = (double)st->codecpar->width/st->codecpar->height;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    return 0;
+}
+
+static int ndi_write_header(AVFormatContext *avctx)
+{
+    int ret = 0;
+    unsigned int n;
+    struct NDIContext *ctx = avctx->priv_data;
+    const NDIlib_send_create_t ndi_send_desc = { .p_ndi_name = avctx->filename,
+        .p_groups = NULL, .clock_video = false, .clock_audio = false };
+
+    if (!NDIlib_initialize()) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_initialize failed.\n");
+        return AVERROR_EXTERNAL;
+    }
+
+    /* check if streams compatible */
+    for (n = 0; n < avctx->nb_streams; n++) {
+        AVStream *st = avctx->streams[n];
+        AVCodecParameters *c = st->codecpar;
+        if        (c->codec_type == AVMEDIA_TYPE_AUDIO) {
+            if ((ret = ndi_setup_audio(avctx, st)))
+                goto error;
+        } else if (c->codec_type == AVMEDIA_TYPE_VIDEO) {
+            if ((ret = ndi_setup_video(avctx, st)))
+                goto error;
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Unsupported stream type.\n");
+            ret = AVERROR(EINVAL);
+            goto error;
+        }
+    }
+
+    ctx->ndi_send = NDIlib_send_create(&ndi_send_desc);
+    if (!ctx->ndi_send) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create NDI output %s\n", avctx->filename);
+        ret = AVERROR_EXTERNAL;
+    }
+
+error:
+    return ret;
+}
+
+#define OFFSET(x) offsetof(struct NDIContext, x)
+static const AVOption options[] = {
+    { "reference_level", "The audio reference level in dB"  , OFFSET(reference_level), AV_OPT_TYPE_INT, { .i64 = 0 }, -20, 20, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM},
+    { NULL },
+};
+
+static const AVClass libndi_newtek_muxer_class = {
+    .class_name = "NDI muxer",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
+};
+
+AVOutputFormat ff_libndi_newtek_muxer = {
+    .name           = "libndi_newtek",
+    .long_name      = NULL_IF_CONFIG_SMALL("Network Device Interface (NDI) output using NewTek library"),
+    .audio_codec    = AV_CODEC_ID_PCM_S16LE,
+    .video_codec    = AV_CODEC_ID_WRAPPED_AVFRAME,
+    .subtitle_codec = AV_CODEC_ID_NONE,
+    .flags          = AVFMT_NOFILE,
+    .priv_class     = &libndi_newtek_muxer_class,
+    .priv_data_size = sizeof(struct NDIContext),
+    .write_header   = ndi_write_header,
+    .write_packet   = ndi_write_packet,
+    .write_trailer  = ndi_write_trailer,
+};
diff --git a/libavdevice/version.h b/libavdevice/version.h
index 0c06602..948e4e1 100644
--- a/libavdevice/version.h
+++ b/libavdevice/version.h
@@ -28,7 +28,7 @@ 
 #include "libavutil/version.h"
 
 #define LIBAVDEVICE_VERSION_MAJOR  57
-#define LIBAVDEVICE_VERSION_MINOR   7
+#define LIBAVDEVICE_VERSION_MINOR   8
 #define LIBAVDEVICE_VERSION_MICRO 100
 
 #define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
-- 
1.8.3.1