Hi,
the attached patch should fix this bug.

-- 
Anton Khirnov
Index: vice-2.4.dfsg/src/gfxoutputdrv/ffmpegdrv.c
===================================================================
--- vice-2.4.dfsg.orig/src/gfxoutputdrv/ffmpegdrv.c	2012-02-13 19:31:44.000000000 +0000
+++ vice-2.4.dfsg/src/gfxoutputdrv/ffmpegdrv.c	2014-02-26 13:05:03.353849329 +0000
@@ -46,29 +46,29 @@
 #include "../sounddrv/soundmovie.h"
 
 static gfxoutputdrv_codec_t avi_audio_codeclist[] = { 
-    { CODEC_ID_MP2, "MP2" },
-    { CODEC_ID_MP3, "MP3" },
-    { CODEC_ID_FLAC, "FLAC" },
-    { CODEC_ID_PCM_S16LE, "PCM uncompressed" },
+    { AV_CODEC_ID_MP2, "MP2" },
+    { AV_CODEC_ID_MP3, "MP3" },
+    { AV_CODEC_ID_FLAC, "FLAC" },
+    { AV_CODEC_ID_PCM_S16LE, "PCM uncompressed" },
     { 0, NULL }
 };
 
 static gfxoutputdrv_codec_t avi_video_codeclist[] = { 
-    { CODEC_ID_MPEG4, "MPEG4 (DivX)" },
-    { CODEC_ID_MPEG1VIDEO, "MPEG1" },
-    { CODEC_ID_FFV1, "FFV1 (lossless)" },
-    { CODEC_ID_H264, "H264" },
-    { CODEC_ID_THEORA, "Theora" },
+    { AV_CODEC_ID_MPEG4, "MPEG4 (DivX)" },
+    { AV_CODEC_ID_MPEG1VIDEO, "MPEG1" },
+    { AV_CODEC_ID_FFV1, "FFV1 (lossless)" },
+    { AV_CODEC_ID_H264, "H264" },
+    { AV_CODEC_ID_THEORA, "Theora" },
     { 0, NULL }
 };
 
 static gfxoutputdrv_codec_t ogg_audio_codeclist[] = { 
-    { CODEC_ID_FLAC, "FLAC" },
+    { AV_CODEC_ID_FLAC, "FLAC" },
     { 0, NULL }
 };
 
 static gfxoutputdrv_codec_t ogg_video_codeclist[] = { 
-    { CODEC_ID_THEORA, "Theora" },
+    { AV_CODEC_ID_THEORA, "Theora" },
     { 0, NULL }
 };
 
@@ -201,9 +201,9 @@
     { "FFMPEGVideoBitrate", VICE_FFMPEG_VIDEO_RATE_DEFAULT,
       RES_EVENT_NO, NULL,
       &video_bitrate, set_video_bitrate, NULL },
