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