Re: [Qemu-devel] [PATCH] Video and sound capture to a videofile through ffmpeg

[Fam Zheng <famz@redhat.com>]

On Thu, 05/04 13:41, Alex K wrote:
> Hello everyone,

Hi Alex, thanks for posting the patch! I don't know much about display and sound
in QEMU, so just making some superficial points.
> 
> I've made a patch that adds ability to record video of what's going on
> inside qemu. It uses ffmpeg libraries. Basically, the patch adds
> 2 new commands to the console:
> capture_start path framerate
> capture_stop

Sounds like a good idea. In addition, I think it's worth to be added to QMP too.

> 
> path is required
> framerate could be 24, 25, 30 or 60. Default is 60
> video codec is always h264
> 
> The patch uses ffmpeg so you will need to install these packages:
> ffmpeg libavformat-dev libavcodec-dev libavutil-dev libswscale-dev
> 
> This is my first time posting here, so please correct me if I'm doing
> something wrong

This line can be moved after a '---' line following the 'signed-off-by' line,
taht way it doesn't go into the git history when your patch is applied by
maintainers, as it is useless there.

> 
> Signed-off-by: Alex K <vip-ak47@yandex.ru>
> ---
>  configure                          |  20 +
>  default-configs/i386-softmmu.mak   |   1 +
>  default-configs/x86_64-softmmu.mak |   1 +
>  hmp-commands.hx                    |  34 ++
>  hmp.h                              |   2 +
>  hw/display/Makefile.objs           |   2 +
>  hw/display/capture.c               | 761 +++++++++++++++++++++++++++++++++++++
>  hw/display/capture.h               |  78 ++++
>  8 files changed, 899 insertions(+)
>  create mode 100644 hw/display/capture.c
>  create mode 100644 hw/display/capture.h
> 
> diff --git a/configure b/configure
> index 48a9370..a6ddbf0 100755
> --- a/configure
> +++ b/configure
> @@ -281,6 +281,7 @@ opengl=""
>  opengl_dmabuf="no"
>  avx2_opt="no"
>  zlib="yes"
> +libav="yes"
>  lzo=""
>  snappy=""
>  bzip2=""
> @@ -1993,6 +1994,25 @@ if test "$seccomp" != "no" ; then
>          seccomp="no"
>      fi
>  fi
> +#########################################
> +# libav check
> +

Use $pkg_config?

> +if test "$libav" != "no" ; then
> +    cat > $TMPC << EOF
> +#include <libavcodec/avcodec.h>
> +#include <libavformat/avformat.h>
> +
> +int main(void){ av_register_all(); avcodec_register_all(); return 0; }
> +EOF
> +    if compile_prog "" "-lm -lpthread -lavformat -lavcodec -lavutil -lswscale -lswresample" ; then
> +        :
> +    else
> +        error_exit "libav check failed" \
> +            "Make sure to have the libav libs and headers installed."

Please don't make this an error - the dependency should be optional.

> +    fi
> +fi
> +LIBS="$LIBS -lm -lpthread -lavformat -lavcodec -lavutil -lswscale -lswresample"
> +

Please don't extend $LIBS, use something like AV_LIBS and only add it to the
object that uses the library, with per object flags.

Also, add AV_CFLAGS if necessary.

See also how $curl_libs and friends are created and used in configure and
Makefile.


>  ##########################################
>  # xen probe
>  
> diff --git a/default-configs/i386-softmmu.mak b/default-configs/i386-softmmu.mak
> index d2ab2f6..35ce513 100644
> --- a/default-configs/i386-softmmu.mak
> +++ b/default-configs/i386-softmmu.mak
> @@ -59,3 +59,4 @@ CONFIG_SMBIOS=y
>  CONFIG_HYPERV_TESTDEV=$(CONFIG_KVM)
>  CONFIG_PXB=y
>  CONFIG_ACPI_VMGENID=y
> +CONFIG_CAPTURE=y
> diff --git a/default-configs/x86_64-softmmu.mak b/default-configs/x86_64-softmmu.mak
> index 9bde2f1..b9a7175 100644
> --- a/default-configs/x86_64-softmmu.mak
> +++ b/default-configs/x86_64-softmmu.mak
> @@ -59,3 +59,4 @@ CONFIG_SMBIOS=y
>  CONFIG_HYPERV_TESTDEV=$(CONFIG_KVM)
>  CONFIG_PXB=y
>  CONFIG_ACPI_VMGENID=y
> +CONFIG_CAPTURE=y

These two hunks are wrong. Probe and generate it in configure, and config.h.

See how CONFIG_CURL is handled in configure and Makefiles.

For more information, see docs/build-system.txt. But I believe following the
libcurl example is enough.

