Cleanup: compiler warning
[blender.git] / source / blender / blenkernel / intern / writeffmpeg.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  * Partial Copyright (c) 2006 Peter Schlaile
16  */
17
18 /** \file
19  * \ingroup bke
20  */
21
22 #ifdef WITH_FFMPEG
23 #  include <stdio.h>
24 #  include <string.h>
25
26 #  include <stdlib.h>
27
28 #  include "MEM_guardedalloc.h"
29
30 #  include "DNA_scene_types.h"
31
32 #  include "BLI_blenlib.h"
33
34 #  ifdef WITH_AUDASPACE
35 #    include <AUD_Device.h>
36 #    include <AUD_Special.h>
37 #  endif
38
39 #  include "BLI_math_base.h"
40 #  include "BLI_utildefines.h"
41
42 #  include "BKE_global.h"
43 #  include "BKE_idprop.h"
44 #  include "BKE_image.h"
45 #  include "BKE_lib_id.h"
46 #  include "BKE_main.h"
47 #  include "BKE_report.h"
48 #  include "BKE_sound.h"
49 #  include "BKE_writeffmpeg.h"
50
51 #  include "IMB_imbuf.h"
52
53 /* This needs to be included after BLI_math_base.h otherwise it will redefine some math defines
54  * like M_SQRT1_2 leading to warnings with MSVC */
55 #  include <libavcodec/avcodec.h>
56 #  include <libavformat/avformat.h>
57 #  include <libavutil/imgutils.h>
58 #  include <libavutil/rational.h>
59 #  include <libavutil/samplefmt.h>
60 #  include <libswscale/swscale.h>
61
62 #  include "ffmpeg_compat.h"
63
64 struct StampData;
65
66 typedef struct FFMpegContext {
67   int ffmpeg_type;
68   int ffmpeg_codec;
69   int ffmpeg_audio_codec;
70   int ffmpeg_video_bitrate;
71   int ffmpeg_audio_bitrate;
72   int ffmpeg_gop_size;
73   int ffmpeg_max_b_frames;
74   int ffmpeg_autosplit;
75   int ffmpeg_autosplit_count;
76   bool ffmpeg_preview;
77
78   int ffmpeg_crf;    /* set to 0 to not use CRF mode; we have another flag for lossless anyway. */
79   int ffmpeg_preset; /* see eFFMpegPreset */
80
81   AVFormatContext *outfile;
82   AVStream *video_stream;
83   AVStream *audio_stream;
84   AVFrame *current_frame; /* Image frame in output pixel format. */
85
86   /* Image frame in Blender's own pixel format, may need conversion to the output pixel format. */
87   AVFrame *img_convert_frame;
88   struct SwsContext *img_convert_ctx;
89
90   uint8_t *audio_input_buffer;
91   uint8_t *audio_deinterleave_buffer;
92   int audio_input_samples;
93 #  ifndef FFMPEG_HAVE_ENCODE_AUDIO2
94   uint8_t *audio_output_buffer;
95   int audio_outbuf_size;
96 #  endif
97   double audio_time;
98   bool audio_deinterleave;
99   int audio_sample_size;
100
101   struct StampData *stamp_data;
102
103 #  ifdef WITH_AUDASPACE
104   AUD_Device *audio_mixdown_device;
105 #  endif
106 } FFMpegContext;
107
108 #  define FFMPEG_AUTOSPLIT_SIZE 2000000000
109
110 #  define PRINT \
111     if (G.debug & G_DEBUG_FFMPEG) \
112     printf
113
114 static void ffmpeg_dict_set_int(AVDictionary **dict, const char *key, int value);
115 static void ffmpeg_dict_set_float(AVDictionary **dict, const char *key, float value);
116 static void ffmpeg_set_expert_options(RenderData *rd);
117 static void ffmpeg_filepath_get(FFMpegContext *context,
118                                 char *string,
119                                 const struct RenderData *rd,
120                                 bool preview,
121                                 const char *suffix);
122
123 /* Delete a picture buffer */
124
125 static void delete_picture(AVFrame *f)
126 {
127   if (f) {
128     if (f->data[0]) {
129       MEM_freeN(f->data[0]);
130     }
131     av_free(f);
132   }
133 }
134
135 static int request_float_audio_buffer(int codec_id)
136 {
137   /* If any of these codecs, we prefer the float sample format (if supported) */
138   return codec_id == AV_CODEC_ID_AAC || codec_id == AV_CODEC_ID_AC3 ||
139          codec_id == AV_CODEC_ID_VORBIS;
140 }
141
142 #  ifdef WITH_AUDASPACE
143 static int write_audio_frame(FFMpegContext *context)
144 {
145   AVCodecContext *c = NULL;
146   AVPacket pkt;
147   AVFrame *frame = NULL;
148   int got_output = 0;
149
150   c = context->audio_stream->codec;
151
152   av_init_packet(&pkt);
153   pkt.size = 0;
154   pkt.data = NULL;
155
156   AUD_Device_read(
157       context->audio_mixdown_device, context->audio_input_buffer, context->audio_input_samples);
158   context->audio_time += (double)context->audio_input_samples / (double)c->sample_rate;
159
160 #    ifdef FFMPEG_HAVE_ENCODE_AUDIO2
161   frame = av_frame_alloc();
162   av_frame_unref(frame);
163   frame->pts = context->audio_time / av_q2d(c->time_base);
164   frame->nb_samples = context->audio_input_samples;
165   frame->format = c->sample_fmt;
166 #      ifdef FFMPEG_HAVE_FRAME_CHANNEL_LAYOUT
167   frame->channel_layout = c->channel_layout;
168 #      endif
169
170   if (context->audio_deinterleave) {
171     int channel, i;
172     uint8_t *temp;
173
174     for (channel = 0; channel < c->channels; channel++) {
175       for (i = 0; i < frame->nb_samples; i++) {
176         memcpy(context->audio_deinterleave_buffer +
177                    (i + channel * frame->nb_samples) * context->audio_sample_size,
178                context->audio_input_buffer +
179                    (c->channels * i + channel) * context->audio_sample_size,
180                context->audio_sample_size);
181       }
182     }
183
184     temp = context->audio_deinterleave_buffer;
185     context->audio_deinterleave_buffer = context->audio_input_buffer;
186     context->audio_input_buffer = temp;
187   }
188
189   avcodec_fill_audio_frame(frame,
190                            c->channels,
191                            c->sample_fmt,
192                            context->audio_input_buffer,
193                            context->audio_input_samples * c->channels * context->audio_sample_size,
194                            1);
195
196   if (avcodec_encode_audio2(c, &pkt, frame, &got_output) < 0) {
197     // XXX error("Error writing audio packet");
198     return -1;
199   }
200
201   if (!got_output) {
202     av_frame_free(&frame);
203     return 0;
204   }
205 #    else
206   pkt.size = avcodec_encode_audio(c,
207                                   context->audio_output_buffer,
208                                   context->audio_outbuf_size,
209                                   (short *)context->audio_input_buffer);
210
211   if (pkt.size < 0) {
212     // XXX error("Error writing audio packet");
213     return -1;
214   }
215
216   pkt.data = context->audio_output_buffer;
217   got_output = 1;
218 #    endif
219
220   if (got_output) {
221     if (pkt.pts != AV_NOPTS_VALUE) {
222       pkt.pts = av_rescale_q(pkt.pts, c->time_base, context->audio_stream->time_base);
223     }
224     if (pkt.dts != AV_NOPTS_VALUE) {
225       pkt.dts = av_rescale_q(pkt.dts, c->time_base, context->audio_stream->time_base);
226     }
227     if (pkt.duration > 0) {
228       pkt.duration = av_rescale_q(pkt.duration, c->time_base, context->audio_stream->time_base);
229     }
230
231     pkt.stream_index = context->audio_stream->index;
232
233     pkt.flags |= AV_PKT_FLAG_KEY;
234
235     if (av_interleaved_write_frame(context->outfile, &pkt) != 0) {
236       fprintf(stderr, "Error writing audio packet!\n");
237       if (frame) {
238         av_frame_free(&frame);
239       }
240       return -1;
241     }
242
243     av_free_packet(&pkt);
244   }
245
246   if (frame) {
247     av_frame_free(&frame);
248   }
249
250   return 0;
251 }
252 #  endif  // #ifdef WITH_AUDASPACE
253
254 /* Allocate a temporary frame */
255 static AVFrame *alloc_picture(int pix_fmt, int width, int height)
256 {
257   AVFrame *f;
258   uint8_t *buf;
259   int size;
260
261   /* allocate space for the struct */
262   f = av_frame_alloc();
263   if (!f) {
264     return NULL;
265   }
266   size = avpicture_get_size(pix_fmt, width, height);
267   /* allocate the actual picture buffer */
268   buf = MEM_mallocN(size, "AVFrame buffer");
269   if (!buf) {
270     free(f);
271     return NULL;
272   }
273   avpicture_fill((AVPicture *)f, buf, pix_fmt, width, height);
274   f->format = pix_fmt;
275   f->width = width;
276   f->height = height;
277
278   return f;
279 }
280
281 /* Get the correct file extensions for the requested format,
282  * first is always desired guess_format parameter */
283 static const char **get_file_extensions(int format)
284 {
285   switch (format) {
286     case FFMPEG_DV: {
287       static const char *rv[] = {".dv", NULL};
288       return rv;
289     }
290     case FFMPEG_MPEG1: {
291       static const char *rv[] = {".mpg", ".mpeg", NULL};
292       return rv;
293     }
294     case FFMPEG_MPEG2: {
295       static const char *rv[] = {".dvd", ".vob", ".mpg", ".mpeg", NULL};
296       return rv;
297     }
298     case FFMPEG_MPEG4: {
299       static const char *rv[] = {".mp4", ".mpg", ".mpeg", NULL};
300       return rv;
301     }
302     case FFMPEG_AVI: {
303       static const char *rv[] = {".avi", NULL};
304       return rv;
305     }
306     case FFMPEG_MOV: {
307       static const char *rv[] = {".mov", NULL};
308       return rv;
309     }
310     case FFMPEG_H264: {
311       /* FIXME: avi for now... */
312       static const char *rv[] = {".avi", NULL};
313       return rv;
314     }
315
316     case FFMPEG_XVID: {
317       /* FIXME: avi for now... */
318       static const char *rv[] = {".avi", NULL};
319       return rv;
320     }
321     case FFMPEG_FLV: {
322       static const char *rv[] = {".flv", NULL};
323       return rv;
324     }
325     case FFMPEG_MKV: {
326       static const char *rv[] = {".mkv", NULL};
327       return rv;
328     }
329     case FFMPEG_OGG: {
330       static const char *rv[] = {".ogv", ".ogg", NULL};
331       return rv;
332     }
333     case FFMPEG_WEBM: {
334       static const char *rv[] = {".webm", NULL};
335       return rv;
336     }
337     default:
338       return NULL;
339   }
340 }
341
342 /* Write a frame to the output file */
343 static int write_video_frame(
344     FFMpegContext *context, const RenderData *rd, int cfra, AVFrame *frame, ReportList *reports)
345 {
346   int got_output;
347   int ret, success = 1;
348   AVCodecContext *c = context->video_stream->codec;
349   AVPacket packet = {0};
350
351   av_init_packet(&packet);
352
353   frame->pts = cfra;
354
355   ret = avcodec_encode_video2(c, &packet, frame, &got_output);
356
357   if (ret >= 0 && got_output) {
358     if (packet.pts != AV_NOPTS_VALUE) {
359       packet.pts = av_rescale_q(packet.pts, c->time_base, context->video_stream->time_base);
360       PRINT("Video Frame PTS: %d\n", (int)packet.pts);
361     }
362     else {
363       PRINT("Video Frame PTS: not set\n");
364     }
365     if (packet.dts != AV_NOPTS_VALUE) {
366       packet.dts = av_rescale_q(packet.dts, c->time_base, context->video_stream->time_base);
367       PRINT("Video Frame DTS: %d\n", (int)packet.dts);
368     }
369     else {
370       PRINT("Video Frame DTS: not set\n");
371     }
372
373     packet.stream_index = context->video_stream->index;
374     ret = av_interleaved_write_frame(context->outfile, &packet);
375     success = (ret == 0);
376   }
377   else if (ret < 0) {
378     success = 0;
379   }
380
381   if (!success) {
382     BKE_report(reports, RPT_ERROR, "Error writing frame");
383   }
384
385   return success;
386 }
387
388 /* read and encode a frame of audio from the buffer */
389 static AVFrame *generate_video_frame(FFMpegContext *context,
390                                      const uint8_t *pixels,
391                                      ReportList *reports)
392 {
393   AVCodecContext *c = context->video_stream->codec;
394   int height = c->height;
395   AVFrame *rgb_frame;
396
397   if (context->img_convert_frame != NULL) {
398     /* Pixel format conversion is needed. */
399     rgb_frame = context->img_convert_frame;
400   }
401   else {
402     /* The output pixel format is Blender's internal pixel format. */
403     rgb_frame = context->current_frame;
404   }
405
406   /* Copy the Blender pixels into the FFmpeg datastructure, taking care of endianness and flipping
407    * the image vertically. */
408   int linesize = rgb_frame->linesize[0];
409   for (int y = 0; y < height; y++) {
410     uint8_t *target = rgb_frame->data[0] + linesize * (height - y - 1);
411     const uint8_t *src = pixels + linesize * y;
412
413 #  if ENDIAN_ORDER == L_ENDIAN
414     memcpy(target, src, linesize);
415
416 #  elif ENDIAN_ORDER == B_ENDIAN
417     const uint8_t *end = src + linesize;
418     while (src != end) {
419       target[3] = src[0];
420       target[2] = src[1];
421       target[1] = src[2];
422       target[0] = src[3];
423
424       target += 4;
425       src += 4;
426     }
427 #  else
428 #    error ENDIAN_ORDER should either be L_ENDIAN or B_ENDIAN.
429 #  endif
430   }
431
432   /* Convert to the output pixel format, if it's different that Blender's internal one. */
433   if (context->img_convert_frame != NULL) {
434     BLI_assert(context->img_convert_ctx != NULL);
435     sws_scale(context->img_convert_ctx,
436               (const uint8_t *const *)rgb_frame->data,
437               rgb_frame->linesize,
438               0,
439               c->height,
440               context->current_frame->data,
441               context->current_frame->linesize);
442   }
443
444   return context->current_frame;
445 }
446
447 static void set_ffmpeg_property_option(AVCodecContext *c,
448                                        IDProperty *prop,
449                                        AVDictionary **dictionary)
450 {
451   char name[128];
452   char *param;
453
454   PRINT("FFMPEG expert option: %s: ", prop->name);
455
456   BLI_strncpy(name, prop->name, sizeof(name));
457
458   param = strchr(name, ':');
459
460   if (param) {
461     *param++ = '\0';
462   }
463
464   switch (prop->type) {
465     case IDP_STRING:
466       PRINT("%s.\n", IDP_String(prop));
467       av_dict_set(dictionary, name, IDP_String(prop), 0);
468       break;
469     case IDP_FLOAT:
470       PRINT("%g.\n", IDP_Float(prop));
471       ffmpeg_dict_set_float(dictionary, prop->name, IDP_Float(prop));
472       break;
473     case IDP_INT:
474       PRINT("%d.\n", IDP_Int(prop));
475
476       if (param) {
477         if (IDP_Int(prop)) {
478           av_dict_set(dictionary, name, param, 0);
479         }
480         else {
481           return;
482         }
483       }
484       else {
485         ffmpeg_dict_set_int(dictionary, prop->name, IDP_Int(prop));
486       }
487       break;
488   }
489 }
490
491 static int ffmpeg_proprty_valid(AVCodecContext *c, const char *prop_name, IDProperty *curr)
492 {
493   int valid = 1;
494
495   if (STREQ(prop_name, "video")) {
496     if (STREQ(curr->name, "bf")) {
497       /* flash codec doesn't support b frames */
498       valid &= c->codec_id != AV_CODEC_ID_FLV1;
499     }
500   }
501
502   return valid;
503 }
504
505 static void set_ffmpeg_properties(RenderData *rd,
506                                   AVCodecContext *c,
507                                   const char *prop_name,
508                                   AVDictionary **dictionary)
509 {
510   IDProperty *prop;
511   IDProperty *curr;
512
513   /* TODO(sergey): This is actually rather stupid, because changing
514    * codec settings in render panel would also set expert options.
515    *
516    * But we need ti here in order to get rid of deprecated settings
517    * when opening old files in new blender.
518    *
519    * For as long we don't allow editing properties in the interface
520    * it's all good. bug if we allow editing them, we'll need to
521    * replace it with some smarter code which would port settings
522    * from deprecated to new one.
523    */
524   ffmpeg_set_expert_options(rd);
525
526   if (!rd->ffcodecdata.properties) {
527     return;
528   }
529
530   prop = IDP_GetPropertyFromGroup(rd->ffcodecdata.properties, prop_name);
531   if (!prop) {
532     return;
533   }
534
535   for (curr = prop->data.group.first; curr; curr = curr->next) {
536     if (ffmpeg_proprty_valid(c, prop_name, curr)) {
537       set_ffmpeg_property_option(c, curr, dictionary);
538     }
539   }
540 }
541
542 /* prepare a video stream for the output file */
543
544 static AVStream *alloc_video_stream(FFMpegContext *context,
545                                     RenderData *rd,
546                                     int codec_id,
547                                     AVFormatContext *of,
548                                     int rectx,
549                                     int recty,
550                                     char *error,
551                                     int error_size)
552 {
553   AVStream *st;
554   AVCodecContext *c;
555   AVCodec *codec;
556   AVDictionary *opts = NULL;
557
558   error[0] = '\0';
559
560   st = avformat_new_stream(of, NULL);
561   if (!st) {
562     return NULL;
563   }
564   st->id = 0;
565
566   /* Set up the codec context */
567
568   c = st->codec;
569   c->thread_count = 0;
570   c->thread_type = FF_THREAD_FRAME;
571
572   c->codec_id = codec_id;
573   c->codec_type = AVMEDIA_TYPE_VIDEO;
574
575   /* Get some values from the current render settings */
576
577   c->width = rectx;
578   c->height = recty;
579
580   /* FIXME: Really bad hack (tm) for NTSC support */
581   if (context->ffmpeg_type == FFMPEG_DV && rd->frs_sec != 25) {
582     c->time_base.den = 2997;
583     c->time_base.num = 100;
584   }
585   else if ((float)((int)rd->frs_sec_base) == rd->frs_sec_base) {
586     c->time_base.den = rd->frs_sec;
587     c->time_base.num = (int)rd->frs_sec_base;
588   }
589   else if (compare_ff(rd->frs_sec_base, 1.001f, 0.000001f)) {
590     /* This converts xx/1.001 (which is used in presets) to xx000/1001 (which is used in the rest
591      * of the world, including FFmpeg). */
592     c->time_base.den = (int)(rd->frs_sec * 1000);
593     c->time_base.num = (int)(rd->frs_sec_base * 1000);
594   }
595   else {
596     /* This calculates a fraction (DENUM_MAX / num) which approximates the scene frame rate
597      * (frs_sec / frs_sec_base). It uses the maximum denominator allowed by FFmpeg.
598      */
599     const double DENUM_MAX = (codec_id == AV_CODEC_ID_MPEG4) ? (1UL << 16) - 1 : (1UL << 31) - 1;
600     const double num = (DENUM_MAX / (double)rd->frs_sec) * rd->frs_sec_base;
601
602     c->time_base.den = (int)DENUM_MAX;
603     c->time_base.num = (int)num;
604   }
605
606   c->gop_size = context->ffmpeg_gop_size;
607   c->max_b_frames = context->ffmpeg_max_b_frames;
608
609   if (context->ffmpeg_type == FFMPEG_WEBM && context->ffmpeg_crf == 0) {
610     ffmpeg_dict_set_int(&opts, "lossless", 1);
611   }
612   else if (context->ffmpeg_crf >= 0) {
613     ffmpeg_dict_set_int(&opts, "crf", context->ffmpeg_crf);
614   }
615   else {
616     c->bit_rate = context->ffmpeg_video_bitrate * 1000;
617     c->rc_max_rate = rd->ffcodecdata.rc_max_rate * 1000;
618     c->rc_min_rate = rd->ffcodecdata.rc_min_rate * 1000;
619     c->rc_buffer_size = rd->ffcodecdata.rc_buffer_size * 1024;
620   }
621
622   if (context->ffmpeg_preset) {
623     /* 'preset' is used by h.264, 'deadline' is used by webm/vp9. I'm not
624      * setting those properties conditionally based on the video codec,
625      * as the FFmpeg encoder simply ignores unknown settings anyway. */
626     char const *preset_name = NULL;   /* used by h.264 */
627     char const *deadline_name = NULL; /* used by webm/vp9 */
628     switch (context->ffmpeg_preset) {
629       case FFM_PRESET_GOOD:
630         preset_name = "medium";
631         deadline_name = "good";
632         break;
633       case FFM_PRESET_BEST:
634         preset_name = "slower";
635         deadline_name = "best";
636         break;
637       case FFM_PRESET_REALTIME:
638         preset_name = "superfast";
639         deadline_name = "realtime";
640         break;
641       default:
642         printf("Unknown preset number %i, ignoring.\n", context->ffmpeg_preset);
643     }
644     if (preset_name != NULL) {
645       av_dict_set(&opts, "preset", preset_name, 0);
646     }
647     if (deadline_name != NULL) {
648       av_dict_set(&opts, "deadline", deadline_name, 0);
649     }
650   }
651
652   /* Deprecated and not doing anything since July 2015, deleted in recent ffmpeg */
653   // c->me_method = ME_EPZS;
654
655   codec = avcodec_find_encoder(c->codec_id);
656   if (!codec) {
657     return NULL;
658   }
659
660   /* Be sure to use the correct pixel format(e.g. RGB, YUV) */
661
662   if (codec->pix_fmts) {
663     c->pix_fmt = codec->pix_fmts[0];
664   }
665   else {
666     /* makes HuffYUV happy ... */
667     c->pix_fmt = AV_PIX_FMT_YUV422P;
668   }
669
670   if (context->ffmpeg_type == FFMPEG_XVID) {
671     /* arghhhh ... */
672     c->pix_fmt = AV_PIX_FMT_YUV420P;
673     c->codec_tag = (('D' << 24) + ('I' << 16) + ('V' << 8) + 'X');
674   }
675
676   if (codec_id == AV_CODEC_ID_H264) {
677     /* correct wrong default ffmpeg param which crash x264 */
678     c->qmin = 10;
679     c->qmax = 51;
680   }
681
682   /* Keep lossless encodes in the RGB domain. */
683   if (codec_id == AV_CODEC_ID_HUFFYUV) {
684     if (rd->im_format.planes == R_IMF_PLANES_RGBA) {
685       c->pix_fmt = AV_PIX_FMT_BGRA;
686     }
687     else {
688       c->pix_fmt = AV_PIX_FMT_RGB32;
689     }
690   }
691
692   if (codec_id == AV_CODEC_ID_FFV1) {
693     c->pix_fmt = AV_PIX_FMT_RGB32;
694   }
695
696   if (codec_id == AV_CODEC_ID_QTRLE) {
697     if (rd->im_format.planes == R_IMF_PLANES_RGBA) {
698       c->pix_fmt = AV_PIX_FMT_ARGB;
699     }
700   }
701
702   if (codec_id == AV_CODEC_ID_VP9) {
703     if (rd->im_format.planes == R_IMF_PLANES_RGBA) {
704       c->pix_fmt = AV_PIX_FMT_YUVA420P;
705     }
706   }
707
708   if (codec_id == AV_CODEC_ID_PNG) {
709     if (rd->im_format.planes == R_IMF_PLANES_RGBA) {
710       c->pix_fmt = AV_PIX_FMT_RGBA;
711     }
712   }
713
714   if ((of->oformat->flags & AVFMT_GLOBALHEADER)) {
715     PRINT("Using global header\n");
716     c->flags |= CODEC_FLAG_GLOBAL_HEADER;
717   }
718
719   /* xasp & yasp got float lately... */
720
721   st->sample_aspect_ratio = c->sample_aspect_ratio = av_d2q(((double)rd->xasp / (double)rd->yasp),
722                                                             255);
723   st->avg_frame_rate = av_inv_q(c->time_base);
724
725   set_ffmpeg_properties(rd, c, "video", &opts);
726
727   if (avcodec_open2(c, codec, &opts) < 0) {
728     BLI_strncpy(error, IMB_ffmpeg_last_error(), error_size);
729     av_dict_free(&opts);
730     return NULL;
731   }
732   av_dict_free(&opts);
733
734   /* FFmpeg expects its data in the output pixel format. */
735   context->current_frame = alloc_picture(c->pix_fmt, c->width, c->height);
736
737   if (c->pix_fmt == AV_PIX_FMT_RGBA) {
738     /* Output pixel format is the same we use internally, no conversion necessary. */
739     context->img_convert_frame = NULL;
740     context->img_convert_ctx = NULL;
741   }
742   else {
743     /* Output pixel format is different, allocate frame for conversion. */
744     context->img_convert_frame = alloc_picture(AV_PIX_FMT_RGBA, c->width, c->height);
745     context->img_convert_ctx = sws_getContext(c->width,
746                                               c->height,
747                                               AV_PIX_FMT_RGBA,
748                                               c->width,
749                                               c->height,
750                                               c->pix_fmt,
751                                               SWS_BICUBIC,
752                                               NULL,
753                                               NULL,
754                                               NULL);
755   }
756
757   return st;
758 }
759
760 static AVStream *alloc_audio_stream(FFMpegContext *context,
761                                     RenderData *rd,
762                                     int codec_id,
763                                     AVFormatContext *of,
764                                     char *error,
765                                     int error_size)
766 {
767   AVStream *st;
768   AVCodecContext *c;
769   AVCodec *codec;
770   AVDictionary *opts = NULL;
771
772   error[0] = '\0';
773
774   st = avformat_new_stream(of, NULL);
775   if (!st) {
776     return NULL;
777   }
778   st->id = 1;
779
780   c = st->codec;
781   c->thread_count = 0;
782   c->thread_type = FF_THREAD_FRAME;
783
784   c->codec_id = codec_id;
785   c->codec_type = AVMEDIA_TYPE_AUDIO;
786
787   c->sample_rate = rd->ffcodecdata.audio_mixrate;
788   c->bit_rate = context->ffmpeg_audio_bitrate * 1000;
789   c->sample_fmt = AV_SAMPLE_FMT_S16;
790   c->channels = rd->ffcodecdata.audio_channels;
791
792 #  ifdef FFMPEG_HAVE_FRAME_CHANNEL_LAYOUT
793   switch (rd->ffcodecdata.audio_channels) {
794     case FFM_CHANNELS_MONO:
795       c->channel_layout = AV_CH_LAYOUT_MONO;
796       break;
797     case FFM_CHANNELS_STEREO:
798       c->channel_layout = AV_CH_LAYOUT_STEREO;
799       break;
800     case FFM_CHANNELS_SURROUND4:
801       c->channel_layout = AV_CH_LAYOUT_QUAD;
802       break;
803     case FFM_CHANNELS_SURROUND51:
804       c->channel_layout = AV_CH_LAYOUT_5POINT1_BACK;
805       break;
806     case FFM_CHANNELS_SURROUND71:
807       c->channel_layout = AV_CH_LAYOUT_7POINT1;
808       break;
809   }
810 #  endif
811
812   if (request_float_audio_buffer(codec_id)) {
813     /* mainly for AAC codec which is experimental */
814     c->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
815     c->sample_fmt = AV_SAMPLE_FMT_FLT;
816   }
817
818   codec = avcodec_find_encoder(c->codec_id);
819   if (!codec) {
820     // XXX error("Couldn't find a valid audio codec");
821     return NULL;
822   }
823
824   if (codec->sample_fmts) {
825     /* Check if the preferred sample format for this codec is supported.
826      * this is because, depending on the version of libav,
827      * and with the whole ffmpeg/libav fork situation,
828      * you have various implementations around.
829      * Float samples in particular are not always supported. */
830     const enum AVSampleFormat *p = codec->sample_fmts;
831     for (; *p != -1; p++) {
832       if (*p == st->codec->sample_fmt) {
833         break;
834       }
835     }
836     if (*p == -1) {
837       /* sample format incompatible with codec. Defaulting to a format known to work */
838       st->codec->sample_fmt = codec->sample_fmts[0];
839     }
840   }
841
842   if (codec->supported_samplerates) {
843     const int *p = codec->supported_samplerates;
844     int best = 0;
845     int best_dist = INT_MAX;
846     for (; *p; p++) {
847       int dist = abs(st->codec->sample_rate - *p);
848       if (dist < best_dist) {
849         best_dist = dist;
850         best = *p;
851       }
852     }
853     /* best is the closest supported sample rate (same as selected if best_dist == 0) */
854     st->codec->sample_rate = best;
855   }
856
857   if (of->oformat->flags & AVFMT_GLOBALHEADER) {
858     c->flags |= CODEC_FLAG_GLOBAL_HEADER;
859   }
860
861   set_ffmpeg_properties(rd, c, "audio", &opts);
862
863   if (avcodec_open2(c, codec, &opts) < 0) {
864     // XXX error("Couldn't initialize audio codec");
865     BLI_strncpy(error, IMB_ffmpeg_last_error(), error_size);
866     av_dict_free(&opts);
867     return NULL;
868   }
869   av_dict_free(&opts);
870
871   /* need to prevent floating point exception when using vorbis audio codec,
872    * initialize this value in the same way as it's done in FFmpeg itself (sergey) */
873   st->codec->time_base.num = 1;
874   st->codec->time_base.den = st->codec->sample_rate;
875
876 #  ifndef FFMPEG_HAVE_ENCODE_AUDIO2
877   context->audio_outbuf_size = FF_MIN_BUFFER_SIZE;
878 #  endif
879
880   if (c->frame_size == 0) {
881     // used to be if ((c->codec_id >= CODEC_ID_PCM_S16LE) && (c->codec_id <= CODEC_ID_PCM_DVD))
882     // not sure if that is needed anymore, so let's try out if there are any
883     // complaints regarding some ffmpeg versions users might have
884     context->audio_input_samples = FF_MIN_BUFFER_SIZE * 8 / c->bits_per_coded_sample / c->channels;
885   }
886   else {
887     context->audio_input_samples = c->frame_size;
888 #  ifndef FFMPEG_HAVE_ENCODE_AUDIO2
889     if (c->frame_size * c->channels * sizeof(int16_t) * 4 > context->audio_outbuf_size) {
890       context->audio_outbuf_size = c->frame_size * c->channels * sizeof(int16_t) * 4;
891     }
892 #  endif
893   }
894
895   context->audio_deinterleave = av_sample_fmt_is_planar(c->sample_fmt);
896
897   context->audio_sample_size = av_get_bytes_per_sample(c->sample_fmt);
898
899   context->audio_input_buffer = (uint8_t *)av_malloc(context->audio_input_samples * c->channels *
900                                                      context->audio_sample_size);
901 #  ifndef FFMPEG_HAVE_ENCODE_AUDIO2
902   context->audio_output_buffer = (uint8_t *)av_malloc(context->audio_outbuf_size);
903 #  endif
904
905   if (context->audio_deinterleave) {
906     context->audio_deinterleave_buffer = (uint8_t *)av_malloc(
907         context->audio_input_samples * c->channels * context->audio_sample_size);
908   }
909
910   context->audio_time = 0.0f;
911
912   return st;
913 }
914 /* essential functions -- start, append, end */
915
916 static void ffmpeg_dict_set_int(AVDictionary **dict, const char *key, int value)
917 {
918   char buffer[32];
919
920   BLI_snprintf(buffer, sizeof(buffer), "%d", value);
921
922   av_dict_set(dict, key, buffer, 0);
923 }
924
925 static void ffmpeg_dict_set_float(AVDictionary **dict, const char *key, float value)
926 {
927   char buffer[32];
928
929   BLI_snprintf(buffer, sizeof(buffer), "%.8f", value);
930
931   av_dict_set(dict, key, buffer, 0);
932 }
933
934 static void ffmpeg_add_metadata_callback(void *data,
935                                          const char *propname,
936                                          char *propvalue,
937                                          int len)
938 {
939   AVDictionary **metadata = (AVDictionary **)data;
940   av_dict_set(metadata, propname, propvalue, 0);
941 }
942
943 static int start_ffmpeg_impl(FFMpegContext *context,
944                              struct RenderData *rd,
945                              int rectx,
946                              int recty,
947                              const char *suffix,
948                              ReportList *reports)
949 {
950   /* Handle to the output file */
951   AVFormatContext *of;
952   AVOutputFormat *fmt;
953   AVDictionary *opts = NULL;
954   char name[FILE_MAX], error[1024];
955   const char **exts;
956
957   context->ffmpeg_type = rd->ffcodecdata.type;
958   context->ffmpeg_codec = rd->ffcodecdata.codec;
959   context->ffmpeg_audio_codec = rd->ffcodecdata.audio_codec;
960   context->ffmpeg_video_bitrate = rd->ffcodecdata.video_bitrate;
961   context->ffmpeg_audio_bitrate = rd->ffcodecdata.audio_bitrate;
962   context->ffmpeg_gop_size = rd->ffcodecdata.gop_size;
963   context->ffmpeg_autosplit = rd->ffcodecdata.flags & FFMPEG_AUTOSPLIT_OUTPUT;
964   context->ffmpeg_crf = rd->ffcodecdata.constant_rate_factor;
965   context->ffmpeg_preset = rd->ffcodecdata.ffmpeg_preset;
966
967   if ((rd->ffcodecdata.flags & FFMPEG_USE_MAX_B_FRAMES) != 0) {
968     context->ffmpeg_max_b_frames = rd->ffcodecdata.max_b_frames;
969   }
970
971   /* Determine the correct filename */
972   ffmpeg_filepath_get(context, name, rd, context->ffmpeg_preview, suffix);
973   PRINT(
974       "Starting output to %s(ffmpeg)...\n"
975       "  Using type=%d, codec=%d, audio_codec=%d,\n"
976       "  video_bitrate=%d, audio_bitrate=%d,\n"
977       "  gop_size=%d, autosplit=%d\n"
978       "  render width=%d, render height=%d\n",
979       name,
980       context->ffmpeg_type,
981       context->ffmpeg_codec,
982       context->ffmpeg_audio_codec,
983       context->ffmpeg_video_bitrate,
984       context->ffmpeg_audio_bitrate,
985       context->ffmpeg_gop_size,
986       context->ffmpeg_autosplit,
987       rectx,
988       recty);
989
990   exts = get_file_extensions(context->ffmpeg_type);
991   if (!exts) {
992     BKE_report(reports, RPT_ERROR, "No valid formats found");
993     return 0;
994   }
995   fmt = av_guess_format(NULL, exts[0], NULL);
996   if (!fmt) {
997     BKE_report(reports, RPT_ERROR, "No valid formats found");
998     return 0;
999   }
1000
1001   of = avformat_alloc_context();
1002   if (!of) {
1003     BKE_report(reports, RPT_ERROR, "Error opening output file");
1004     return 0;
1005   }
1006
1007   /* Returns after this must 'goto fail;' */
1008
1009   of->oformat = fmt;
1010
1011   /* Only bother with setting packet size & mux rate when CRF is not used. */
1012   if (context->ffmpeg_crf == 0) {
1013     of->packet_size = rd->ffcodecdata.mux_packet_size;
1014     if (context->ffmpeg_audio_codec != AV_CODEC_ID_NONE) {
1015       ffmpeg_dict_set_int(&opts, "muxrate", rd->ffcodecdata.mux_rate);
1016     }
1017     else {
1018       av_dict_set(&opts, "muxrate", "0", 0);
1019     }
1020   }
1021
1022   ffmpeg_dict_set_int(&opts, "preload", (int)(0.5 * AV_TIME_BASE));
1023
1024   of->max_delay = (int)(0.7 * AV_TIME_BASE);
1025
1026   fmt->audio_codec = context->ffmpeg_audio_codec;
1027
1028   BLI_strncpy(of->filename, name, sizeof(of->filename));
1029   /* set the codec to the user's selection */
1030   switch (context->ffmpeg_type) {
1031     case FFMPEG_AVI:
1032     case FFMPEG_MOV:
1033     case FFMPEG_MKV:
1034       fmt->video_codec = context->ffmpeg_codec;
1035       break;
1036     case FFMPEG_OGG:
1037       fmt->video_codec = AV_CODEC_ID_THEORA;
1038       break;
1039     case FFMPEG_DV:
1040       fmt->video_codec = AV_CODEC_ID_DVVIDEO;
1041       break;
1042     case FFMPEG_MPEG1:
1043       fmt->video_codec = AV_CODEC_ID_MPEG1VIDEO;
1044       break;
1045     case FFMPEG_MPEG2:
1046       fmt->video_codec = AV_CODEC_ID_MPEG2VIDEO;
1047       break;
1048     case FFMPEG_H264:
1049       fmt->video_codec = AV_CODEC_ID_H264;
1050       break;
1051     case FFMPEG_XVID:
1052       fmt->video_codec = AV_CODEC_ID_MPEG4;
1053       break;
1054     case FFMPEG_FLV:
1055       fmt->video_codec = AV_CODEC_ID_FLV1;
1056       break;
1057     case FFMPEG_MPEG4:
1058     default:
1059       fmt->video_codec = context->ffmpeg_codec;
1060       break;
1061   }
1062   if (fmt->video_codec == AV_CODEC_ID_DVVIDEO) {
1063     if (rectx != 720) {
1064       BKE_report(reports, RPT_ERROR, "Render width has to be 720 pixels for DV!");
1065       goto fail;
1066     }
1067     if (rd->frs_sec != 25 && recty != 480) {
1068       BKE_report(reports, RPT_ERROR, "Render height has to be 480 pixels for DV-NTSC!");
1069       goto fail;
1070     }
1071     if (rd->frs_sec == 25 && recty != 576) {
1072       BKE_report(reports, RPT_ERROR, "Render height has to be 576 pixels for DV-PAL!");
1073       goto fail;
1074     }
1075   }
1076
1077   if (context->ffmpeg_type == FFMPEG_DV) {
1078     fmt->audio_codec = AV_CODEC_ID_PCM_S16LE;
1079     if (context->ffmpeg_audio_codec != AV_CODEC_ID_NONE &&
1080         rd->ffcodecdata.audio_mixrate != 48000 && rd->ffcodecdata.audio_channels != 2) {
1081       BKE_report(reports, RPT_ERROR, "FFMPEG only supports 48khz / stereo audio for DV!");
1082       goto fail;
1083     }
1084   }
1085
1086   if (fmt->video_codec != AV_CODEC_ID_NONE) {
1087     context->video_stream = alloc_video_stream(
1088         context, rd, fmt->video_codec, of, rectx, recty, error, sizeof(error));
1089     PRINT("alloc video stream %p\n", context->video_stream);
1090     if (!context->video_stream) {
1091       if (error[0]) {
1092         BKE_report(reports, RPT_ERROR, error);
1093       }
1094       else {
1095         BKE_report(reports, RPT_ERROR, "Error initializing video stream");
1096       }
1097       goto fail;
1098     }
1099   }
1100
1101   if (context->ffmpeg_audio_codec != AV_CODEC_ID_NONE) {
1102     context->audio_stream = alloc_audio_stream(
1103         context, rd, fmt->audio_codec, of, error, sizeof(error));
1104     if (!context->audio_stream) {
1105       if (error[0]) {
1106         BKE_report(reports, RPT_ERROR, error);
1107       }
1108       else {
1109         BKE_report(reports, RPT_ERROR, "Error initializing audio stream");
1110       }
1111       goto fail;
1112     }
1113   }
1114   if (!(fmt->flags & AVFMT_NOFILE)) {
1115     if (avio_open(&of->pb, name, AVIO_FLAG_WRITE) < 0) {
1116       BKE_report(reports, RPT_ERROR, "Could not open file for writing");
1117       goto fail;
1118     }
1119   }
1120
1121   if (context->stamp_data != NULL) {
1122     BKE_stamp_info_callback(
1123         &of->metadata, context->stamp_data, ffmpeg_add_metadata_callback, false);
1124   }
1125
1126   if (avformat_write_header(of, NULL) < 0) {
1127     BKE_report(reports,
1128                RPT_ERROR,
1129                "Could not initialize streams, probably unsupported codec combination");
1130     goto fail;
1131   }
1132
1133   context->outfile = of;
1134   av_dump_format(of, 0, name, 1);
1135   av_dict_free(&opts);
1136
1137   return 1;
1138
1139 fail:
1140   if (of->pb) {
1141     avio_close(of->pb);
1142   }
1143
1144   if (context->video_stream && context->video_stream->codec) {
1145     avcodec_close(context->video_stream->codec);
1146     context->video_stream = NULL;
1147   }
1148
1149   if (context->audio_stream && context->audio_stream->codec) {
1150     avcodec_close(context->audio_stream->codec);
1151     context->audio_stream = NULL;
1152   }
1153
1154   av_dict_free(&opts);
1155   avformat_free_context(of);
1156   return 0;
1157 }
1158
1159 /**
1160  * Writes any delayed frames in the encoder. This function is called before
1161  * closing the encoder.
1162  *
1163  * <p>
1164  * Since an encoder may use both past and future frames to predict
1165  * inter-frames (H.264 B-frames, for example), it can output the frames
1166  * in a different order from the one it was given.
1167  * For example, when sending frames 1, 2, 3, 4 to the encoder, it may write
1168  * them in the order 1, 4, 2, 3 - first the two frames used for prediction,
1169  * and then the bidirectionally-predicted frames. What this means in practice
1170  * is that the encoder may not immediately produce one output frame for each
1171  * input frame. These delayed frames must be flushed before we close the
1172  * stream. We do this by calling avcodec_encode_video with NULL for the last
1173  * parameter.
1174  * </p>
1175  */
1176 static void flush_ffmpeg(FFMpegContext *context)
1177 {
1178   int ret = 0;
1179
1180   AVCodecContext *c = context->video_stream->codec;
1181   /* get the delayed frames */
1182   while (1) {
1183     int got_output;
1184     AVPacket packet = {0};
1185     av_init_packet(&packet);
1186
1187     ret = avcodec_encode_video2(c, &packet, NULL, &got_output);
1188     if (ret < 0) {
1189       fprintf(stderr, "Error encoding delayed frame %d\n", ret);
1190       break;
1191     }
1192     if (!got_output) {
1193       break;
1194     }
1195     if (packet.pts != AV_NOPTS_VALUE) {
1196       packet.pts = av_rescale_q(packet.pts, c->time_base, context->video_stream->time_base);
1197       PRINT("Video Frame PTS: %d\n", (int)packet.pts);
1198     }
1199     else {
1200       PRINT("Video Frame PTS: not set\n");
1201     }
1202     if (packet.dts != AV_NOPTS_VALUE) {
1203       packet.dts = av_rescale_q(packet.dts, c->time_base, context->video_stream->time_base);
1204       PRINT("Video Frame DTS: %d\n", (int)packet.dts);
1205     }
1206     else {
1207       PRINT("Video Frame DTS: not set\n");
1208     }
1209
1210     packet.stream_index = context->video_stream->index;
1211     ret = av_interleaved_write_frame(context->outfile, &packet);
1212     if (ret != 0) {
1213       fprintf(stderr, "Error writing delayed frame %d\n", ret);
1214       break;
1215     }
1216   }
1217   avcodec_flush_buffers(context->video_stream->codec);
1218 }
1219
1220 /* **********************************************************************
1221  * * public interface
1222  * ********************************************************************** */
1223
1224 /* Get the output filename-- similar to the other output formats */
1225 static void ffmpeg_filepath_get(
1226     FFMpegContext *context, char *string, const RenderData *rd, bool preview, const char *suffix)
1227 {
1228   char autosplit[20];
1229
1230   const char **exts = get_file_extensions(rd->ffcodecdata.type);
1231   const char **fe = exts;
1232   int sfra, efra;
1233
1234   if (!string || !exts) {
1235     return;
1236   }
1237
1238   if (preview) {
1239     sfra = rd->psfra;
1240     efra = rd->pefra;
1241   }
1242   else {
1243     sfra = rd->sfra;
1244     efra = rd->efra;
1245   }
1246
1247   strcpy(string, rd->pic);
1248   BLI_path_abs(string, BKE_main_blendfile_path_from_global());
1249
1250   BLI_make_existing_file(string);
1251
1252   autosplit[0] = '\0';
1253
1254   if ((rd->ffcodecdata.flags & FFMPEG_AUTOSPLIT_OUTPUT) != 0) {
1255     if (context) {
1256       sprintf(autosplit, "_%03d", context->ffmpeg_autosplit_count);
1257     }
1258   }
1259
1260   if (rd->scemode & R_EXTENSION) {
1261     while (*fe) {
1262       if (BLI_strcasecmp(string + strlen(string) - strlen(*fe), *fe) == 0) {
1263         break;
1264       }
1265       fe++;
1266     }
1267
1268     if (*fe == NULL) {
1269       strcat(string, autosplit);
1270
1271       BLI_path_frame_range(string, sfra, efra, 4);
1272       strcat(string, *exts);
1273     }
1274     else {
1275       *(string + strlen(string) - strlen(*fe)) = '\0';
1276       strcat(string, autosplit);
1277       strcat(string, *fe);
1278     }
1279   }
1280   else {
1281     if (BLI_path_frame_check_chars(string)) {
1282       BLI_path_frame_range(string, sfra, efra, 4);
1283     }
1284
1285     strcat(string, autosplit);
1286   }
1287
1288   BLI_path_suffix(string, FILE_MAX, suffix, "");
1289 }
1290
1291 void BKE_ffmpeg_filepath_get(char *string, const RenderData *rd, bool preview, const char *suffix)
1292 {
1293   ffmpeg_filepath_get(NULL, string, rd, preview, suffix);
1294 }
1295
1296 int BKE_ffmpeg_start(void *context_v,
1297                      const struct Scene *scene,
1298                      RenderData *rd,
1299                      int rectx,
1300                      int recty,
1301                      ReportList *reports,
1302                      bool preview,
1303                      const char *suffix)
1304 {
1305   int success;
1306   FFMpegContext *context = context_v;
1307
1308   context->ffmpeg_autosplit_count = 0;
1309   context->ffmpeg_preview = preview;
1310   context->stamp_data = BKE_stamp_info_from_scene_static(scene);
1311
1312   success = start_ffmpeg_impl(context, rd, rectx, recty, suffix, reports);
1313 #  ifdef WITH_AUDASPACE
1314   if (context->audio_stream) {
1315     AVCodecContext *c = context->audio_stream->codec;
1316     AUD_DeviceSpecs specs;
1317     specs.channels = c->channels;
1318
1319     switch (av_get_packed_sample_fmt(c->sample_fmt)) {
1320       case AV_SAMPLE_FMT_U8:
1321         specs.format = AUD_FORMAT_U8;
1322         break;
1323       case AV_SAMPLE_FMT_S16:
1324         specs.format = AUD_FORMAT_S16;
1325         break;
1326       case AV_SAMPLE_FMT_S32:
1327         specs.format = AUD_FORMAT_S32;
1328         break;
1329       case AV_SAMPLE_FMT_FLT:
1330         specs.format = AUD_FORMAT_FLOAT32;
1331         break;
1332       case AV_SAMPLE_FMT_DBL:
1333         specs.format = AUD_FORMAT_FLOAT64;
1334         break;
1335       default:
1336         return -31415;
1337     }
1338
1339     specs.rate = rd->ffcodecdata.audio_mixrate;
1340     context->audio_mixdown_device = BKE_sound_mixdown(
1341         scene, specs, preview ? rd->psfra : rd->sfra, rd->ffcodecdata.audio_volume);
1342 #    ifdef FFMPEG_CODEC_TIME_BASE
1343     c->time_base.den = specs.rate;
1344     c->time_base.num = 1;
1345 #    endif
1346   }
1347 #  endif
1348   return success;
1349 }
1350
1351 static void end_ffmpeg_impl(FFMpegContext *context, int is_autosplit);
1352
1353 #  ifdef WITH_AUDASPACE
1354 static void write_audio_frames(FFMpegContext *context, double to_pts)
1355 {
1356   int finished = 0;
1357
1358   while (context->audio_stream && !finished) {
1359     if ((context->audio_time >= to_pts) || (write_audio_frame(context))) {
1360       finished = 1;
1361     }
1362   }
1363 }
1364 #  endif
1365
1366 int BKE_ffmpeg_append(void *context_v,
1367                       RenderData *rd,
1368                       int start_frame,
1369                       int frame,
1370                       int *pixels,
1371                       int rectx,
1372                       int recty,
1373                       const char *suffix,
1374                       ReportList *reports)
1375 {
1376   FFMpegContext *context = context_v;
1377   AVFrame *avframe;
1378   int success = 1;
1379
1380   PRINT("Writing frame %i, render width=%d, render height=%d\n", frame, rectx, recty);
1381
1382   /* why is this done before writing the video frame and again at end_ffmpeg? */
1383   //  write_audio_frames(frame / (((double)rd->frs_sec) / rd->frs_sec_base));
1384
1385   if (context->video_stream) {
1386     avframe = generate_video_frame(context, (unsigned char *)pixels, reports);
1387     success = (avframe && write_video_frame(context, rd, frame - start_frame, avframe, reports));
1388
1389     if (context->ffmpeg_autosplit) {
1390       if (avio_tell(context->outfile->pb) > FFMPEG_AUTOSPLIT_SIZE) {
1391         end_ffmpeg_impl(context, true);
1392         context->ffmpeg_autosplit_count++;
1393         success &= start_ffmpeg_impl(context, rd, rectx, recty, suffix, reports);
1394       }
1395     }
1396   }
1397
1398 #  ifdef WITH_AUDASPACE
1399   write_audio_frames(context,
1400                      (frame - start_frame) / (((double)rd->frs_sec) / (double)rd->frs_sec_base));
1401 #  endif
1402   return success;
1403 }
1404
1405 static void end_ffmpeg_impl(FFMpegContext *context, int is_autosplit)
1406 {
1407   PRINT("Closing ffmpeg...\n");
1408
1409 #  ifdef WITH_AUDASPACE
1410   if (is_autosplit == false) {
1411     if (context->audio_mixdown_device) {
1412       AUD_Device_free(context->audio_mixdown_device);
1413       context->audio_mixdown_device = NULL;
1414     }
1415   }
1416 #  endif
1417
1418   if (context->video_stream && context->video_stream->codec) {
1419     PRINT("Flushing delayed frames...\n");
1420     flush_ffmpeg(context);
1421   }
1422
1423   if (context->outfile) {
1424     av_write_trailer(context->outfile);
1425   }
1426
1427   /* Close the video codec */
1428
1429   if (context->video_stream != NULL && context->video_stream->codec != NULL) {
1430     avcodec_close(context->video_stream->codec);
1431     PRINT("zero video stream %p\n", context->video_stream);
1432     context->video_stream = NULL;
1433   }
1434
1435   if (context->audio_stream != NULL && context->audio_stream->codec != NULL) {
1436     avcodec_close(context->audio_stream->codec);
1437     context->audio_stream = NULL;
1438   }
1439
1440   /* free the temp buffer */
1441   if (context->current_frame != NULL) {
1442     delete_picture(context->current_frame);
1443     context->current_frame = NULL;
1444   }
1445   if (context->img_convert_frame != NULL) {
1446     delete_picture(context->img_convert_frame);
1447     context->img_convert_frame = NULL;
1448   }
1449
1450   if (context->outfile != NULL && context->outfile->oformat) {
1451     if (!(context->outfile->oformat->flags & AVFMT_NOFILE)) {
1452       avio_close(context->outfile->pb);
1453     }
1454   }
1455   if (context->outfile != NULL) {
1456     avformat_free_context(context->outfile);
1457     context->outfile = NULL;
1458   }
1459   if (context->audio_input_buffer != NULL) {
1460     av_free(context->audio_input_buffer);
1461     context->audio_input_buffer = NULL;
1462   }
1463 #  ifndef FFMPEG_HAVE_ENCODE_AUDIO2
1464   if (context->audio_output_buffer != NULL) {
1465     av_free(context->audio_output_buffer);
1466     context->audio_output_buffer = NULL;
1467   }
1468 #  endif
1469
1470   if (context->audio_deinterleave_buffer != NULL) {
1471     av_free(context->audio_deinterleave_buffer);
1472     context->audio_deinterleave_buffer = NULL;
1473   }
1474
1475   if (context->img_convert_ctx != NULL) {
1476     sws_freeContext(context->img_convert_ctx);
1477     context->img_convert_ctx = NULL;
1478   }
1479 }
1480
1481 void BKE_ffmpeg_end(void *context_v)
1482 {
1483   FFMpegContext *context = context_v;
1484   end_ffmpeg_impl(context, false);
1485 }
1486
1487 /* properties */
1488
1489 void BKE_ffmpeg_property_del(RenderData *rd, void *type, void *prop_)
1490 {
1491   struct IDProperty *prop = (struct IDProperty *)prop_;
1492   IDProperty *group;
1493
1494   if (!rd->ffcodecdata.properties) {
1495     return;
1496   }
1497
1498   group = IDP_GetPropertyFromGroup(rd->ffcodecdata.properties, type);
1499   if (group && prop) {
1500     IDP_FreeFromGroup(group, prop);
1501   }
1502 }
1503
1504 static IDProperty *BKE_ffmpeg_property_add(RenderData *rd,
1505                                            const char *type,
1506                                            const AVOption *o,
1507                                            const AVOption *parent)
1508 {
1509   AVCodecContext c;
1510   IDProperty *group;
1511   IDProperty *prop;
1512   IDPropertyTemplate val;
1513   int idp_type;
1514   char name[256];
1515
1516   val.i = 0;
1517
1518   avcodec_get_context_defaults3(&c, NULL);
1519
1520   if (!rd->ffcodecdata.properties) {
1521     rd->ffcodecdata.properties = IDP_New(IDP_GROUP, &val, "ffmpeg");
1522   }
1523
1524   group = IDP_GetPropertyFromGroup(rd->ffcodecdata.properties, type);
1525
1526   if (!group) {
1527     group = IDP_New(IDP_GROUP, &val, type);
1528     IDP_AddToGroup(rd->ffcodecdata.properties, group);
1529   }
1530
1531   if (parent) {
1532     BLI_snprintf(name, sizeof(name), "%s:%s", parent->name, o->name);
1533   }
1534   else {
1535     BLI_strncpy(name, o->name, sizeof(name));
1536   }
1537
1538   PRINT("ffmpeg_property_add: %s %s\n", type, name);
1539
1540   prop = IDP_GetPropertyFromGroup(group, name);
1541   if (prop) {
1542     return prop;
1543   }
1544
1545   switch (o->type) {
1546     case AV_OPT_TYPE_INT:
1547     case AV_OPT_TYPE_INT64:
1548       val.i = FFMPEG_DEF_OPT_VAL_INT(o);
1549       idp_type = IDP_INT;
1550       break;
1551     case AV_OPT_TYPE_DOUBLE:
1552     case AV_OPT_TYPE_FLOAT:
1553       val.f = FFMPEG_DEF_OPT_VAL_DOUBLE(o);
1554       idp_type = IDP_FLOAT;
1555       break;
1556     case AV_OPT_TYPE_STRING:
1557       val.string.str =
1558           (char
1559                *)"                                                                               ";
1560       val.string.len = 80;
1561       idp_type = IDP_STRING;
1562       break;
1563     case AV_OPT_TYPE_CONST:
1564       val.i = 1;
1565       idp_type = IDP_INT;
1566       break;
1567     default:
1568       return NULL;
1569   }
1570   prop = IDP_New(idp_type, &val, name);
1571   IDP_AddToGroup(group, prop);
1572   return prop;
1573 }
1574
1575 /* not all versions of ffmpeg include that, so here we go ... */
1576
1577 int BKE_ffmpeg_property_add_string(RenderData *rd, const char *type, const char *str)
1578 {
1579   AVCodecContext c;
1580   const AVOption *o = NULL;
1581   const AVOption *p = NULL;
1582   char name_[128];
1583   char *name;
1584   char *param;
1585   IDProperty *prop = NULL;
1586
1587   avcodec_get_context_defaults3(&c, NULL);
1588
1589   BLI_strncpy(name_, str, sizeof(name_));
1590
1591   name = name_;
1592   while (*name == ' ') {
1593     name++;
1594   }
1595
1596   param = strchr(name, ':');
1597
1598   if (!param) {
1599     param = strchr(name, ' ');
1600   }
1601   if (param) {
1602     *param++ = '\0';
1603     while (*param == ' ') {
1604       param++;
1605     }
1606   }
1607
1608   o = av_opt_find(&c, name, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1609   if (!o) {
1610     PRINT("Ignoring unknown expert option %s\n", str);
1611     return 0;
1612   }
1613   if (param && o->type == AV_OPT_TYPE_CONST) {
1614     return 0;
1615   }
1616   if (param && o->type != AV_OPT_TYPE_CONST && o->unit) {
1617     p = av_opt_find(&c, param, o->unit, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1618     if (p) {
1619       prop = BKE_ffmpeg_property_add(rd, (char *)type, p, o);
1620     }
1621     else {
1622       PRINT("Ignoring unknown expert option %s\n", str);
1623     }
1624   }
1625   else {
1626     prop = BKE_ffmpeg_property_add(rd, (char *)type, o, NULL);
1627   }
1628
1629   if (!prop) {
1630     return 0;
1631   }
1632
1633   if (param && !p) {
1634     switch (prop->type) {
1635       case IDP_INT:
1636         IDP_Int(prop) = atoi(param);
1637         break;
1638       case IDP_FLOAT:
1639         IDP_Float(prop) = atof(param);
1640         break;
1641       case IDP_STRING:
1642         strncpy(IDP_String(prop), param, prop->len);
1643         break;
1644     }
1645   }
1646   return 1;
1647 }
1648
1649 static void ffmpeg_set_expert_options(RenderData *rd)
1650 {
1651   int codec_id = rd->ffcodecdata.codec;
1652
1653   if (rd->ffcodecdata.properties) {
1654     IDP_FreePropertyContent(rd->ffcodecdata.properties);
1655   }
1656
1657   if (codec_id == AV_CODEC_ID_H264) {
1658     /*
1659      * All options here are for x264, but must be set via ffmpeg.
1660      * The names are therefore different - Search for "x264 to FFmpeg option mapping"
1661      * to get a list.
1662      */
1663
1664     /*
1665      * Use CABAC coder. Using "coder:1", which should be equivalent,
1666      * crashes Blender for some reason. Either way - this is no big deal.
1667      */
1668     BKE_ffmpeg_property_add_string(rd, "video", "coder:vlc");
1669
1670     /*
1671      * The other options were taken from the libx264-default.preset
1672      * included in the ffmpeg distribution.
1673      */
1674
1675     /* This breaks compatibility for QT. */
1676     // BKE_ffmpeg_property_add_string(rd, "video", "flags:loop");
1677     BKE_ffmpeg_property_add_string(rd, "video", "cmp:chroma");
1678     BKE_ffmpeg_property_add_string(rd, "video", "partitions:parti4x4");  // Deprecated.
1679     BKE_ffmpeg_property_add_string(rd, "video", "partitions:partp8x8");  // Deprecated.
1680     BKE_ffmpeg_property_add_string(rd, "video", "partitions:partb8x8");  // Deprecated.
1681     BKE_ffmpeg_property_add_string(rd, "video", "me:hex");
1682     BKE_ffmpeg_property_add_string(rd, "video", "subq:6");
1683     BKE_ffmpeg_property_add_string(rd, "video", "me_range:16");
1684     BKE_ffmpeg_property_add_string(rd, "video", "qdiff:4");
1685     BKE_ffmpeg_property_add_string(rd, "video", "keyint_min:25");
1686     BKE_ffmpeg_property_add_string(rd, "video", "sc_threshold:40");
1687     BKE_ffmpeg_property_add_string(rd, "video", "i_qfactor:0.71");
1688     BKE_ffmpeg_property_add_string(rd, "video", "b_strategy:1");
1689     BKE_ffmpeg_property_add_string(rd, "video", "bf:3");
1690     BKE_ffmpeg_property_add_string(rd, "video", "refs:2");
1691     BKE_ffmpeg_property_add_string(rd, "video", "qcomp:0.6");
1692
1693     BKE_ffmpeg_property_add_string(rd, "video", "trellis:0");
1694     BKE_ffmpeg_property_add_string(rd, "video", "weightb:1");
1695 #  ifdef FFMPEG_HAVE_DEPRECATED_FLAGS2
1696     BKE_ffmpeg_property_add_string(rd, "video", "flags2:dct8x8");
1697     BKE_ffmpeg_property_add_string(rd, "video", "directpred:3");
1698     BKE_ffmpeg_property_add_string(rd, "video", "flags2:fastpskip");
1699     BKE_ffmpeg_property_add_string(rd, "video", "flags2:wpred");
1700 #  else
1701     BKE_ffmpeg_property_add_string(rd, "video", "8x8dct:1");
1702     BKE_ffmpeg_property_add_string(rd, "video", "fast-pskip:1");
1703     BKE_ffmpeg_property_add_string(rd, "video", "wpredp:2");
1704 #  endif
1705   }
1706   else if (codec_id == AV_CODEC_ID_DNXHD) {
1707     if (rd->ffcodecdata.flags & FFMPEG_LOSSLESS_OUTPUT) {
1708       BKE_ffmpeg_property_add_string(rd, "video", "mbd:rd");
1709     }
1710   }
1711 }
1712
1713 void BKE_ffmpeg_preset_set(RenderData *rd, int preset)
1714 {
1715   int isntsc = (rd->frs_sec != 25);
1716
1717   if (rd->ffcodecdata.properties) {
1718     IDP_FreePropertyContent(rd->ffcodecdata.properties);
1719   }
1720
1721   switch (preset) {
1722     case FFMPEG_PRESET_VCD:
1723       rd->ffcodecdata.type = FFMPEG_MPEG1;
1724       rd->ffcodecdata.video_bitrate = 1150;
1725       rd->xsch = 352;
1726       rd->ysch = isntsc ? 240 : 288;
1727       rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
1728       rd->ffcodecdata.rc_max_rate = 1150;
1729       rd->ffcodecdata.rc_min_rate = 1150;
1730       rd->ffcodecdata.rc_buffer_size = 40 * 8;
1731       rd->ffcodecdata.mux_packet_size = 2324;
1732       rd->ffcodecdata.mux_rate = 2352 * 75 * 8;
1733       break;
1734
1735     case FFMPEG_PRESET_SVCD:
1736       rd->ffcodecdata.type = FFMPEG_MPEG2;
1737       rd->ffcodecdata.video_bitrate = 2040;
1738       rd->xsch = 480;
1739       rd->ysch = isntsc ? 480 : 576;
1740       rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
1741       rd->ffcodecdata.rc_max_rate = 2516;
1742       rd->ffcodecdata.rc_min_rate = 0;
1743       rd->ffcodecdata.rc_buffer_size = 224 * 8;
1744       rd->ffcodecdata.mux_packet_size = 2324;
1745       rd->ffcodecdata.mux_rate = 0;
1746       break;
1747
1748     case FFMPEG_PRESET_DVD:
1749       rd->ffcodecdata.type = FFMPEG_MPEG2;
1750       rd->ffcodecdata.video_bitrate = 6000;
1751
1752       /* Don't set resolution, see [#21351]
1753        * rd->xsch = 720;
1754        * rd->ysch = isntsc ? 480 : 576; */
1755
1756       rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
1757       rd->ffcodecdata.rc_max_rate = 9000;
1758       rd->ffcodecdata.rc_min_rate = 0;
1759       rd->ffcodecdata.rc_buffer_size = 224 * 8;
1760       rd->ffcodecdata.mux_packet_size = 2048;
1761       rd->ffcodecdata.mux_rate = 10080000;
1762       break;
1763
1764     case FFMPEG_PRESET_DV:
1765       rd->ffcodecdata.type = FFMPEG_DV;
1766       rd->xsch = 720;
1767       rd->ysch = isntsc ? 480 : 576;
1768       break;
1769
1770     case FFMPEG_PRESET_H264:
1771       rd->ffcodecdata.type = FFMPEG_AVI;
1772       rd->ffcodecdata.codec = AV_CODEC_ID_H264;
1773       rd->ffcodecdata.video_bitrate = 6000;
1774       rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
1775       rd->ffcodecdata.rc_max_rate = 9000;
1776       rd->ffcodecdata.rc_min_rate = 0;
1777       rd->ffcodecdata.rc_buffer_size = 224 * 8;
1778       rd->ffcodecdata.mux_packet_size = 2048;
1779       rd->ffcodecdata.mux_rate = 10080000;
1780
1781       break;
1782
1783     case FFMPEG_PRESET_THEORA:
1784     case FFMPEG_PRESET_XVID:
1785       if (preset == FFMPEG_PRESET_XVID) {
1786         rd->ffcodecdata.type = FFMPEG_AVI;
1787         rd->ffcodecdata.codec = AV_CODEC_ID_MPEG4;
1788       }
1789       else if (preset == FFMPEG_PRESET_THEORA) {
1790         rd->ffcodecdata.type = FFMPEG_OGG;  // XXX broken
1791         rd->ffcodecdata.codec = AV_CODEC_ID_THEORA;
1792       }
1793
1794       rd->ffcodecdata.video_bitrate = 6000;
1795       rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
1796       rd->ffcodecdata.rc_max_rate = 9000;
1797       rd->ffcodecdata.rc_min_rate = 0;
1798       rd->ffcodecdata.rc_buffer_size = 224 * 8;
1799       rd->ffcodecdata.mux_packet_size = 2048;
1800       rd->ffcodecdata.mux_rate = 10080000;
1801       break;
1802   }
1803
1804   ffmpeg_set_expert_options(rd);
1805 }
1806
1807 void BKE_ffmpeg_image_type_verify(RenderData *rd, ImageFormatData *imf)
1808 {
1809   int audio = 0;
1810
1811   if (imf->imtype == R_IMF_IMTYPE_FFMPEG) {
1812     if (rd->ffcodecdata.type <= 0 || rd->ffcodecdata.codec <= 0 ||
1813         rd->ffcodecdata.audio_codec <= 0 || rd->ffcodecdata.video_bitrate <= 1) {
1814       BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_H264);
1815       rd->ffcodecdata.constant_rate_factor = FFM_CRF_MEDIUM;
1816       rd->ffcodecdata.ffmpeg_preset = FFM_PRESET_GOOD;
1817       rd->ffcodecdata.type = FFMPEG_MKV;
1818     }
1819     if (rd->ffcodecdata.type == FFMPEG_OGG) {
1820       rd->ffcodecdata.type = FFMPEG_MPEG2;
1821     }
1822
1823     audio = 1;
1824   }
1825   else if (imf->imtype == R_IMF_IMTYPE_H264) {
1826     if (rd->ffcodecdata.codec != AV_CODEC_ID_H264) {
1827       BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_H264);
1828       audio = 1;
1829     }
1830   }
1831   else if (imf->imtype == R_IMF_IMTYPE_XVID) {
1832     if (rd->ffcodecdata.codec != AV_CODEC_ID_MPEG4) {
1833       BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_XVID);
1834       audio = 1;
1835     }
1836   }
1837   else if (imf->imtype == R_IMF_IMTYPE_THEORA) {
1838     if (rd->ffcodecdata.codec != AV_CODEC_ID_THEORA) {
1839       BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_THEORA);
1840       audio = 1;
1841     }
1842   }
1843
1844   if (audio && rd->ffcodecdata.audio_codec < 0) {
1845     rd->ffcodecdata.audio_codec = AV_CODEC_ID_NONE;
1846     rd->ffcodecdata.audio_bitrate = 128;
1847   }
1848 }
1849
1850 void BKE_ffmpeg_codec_settings_verify(RenderData *rd)
1851 {
1852   ffmpeg_set_expert_options(rd);
1853 }
1854
1855 bool BKE_ffmpeg_alpha_channel_is_supported(const RenderData *rd)
1856 {
1857   int codec = rd->ffcodecdata.codec;
1858
1859 #  ifdef FFMPEG_FFV1_ALPHA_SUPPORTED
1860   /* Visual Studio 2019 doesn't like #ifdef within ELEM(). */
1861   if (codec == AV_CODEC_ID_FFV1) {
1862     return true;
1863   }
1864 #  endif
1865
1866   return ELEM(codec, AV_CODEC_ID_QTRLE, AV_CODEC_ID_PNG, AV_CODEC_ID_VP9, AV_CODEC_ID_HUFFYUV);
1867 }
1868
1869 void *BKE_ffmpeg_context_create(void)
1870 {
1871   FFMpegContext *context;
1872
1873   /* new ffmpeg data struct */
1874   context = MEM_callocN(sizeof(FFMpegContext), "new ffmpeg context");
1875
1876   context->ffmpeg_codec = AV_CODEC_ID_MPEG4;
1877   context->ffmpeg_audio_codec = AV_CODEC_ID_NONE;
1878   context->ffmpeg_video_bitrate = 1150;
1879   context->ffmpeg_audio_bitrate = 128;
1880   context->ffmpeg_gop_size = 12;
1881   context->ffmpeg_autosplit = 0;
1882   context->ffmpeg_autosplit_count = 0;
1883   context->ffmpeg_preview = false;
1884   context->stamp_data = NULL;
1885
1886   return context;
1887 }
1888
1889 void BKE_ffmpeg_context_free(void *context_v)
1890 {
1891   FFMpegContext *context = context_v;
1892   if (context == NULL) {
1893     return;
1894   }
1895   if (context->stamp_data) {
1896     MEM_freeN(context->stamp_data);
1897   }
1898   MEM_freeN(context);
1899 }
1900
1901 #endif /* WITH_FFMPEG */