avcodec/cbs_h2645: Remove unnecessary (h264|hevc)_sei.h inclusions
[ffmpeg.git] / libavcodec / mfenc.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #define COBJMACROS
20 #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
21 #undef _WIN32_WINNT
22 #define _WIN32_WINNT 0x0602
23 #endif
24
25 #include "encode.h"
26 #include "mf_utils.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/time.h"
30 #include "codec_internal.h"
31 #include "internal.h"
32
33 typedef struct MFContext {
34     AVClass *av_class;
35     HMODULE library;
36     MFFunctions functions;
37     AVFrame *frame;
38     int is_video, is_audio;
39     GUID main_subtype;
40     IMFTransform *mft;
41     IMFMediaEventGenerator *async_events;
42     DWORD in_stream_id, out_stream_id;
43     MFT_INPUT_STREAM_INFO in_info;
44     MFT_OUTPUT_STREAM_INFO out_info;
45     int out_stream_provides_samples;
46     int draining, draining_done;
47     int sample_sent;
48     int async_need_input, async_have_output, async_marker;
49     int64_t reorder_delay;
50     ICodecAPI *codec_api;
51     // set by AVOption
52     int opt_enc_rc;
53     int opt_enc_quality;
54     int opt_enc_scenario;
55     int opt_enc_hw;
56 } MFContext;
57
58 static int mf_choose_output_type(AVCodecContext *avctx);
59 static int mf_setup_context(AVCodecContext *avctx);
60
61 #define MF_TIMEBASE (AVRational){1, 10000000}
62 // Sentinel value only used by us.
63 #define MF_INVALID_TIME AV_NOPTS_VALUE
64
65 static int mf_wait_events(AVCodecContext *avctx)
66 {
67     MFContext *c = avctx->priv_data;
68
69     if (!c->async_events)
70         return 0;
71
72     while (!(c->async_need_input || c->async_have_output || c->draining_done || c->async_marker)) {
73         IMFMediaEvent *ev = NULL;
74         MediaEventType ev_id = 0;
75         HRESULT hr = IMFMediaEventGenerator_GetEvent(c->async_events, 0, &ev);
76         if (FAILED(hr)) {
77             av_log(avctx, AV_LOG_ERROR, "IMFMediaEventGenerator_GetEvent() failed: %s\n",
78                    ff_hr_str(hr));
79             return AVERROR_EXTERNAL;
80         }
81         IMFMediaEvent_GetType(ev, &ev_id);
82         switch (ev_id) {
83         case ff_METransformNeedInput:
84             if (!c->draining)
85                 c->async_need_input = 1;
86             break;
87         case ff_METransformHaveOutput:
88             c->async_have_output = 1;
89             break;
90         case ff_METransformDrainComplete:
91             c->draining_done = 1;
92             break;
93         case ff_METransformMarker:
94             c->async_marker = 1;
95             break;
96         default: ;
97         }
98         IMFMediaEvent_Release(ev);
99     }
100
101     return 0;
102 }
103
104 static AVRational mf_get_tb(AVCodecContext *avctx)
105 {
106     if (avctx->time_base.num > 0 && avctx->time_base.den > 0)
107         return avctx->time_base;
108     return MF_TIMEBASE;
109 }
110
111 static LONGLONG mf_to_mf_time(AVCodecContext *avctx, int64_t av_pts)
112 {
113     if (av_pts == AV_NOPTS_VALUE)
114         return MF_INVALID_TIME;
115     return av_rescale_q(av_pts, mf_get_tb(avctx), MF_TIMEBASE);
116 }
117
118 static void mf_sample_set_pts(AVCodecContext *avctx, IMFSample *sample, int64_t av_pts)
119 {
120     LONGLONG stime = mf_to_mf_time(avctx, av_pts);
121     if (stime != MF_INVALID_TIME)
122         IMFSample_SetSampleTime(sample, stime);
123 }
124
125 static int64_t mf_from_mf_time(AVCodecContext *avctx, LONGLONG stime)
126 {
127     return av_rescale_q(stime, MF_TIMEBASE, mf_get_tb(avctx));
128 }
129
130 static int64_t mf_sample_get_pts(AVCodecContext *avctx, IMFSample *sample)
131 {
132     LONGLONG pts;
133     HRESULT hr = IMFSample_GetSampleTime(sample, &pts);
134     if (FAILED(hr))
135         return AV_NOPTS_VALUE;
136     return mf_from_mf_time(avctx, pts);
137 }
138
139 static int mf_enca_output_type_get(AVCodecContext *avctx, IMFMediaType *type)
140 {
141     MFContext *c = avctx->priv_data;
142     HRESULT hr;
143     UINT32 sz;
144
145     if (avctx->codec_id != AV_CODEC_ID_MP3 && avctx->codec_id != AV_CODEC_ID_AC3) {
146         hr = IMFAttributes_GetBlobSize(type, &MF_MT_USER_DATA, &sz);
147         if (!FAILED(hr) && sz > 0) {
148             avctx->extradata = av_mallocz(sz + AV_INPUT_BUFFER_PADDING_SIZE);
149             if (!avctx->extradata)
150                 return AVERROR(ENOMEM);
151             avctx->extradata_size = sz;
152             hr = IMFAttributes_GetBlob(type, &MF_MT_USER_DATA, avctx->extradata, sz, NULL);
153             if (FAILED(hr))
154                 return AVERROR_EXTERNAL;
155
156             if (avctx->codec_id == AV_CODEC_ID_AAC && avctx->extradata_size >= 12) {
157                 // Get rid of HEAACWAVEINFO (after wfx field, 12 bytes).
158                 avctx->extradata_size = avctx->extradata_size - 12;
159                 memmove(avctx->extradata, avctx->extradata + 12, avctx->extradata_size);
160             }
161         }
162     }
163
164     // I don't know where it's documented that we need this. It happens with the
165     // MS mp3 encoder MFT. The idea for the workaround is taken from NAudio.
166     // (Certainly any lossy codec will have frames much smaller than 1 second.)
167     if (!c->out_info.cbSize && !c->out_stream_provides_samples) {
168         hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &sz);
169         if (!FAILED(hr)) {
170             av_log(avctx, AV_LOG_VERBOSE, "MFT_OUTPUT_STREAM_INFO.cbSize set to 0, "
171                    "assuming %d bytes instead.\n", (int)sz);
172             c->out_info.cbSize = sz;
173         }
174     }
175
176     return 0;
177 }
178
179 static int mf_encv_output_type_get(AVCodecContext *avctx, IMFMediaType *type)
180 {
181     HRESULT hr;
182     UINT32 sz;
183
184     hr = IMFAttributes_GetBlobSize(type, &MF_MT_MPEG_SEQUENCE_HEADER, &sz);
185     if (!FAILED(hr) && sz > 0) {
186         uint8_t *extradata = av_mallocz(sz + AV_INPUT_BUFFER_PADDING_SIZE);
187         if (!extradata)
188             return AVERROR(ENOMEM);
189         hr = IMFAttributes_GetBlob(type, &MF_MT_MPEG_SEQUENCE_HEADER, extradata, sz, NULL);
190         if (FAILED(hr)) {
191             av_free(extradata);
192             return AVERROR_EXTERNAL;
193         }
194         av_freep(&avctx->extradata);
195         avctx->extradata = extradata;
196         avctx->extradata_size = sz;
197     }
198
199     return 0;
200 }
201
202 static int mf_output_type_get(AVCodecContext *avctx)
203 {
204     MFContext *c = avctx->priv_data;
205     HRESULT hr;
206     IMFMediaType *type;
207     int ret;
208
209     hr = IMFTransform_GetOutputCurrentType(c->mft, c->out_stream_id, &type);
210     if (FAILED(hr)) {
211         av_log(avctx, AV_LOG_ERROR, "could not get output type\n");
212         return AVERROR_EXTERNAL;
213     }
214
215     av_log(avctx, AV_LOG_VERBOSE, "final output type:\n");
216     ff_media_type_dump(avctx, type);
217
218     ret = 0;
219     if (c->is_video) {
220         ret = mf_encv_output_type_get(avctx, type);
221     } else if (c->is_audio) {
222         ret = mf_enca_output_type_get(avctx, type);
223     }
224
225     if (ret < 0)
226         av_log(avctx, AV_LOG_ERROR, "output type not supported\n");
227
228     IMFMediaType_Release(type);
229     return ret;
230 }
231
232 static int mf_sample_to_avpacket(AVCodecContext *avctx, IMFSample *sample, AVPacket *avpkt)
233 {
234     MFContext *c = avctx->priv_data;
235     HRESULT hr;
236     int ret;
237     DWORD len;
238     IMFMediaBuffer *buffer;
239     BYTE *data;
240     UINT64 t;
241     UINT32 t32;
242
243     hr = IMFSample_GetTotalLength(sample, &len);
244     if (FAILED(hr))
245         return AVERROR_EXTERNAL;
246
247     if ((ret = ff_get_encode_buffer(avctx, avpkt, len, 0)) < 0)
248         return ret;
249
250     IMFSample_ConvertToContiguousBuffer(sample, &buffer);
251     if (FAILED(hr))
252         return AVERROR_EXTERNAL;
253
254     hr = IMFMediaBuffer_Lock(buffer, &data, NULL, NULL);
255     if (FAILED(hr)) {
256         IMFMediaBuffer_Release(buffer);
257         return AVERROR_EXTERNAL;
258     }
259
260     memcpy(avpkt->data, data, len);
261
262     IMFMediaBuffer_Unlock(buffer);
263     IMFMediaBuffer_Release(buffer);
264
265     avpkt->pts = avpkt->dts = mf_sample_get_pts(avctx, sample);
266
267     hr = IMFAttributes_GetUINT32(sample, &MFSampleExtension_CleanPoint, &t32);
268     if (c->is_audio || (!FAILED(hr) && t32 != 0))
269         avpkt->flags |= AV_PKT_FLAG_KEY;
270
271     hr = IMFAttributes_GetUINT64(sample, &MFSampleExtension_DecodeTimestamp, &t);
272     if (!FAILED(hr)) {
273         avpkt->dts = mf_from_mf_time(avctx, t);
274         // At least on Qualcomm's HEVC encoder on SD 835, the output dts
275         // starts from the input pts of the first frame, while the output pts
276         // is shifted forward. Therefore, shift the output values back so that
277         // the output pts matches the input.
278         if (c->reorder_delay == AV_NOPTS_VALUE)
279             c->reorder_delay = avpkt->pts - avpkt->dts;
280         avpkt->dts -= c->reorder_delay;
281         avpkt->pts -= c->reorder_delay;
282     }
283
284     return 0;
285 }
286
287 static IMFSample *mf_a_avframe_to_sample(AVCodecContext *avctx, const AVFrame *frame)
288 {
289     MFContext *c = avctx->priv_data;
290     size_t len;
291     size_t bps;
292     IMFSample *sample;
293
294     bps = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->ch_layout.nb_channels;
295     len = frame->nb_samples * bps;
296
297     sample = ff_create_memory_sample(&c->functions, frame->data[0], len,
298                                      c->in_info.cbAlignment);
299     if (sample)
300         IMFSample_SetSampleDuration(sample, mf_to_mf_time(avctx, frame->nb_samples));
301     return sample;
302 }
303
304 static IMFSample *mf_v_avframe_to_sample(AVCodecContext *avctx, const AVFrame *frame)
305 {
306     MFContext *c = avctx->priv_data;
307     IMFSample *sample;
308     IMFMediaBuffer *buffer;
309     BYTE *data;
310     HRESULT hr;
311     int ret;
312     int size;
313
314     size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width, avctx->height, 1);
315     if (size < 0)
316         return NULL;
317
318     sample = ff_create_memory_sample(&c->functions, NULL, size,
319                                      c->in_info.cbAlignment);
320     if (!sample)
321         return NULL;
322
323     hr = IMFSample_GetBufferByIndex(sample, 0, &buffer);
324     if (FAILED(hr)) {
325         IMFSample_Release(sample);
326         return NULL;
327     }
328
329     hr = IMFMediaBuffer_Lock(buffer, &data, NULL, NULL);
330     if (FAILED(hr)) {
331         IMFMediaBuffer_Release(buffer);
332         IMFSample_Release(sample);
333         return NULL;
334     }
335
336     ret = av_image_copy_to_buffer((uint8_t *)data, size, (void *)frame->data, frame->linesize,
337                                   avctx->pix_fmt, avctx->width, avctx->height, 1);
338     IMFMediaBuffer_SetCurrentLength(buffer, size);
339     IMFMediaBuffer_Unlock(buffer);
340     IMFMediaBuffer_Release(buffer);
341     if (ret < 0) {
342         IMFSample_Release(sample);
343         return NULL;
344     }
345
346     IMFSample_SetSampleDuration(sample, mf_to_mf_time(avctx, frame->pkt_duration));
347
348     return sample;
349 }
350
351 static IMFSample *mf_avframe_to_sample(AVCodecContext *avctx, const AVFrame *frame)
352 {
353     MFContext *c = avctx->priv_data;
354     IMFSample *sample;
355
356     if (c->is_audio) {
357         sample = mf_a_avframe_to_sample(avctx, frame);
358     } else {
359         sample = mf_v_avframe_to_sample(avctx, frame);
360     }
361
362     if (sample)
363         mf_sample_set_pts(avctx, sample, frame->pts);
364
365     return sample;
366 }
367
368 static int mf_send_sample(AVCodecContext *avctx, IMFSample *sample)
369 {
370     MFContext *c = avctx->priv_data;
371     HRESULT hr;
372     int ret;
373
374     if (sample) {
375         if (c->async_events) {
376             if ((ret = mf_wait_events(avctx)) < 0)
377                 return ret;
378             if (!c->async_need_input)
379                 return AVERROR(EAGAIN);
380         }
381         if (!c->sample_sent)
382             IMFSample_SetUINT32(sample, &MFSampleExtension_Discontinuity, TRUE);
383         c->sample_sent = 1;
384         hr = IMFTransform_ProcessInput(c->mft, c->in_stream_id, sample, 0);
385         if (hr == MF_E_NOTACCEPTING) {
386             return AVERROR(EAGAIN);
387         } else if (FAILED(hr)) {
388             av_log(avctx, AV_LOG_ERROR, "failed processing input: %s\n", ff_hr_str(hr));
389             return AVERROR_EXTERNAL;
390         }
391         c->async_need_input = 0;
392     } else if (!c->draining) {
393         hr = IMFTransform_ProcessMessage(c->mft, MFT_MESSAGE_COMMAND_DRAIN, 0);
394         if (FAILED(hr))
395             av_log(avctx, AV_LOG_ERROR, "failed draining: %s\n", ff_hr_str(hr));
396         // Some MFTs (AC3) will send a frame after each drain command (???), so
397         // this is required to make draining actually terminate.
398         c->draining = 1;
399         c->async_need_input = 0;
400     } else {
401         return AVERROR_EOF;
402     }
403     return 0;
404 }
405
406 static int mf_receive_sample(AVCodecContext *avctx, IMFSample **out_sample)
407 {
408     MFContext *c = avctx->priv_data;
409     HRESULT hr;
410     DWORD st;
411     MFT_OUTPUT_DATA_BUFFER out_buffers;
412     IMFSample *sample;
413     int ret = 0;
414
415     while (1) {
416         *out_sample = NULL;
417         sample = NULL;
418
419         if (c->async_events) {
420             if ((ret = mf_wait_events(avctx)) < 0)
421                 return ret;
422             if (!c->async_have_output || c->draining_done) {
423                 ret = 0;
424                 break;
425             }
426         }
427
428         if (!c->out_stream_provides_samples) {
429             sample = ff_create_memory_sample(&c->functions, NULL,
430                                              c->out_info.cbSize,
431                                              c->out_info.cbAlignment);
432             if (!sample)
433                 return AVERROR(ENOMEM);
434         }
435
436         out_buffers = (MFT_OUTPUT_DATA_BUFFER) {
437             .dwStreamID = c->out_stream_id,
438             .pSample = sample,
439         };
440
441         st = 0;
442         hr = IMFTransform_ProcessOutput(c->mft, 0, 1, &out_buffers, &st);
443
444         if (out_buffers.pEvents)
445             IMFCollection_Release(out_buffers.pEvents);
446
447         if (!FAILED(hr)) {
448             *out_sample = out_buffers.pSample;
449             ret = 0;
450             break;
451         }
452
453         if (out_buffers.pSample)
454             IMFSample_Release(out_buffers.pSample);
455
456         if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
457             if (c->draining)
458                 c->draining_done = 1;
459             ret = 0;
460         } else if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
461             av_log(avctx, AV_LOG_WARNING, "stream format change\n");
462             ret = mf_choose_output_type(avctx);
463             if (ret == 0) // we don't expect renegotiating the input type
464                 ret = AVERROR_EXTERNAL;
465             if (ret > 0) {
466                 ret = mf_setup_context(avctx);
467                 if (ret >= 0) {
468                     c->async_have_output = 0;
469                     continue;
470                 }
471             }
472         } else {
473             av_log(avctx, AV_LOG_ERROR, "failed processing output: %s\n", ff_hr_str(hr));
474             ret = AVERROR_EXTERNAL;
475         }
476
477         break;
478     }
479
480     c->async_have_output = 0;
481
482     if (ret >= 0 && !*out_sample)
483         ret = c->draining_done ? AVERROR_EOF : AVERROR(EAGAIN);
484
485     return ret;
486 }
487
488 static int mf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
489 {
490     MFContext *c = avctx->priv_data;
491     IMFSample *sample = NULL;
492     int ret;
493
494     if (!c->frame->buf[0]) {
495         ret = ff_encode_get_frame(avctx, c->frame);
496         if (ret < 0 && ret != AVERROR_EOF)
497             return ret;
498     }
499
500     if (c->frame->buf[0]) {
501         sample = mf_avframe_to_sample(avctx, c->frame);
502         if (!sample) {
503             av_frame_unref(c->frame);
504             return AVERROR(ENOMEM);
505         }
506         if (c->is_video && c->codec_api) {
507             if (c->frame->pict_type == AV_PICTURE_TYPE_I || !c->sample_sent)
508                 ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncVideoForceKeyFrame, FF_VAL_VT_UI4(1));
509         }
510     }
511
512     ret = mf_send_sample(avctx, sample);
513     if (sample)
514         IMFSample_Release(sample);
515     if (ret != AVERROR(EAGAIN))
516         av_frame_unref(c->frame);
517     if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
518         return ret;
519
520     ret = mf_receive_sample(avctx, &sample);
521     if (ret < 0)
522         return ret;
523
524     ret = mf_sample_to_avpacket(avctx, sample, avpkt);
525     IMFSample_Release(sample);
526
527     return ret;
528 }
529
530 // Most encoders seem to enumerate supported audio formats on the output types,
531 // at least as far as channel configuration and sample rate is concerned. Pick
532 // the one which seems to match best.
533 static int64_t mf_enca_output_score(AVCodecContext *avctx, IMFMediaType *type)
534 {
535     MFContext *c = avctx->priv_data;
536     HRESULT hr;
537     UINT32 t;
538     GUID tg;
539     int64_t score = 0;
540
541     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &t);
542     if (!FAILED(hr) && t == avctx->sample_rate)
543         score |= 1LL << 32;
544
545     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &t);
546     if (!FAILED(hr) && t == avctx->ch_layout.nb_channels)
547         score |= 2LL << 32;
548
549     hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &tg);
550     if (!FAILED(hr)) {
551         if (IsEqualGUID(&c->main_subtype, &tg))
552             score |= 4LL << 32;
553     }
554
555     // Select the bitrate (lowest priority).
556     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &t);
557     if (!FAILED(hr)) {
558         int diff = (int)t - avctx->bit_rate / 8;
559         if (diff >= 0) {
560             score |= (1LL << 31) - diff; // prefer lower bitrate
561         } else {
562             score |= (1LL << 30) + diff; // prefer higher bitrate
563         }
564     }
565
566     hr = IMFAttributes_GetUINT32(type, &MF_MT_AAC_PAYLOAD_TYPE, &t);
567     if (!FAILED(hr) && t != 0)
568         return -1;
569
570     return score;
571 }
572
573 static int mf_enca_output_adjust(AVCodecContext *avctx, IMFMediaType *type)
574 {
575     // (some decoders allow adjusting this freely, but it can also cause failure
576     //  to set the output type - so it's commented for being too fragile)
577     //IMFAttributes_SetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, avctx->bit_rate / 8);
578     //IMFAttributes_SetUINT32(type, &MF_MT_AVG_BITRATE, avctx->bit_rate);
579
580     return 0;
581 }
582
583 static int64_t mf_enca_input_score(AVCodecContext *avctx, IMFMediaType *type)
584 {
585     HRESULT hr;
586     UINT32 t;
587     int64_t score = 0;
588
589     enum AVSampleFormat sformat = ff_media_type_to_sample_fmt((IMFAttributes *)type);
590     if (sformat == AV_SAMPLE_FMT_NONE)
591         return -1; // can not use
592
593     if (sformat == avctx->sample_fmt)
594         score |= 1;
595
596     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &t);
597     if (!FAILED(hr) && t == avctx->sample_rate)
598         score |= 2;
599
600     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &t);
601     if (!FAILED(hr) && t == avctx->ch_layout.nb_channels)
602         score |= 4;
603
604     return score;
605 }
606
607 static int mf_enca_input_adjust(AVCodecContext *avctx, IMFMediaType *type)
608 {
609     HRESULT hr;
610     UINT32 t;
611
612     enum AVSampleFormat sformat = ff_media_type_to_sample_fmt((IMFAttributes *)type);
613     if (sformat != avctx->sample_fmt) {
614         av_log(avctx, AV_LOG_ERROR, "unsupported input sample format set\n");
615         return AVERROR(EINVAL);
616     }
617
618     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &t);
619     if (FAILED(hr) || t != avctx->sample_rate) {
620         av_log(avctx, AV_LOG_ERROR, "unsupported input sample rate set\n");
621         return AVERROR(EINVAL);
622     }
623
624     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &t);
625     if (FAILED(hr) || t != avctx->ch_layout.nb_channels) {
626         av_log(avctx, AV_LOG_ERROR, "unsupported input channel number set\n");
627         return AVERROR(EINVAL);
628     }
629
630     return 0;
631 }
632
633 static int64_t mf_encv_output_score(AVCodecContext *avctx, IMFMediaType *type)
634 {
635     MFContext *c = avctx->priv_data;
636     GUID tg;
637     HRESULT hr;
638     int score = -1;
639
640     hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &tg);
641     if (!FAILED(hr)) {
642         if (IsEqualGUID(&c->main_subtype, &tg))
643             score = 1;
644     }
645
646     return score;
647 }
648
649 static int mf_encv_output_adjust(AVCodecContext *avctx, IMFMediaType *type)
650 {
651     MFContext *c = avctx->priv_data;
652     AVRational framerate;
653
654     ff_MFSetAttributeSize((IMFAttributes *)type, &MF_MT_FRAME_SIZE, avctx->width, avctx->height);
655     IMFAttributes_SetUINT32(type, &MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
656
657     if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
658         framerate = avctx->framerate;
659     } else {
660         framerate = av_inv_q(avctx->time_base);
661         framerate.den *= avctx->ticks_per_frame;
662     }
663
664     ff_MFSetAttributeRatio((IMFAttributes *)type, &MF_MT_FRAME_RATE, framerate.num, framerate.den);
665
666     // (MS HEVC supports eAVEncH265VProfile_Main_420_8 only.)
667     if (avctx->codec_id == AV_CODEC_ID_H264) {
668         UINT32 profile = ff_eAVEncH264VProfile_Base;
669         switch (avctx->profile) {
670         case FF_PROFILE_H264_MAIN:
671             profile = ff_eAVEncH264VProfile_Main;
672             break;
673         case FF_PROFILE_H264_HIGH:
674             profile = ff_eAVEncH264VProfile_High;
675             break;
676         }
677         IMFAttributes_SetUINT32(type, &MF_MT_MPEG2_PROFILE, profile);
678     }
679
680     IMFAttributes_SetUINT32(type, &MF_MT_AVG_BITRATE, avctx->bit_rate);
681
682     // Note that some of the ICodecAPI options must be set before SetOutputType.
683     if (c->codec_api) {
684         if (avctx->bit_rate)
685             ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncCommonMeanBitRate, FF_VAL_VT_UI4(avctx->bit_rate));
686
687         if (c->opt_enc_rc >= 0)
688             ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncCommonRateControlMode, FF_VAL_VT_UI4(c->opt_enc_rc));
689
690         if (c->opt_enc_quality >= 0)
691             ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncCommonQuality, FF_VAL_VT_UI4(c->opt_enc_quality));
692
693         // Always set the number of b-frames. Qualcomm's HEVC encoder on SD835
694         // defaults this to 1, and that setting is buggy with many of the
695         // rate control modes. (0 or 2 b-frames works fine with most rate
696         // control modes, but 2 seems buggy with the u_vbr mode.) Setting
697         // "scenario" to "camera_record" sets it in CFR mode (where the default
698         // is VFR), which makes the encoder avoid dropping frames.
699         ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncMPVDefaultBPictureCount, FF_VAL_VT_UI4(avctx->max_b_frames));
700         avctx->has_b_frames = avctx->max_b_frames > 0;
701
702         ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVEncH264CABACEnable, FF_VAL_VT_BOOL(1));
703
704         if (c->opt_enc_scenario >= 0)
705             ICodecAPI_SetValue(c->codec_api, &ff_CODECAPI_AVScenarioInfo, FF_VAL_VT_UI4(c->opt_enc_scenario));
706     }
707
708     return 0;
709 }
710
711 static int64_t mf_encv_input_score(AVCodecContext *avctx, IMFMediaType *type)
712 {
713     enum AVPixelFormat pix_fmt = ff_media_type_to_pix_fmt((IMFAttributes *)type);
714     if (pix_fmt != avctx->pix_fmt)
715         return -1; // can not use
716
717     return 0;
718 }
719
720 static int mf_encv_input_adjust(AVCodecContext *avctx, IMFMediaType *type)
721 {
722     enum AVPixelFormat pix_fmt = ff_media_type_to_pix_fmt((IMFAttributes *)type);
723     if (pix_fmt != avctx->pix_fmt) {
724         av_log(avctx, AV_LOG_ERROR, "unsupported input pixel format set\n");
725         return AVERROR(EINVAL);
726     }
727
728     //ff_MFSetAttributeSize((IMFAttributes *)type, &MF_MT_FRAME_SIZE, avctx->width, avctx->height);
729
730     return 0;
731 }
732
733 static int mf_choose_output_type(AVCodecContext *avctx)
734 {
735     MFContext *c = avctx->priv_data;
736     HRESULT hr;
737     int ret;
738     IMFMediaType *out_type = NULL;
739     int64_t out_type_score = -1;
740     int out_type_index = -1;
741     int n;
742
743     av_log(avctx, AV_LOG_VERBOSE, "output types:\n");
744     for (n = 0; ; n++) {
745         IMFMediaType *type;
746         int64_t score = -1;
747
748         hr = IMFTransform_GetOutputAvailableType(c->mft, c->out_stream_id, n, &type);
749         if (hr == MF_E_NO_MORE_TYPES || hr == E_NOTIMPL)
750             break;
751         if (hr == MF_E_TRANSFORM_TYPE_NOT_SET) {
752             av_log(avctx, AV_LOG_VERBOSE, "(need to set input type)\n");
753             ret = 0;
754             goto done;
755         }
756         if (FAILED(hr)) {
757             av_log(avctx, AV_LOG_ERROR, "error getting output type: %s\n", ff_hr_str(hr));
758             ret = AVERROR_EXTERNAL;
759             goto done;
760         }
761
762         av_log(avctx, AV_LOG_VERBOSE, "output type %d:\n", n);
763         ff_media_type_dump(avctx, type);
764
765         if (c->is_video) {
766             score = mf_encv_output_score(avctx, type);
767         } else if (c->is_audio) {
768             score = mf_enca_output_score(avctx, type);
769         }
770
771         if (score > out_type_score) {
772             if (out_type)
773                 IMFMediaType_Release(out_type);
774             out_type = type;
775             out_type_score = score;
776             out_type_index = n;
777             IMFMediaType_AddRef(out_type);
778         }
779
780         IMFMediaType_Release(type);
781     }
782
783     if (out_type) {
784         av_log(avctx, AV_LOG_VERBOSE, "picking output type %d.\n", out_type_index);
785     } else {
786         hr = c->functions.MFCreateMediaType(&out_type);
787         if (FAILED(hr)) {
788             ret = AVERROR(ENOMEM);
789             goto done;
790         }
791     }
792
793     ret = 0;
794     if (c->is_video) {
795         ret = mf_encv_output_adjust(avctx, out_type);
796     } else if (c->is_audio) {
797         ret = mf_enca_output_adjust(avctx, out_type);
798     }
799
800     if (ret >= 0) {
801         av_log(avctx, AV_LOG_VERBOSE, "setting output type:\n");
802         ff_media_type_dump(avctx, out_type);
803
804         hr = IMFTransform_SetOutputType(c->mft, c->out_stream_id, out_type, 0);
805         if (!FAILED(hr)) {
806             ret = 1;
807         } else if (hr == MF_E_TRANSFORM_TYPE_NOT_SET) {
808             av_log(avctx, AV_LOG_VERBOSE, "rejected - need to set input type\n");
809             ret = 0;
810         } else {
811             av_log(avctx, AV_LOG_ERROR, "could not set output type (%s)\n", ff_hr_str(hr));
812             ret = AVERROR_EXTERNAL;
813         }
814     }
815
816 done:
817     if (out_type)
818         IMFMediaType_Release(out_type);
819     return ret;
820 }
821
822 static int mf_choose_input_type(AVCodecContext *avctx)
823 {
824     MFContext *c = avctx->priv_data;
825     HRESULT hr;
826     int ret;
827     IMFMediaType *in_type = NULL;
828     int64_t in_type_score = -1;
829     int in_type_index = -1;
830     int n;
831
832     av_log(avctx, AV_LOG_VERBOSE, "input types:\n");
833     for (n = 0; ; n++) {
834         IMFMediaType *type = NULL;
835         int64_t score = -1;
836
837         hr = IMFTransform_GetInputAvailableType(c->mft, c->in_stream_id, n, &type);
838         if (hr == MF_E_NO_MORE_TYPES || hr == E_NOTIMPL)
839             break;
840         if (hr == MF_E_TRANSFORM_TYPE_NOT_SET) {
841             av_log(avctx, AV_LOG_VERBOSE, "(need to set output type 1)\n");
842             ret = 0;
843             goto done;
844         }
845         if (FAILED(hr)) {
846             av_log(avctx, AV_LOG_ERROR, "error getting input type: %s\n", ff_hr_str(hr));
847             ret = AVERROR_EXTERNAL;
848             goto done;
849         }
850
851         av_log(avctx, AV_LOG_VERBOSE, "input type %d:\n", n);
852         ff_media_type_dump(avctx, type);
853
854         if (c->is_video) {
855             score = mf_encv_input_score(avctx, type);
856         } else if (c->is_audio) {
857             score = mf_enca_input_score(avctx, type);
858         }
859
860         if (score > in_type_score) {
861             if (in_type)
862                 IMFMediaType_Release(in_type);
863             in_type = type;
864             in_type_score = score;
865             in_type_index = n;
866             IMFMediaType_AddRef(in_type);
867         }
868
869         IMFMediaType_Release(type);
870     }
871
872     if (in_type) {
873         av_log(avctx, AV_LOG_VERBOSE, "picking input type %d.\n", in_type_index);
874     } else {
875         // Some buggy MFTs (WMA encoder) fail to return MF_E_TRANSFORM_TYPE_NOT_SET.
876         av_log(avctx, AV_LOG_VERBOSE, "(need to set output type 2)\n");
877         ret = 0;
878         goto done;
879     }
880
881     ret = 0;
882     if (c->is_video) {
883         ret = mf_encv_input_adjust(avctx, in_type);
884     } else if (c->is_audio) {
885         ret = mf_enca_input_adjust(avctx, in_type);
886     }
887
888     if (ret >= 0) {
889         av_log(avctx, AV_LOG_VERBOSE, "setting input type:\n");
890         ff_media_type_dump(avctx, in_type);
891
892         hr = IMFTransform_SetInputType(c->mft, c->in_stream_id, in_type, 0);
893         if (!FAILED(hr)) {
894             ret = 1;
895         } else if (hr == MF_E_TRANSFORM_TYPE_NOT_SET) {
896             av_log(avctx, AV_LOG_VERBOSE, "rejected - need to set output type\n");
897             ret = 0;
898         } else {
899             av_log(avctx, AV_LOG_ERROR, "could not set input type (%s)\n", ff_hr_str(hr));
900             ret = AVERROR_EXTERNAL;
901         }
902     }
903
904 done:
905     if (in_type)
906         IMFMediaType_Release(in_type);
907     return ret;
908 }
909
910 static int mf_negotiate_types(AVCodecContext *avctx)
911 {
912     // This follows steps 1-5 on:
913     //  https://msdn.microsoft.com/en-us/library/windows/desktop/aa965264(v=vs.85).aspx
914     // If every MFT implementer does this correctly, this loop should at worst
915     // be repeated once.
916     int need_input = 1, need_output = 1;
917     int n;
918     for (n = 0; n < 2 && (need_input || need_output); n++) {
919         int ret;
920         ret = mf_choose_input_type(avctx);
921         if (ret < 0)
922             return ret;
923         need_input = ret < 1;
924         ret = mf_choose_output_type(avctx);
925         if (ret < 0)
926             return ret;
927         need_output = ret < 1;
928     }
929     if (need_input || need_output) {
930         av_log(avctx, AV_LOG_ERROR, "format negotiation failed (%d/%d)\n",
931                need_input, need_output);
932         return AVERROR_EXTERNAL;
933     }
934     return 0;
935 }
936
937 static int mf_setup_context(AVCodecContext *avctx)
938 {
939     MFContext *c = avctx->priv_data;
940     HRESULT hr;
941     int ret;
942
943     hr = IMFTransform_GetInputStreamInfo(c->mft, c->in_stream_id, &c->in_info);
944     if (FAILED(hr))
945         return AVERROR_EXTERNAL;
946     av_log(avctx, AV_LOG_VERBOSE, "in_info: size=%d, align=%d\n",
947            (int)c->in_info.cbSize, (int)c->in_info.cbAlignment);
948
949     hr = IMFTransform_GetOutputStreamInfo(c->mft, c->out_stream_id, &c->out_info);
950     if (FAILED(hr))
951         return AVERROR_EXTERNAL;
952     c->out_stream_provides_samples =
953         (c->out_info.dwFlags & MFT_OUTPUT_STREAM_PROVIDES_SAMPLES) ||
954         (c->out_info.dwFlags & MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES);
955     av_log(avctx, AV_LOG_VERBOSE, "out_info: size=%d, align=%d%s\n",
956            (int)c->out_info.cbSize, (int)c->out_info.cbAlignment,
957            c->out_stream_provides_samples ? " (provides samples)" : "");
958
959     if ((ret = mf_output_type_get(avctx)) < 0)
960         return ret;
961
962     return 0;
963 }
964
965 static int mf_unlock_async(AVCodecContext *avctx)
966 {
967     MFContext *c = avctx->priv_data;
968     HRESULT hr;
969     IMFAttributes *attrs;
970     UINT32 v;
971     int res = AVERROR_EXTERNAL;
972
973     // For hw encoding we unfortunately need to use async mode, otherwise
974     // play it safe and avoid it.
975     if (!(c->is_video && c->opt_enc_hw))
976         return 0;
977
978     hr = IMFTransform_GetAttributes(c->mft, &attrs);
979     if (FAILED(hr)) {
980         av_log(avctx, AV_LOG_ERROR, "error retrieving MFT attributes: %s\n", ff_hr_str(hr));
981         goto err;
982     }
983
984     hr = IMFAttributes_GetUINT32(attrs, &MF_TRANSFORM_ASYNC, &v);
985     if (FAILED(hr)) {
986         av_log(avctx, AV_LOG_ERROR, "error querying async: %s\n", ff_hr_str(hr));
987         goto err;
988     }
989
990     if (!v) {
991         av_log(avctx, AV_LOG_ERROR, "hardware MFT is not async\n");
992         goto err;
993     }
994
995     hr = IMFAttributes_SetUINT32(attrs, &MF_TRANSFORM_ASYNC_UNLOCK, TRUE);
996     if (FAILED(hr)) {
997         av_log(avctx, AV_LOG_ERROR, "could not set async unlock: %s\n", ff_hr_str(hr));
998         goto err;
999     }
1000
1001     hr = IMFTransform_QueryInterface(c->mft, &IID_IMFMediaEventGenerator, (void **)&c->async_events);
1002     if (FAILED(hr)) {
1003         av_log(avctx, AV_LOG_ERROR, "could not get async interface\n");
1004         goto err;
1005     }
1006
1007     res = 0;
1008
1009 err:
1010     IMFAttributes_Release(attrs);
1011     return res;
1012 }
1013
1014 static int mf_create(void *log, MFFunctions *f, IMFTransform **mft,
1015                      const AVCodec *codec, int use_hw)
1016 {
1017     int is_audio = codec->type == AVMEDIA_TYPE_AUDIO;
1018     const CLSID *subtype = ff_codec_to_mf_subtype(codec->id);
1019     MFT_REGISTER_TYPE_INFO reg = {0};
1020     GUID category;
1021     int ret;
1022
1023     *mft = NULL;
1024
1025     if (!subtype)
1026         return AVERROR(ENOSYS);
1027
1028     reg.guidSubtype = *subtype;
1029
1030     if (is_audio) {
1031         reg.guidMajorType = MFMediaType_Audio;
1032         category = MFT_CATEGORY_AUDIO_ENCODER;
1033     } else {
1034         reg.guidMajorType = MFMediaType_Video;
1035         category = MFT_CATEGORY_VIDEO_ENCODER;
1036     }
1037
1038     if ((ret = ff_instantiate_mf(log, f, category, NULL, &reg, use_hw, mft)) < 0)
1039         return ret;
1040
1041     return 0;
1042 }
1043
1044 static int mf_init_encoder(AVCodecContext *avctx)
1045 {
1046     MFContext *c = avctx->priv_data;
1047     HRESULT hr;
1048     int ret;
1049     const CLSID *subtype = ff_codec_to_mf_subtype(avctx->codec_id);
1050     int use_hw = 0;
1051
1052     c->frame = av_frame_alloc();
1053     if (!c->frame)
1054         return AVERROR(ENOMEM);
1055
1056     c->is_audio = avctx->codec_type == AVMEDIA_TYPE_AUDIO;
1057     c->is_video = !c->is_audio;
1058     c->reorder_delay = AV_NOPTS_VALUE;
1059
1060     if (c->is_video && c->opt_enc_hw)
1061         use_hw = 1;
1062
1063     if (!subtype)
1064         return AVERROR(ENOSYS);
1065
1066     c->main_subtype = *subtype;
1067
1068     if ((ret = mf_create(avctx, &c->functions, &c->mft, avctx->codec, use_hw)) < 0)
1069         return ret;
1070
1071     if ((ret = mf_unlock_async(avctx)) < 0)
1072         return ret;
1073
1074     hr = IMFTransform_QueryInterface(c->mft, &IID_ICodecAPI, (void **)&c->codec_api);
1075     if (!FAILED(hr))
1076         av_log(avctx, AV_LOG_VERBOSE, "MFT supports ICodecAPI.\n");
1077
1078
1079     hr = IMFTransform_GetStreamIDs(c->mft, 1, &c->in_stream_id, 1, &c->out_stream_id);
1080     if (hr == E_NOTIMPL) {
1081         c->in_stream_id = c->out_stream_id = 0;
1082     } else if (FAILED(hr)) {
1083         av_log(avctx, AV_LOG_ERROR, "could not get stream IDs (%s)\n", ff_hr_str(hr));
1084         return AVERROR_EXTERNAL;
1085     }
1086
1087     if ((ret = mf_negotiate_types(avctx)) < 0)
1088         return ret;
1089
1090     if ((ret = mf_setup_context(avctx)) < 0)
1091         return ret;
1092
1093     hr = IMFTransform_ProcessMessage(c->mft, MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
1094     if (FAILED(hr)) {
1095         av_log(avctx, AV_LOG_ERROR, "could not start streaming (%s)\n", ff_hr_str(hr));
1096         return AVERROR_EXTERNAL;
1097     }
1098
1099     hr = IMFTransform_ProcessMessage(c->mft, MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0);
1100     if (FAILED(hr)) {
1101         av_log(avctx, AV_LOG_ERROR, "could not start stream (%s)\n", ff_hr_str(hr));
1102         return AVERROR_EXTERNAL;
1103     }
1104
1105     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER && c->async_events &&
1106         c->is_video && !avctx->extradata) {
1107         int sleep = 10000, total = 0;
1108         av_log(avctx, AV_LOG_VERBOSE, "Awaiting extradata\n");
1109         while (total < 70*1000) {
1110             // The Qualcomm H264 encoder on SD835 doesn't provide extradata
1111             // immediately, but it becomes available soon after init (without
1112             // any waitable event). In practice, it's available after less
1113             // than 10 ms, but wait for up to 70 ms before giving up.
1114             // Some encoders (Qualcomm's HEVC encoder on SD835, some versions
1115             // of the QSV H264 encoder at least) don't provide extradata this
1116             // way at all, not even after encoding a frame - it's only
1117             // available prepended to frames.
1118             av_usleep(sleep);
1119             total += sleep;
1120             mf_output_type_get(avctx);
1121             if (avctx->extradata)
1122                 break;
1123             sleep *= 2;
1124         }
1125         av_log(avctx, AV_LOG_VERBOSE, "%s extradata in %d ms\n",
1126                avctx->extradata ? "Got" : "Didn't get", total / 1000);
1127     }
1128
1129     return 0;
1130 }
1131
1132 #if !HAVE_UWP
1133 #define LOAD_MF_FUNCTION(context, func_name) \
1134     context->functions.func_name = (void *)GetProcAddress(context->library, #func_name); \
1135     if (!context->functions.func_name) { \
1136         av_log(context, AV_LOG_ERROR, "DLL mfplat.dll failed to find function "\
1137            #func_name "\n"); \
1138         return AVERROR_UNKNOWN; \
1139     }
1140 #else
1141 // In UWP (which lacks LoadLibrary), just link directly against
1142 // the functions - this requires building with new/complete enough
1143 // import libraries.
1144 #define LOAD_MF_FUNCTION(context, func_name) \
1145     context->functions.func_name = func_name; \
1146     if (!context->functions.func_name) { \
1147         av_log(context, AV_LOG_ERROR, "Failed to find function " #func_name \
1148                "\n"); \
1149         return AVERROR_UNKNOWN; \
1150     }
1151 #endif
1152
1153 // Windows N editions does not provide MediaFoundation by default.
1154 // So to avoid DLL loading error, MediaFoundation is dynamically loaded except
1155 // on UWP build since LoadLibrary is not available on it.
1156 static int mf_load_library(AVCodecContext *avctx)
1157 {
1158     MFContext *c = avctx->priv_data;
1159
1160 #if !HAVE_UWP
1161     c->library = LoadLibraryA("mfplat.dll");
1162
1163     if (!c->library) {
1164         av_log(c, AV_LOG_ERROR, "DLL mfplat.dll failed to open\n");
1165         return AVERROR_UNKNOWN;
1166     }
1167 #endif
1168
1169     LOAD_MF_FUNCTION(c, MFStartup);
1170     LOAD_MF_FUNCTION(c, MFShutdown);
1171     LOAD_MF_FUNCTION(c, MFCreateAlignedMemoryBuffer);
1172     LOAD_MF_FUNCTION(c, MFCreateSample);
1173     LOAD_MF_FUNCTION(c, MFCreateMediaType);
1174     // MFTEnumEx is missing in Windows Vista's mfplat.dll.
1175     LOAD_MF_FUNCTION(c, MFTEnumEx);
1176
1177     return 0;
1178 }
1179
1180 static int mf_close(AVCodecContext *avctx)
1181 {
1182     MFContext *c = avctx->priv_data;
1183
1184     if (c->codec_api)
1185         ICodecAPI_Release(c->codec_api);
1186
1187     if (c->async_events)
1188         IMFMediaEventGenerator_Release(c->async_events);
1189
1190 #if !HAVE_UWP
1191     if (c->library)
1192         ff_free_mf(&c->functions, &c->mft);
1193
1194     FreeLibrary(c->library);
1195     c->library = NULL;
1196 #else
1197     ff_free_mf(&c->functions, &c->mft);
1198 #endif
1199
1200     av_frame_free(&c->frame);
1201
1202     av_freep(&avctx->extradata);
1203     avctx->extradata_size = 0;
1204
1205     return 0;
1206 }
1207
1208 static int mf_init(AVCodecContext *avctx)
1209 {
1210     int ret;
1211     if ((ret = mf_load_library(avctx)) == 0) {
1212            if ((ret = mf_init_encoder(avctx)) == 0) {
1213                 return 0;
1214         }
1215     }
1216     mf_close(avctx);
1217     return ret;
1218 }
1219
1220 #define OFFSET(x) offsetof(MFContext, x)
1221
1222 #define MF_ENCODER(MEDIATYPE, NAME, ID, OPTS, EXTRA) \
1223     static const AVClass ff_ ## NAME ## _mf_encoder_class = {                  \
1224         .class_name = #NAME "_mf",                                             \
1225         .item_name  = av_default_item_name,                                    \
1226         .option     = OPTS,                                                    \
1227         .version    = LIBAVUTIL_VERSION_INT,                                   \
1228     };                                                                         \
1229     const FFCodec ff_ ## NAME ## _mf_encoder = {                               \
1230         .p.priv_class   = &ff_ ## NAME ## _mf_encoder_class,                   \
1231         .p.name         = #NAME "_mf",                                         \
1232         .p.long_name    = NULL_IF_CONFIG_SMALL(#ID " via MediaFoundation"),    \
1233         .p.type         = AVMEDIA_TYPE_ ## MEDIATYPE,                          \
1234         .p.id           = AV_CODEC_ID_ ## ID,                                  \
1235         .priv_data_size = sizeof(MFContext),                                   \
1236         .init           = mf_init,                                             \
1237         .close          = mf_close,                                            \
1238         FF_CODEC_RECEIVE_PACKET_CB(mf_receive_packet),                         \
1239         EXTRA                                                                  \
1240         .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID |           \
1241                           AV_CODEC_CAP_DR1,                                    \
1242         .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |                       \
1243                           FF_CODEC_CAP_INIT_CLEANUP,                           \
1244     };
1245
1246 #define AFMTS \
1247         .p.sample_fmts  = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,    \
1248                                                          AV_SAMPLE_FMT_NONE },
1249
1250 MF_ENCODER(AUDIO, aac,         AAC, NULL, AFMTS);
1251 MF_ENCODER(AUDIO, ac3,         AC3, NULL, AFMTS);
1252 MF_ENCODER(AUDIO, mp3,         MP3, NULL, AFMTS);
1253
1254 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1255 static const AVOption venc_opts[] = {
1256     {"rate_control",  "Select rate control mode", OFFSET(opt_enc_rc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "rate_control"},
1257     { "default",      "Default mode", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "rate_control"},
1258     { "cbr",          "CBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_CBR}, 0, 0, VE, "rate_control"},
1259     { "pc_vbr",       "Peak constrained VBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_PeakConstrainedVBR}, 0, 0, VE, "rate_control"},
1260     { "u_vbr",        "Unconstrained VBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_UnconstrainedVBR}, 0, 0, VE, "rate_control"},
1261     { "quality",      "Quality mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_Quality}, 0, 0, VE, "rate_control" },
1262     // The following rate_control modes require Windows 8.
1263     { "ld_vbr",       "Low delay VBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_LowDelayVBR}, 0, 0, VE, "rate_control"},
1264     { "g_vbr",        "Global VBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_GlobalVBR}, 0, 0, VE, "rate_control" },
1265     { "gld_vbr",      "Global low delay VBR mode", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVEncCommonRateControlMode_GlobalLowDelayVBR}, 0, 0, VE, "rate_control"},
1266
1267     {"scenario",          "Select usage scenario", OFFSET(opt_enc_scenario), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "scenario"},
1268     { "default",          "Default scenario", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "scenario"},
1269     { "display_remoting", "Display remoting", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_DisplayRemoting}, 0, 0, VE, "scenario"},
1270     { "video_conference", "Video conference", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_VideoConference}, 0, 0, VE, "scenario"},
1271     { "archive",          "Archive", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_Archive}, 0, 0, VE, "scenario"},
1272     { "live_streaming",   "Live streaming", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_LiveStreaming}, 0, 0, VE, "scenario"},
1273     { "camera_record",    "Camera record", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_CameraRecord}, 0, 0, VE, "scenario"},
1274     { "display_remoting_with_feature_map", "Display remoting with feature map", 0, AV_OPT_TYPE_CONST, {.i64 = ff_eAVScenarioInfo_DisplayRemotingWithFeatureMap}, 0, 0, VE, "scenario"},
1275
1276     {"quality",       "Quality", OFFSET(opt_enc_quality), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1277     {"hw_encoding",   "Force hardware encoding", OFFSET(opt_enc_hw), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VE},
1278     {NULL}
1279 };
1280
1281 #define VFMTS \
1282         .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,       \
1283                                                         AV_PIX_FMT_YUV420P,    \
1284                                                         AV_PIX_FMT_NONE },
1285
1286 MF_ENCODER(VIDEO, h264,        H264, venc_opts, VFMTS);
1287 MF_ENCODER(VIDEO, hevc,        HEVC, venc_opts, VFMTS);