> diff --git a/hmp-commands.hx b/hmp-commands.hx
> index 0aca984..9066aac 100644
> --- a/hmp-commands.hx
> +++ b/hmp-commands.hx
> @@ -1809,3 +1809,37 @@ ETEXI
>  STEXI
>  @end table
>  ETEXI
> +
> +    {
> +        .name       = "capture_start",
> +        .args_type  = "filename:F,fps:i?",
> +        .params     = "filename [framerate]",
> +        .help       = "Start video capture",
> +        .cmd        = hmp_capture_start,
> +    },
> +
> +STEXI
> +@item capture_start @var{filename} [@var{framerate}]
> +@findex capture_start
> +Start video capture.
> +Capture video into @var{filename} with framerate @var{framerate}.

Is there an fps limit? Is it possible to do 0.5 fps?

> +
> +Defaults:
> +@itemize @minus
> +@item framerate = 60
> +@end itemize
> +ETEXI
> +
> +    {
> +        .name       = "capture_stop",
> +        .args_type  = "",
> +        .params     = "",
> +        .help       = "Stop video capture",
> +        .cmd        = hmp_capture_stop,
> +    },
> +
> +STEXI
> +@item capture_stop
> +@findex capture_stop
> +Stop video capture.
> +ETEXI
> diff --git a/hmp.h b/hmp.h
> index 799fd37..36c7a4d 100644
> --- a/hmp.h
> +++ b/hmp.h
> @@ -138,5 +138,7 @@ void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict);
>  void hmp_info_dump(Monitor *mon, const QDict *qdict);
>  void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict);
>  void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict);
> +void hmp_capture_start(Monitor *mon, const QDict *qdict);
> +void hmp_capture_stop(Monitor *mon, const QDict *qdict);
>  
>  #endif
> diff --git a/hw/display/Makefile.objs b/hw/display/Makefile.objs
> index 551c050..a918896 100644
> --- a/hw/display/Makefile.objs
> +++ b/hw/display/Makefile.objs
> @@ -20,6 +20,8 @@ common-obj-$(CONFIG_ZAURUS) += tc6393xb.o
>  
>  common-obj-$(CONFIG_MILKYMIST_TMU2) += milkymist-tmu2.o
>  
> +obj-$(CONFIG_CAPTURE) += capture.o
> +
>  obj-$(CONFIG_OMAP) += omap_dss.o
>  obj-$(CONFIG_OMAP) += omap_lcdc.o
>  obj-$(CONFIG_PXA2XX) += pxa2xx_lcd.o
> diff --git a/hw/display/capture.c b/hw/display/capture.c
> new file mode 100644
> index 0000000..c89aaa0
> --- /dev/null
> +++ b/hw/display/capture.c
> @@ -0,0 +1,761 @@

A copy right header is mandatory for this source file.

Please also include "qemu/osdep.h" before any other headers.