-    { "FFMPEGAudioCodec", CODEC_ID_MP3, RES_EVENT_NO, NULL,
+    { "FFMPEGAudioCodec", AV_CODEC_ID_MP3, RES_EVENT_NO, NULL,
       &audio_codec, set_audio_codec, NULL },
-    { "FFMPEGVideoCodec", CODEC_ID_MPEG4, RES_EVENT_NO, NULL,
+    { "FFMPEGVideoCodec", AV_CODEC_ID_MPEG4, RES_EVENT_NO, NULL,
       &video_codec, set_video_codec, NULL },
     { "FFMPEGVideoHalveFramerate", 0, RES_EVENT_NO, NULL,
       &video_halve_framerate, set_video_halve_framerate, NULL },
@@ -264,7 +264,7 @@
     }
 
     /* open it */
-    if ((*ffmpeglib.p_avcodec_open)(c, codec) < 0) {
+    if ((*ffmpeglib.p_avcodec_open2)(c, codec, NULL) < 0) {
         log_debug("ffmpegdrv: could not open audio codec");
         return -1;
     }
@@ -278,10 +278,10 @@
     if (c->frame_size <= 1) {
         audio_inbuf_samples = audio_outbuf_size;
         switch(st->codec->codec_id) {
-        case CODEC_ID_PCM_S16LE:
-        case CODEC_ID_PCM_S16BE:
-        case CODEC_ID_PCM_U16LE:
-        case CODEC_ID_PCM_U16BE:
+        case AV_CODEC_ID_PCM_S16LE:
+        case AV_CODEC_ID_PCM_S16BE:
+        case AV_CODEC_ID_PCM_U16LE:
+        case AV_CODEC_ID_PCM_U16BE:
             audio_inbuf_samples >>= 1;
             break;
         default:
@@ -326,7 +326,7 @@
 
     audio_init_done = 1;
 
-    if (ffmpegdrv_fmt->audio_codec == CODEC_ID_NONE)
+    if (ffmpegdrv_fmt->audio_codec == AV_CODEC_ID_NONE)
         return -1;
 
     *audio_in = &ffmpegdrv_audio_in;
@@ -334,7 +334,7 @@
     (*audio_in)->size = 0; /* not allocated yet */
     (*audio_in)->used = 0;
 
-    st = (*ffmpeglib.p_av_new_stream)(ffmpegdrv_oc, 1);
+    st = (*ffmpeglib.p_avformat_new_stream)(ffmpegdrv_oc, NULL);
     if (!st) {
         log_debug("ffmpegdrv: Could not alloc audio stream\n");
         return -1;
@@ -343,7 +343,7 @@
     c = st->codec;
     c->codec_id = ffmpegdrv_fmt->audio_codec;
     c->codec_type = AVMEDIA_TYPE_AUDIO;
-    c->sample_fmt = SAMPLE_FMT_S16;
+    c->sample_fmt = AV_SAMPLE_FMT_S16;
 
     /* put sample parameters */
     c->bit_rate = audio_bitrate;
@@ -471,7 +471,7 @@
     }
 
     /* open the codec */
-    if ((*ffmpeglib.p_avcodec_open)(c, codec) < 0) {
+    if ((*ffmpeglib.p_avcodec_open2)(c, codec, NULL) < 0) {
         log_debug("ffmpegdrv: could not open video codec");
         return -1;
     }
@@ -548,10 +548,10 @@
 
      video_init_done = 1;
 
-     if (ffmpegdrv_fmt->video_codec == CODEC_ID_NONE)
+     if (ffmpegdrv_fmt->video_codec == AV_CODEC_ID_NONE)
         return;
 
-    st = (*ffmpeglib.p_av_new_stream)(ffmpegdrv_oc, 0);
+    st = (*ffmpeglib.p_avformat_new_stream)(ffmpegdrv_oc, NULL);
     if (!st) {
         log_debug("ffmpegdrv: Could not alloc video stream\n");
         return;
@@ -576,12 +576,12 @@
     c->pix_fmt = PIX_FMT_YUV420P;
 
     /* Avoid format conversion which would lead to loss of quality */
-    if (c->codec_id == CODEC_ID_FFV1) {
+    if (c->codec_id == AV_CODEC_ID_FFV1) {
         c->pix_fmt = PIX_FMT_RGB32;
     }
 
     /* Use XVID instead of FMP4 FOURCC for better compatibility */
-    if (c->codec_id == CODEC_ID_MPEG4) {
+    if (c->codec_id == AV_CODEC_ID_MPEG4) {
         c->codec_tag = MKTAG('X','V','I','D');
     }
 
@@ -613,12 +613,7 @@
     if (!video_init_done || !audio_init_done)
         return 0;
 
-    if ((*ffmpeglib.p_av_set_parameters)(ffmpegdrv_oc, NULL) < 0) {
-        log_debug("ffmpegdrv: Invalid output format parameters");
-            return -1;
-    }
-
-    (*ffmpeglib.p_dump_format)(ffmpegdrv_oc, 0, ffmpegdrv_oc->filename, 1);
+    (*ffmpeglib.p_av_dump_format)(ffmpegdrv_oc, 0, ffmpegdrv_oc->filename, 1);
 
     if (video_st && (ffmpegdrv_open_video(ffmpegdrv_oc, video_st) < 0)) {
         ui_error(translate_text(IDGS_FFMPEG_CANNOT_OPEN_VSTREAM));
@@ -632,8 +627,8 @@
     }
 
     if (!(ffmpegdrv_fmt->flags & AVFMT_NOFILE)) {
-        if ((*ffmpeglib.p_url_fopen)(&ffmpegdrv_oc->pb, ffmpegdrv_oc->filename,
-                            URL_WRONLY) < 0) 
+        if ((*ffmpeglib.p_avio_open)(&ffmpegdrv_oc->pb, ffmpegdrv_oc->filename,
+                            AVIO_FLAG_WRITE) < 0) 
         {
             ui_error(translate_text(IDGS_FFMPEG_CANNOT_OPEN_S), ffmpegdrv_oc->filename);
             screenshot_stop_recording();
@@ -642,7 +637,7 @@
 
     }
 
-    (*ffmpeglib.p_av_write_header)(ffmpegdrv_oc);
+    (*ffmpeglib.p_avformat_write_header)(ffmpegdrv_oc, NULL);
 
     log_debug("ffmpegdrv: Initialized file successfully");
 
@@ -724,7 +719,7 @@
         (*ffmpeglib.p_av_write_trailer)(ffmpegdrv_oc);
         if (!(ffmpegdrv_fmt->flags & AVFMT_NOFILE)) {
             /* close the output file */
-            (*ffmpeglib.p_url_fclose)(ffmpegdrv_oc->pb);
+            (*ffmpeglib.p_avio_close)(ffmpegdrv_oc->pb);
         }
     }
     
Index: vice-2.4.dfsg/src/gfxoutputdrv/ffmpeglib.c
===================================================================
--- vice-2.4.dfsg.orig/src/gfxoutputdrv/ffmpeglib.c	2011-09-18 13:09:45.000000000 +0000
+++ vice-2.4.dfsg/src/gfxoutputdrv/ffmpeglib.c	2014-02-26 13:00:40.676269253 +0000
@@ -165,7 +165,7 @@
             return -1;
         }
 
-        GET_SYMBOL_AND_TEST_AVCODEC(avcodec_open);
+        GET_SYMBOL_AND_TEST_AVCODEC(avcodec_open2);
         GET_SYMBOL_AND_TEST_AVCODEC(avcodec_close);
         GET_SYMBOL_AND_TEST_AVCODEC(avcodec_find_encoder);
         GET_SYMBOL_AND_TEST_AVCODEC(avcodec_encode_audio);
@@ -186,7 +186,7 @@
     }
     avcodec_so = NULL;
 
-    lib->p_avcodec_open = NULL;
+    lib->p_avcodec_open2 = NULL;
     lib->p_avcodec_close = NULL;
     lib->p_avcodec_find_encoder = NULL;
     lib->p_avcodec_encode_audio = NULL;
@@ -207,14 +207,13 @@
 
         GET_SYMBOL_AND_TEST_AVFORMAT(av_init_packet);
         GET_SYMBOL_AND_TEST_AVFORMAT(av_register_all);
-        GET_SYMBOL_AND_TEST_AVFORMAT(av_new_stream);
-        GET_SYMBOL_AND_TEST_AVFORMAT(av_set_parameters);
-        GET_SYMBOL_AND_TEST_AVFORMAT(av_write_header);
+        GET_SYMBOL_AND_TEST_AVFORMAT(avformat_new_stream);
+        GET_SYMBOL_AND_TEST_AVFORMAT(avformat_write_header);
         GET_SYMBOL_AND_TEST_AVFORMAT(av_write_frame);
         GET_SYMBOL_AND_TEST_AVFORMAT(av_write_trailer);
-        GET_SYMBOL_AND_TEST_AVFORMAT(url_fopen);
-        GET_SYMBOL_AND_TEST_AVFORMAT(url_fclose);
-        GET_SYMBOL_AND_TEST_AVFORMAT(dump_format);
+        GET_SYMBOL_AND_TEST_AVFORMAT(avio_open);
+        GET_SYMBOL_AND_TEST_AVFORMAT(avio_close);
+        GET_SYMBOL_AND_TEST_AVFORMAT(av_dump_format);
         GET_SYMBOL_AND_TEST_AVFORMAT(av_guess_format);
 #ifndef HAVE_FFMPEG_SWSCALE
         GET_SYMBOL_AND_TEST_AVFORMAT(img_convert);
@@ -239,14 +238,13 @@
 
     lib->p_av_init_packet = NULL;
     lib->p_av_register_all = NULL;
-    lib->p_av_new_stream = NULL;
-    lib->p_av_set_parameters = NULL;
-    lib->p_av_write_header = NULL;
+    lib->p_avformat_new_stream = NULL;
+    lib->p_avformat_write_header = NULL;
     lib->p_av_write_frame = NULL;
     lib->p_av_write_trailer = NULL;
-    lib->p_url_fopen = NULL;
-    lib->p_url_fclose = NULL;
-    lib->p_dump_format = NULL;
+    lib->p_avio_open = NULL;
+    lib->p_avio_close = NULL;
+    lib->p_av_dump_format = NULL;
     lib->p_av_guess_format = NULL;
 #ifndef HAVE_FFMPEG_SWSCALE
     lib->p_img_convert = NULL;
Index: vice-2.4.dfsg/src/gfxoutputdrv/ffmpeglib.h
===================================================================
--- vice-2.4.dfsg.orig/src/gfxoutputdrv/ffmpeglib.h	2011-10-24 19:06:48.000000000 +0000
+++ vice-2.4.dfsg/src/gfxoutputdrv/ffmpeglib.h	2014-02-26 13:01:10.542017373 +0000
@@ -68,9 +68,9 @@
 typedef unsigned (*ffmpeg_version_t) (void);
 
 /* avcodec fucntions */
-typedef int (*avcodec_open_t) (AVCodecContext*, AVCodec*);
+typedef int (*avcodec_open2_t) (AVCodecContext*, AVCodec*, AVDictionary**);
 typedef int (*avcodec_close_t) (AVCodecContext*);
-typedef AVCodec* (*avcodec_find_encoder_t) (enum CodecID);
+typedef AVCodec* (*avcodec_find_encoder_t) (enum AVCodecID);
 typedef int (*avcodec_encode_audio_t) (AVCodecContext*, uint8_t*, int, const short*);
 typedef int (*avcodec_encode_video_t) (AVCodecContext*, uint8_t*, int, const AVFrame*);
 typedef int (*avpicture_fill_t) (AVPicture*, uint8_t*, int, int, int);
@@ -79,14 +79,13 @@
 /* avformat functions */
 typedef void (*av_init_packet_t) (AVPacket *pkt);
 typedef void (*av_register_all_t) (void);
-typedef AVStream* (*av_new_stream_t) (AVFormatContext*, int);
-typedef int (*av_set_parameters_t) (AVFormatContext*, AVFormatParameters*);
-typedef int (*av_write_header_t) (AVFormatContext*);
+typedef AVStream* (*avformat_new_stream_t) (AVFormatContext*, AVCodec*);
+typedef int (*avformat_write_header_t) (AVFormatContext*, AVDictionary**);
 typedef int (*av_write_frame_t) (AVFormatContext*, AVPacket*);
 typedef int (*av_write_trailer_t) (AVFormatContext*);
-typedef int (*url_fopen_t) (ByteIOContext**, const char*, int);
-typedef int (*url_fclose_t) (ByteIOContext*);
-typedef void (*dump_format_t) (AVFormatContext *, int, const char*, int);
+typedef int (*avio_open_t) (AVIOContext**, const char*, int);
+typedef int (*avio_close_t) (AVIOContext*);
+typedef void (*av_dump_format_t) (AVFormatContext *, int, const char*, int);
 typedef AVOutputFormat* (*av_guess_format_t) (const char*, const char*, const char*);
 typedef int (*img_convert_t) (AVPicture*, int, AVPicture*, int, int, int);
 
@@ -106,7 +105,7 @@
 
 struct ffmpeglib_s {
     /* avcodec */
-    avcodec_open_t              p_avcodec_open;
+    avcodec_open2_t             p_avcodec_open2;
     avcodec_close_t             p_avcodec_close;
     avcodec_find_encoder_t      p_avcodec_find_encoder;
     avcodec_encode_audio_t      p_avcodec_encode_audio;
@@ -117,14 +116,13 @@
     /* avformat */
     av_init_packet_t            p_av_init_packet;
     av_register_all_t           p_av_register_all;
-    av_new_stream_t             p_av_new_stream;
-    av_set_parameters_t         p_av_set_parameters;
-    av_write_header_t           p_av_write_header;
+    avformat_new_stream_t       p_avformat_new_stream;
+    avformat_write_header_t     p_avformat_write_header;
     av_write_frame_t            p_av_write_frame;
     av_write_trailer_t          p_av_write_trailer;
-    url_fopen_t                 p_url_fopen;
-    url_fclose_t                p_url_fclose;
-    dump_format_t               p_dump_format;
+    avio_open_t                 p_avio_open;
+    avio_close_t                p_avio_close;
+    av_dump_format_t            p_av_dump_format;
     av_guess_format_t           p_av_guess_format;
 #ifndef HAVE_FFMPEG_SWSCALE
     img_convert_t               p_img_convert;

Reply via email to