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