> +#include "capture.h"
> +
> +static void sound_capture_notify(void *opaque, audcnotification_e cmd)
> +{
> +    (void) opaque;
> +    (void) cmd;

These lines are not needed per QEMU's compiler warning level.

> +}
> +
> +static void sound_capture_destroy(void *opaque)
> +{
> +    (void) opaque;

This one too.

> +}
> +
> +static void write_empty_sound(void *opaque, struct CaptureThreadWorkerData *data)
> +{
> +    AVFormatContext *oc = data->oc;
> +    OutputStream *ost = &data->audio_stream;
> +
> +    AVFrame *tmp = ost->tmp_frame;
> +    ost->tmp_frame = ost->empty_frame;
> +    double newlen = write_audio_frame(oc, ost);
> +    ost->tmp_frame = tmp;
> +
> +    if (newlen >= 0.0) {
> +        data->video_len = newlen;
> +    }
> +}
> +
> +static void sound_capture_capture(void *opaque, void *buf, int size)
> +{
> +    int bufsize = size;
> +    SoundCapture *wav = opaque;
> +    AVFrame *frame;
> +    int sampleCount;
> +    double len1, len2, delta;
> +    int8_t *q;
> +    int buffpos;
> +
> +    /*int32_t n = 0;
> +    int i = 0;
> +    for(i=0;i<size;i++) {
> +        int8_t a = ((int8_t*)buf)[i];
> +        n+=a;
> +    }
> +    wav->bytes += size;
> +    if(n==0)
> +        return;
> +    printf("%d\n",n);*/
> +    frame = wav->data->audio_stream.tmp_frame;
> +    sampleCount = frame->nb_samples * 4;
> +
> +    len1 = wav->data->video_len;
> +    len2 = wav->data->video_len2;
> +    delta = len1 - len2;
> +
> +    while (delta < 0.0) {
> +        write_empty_sound(opaque, wav->data);
> +
> +        len1 = wav->data->video_len;
> +        len2 = wav->data->video_len2;
> +        delta = len1 - len2;
> +    }
> +
> +    q = (int8_t *)frame->data[0];
> +
> +    buffpos = 0;
> +    while (bufsize > 0) {
> +        int start = wav->bufferPos;
> +        int freeSpace = sampleCount - start;
> +
> +        int willWrite = freeSpace;
> +        if (willWrite > bufsize) {
> +            willWrite = bufsize;
> +        }
> +
> +        memcpy(q + start, buf + buffpos, willWrite);
> +        bufsize -= willWrite;
> +        buffpos += willWrite;
> +
> +        freeSpace = sampleCount - start - willWrite;
> +
> +        if (freeSpace == 0) {
> +            double newlen = write_audio_frame(wav->data->oc, &wav->data->audio_stream);
> +
> +            if (newlen >= 0.0) {
> +                wav->data->video_len = newlen;
> +            }
> +            wav->bufferPos = 0;
> +        } else {
> +            wav->bufferPos = start + willWrite;
> +        }
> +    }
> +}
> +
> +static void sound_capture_capture_destroy(void *opaque)
> +{
> +    SoundCapture *wav = opaque;
> +
> +    AUD_del_capture (wav->cap, wav);
> +}
> +
> +static int sound_capture_start_capture(struct CaptureThreadWorkerData *data)
> +{
> +    Monitor *mon = cur_mon;
> +    SoundCapture *wav;
> +    struct audsettings as;
> +    struct audio_capture_ops ops;
> +    CaptureVoiceOut *cap;
> +
> +    as.freq = 44100;
> +    as.nchannels = 2;
> +    as.fmt = AUD_FMT_S16;
> +    as.endianness = 0;
> +
> +    ops.notify = sound_capture_notify;
> +    ops.capture = sound_capture_capture;
> +    ops.destroy = sound_capture_destroy;
> +
> +    wav = g_malloc0(sizeof(*wav));
> +
> +
> +    cap = AUD_add_capture(&as, &ops, wav);
> +    if (!cap) {
> +        monitor_printf(mon, "Failed to add audio capture\n");
> +        goto error_free;
> +    }
> +
> +    wav->bufferPos = 0;
> +    wav->data = data;
> +    wav->cap = cap;
> +    data->soundCapture = wav;
> +    return 0;
> +
> +error_free:
> +    g_free(wav);
> +    return -1;
> +}
> +
> +static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base,
> +                        AVStream *st, AVPacket *pkt)

Parameter list is off by one column.

> +{
> +    /* rescale output packet timestamp values from codec to stream timebase */
> +    av_packet_rescale_ts(pkt, *time_base, st->time_base);
> +    pkt->stream_index = st->index;
> +    /* Write the compressed frame to the media file. */
> +    return av_interleaved_write_frame(fmt_ctx, pkt);
> +}
> +
> +/* Add an output stream. */
> +static void add_video_stream(OutputStream *ost, AVFormatContext *oc,
> +                       AVCodec **codec,
> +                       enum AVCodecID codec_id,
> +                       int w, int h, int bit_rate, int framerate)

Parameter list indentation is off.
> +{
> +    AVCodecContext *c;
> +    /* find the encoder */
> +    *codec = avcodec_find_encoder(codec_id);
> +    if (!(*codec)) {
> +        fprintf(stderr, "Could not find encoder for '%s'\n",
> +                avcodec_get_name(codec_id));
> +        exit(1);

Can this be handled more gracefully instead of exit? (The same question to all
other 'exits' in this patch).

> +    }
> +    ost->st = avformat_new_stream(oc, *codec);
> +    if (!ost->st) {
> +        fprintf(stderr, "Could not allocate stream\n");
> +        exit(1);
> +    }
> +    ost->st->id = oc->nb_streams - 1;
> +    c = ost->st->codec;
> +    if ((*codec)->type == AVMEDIA_TYPE_VIDEO) {
> +        c->codec_id = codec_id;
> +        c->bit_rate = bit_rate;
> +        /* Resolution must be a multiple of two. */
> +        c->width    = w;
> +        c->height   = h;
> +        /* timebase: This is the fundamental unit of time (in seconds) in terms
> +         * of which frame timestamps are represented. For fixed-fps content,
> +         * timebase should be 1/framerate and timestamp increments should be
> +         * identical to 1. */
> +        ost->st->time_base = (AVRational){ 1, framerate };
> +        c->time_base = ost->st->time_base;
> +        c->gop_size  = 12; /* emit one intra frame every 12 frames at most */
> +        c->pix_fmt   = AV_PIX_FMT_YUV420P;
> +        if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
> +            /* just for testing, we also add B frames */
> +            c->max_b_frames = 2;
> +        }
> +        if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
> +            /* Needed to avoid using macroblocks in which some coeffs overflow.
> +             * This does not happen with normal video, it just happens here as
> +             * the motion of the chroma plane does not match the luma plane. */
> +            c->mb_decision = 2;
> +        }
> +    } else {
> +        fprintf(stderr, "Wrong stream type\n");
> +        exit(1);
> +    }
> +    /* Some formats want stream headers to be separate. */
> +    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
> +        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
> +    }
> +}
> +
> +static void add_audio_stream(OutputStream *ost, AVFormatContext *oc,
> +                             AVCodec **codec,
> +                             enum AVCodecID codec_id)
> +{
> +    AVCodecContext *c;
> +    int i;
> +    /* find the encoder */
> +    *codec = avcodec_find_encoder(codec_id);
> +    if (!(*codec)) {
> +        fprintf(stderr, "Could not find encoder for '%s'\n",
> +                avcodec_get_name(codec_id));
> +        exit(1);
> +    }
> +    ost->st = avformat_new_stream(oc, *codec);
> +    if (!ost->st) {
> +        fprintf(stderr, "Could not allocate stream\n");
> +        exit(1);
> +    }
> +    ost->st->id = oc->nb_streams - 1;
> +    c = ost->st->codec;
> +    if ((*codec)->type == AVMEDIA_TYPE_AUDIO) {
> +        c->sample_fmt = AV_SAMPLE_FMT_FLTP;
> +        c->bit_rate    = 128000;
> +        c->sample_rate = 44100;
> +        c->channels    = av_get_channel_layout_nb_channels(c->channel_layout);
> +        c->channel_layout = AV_CH_LAYOUT_STEREO;
> +        if ((*codec)->channel_layouts) {
> +            c->channel_layout = (*codec)->channel_layouts[0];
> +            for (i = 0; (*codec)->channel_layouts[i]; i++) {
> +                if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO) {
> +                    c->channel_layout = AV_CH_LAYOUT_STEREO;
> +                }
> +            }
> +        }
> +        c->channels   = av_get_channel_layout_nb_channels(c->channel_layout);
> +        ost->st->time_base = (AVRational){ 1, c->sample_rate };
> +    } else {
> +        fprintf(stderr, "Wrong stream type\n");
> +        exit(1);
> +    }
> +    /* Some formats want stream headers to be separate. */
> +    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
> +        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
> +    }
> +}
> +/**************************************************************/
> +/* audio output */
> +static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,
> +                                  uint64_t channel_layout,
> +                                  int sample_rate, int nb_samples)
> +{
> +    AVFrame *frame = av_frame_alloc();
> +    int ret;
> +    if (!frame) {
> +        fprintf(stderr, "Error allocating an audio frame\n");
> +        exit(1);
> +    }
> +    frame->format = sample_fmt;
> +    frame->channel_layout = channel_layout;
> +    frame->sample_rate = sample_rate;
> +    frame->nb_samples = nb_samples;
> +    if (nb_samples) {
> +        ret = av_frame_get_buffer(frame, 0);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error allocating an audio buffer\n");
> +            exit(1);
> +        }
> +    }
> +    return frame;
> +}
> +
> +static void open_audio(AVFormatContext *oc, AVCodec *codec,
> +                       OutputStream *ost, AVDictionary *opt_arg)
> +{
> +    AVCodecContext *c;
> +    int nb_samples;
> +    int ret;
> +    AVDictionary *opt = NULL;
> +    c = ost->st->codec;
> +    /* open it */
> +    av_dict_copy(&opt, opt_arg, 0);
> +    ret = avcodec_open2(c, codec, &opt);
> +    av_dict_free(&opt);
> +    if (ret < 0) {
> +        fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
> +        exit(1);
> +    }
> +    nb_samples = c->frame_size;
> +    ost->frame     = alloc_audio_frame(c->sample_fmt, c->channel_layout,
> +                                       c->sample_rate, nb_samples);
> +
> +    ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,
> +                                       c->sample_rate, nb_samples);
> +    ost->tmp_frame->pts = 0;
> +
> +    ost->empty_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,
> +                                       c->sample_rate, nb_samples);
> +    int sampleCount = nb_samples * 4;
> +    int8_t *q = (int8_t *)ost->empty_frame->data[0];
> +    memset(q, 0, sampleCount);
> +
> +    /* create resampler context */
> +    ost->swr_ctx = swr_alloc();
> +    if (!ost->swr_ctx) {
> +        fprintf(stderr, "Could not allocate resampler context\n");
> +        exit(1);
> +    }
> +    /* set options */
> +    av_opt_set_int       (ost->swr_ctx, "in_channel_count",  c->channels,       0);
> +    av_opt_set_int       (ost->swr_ctx, "in_sample_rate",    c->sample_rate,    0);
> +    av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",     AV_SAMPLE_FMT_S16, 0);
> +    av_opt_set_int       (ost->swr_ctx, "out_channel_count", c->channels,       0);
> +    av_opt_set_int       (ost->swr_ctx, "out_sample_rate",   c->sample_rate,    0);
> +    av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",    c->sample_fmt,     0);
> +    /* initialize the resampling context */
> +    if (swr_init(ost->swr_ctx) < 0) {
> +        fprintf(stderr, "Failed to initialize the resampling context\n");
> +        exit(1);
> +    }
> +}
> +
> +/*
> + * encode one audio frame and send it to the muxer
> + */
> +static double write_audio_frame(AVFormatContext *oc, OutputStream *ost)
> +{
> +    AVCodecContext *c;
> +    AVPacket pkt = { 0 };
> +    AVFrame *frame;
> +    int ret;
> +    int got_packet;
> +    int dst_nb_samples;
> +    av_init_packet(&pkt);
> +    c = ost->st->codec;
> +    frame = ost->tmp_frame;
> +    frame->pts = frame->pts + 1;
> +    double videolen = -1.0;
> +    if (frame) {
> +        /* convert samples from native format to destination codec format,
> +         * using the resampler */
> +        /* compute destination number of samples */
> +        dst_nb_samples = av_rescale_rnd(
> +            swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples,
> +            c->sample_rate, c->sample_rate, AV_ROUND_UP);
> +        av_assert0(dst_nb_samples == frame->nb_samples);
> +        /* when we pass a frame to the encoder, it may keep a reference to it
> +         * internally;
> +         * make sure we do not overwrite it here
> +         */
> +        ret = av_frame_make_writable(ost->frame);
> +        if (ret < 0) {
> +            exit(1);
> +        }
> +        /* convert to destination format */
> +        ret = swr_convert(ost->swr_ctx,
> +                          ost->frame->data, dst_nb_samples,
> +                          (const uint8_t **)frame->data, frame->nb_samples);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error while converting\n");
> +            exit(1);
> +        }
> +        frame = ost->frame;
> +        frame->pts = av_rescale_q(ost->samples_count,
> +                                  (AVRational){1, c->sample_rate},
> +                                  c->time_base);
> +
> +        videolen = (double)frame->pts / c->sample_rate;
> +        ost->samples_count += dst_nb_samples;
> +    }
> +    ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
> +    if (ret < 0) {
> +        fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
> +        exit(1);
> +    }
> +    if (got_packet) {
> +        ret = write_frame(oc, &c->time_base, ost->st, &pkt);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error while writing audio frame: %s\n",
> +                    av_err2str(ret));
> +            exit(1);
> +        }
> +    }
> +    return videolen;
> +}

Add a blank line?

> +static void write_delayed_audio_frames(void)
> +{
> +    struct CaptureThreadWorkerData *data = capture_get_data();
> +    AVFormatContext *oc = data->oc;
> +    OutputStream *ost = &data->audio_stream;
> +    AVCodecContext *c = ost->st->codec;
> +
> +    AVPacket pkt = { 0 };
> +    pkt.data = NULL;
> +    pkt.size = 0;
> +    av_init_packet(&pkt);
> +    int got_output = 1;
> +    int ret;
> +    while (got_output) {
> +
> +        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error encoding frame\n");
> +            exit(1);
> +        }
> +
> +        if (got_output) {
> +            ret = write_frame(oc, &c->time_base, ost->st, &pkt);
> +            av_free_packet(&pkt);
> +        }
> +    }
> +}

Blank line.

> +/**************************************************************/
> +/* video output */
> +static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
> +{
> +    AVFrame *picture;
> +    int ret;
> +    picture = av_frame_alloc();
> +    if (!picture) {
> +        return NULL;
> +    }
> +    picture->format = pix_fmt;
> +    picture->width  = width;
> +    picture->height = height;
> +    /* allocate the buffers for the frame data */
> +    ret = av_frame_get_buffer(picture, 32);
> +    if (ret < 0) {
> +        fprintf(stderr, "Could not allocate frame data.\n");
> +        exit(1);
> +    }
> +    return picture;
> +}
> +
> +static void open_video(AVFormatContext *oc, AVCodec *codec,
> +                       OutputStream *ost, AVDictionary *opt_arg)
> +{
> +    int ret;
> +    AVCodecContext *c = ost->st->codec;
> +    AVDictionary *opt = NULL;
> +    av_dict_copy(&opt, opt_arg, 0);
> +    /* open the codec */
> +    ret = avcodec_open2(c, codec, &opt);
> +    av_dict_free(&opt);
> +    if (ret < 0) {
> +        fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
> +        exit(1);
> +    }
> +    /* allocate and init a re-usable frame */
> +    ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
> +    if (!ost->frame) {
> +        fprintf(stderr, "Could not allocate video frame\n");
> +        exit(1);
> +    }
> +}
> +
> +static AVFrame *get_filled_image(void)
> +{
> +    QemuConsole *con = qemu_console_lookup_by_index(0);
> +    DisplaySurface *surface;
> +    surface = qemu_console_surface(con);
> +
> +    if (con == NULL) {
> +        fprintf(stderr, "There is no QemuConsole I can screendump from.\n");
> +        return NULL;
> +    }
> +
> +    int ourW = pixman_image_get_width(surface->image);
> +    int ourH = pixman_image_get_height(surface->image);
> +
> +    AVFrame *pict = alloc_picture(AV_PIX_FMT_RGB32, ourW, ourH);
> +    av_frame_make_writable(pict);
> +
> +    uint8_t* picdata = (uint8_t *)pixman_image_get_data(surface->image);
> +
> +    memcpy(pict->data[0], picdata, ourW * ourH * 4);
> +    return pict;
> +}
> +
> +static AVFrame *get_video_frame(OutputStream *ost, int64_t frame)
> +{
> +    AVCodecContext *c = ost->st->codec;
> +
> +    AVFrame *pict = get_filled_image();
> +    if (pict == NULL) {
> +        return NULL;
> +    }
> +
> +    struct SwsContext *swsContext = sws_getContext(
> +        pict->width, pict->height, pict->format,
> +        ost->frame->width, ost->frame->height,
> +        ost->frame->format, SWS_BICUBIC, NULL, NULL, NULL);
> +    sws_scale(swsContext, (const uint8_t * const *)pict->data,
> +              pict->linesize , 0, c->height, ost->frame->data,
> +              ost->frame->linesize);
> +
> +    av_frame_free(&pict);
> +    sws_freeContext(swsContext);
> +
> +    if (frame <= ost->frame->pts) {
> +        ost->frame->pts = ost->frame->pts + 1;
> +    } else {
> +        ost->frame->pts = frame;
> +    }
> +
> +    return ost->frame;
> +}

Blank line.

> +/*
> + * encode one video frame and send it to the muxer
> + */
> +static void write_video_frame(AVFormatContext *oc,
> +                              OutputStream *ost, int frameNumber)
> +{
> +    int ret;
> +    AVCodecContext *c;
> +    AVFrame *frame;
> +    int got_packet = 0;
> +    AVPacket pkt = { 0 };
> +
> +    frame = get_video_frame(ost, frameNumber);
> +    if (frame == NULL) {
> +        return;
> +    }
> +
> +    c = ost->st->codec;
> +    av_init_packet(&pkt);
> +    /* encode the image */
> +    ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
> +    if (ret < 0) {
> +        fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
> +        exit(1);
> +    }
> +    if (got_packet) {
> +        ret = write_frame(oc, &c->time_base, ost->st, &pkt);
> +    } else {
> +        ret = 0;
> +    }
> +    if (ret < 0) {
> +        fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
> +        return;
> +    }
> +}
> +
> +static void write_delayed_video_frames(void)
> +{
> +    struct CaptureThreadWorkerData *data = capture_get_data();
> +    AVFormatContext *oc = data->oc;
> +    OutputStream *ost = &data->stream;
> +    AVCodecContext *c = ost->st->codec;
> +
> +    AVPacket pkt = { 0 };
> +    pkt.data = NULL;
> +    pkt.size = 0;
> +    av_init_packet(&pkt);
> +    int got_output = 1;
> +    int ret;
> +    while (got_output) {
> +        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error encoding frame\n");
> +            exit(1);
> +        }
> +
> +        if (got_output) {
> +            ret = write_frame(oc, &c->time_base, ost->st, &pkt);
> +            av_free_packet(&pkt);
> +        }
> +    }
> +}
> +
> +static void close_stream(AVFormatContext *oc, OutputStream *ost)
> +{
> +    avcodec_close(ost->st->codec);
> +    av_frame_free(&ost->frame);
> +    av_frame_free(&ost->tmp_frame);
> +    sws_freeContext(ost->sws_ctx);
> +    swr_free(&ost->swr_ctx);
> +}
> +
> +static int ends_with(const char *str, const char *suffix)
> +{
> +    if (!str || !suffix) {
> +        return 0;
> +    }
> +    size_t lenstr = strlen(str);
> +    size_t lensuffix = strlen(suffix);
> +    if (lensuffix >  lenstr) {
> +        return 0;
> +    }
> +    return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
> +}
> +
> +static struct CaptureThreadWorkerData *capture_get_data(void)
> +{
> +    static struct CaptureThreadWorkerData data = {0};
> +    return &data;
> +}
> +
> +static void capture_timer(void *p)
> +{
> +    struct CaptureThreadWorkerData *data = (struct CaptureThreadWorkerData *)p;
> +    if (!data->is_capturing) {
> +        return;
> +    }
> +
> +    int64_t n = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
> +    int64_t intdelta = (n - data->time) / 100000;
> +    double delta = (double)intdelta / 10000;
> +    data->delta += delta;
> +    data->time   = n;
> +
> +    while (data->delta > (1.0 / data->framerate)) {
> +        data->delta -= 1.0 / data->framerate;
> +
> +        av_frame_make_writable(data->stream.frame);
> +        write_video_frame(data->oc, &data->stream,
> +            (int)(floor(data->video_len * (double)data->framerate + 0.5)));
> +    }
> +    data->video_len2 = data->video_len2 + delta;
> +
> +    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
> +    if (data->is_capturing) {
> +        timer_mod_ns(data->timer, now + 10000000);
> +    }
> +}
> +
> +static void capture_powerdown_req(void)
> +{
> +    if (capture_stop()) {
> +        printf("Capture stoped\n");
> +    }
> +}
> +
> +void hmp_capture_start(Monitor *mon, const QDict *qdict)
> +{
> +    const char *filename = qdict_get_str(qdict, "filename");
> +    int framerate = qdict_get_try_int(qdict, "fps", 60);
> +
> +    struct CaptureThreadWorkerData *data = capture_get_data();
> +    if (!data->is_loaded) {
> +        av_register_all();
> +        avcodec_register_all();
> +        data->codec = avcodec_find_encoder(AV_CODEC_ID_H264);
> +        if (!data->codec) {
> +            fprintf(stderr, "codec not found\n");
> +            return;
> +        }
> +        data->c = NULL;
> +        data->is_loaded = 1;
> +        atexit(capture_powerdown_req);
> +    }
> +
> +    if (data->is_capturing == 0) {
> +        if (!ends_with(filename, ".mp4")
> +         && !ends_with(filename, ".mpg")
> +         && !ends_with(filename, ".avi")) {
> +            monitor_printf(mon, "Invalid file format, use .mp4 or .mpg\n");
> +            return;
> +        }
> +        if (framerate != 60 && framerate != 30
> +         && framerate != 24 && framerate != 25) {
> +            monitor_printf(mon, "Invalid framerate, valid values are: 24, 25, 30, 60\n");
> +            return;
> +        }
> +        monitor_printf(mon, "Capture started to file: %s\n", filename);
> +
> +        data->framerate = framerate;
> +        data->frame = 0;
> +
> +        data->delta = 0.0;
> +        data->time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
> +
> +        data->video_len = 0.0;
> +        data->video_len2 = 0.0;
> +
> +        QemuConsole *con = qemu_console_lookup_by_index(0);
> +        DisplaySurface *surface;
> +        surface = qemu_console_surface(con);
> +        int resW = pixman_image_get_width(surface->image);
> +        int resH = pixman_image_get_height(surface->image);
> +
> +        OutputStream video_st = { 0 };
> +        data->stream = video_st;
> +        OutputStream audio_st = { 0 };
> +        data->audio_stream = audio_st;
> +
> +        avformat_alloc_output_context2(&data->oc, NULL, "avi", filename);
> +        AVOutputFormat *fmt;
> +        fmt = data->oc->oformat;
> +
> +        add_video_stream(&data->stream, data->oc, &data->codec,
> +                         fmt->video_codec, resW, resH, 4000000, framerate);
> +        add_audio_stream(&data->audio_stream, data->oc, &data->audio_codec,
> +                         fmt->audio_codec);
> +
> +        open_video(data->oc, data->codec, &data->stream, NULL);
> +        open_audio(data->oc, data->audio_codec, &data->audio_stream, NULL);
> +
> +        int ret = avio_open(&data->oc->pb, filename, AVIO_FLAG_WRITE);
> +        if (ret < 0) {
> +            fprintf(stderr, "Could not open '%s': %s\n", filename,
> +                    av_err2str(ret));
> +            return;
> +        }
> +        ret = avformat_write_header(data->oc, NULL);
> +        if (ret < 0) {
> +            fprintf(stderr, "Error occurred when opening output file: %s\n",
> +                    av_err2str(ret));
> +            return;
> +        }
> +
> +        data->is_capturing = 1;
> +
> +        if (data->timer) {
> +            timer_free(data->timer);
> +        }
> +        data->timer = timer_new_ns(QEMU_CLOCK_REALTIME, capture_timer, data);
> +        int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
> +        timer_mod_ns(data->timer, now + 1000000000 / data->framerate);
> +
> +        sound_capture_start_capture(data);
> +    } else {
> +        monitor_printf(mon, "Already capturing\n");
> +    }
> +}
> +
> +static int capture_stop(void)
> +{
> +    struct CaptureThreadWorkerData *data = capture_get_data();
> +    if (!data->is_loaded) {
> +        return 0;
> +    }
> +
> +    if (data->is_capturing) {
> +        data->is_capturing = 0;
> +
> +        write_delayed_video_frames();
> +        write_delayed_audio_frames();
> +
> +        av_write_trailer(data->oc);
> +        close_stream(data->oc, &data->stream);
> +        close_stream(data->oc, &data->audio_stream);
> +        avio_closep(&data->oc->pb);
> +        avformat_free_context(data->oc);
> +
> +        sound_capture_capture_destroy(data->soundCapture);
> +        return 1;
> +    }
> +    return 0;
> +}
> +
> +void hmp_capture_stop(Monitor *mon, const QDict *qdict)
> +{
> +    if (capture_stop()) {
> +        monitor_printf(mon, "Capture stopped\n");
> +    } else {
> +        monitor_printf(mon, "Not capturing\n");
> +    }
> +}
> diff --git a/hw/display/capture.h b/hw/display/capture.h
> new file mode 100644
> index 0000000..73c79f1
> --- /dev/null
> +++ b/hw/display/capture.h
> @@ -0,0 +1,78 @@
> +#ifndef CAPTURE_H
> +#define CAPTURE_H
> +
> +#include "qemu/osdep.h"
> +#include "monitor/monitor.h"
> +#include "ui/console.h"
> +#include "qemu/timer.h"
> +#include "audio/audio.h"
> +
> +#include <libavcodec/avcodec.h>
> +#include <libavformat/avformat.h>
> +#include "libavutil/frame.h"
> +#include "libavutil/imgutils.h"
> +#include <libswscale/swscale.h>
> +#include <libavutil/avassert.h>
> +#include <libavutil/channel_layout.h>
> +#include <libavutil/opt.h>
> +#include <libavutil/mathematics.h>
> +#include <libavutil/timestamp.h>
> +#include <libswresample/swresample.h>
> +
> +void hmp_capture_start(Monitor *mon, const QDict *qdict);
> +void hmp_capture_stop(Monitor *mon, const QDict *qdict);
> +
> +typedef struct OutputStream {
> +    AVStream *st;
> +    int samples_count;
> +    AVFrame *frame;
> +    AVFrame *tmp_frame;
> +    AVFrame *empty_frame;
> +    struct SwsContext *sws_ctx;
> +    struct SwrContext *swr_ctx;
> +} OutputStream;
> +
> +struct CaptureThreadWorkerData {
> +    QEMUTimer *timer;
> +    int frame;
> +    int is_loaded;
> +    int is_capturing;
> +    int framerate;
> +    double video_len;
> +    double video_len2;
> +    CaptureState *wavCapture;
> +
> +    AVCodec *codec;
> +    AVCodecContext *c;
> +
> +    AVFrame *picture;
> +    AVPacket pkt;
> +
> +    AVCodec *audio_codec;
> +    OutputStream stream;
> +    OutputStream audio_stream;
> +    AVFormatContext *oc;
> +
> +    int64_t time;
> +    double delta;
> +
> +    void *soundCapture;
> +};
> +
> +typedef struct {
> +    int bytes;
> +    CaptureVoiceOut *cap;
> +    struct CaptureThreadWorkerData *data;
> +    int bufferPos;
> +} SoundCapture;
> +
> +static int sound_capture_start_capture(struct CaptureThreadWorkerData *data);
> +static int ends_with(const char *str, const char *suffix);
> +static struct CaptureThreadWorkerData *capture_get_data(void);
> +static void write_delayed_audio_frames(void);
> +static void write_delayed_video_frames(void);
> +static int capture_stop(void);
> +static double write_audio_frame(AVFormatContext *oc, OutputStream *ost);
> +static void write_empty_sound(void *opaque, struct CaptureThreadWorkerData* data);

What's the point of these prototypes? 'static' means they are private functions
so they needn't be listed in the header.

> +
> +#endif
> -- 
> 2.7.4
> 
> 

Fam