2012-09-14 15:51:26 +00:00
|
|
|
/*
|
|
|
|
* video encoding using libavformat
|
|
|
|
* Copyright (C) 2010 Nicolas George <george@nsup.org>
|
2012-12-28 10:41:30 +00:00
|
|
|
* Copyright (C) 2011-2012 Rudolf Polzer <divVerent@xonotic.org>
|
2012-09-14 15:51:26 +00:00
|
|
|
*
|
2012-12-28 10:41:30 +00:00
|
|
|
* This file is part of mpv.
|
2012-09-14 15:51:26 +00:00
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* MPlayer is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2012-11-14 01:31:57 +00:00
|
|
|
#include "compat/libav.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/mp_common.h"
|
|
|
|
#include "core/options.h"
|
|
|
|
#include "video/fmt-conversion.h"
|
|
|
|
#include "video/mp_image.h"
|
|
|
|
#include "video/vfcap.h"
|
|
|
|
#include "core/subopt-helper.h"
|
2012-09-14 15:51:26 +00:00
|
|
|
#include "talloc.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "vo.h"
|
2012-09-14 15:51:26 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/encode_lavc.h"
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
#include "sub/sub.h"
|
2012-10-18 15:31:00 +00:00
|
|
|
#include "sub/dec_sub.h"
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
struct priv {
|
|
|
|
uint8_t *buffer;
|
|
|
|
size_t buffer_size;
|
|
|
|
AVStream *stream;
|
|
|
|
int have_first_packet;
|
|
|
|
|
|
|
|
int harddup;
|
|
|
|
|
|
|
|
double lastpts;
|
|
|
|
int64_t lastipts;
|
|
|
|
int64_t lastframeipts;
|
2013-06-09 13:37:28 +00:00
|
|
|
int64_t mindeltapts;
|
2012-09-25 09:53:29 +00:00
|
|
|
double expected_next_pts;
|
2012-09-14 15:51:26 +00:00
|
|
|
mp_image_t *lastimg;
|
2012-10-24 17:25:24 +00:00
|
|
|
int lastimg_wants_osd;
|
2012-09-14 15:51:26 +00:00
|
|
|
int lastdisplaycount;
|
|
|
|
|
|
|
|
AVRational worst_time_base;
|
|
|
|
int worst_time_base_is_stream;
|
|
|
|
|
|
|
|
struct mp_csp_details colorspace;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int preinit(struct vo *vo, const char *arg)
|
|
|
|
{
|
|
|
|
struct priv *vc;
|
|
|
|
if (!encode_lavc_available(vo->encode_lavc_ctx)) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_ERR,
|
|
|
|
"vo-lavc: the option -o (output file) must be specified\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
vo->priv = talloc_zero(vo, struct priv);
|
|
|
|
vc = vo->priv;
|
|
|
|
vc->harddup = vo->encode_lavc_ctx->options->harddup;
|
|
|
|
vc->colorspace = (struct mp_csp_details) MP_CSP_DETAILS_DEFAULTS;
|
2012-12-14 11:59:05 +00:00
|
|
|
vo->untimed = true;
|
2012-09-14 15:51:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
static void draw_image(struct vo *vo, mp_image_t *mpi);
|
2012-09-14 15:51:26 +00:00
|
|
|
static void uninit(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
if (!vc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vc->lastipts >= 0 && vc->stream)
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
draw_image(vo, NULL);
|
2012-09-14 15:51:26 +00:00
|
|
|
|
2012-12-22 20:46:28 +00:00
|
|
|
mp_image_unrefp(&vc->lastimg);
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
vo->priv = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int config(struct vo *vo, uint32_t width, uint32_t height,
|
|
|
|
uint32_t d_width, uint32_t d_height, uint32_t flags,
|
|
|
|
uint32_t format)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
enum PixelFormat pix_fmt = imgfmt2pixfmt(format);
|
|
|
|
AVRational display_aspect_ratio, image_aspect_ratio;
|
|
|
|
AVRational aspect;
|
|
|
|
|
|
|
|
if (!vc)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
display_aspect_ratio.num = d_width;
|
|
|
|
display_aspect_ratio.den = d_height;
|
|
|
|
image_aspect_ratio.num = width;
|
|
|
|
image_aspect_ratio.den = height;
|
|
|
|
aspect = av_div_q(display_aspect_ratio, image_aspect_ratio);
|
|
|
|
|
|
|
|
if (vc->stream) {
|
|
|
|
/* NOTE:
|
|
|
|
* in debug builds we get a "comparison between signed and unsigned"
|
|
|
|
* warning here. We choose to ignore that; just because ffmpeg currently
|
|
|
|
* uses a plain 'int' for these struct fields, it doesn't mean it always
|
|
|
|
* will */
|
|
|
|
if (width == vc->stream->codec->width &&
|
|
|
|
height == vc->stream->codec->height) {
|
|
|
|
if (aspect.num != vc->stream->codec->sample_aspect_ratio.num ||
|
|
|
|
aspect.den != vc->stream->codec->sample_aspect_ratio.den) {
|
|
|
|
/* aspect-only changes are not critical */
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN, "vo-lavc: unsupported pixel aspect "
|
|
|
|
"ratio change from %d:%d to %d:%d\n",
|
|
|
|
vc->stream->codec->sample_aspect_ratio.num,
|
|
|
|
vc->stream->codec->sample_aspect_ratio.den,
|
|
|
|
aspect.num, aspect.den);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME Is it possible with raw video? */
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_ERR,
|
|
|
|
"vo-lavc: resolution changes not supported.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
vc->lastipts = MP_NOPTS_VALUE;
|
|
|
|
vc->lastframeipts = MP_NOPTS_VALUE;
|
|
|
|
|
|
|
|
if (pix_fmt == PIX_FMT_NONE)
|
|
|
|
goto error; /* imgfmt2pixfmt already prints something */
|
|
|
|
|
|
|
|
vc->stream = encode_lavc_alloc_stream(vo->encode_lavc_ctx,
|
|
|
|
AVMEDIA_TYPE_VIDEO);
|
|
|
|
vc->stream->sample_aspect_ratio = vc->stream->codec->sample_aspect_ratio =
|
|
|
|
aspect;
|
|
|
|
vc->stream->codec->width = width;
|
|
|
|
vc->stream->codec->height = height;
|
|
|
|
vc->stream->codec->pix_fmt = pix_fmt;
|
|
|
|
|
|
|
|
encode_lavc_set_csp(vo->encode_lavc_ctx, vc->stream, vc->colorspace.format);
|
|
|
|
encode_lavc_set_csp_levels(vo->encode_lavc_ctx, vc->stream, vc->colorspace.levels_out);
|
|
|
|
|
|
|
|
if (encode_lavc_open_codec(vo->encode_lavc_ctx, vc->stream) < 0)
|
|
|
|
goto error;
|
|
|
|
|
2012-10-24 17:25:24 +00:00
|
|
|
vc->colorspace.format = encode_lavc_get_csp(vo->encode_lavc_ctx, vc->stream);
|
|
|
|
vc->colorspace.levels_out = encode_lavc_get_csp_levels(vo->encode_lavc_ctx, vc->stream);
|
|
|
|
|
2012-09-14 15:51:26 +00:00
|
|
|
vc->buffer_size = 6 * width * height + 200;
|
|
|
|
if (vc->buffer_size < FF_MIN_BUFFER_SIZE)
|
|
|
|
vc->buffer_size = FF_MIN_BUFFER_SIZE;
|
|
|
|
if (vc->buffer_size < sizeof(AVPicture))
|
|
|
|
vc->buffer_size = sizeof(AVPicture);
|
|
|
|
|
|
|
|
vc->buffer = talloc_size(vc, vc->buffer_size);
|
|
|
|
|
2012-12-22 20:46:28 +00:00
|
|
|
mp_image_unrefp(&vc->lastimg);
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
uninit(vo);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int query_format(struct vo *vo, uint32_t format)
|
|
|
|
{
|
|
|
|
enum PixelFormat pix_fmt = imgfmt2pixfmt(format);
|
|
|
|
|
|
|
|
if (!vo->encode_lavc_ctx)
|
|
|
|
return 0;
|
|
|
|
|
2012-10-24 17:25:24 +00:00
|
|
|
if (!encode_lavc_supports_pixfmt(vo->encode_lavc_ctx, pix_fmt))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return
|
|
|
|
VFCAP_CSP_SUPPORTED |
|
|
|
|
// we can do it
|
2013-03-01 10:16:01 +00:00
|
|
|
VFCAP_CSP_SUPPORTED_BY_HW;
|
VO, sub: refactor
Remove VFCTRL_DRAW_OSD, VFCAP_EOSD_FILTER, VFCAP_EOSD_RGBA, VFCAP_EOSD,
VOCTRL_DRAW_EOSD, VOCTRL_GET_EOSD_RES, VOCTRL_QUERY_EOSD_FORMAT.
Remove draw_osd_with_eosd(), which rendered the OSD by calling
VOCTRL_DRAW_EOSD. Change VOs to call osd_draw() directly, which takes
a callback as argument. (This basically works like the old OSD API,
except multiple OSD bitmap formats are supported and caching is
possible.)
Remove all mentions of "eosd". It's simply "osd" now.
Make OSD size per-OSD-object, as they can be different when using
vf_sub. Include display_par/video_par in resolution change detection.
Fix the issue with margin borders in vo_corevideo.
2012-10-19 17:25:18 +00:00
|
|
|
// we don't convert colorspaces here
|
2012-09-14 15:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void write_packet(struct vo *vo, int size, AVPacket *packet)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
|
|
|
|
if (size < 0) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_ERR, "vo-lavc: error encoding\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
packet->stream_index = vc->stream->index;
|
|
|
|
if (packet->pts != AV_NOPTS_VALUE) {
|
|
|
|
packet->pts = av_rescale_q(packet->pts,
|
|
|
|
vc->stream->codec->time_base,
|
|
|
|
vc->stream->time_base);
|
|
|
|
} else {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN, "vo-lavc: codec did not provide pts\n");
|
|
|
|
packet->pts = av_rescale_q(vc->lastipts, vc->worst_time_base,
|
|
|
|
vc->stream->time_base);
|
|
|
|
}
|
|
|
|
if (packet->dts != AV_NOPTS_VALUE) {
|
|
|
|
packet->dts = av_rescale_q(packet->dts,
|
|
|
|
vc->stream->codec->time_base,
|
|
|
|
vc->stream->time_base);
|
|
|
|
}
|
|
|
|
if (packet->duration > 0) {
|
|
|
|
packet->duration = av_rescale_q(packet->duration,
|
|
|
|
vc->stream->codec->time_base,
|
|
|
|
vc->stream->time_base);
|
|
|
|
} else {
|
|
|
|
// HACK: libavformat calculates dts wrong if the initial packet
|
|
|
|
// duration is not set, but ONLY if the time base is "high" and if we
|
|
|
|
// have b-frames!
|
|
|
|
if (!packet->duration)
|
|
|
|
if (!vc->have_first_packet)
|
|
|
|
if (vc->stream->codec->has_b_frames
|
|
|
|
|| vc->stream->codec->max_b_frames)
|
|
|
|
if (vc->stream->time_base.num * 1000LL <=
|
|
|
|
vc->stream->time_base.den)
|
|
|
|
packet->duration = FFMAX(1, av_rescale_q(1,
|
|
|
|
vc->stream->codec->time_base, vc->stream->time_base));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (encode_lavc_write_frame(vo->encode_lavc_ctx, packet) < 0) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_ERR, "vo-lavc: error writing\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
vc->have_first_packet = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int encode_video(struct vo *vo, AVFrame *frame, AVPacket *packet)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
if (encode_lavc_oformat_flags(vo->encode_lavc_ctx) & AVFMT_RAWPICTURE) {
|
|
|
|
if (!frame)
|
|
|
|
return 0;
|
|
|
|
memcpy(vc->buffer, frame, sizeof(AVPicture));
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_DBG2, "vo-lavc: got pts %f\n",
|
|
|
|
frame->pts * (double) vc->stream->codec->time_base.num /
|
|
|
|
(double) vc->stream->codec->time_base.den);
|
|
|
|
packet->size = sizeof(AVPicture);
|
|
|
|
return packet->size;
|
|
|
|
} else {
|
|
|
|
int got_packet = 0;
|
|
|
|
int status = avcodec_encode_video2(vc->stream->codec, packet,
|
|
|
|
frame, &got_packet);
|
|
|
|
int size = (status < 0) ? status : got_packet ? packet->size : 0;
|
|
|
|
|
|
|
|
if (frame)
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_DBG2, "vo-lavc: got pts %f; out size: %d\n",
|
|
|
|
frame->pts * (double) vc->stream->codec->time_base.num /
|
|
|
|
(double) vc->stream->codec->time_base.den, size);
|
|
|
|
|
|
|
|
encode_lavc_write_stats(vo->encode_lavc_ctx, vc->stream);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
static void draw_image(struct vo *vo, mp_image_t *mpi)
|
2012-09-14 15:51:26 +00:00
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
struct encode_lavc_context *ectx = vo->encode_lavc_ctx;
|
|
|
|
int i, size;
|
|
|
|
AVFrame *frame;
|
|
|
|
AVCodecContext *avc;
|
|
|
|
int64_t frameipts;
|
|
|
|
double nextpts;
|
|
|
|
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
double pts = mpi ? mpi->pts : MP_NOPTS_VALUE;
|
|
|
|
|
2012-09-14 15:51:26 +00:00
|
|
|
if (!vc)
|
|
|
|
return;
|
|
|
|
if (!encode_lavc_start(ectx)) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN, "vo-lavc: NOTE: skipped initial video frame (probably because audio is not there yet)\n");
|
|
|
|
return;
|
|
|
|
}
|
2012-09-25 09:53:29 +00:00
|
|
|
if (pts == MP_NOPTS_VALUE) {
|
|
|
|
if (mpi)
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN, "vo-lavc: frame without pts, please report; synthesizing pts instead\n");
|
|
|
|
pts = vc->expected_next_pts;
|
|
|
|
}
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
avc = vc->stream->codec;
|
|
|
|
|
|
|
|
if (vc->worst_time_base.den == 0) {
|
|
|
|
//if (avc->time_base.num / avc->time_base.den >= vc->stream->time_base.num / vc->stream->time_base.den)
|
|
|
|
if (avc->time_base.num * (double) vc->stream->time_base.den >=
|
|
|
|
vc->stream->time_base.num * (double) avc->time_base.den) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_V, "vo-lavc: NOTE: using codec time base "
|
|
|
|
"(%d/%d) for frame dropping; the stream base (%d/%d) is "
|
|
|
|
"not worse.\n", (int)avc->time_base.num,
|
|
|
|
(int)avc->time_base.den, (int)vc->stream->time_base.num,
|
|
|
|
(int)vc->stream->time_base.den);
|
|
|
|
vc->worst_time_base = avc->time_base;
|
|
|
|
vc->worst_time_base_is_stream = 0;
|
|
|
|
} else {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN, "vo-lavc: NOTE: not using codec time "
|
|
|
|
"base (%d/%d) for frame dropping; the stream base (%d/%d) "
|
|
|
|
"is worse.\n", (int)avc->time_base.num,
|
|
|
|
(int)avc->time_base.den, (int)vc->stream->time_base.num,
|
|
|
|
(int)vc->stream->time_base.den);
|
|
|
|
vc->worst_time_base = vc->stream->time_base;
|
|
|
|
vc->worst_time_base_is_stream = 1;
|
|
|
|
}
|
2013-06-09 13:37:28 +00:00
|
|
|
if (ectx->options->maxfps)
|
|
|
|
vc->mindeltapts = ceil(vc->worst_time_base.den /
|
|
|
|
(vc->worst_time_base.num * ectx->options->maxfps));
|
|
|
|
else
|
|
|
|
vc->mindeltapts = 0;
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
// NOTE: we use the following "axiom" of av_rescale_q:
|
|
|
|
// if time base A is worse than time base B, then
|
|
|
|
// av_rescale_q(av_rescale_q(x, A, B), B, A) == x
|
|
|
|
// this can be proven as long as av_rescale_q rounds to nearest, which
|
|
|
|
// it currently does
|
|
|
|
|
|
|
|
// av_rescale_q(x, A, B) * B = "round x*A to nearest multiple of B"
|
|
|
|
// and:
|
|
|
|
// av_rescale_q(av_rescale_q(x, A, B), B, A) * A
|
|
|
|
// == "round av_rescale_q(x, A, B)*B to nearest multiple of A"
|
|
|
|
// == "round 'round x*A to nearest multiple of B' to nearest multiple of A"
|
|
|
|
//
|
|
|
|
// assume this fails. Then there is a value of x*A, for which the
|
|
|
|
// nearest multiple of B is outside the range [(x-0.5)*A, (x+0.5)*A[.
|
|
|
|
// Absurd, as this range MUST contain at least one multiple of B.
|
|
|
|
}
|
|
|
|
|
|
|
|
double timeunit = (double)vc->worst_time_base.num / vc->worst_time_base.den;
|
|
|
|
|
2012-09-25 09:53:29 +00:00
|
|
|
double outpts;
|
|
|
|
if (ectx->options->rawts)
|
|
|
|
outpts = pts;
|
|
|
|
else if (ectx->options->copyts) {
|
|
|
|
// fix the discontinuity pts offset
|
2012-09-14 15:51:26 +00:00
|
|
|
nextpts = pts;
|
2012-09-25 09:53:29 +00:00
|
|
|
if (ectx->discontinuity_pts_offset == MP_NOPTS_VALUE) {
|
|
|
|
ectx->discontinuity_pts_offset = ectx->next_in_pts - nextpts;
|
|
|
|
}
|
|
|
|
else if (fabs(nextpts + ectx->discontinuity_pts_offset - ectx->next_in_pts) > 30) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_WARN,
|
|
|
|
"vo-lavc: detected an unexpected discontinuity (pts jumped by "
|
|
|
|
"%f seconds)\n",
|
|
|
|
nextpts + ectx->discontinuity_pts_offset - ectx->next_in_pts);
|
|
|
|
ectx->discontinuity_pts_offset = ectx->next_in_pts - nextpts;
|
|
|
|
}
|
2012-09-14 15:51:26 +00:00
|
|
|
|
2012-09-25 09:53:29 +00:00
|
|
|
outpts = pts + ectx->discontinuity_pts_offset;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// adjust pts by knowledge of audio pts vs audio playback time
|
|
|
|
double duration = 0;
|
|
|
|
if (ectx->last_video_in_pts != MP_NOPTS_VALUE)
|
|
|
|
duration = pts - ectx->last_video_in_pts;
|
|
|
|
if (duration < 0)
|
|
|
|
duration = timeunit; // XXX warn about discontinuity?
|
|
|
|
outpts = vc->lastpts + duration;
|
|
|
|
if (ectx->audio_pts_offset != MP_NOPTS_VALUE) {
|
|
|
|
double adj = outpts - pts - ectx->audio_pts_offset;
|
|
|
|
adj = FFMIN(adj, duration * 0.1);
|
|
|
|
adj = FFMAX(adj, -duration * 0.1);
|
|
|
|
outpts -= adj;
|
2012-09-14 15:51:26 +00:00
|
|
|
}
|
2012-09-25 09:53:29 +00:00
|
|
|
}
|
|
|
|
vc->lastpts = outpts;
|
|
|
|
ectx->last_video_in_pts = pts;
|
|
|
|
frameipts = floor((outpts + encode_lavc_getoffset(ectx, vc->stream))
|
|
|
|
/ timeunit + 0.5);
|
|
|
|
|
|
|
|
// calculate expected pts of next video frame
|
|
|
|
vc->expected_next_pts = pts + timeunit;
|
|
|
|
|
|
|
|
if (!ectx->options->rawts && ectx->options->copyts) {
|
|
|
|
// set next allowed output pts value
|
|
|
|
nextpts = vc->expected_next_pts + ectx->discontinuity_pts_offset;
|
|
|
|
if (nextpts > ectx->next_in_pts)
|
|
|
|
ectx->next_in_pts = nextpts;
|
2012-09-14 15:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// never-drop mode
|
|
|
|
if (ectx->options->neverdrop && frameipts <= vc->lastipts) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_INFO, "vo-lavc: -oneverdrop increased pts by %d\n",
|
|
|
|
(int) (vc->lastipts - frameipts + 1));
|
|
|
|
frameipts = vc->lastipts + 1;
|
|
|
|
vc->lastpts = frameipts * timeunit - encode_lavc_getoffset(ectx, vc->stream);
|
|
|
|
}
|
|
|
|
|
2013-06-09 13:37:28 +00:00
|
|
|
// lastipts: pts of last vo frame
|
|
|
|
// frameipts: pts of current vo frame
|
|
|
|
// lastframeipts: pts of last ENCODED frame
|
|
|
|
// now we want to go forward in time until at least lastframeipts + mindeltapts
|
|
|
|
// so let's just assume this frame took place at this time or later
|
2013-06-09 13:50:53 +00:00
|
|
|
if (frameipts > vc->lastframeipts && frameipts < vc->lastframeipts + vc->mindeltapts) {
|
2013-06-09 13:37:28 +00:00
|
|
|
frameipts = vc->lastframeipts + vc->mindeltapts;
|
|
|
|
vc->lastpts = frameipts * timeunit - encode_lavc_getoffset(ectx, vc->stream);
|
|
|
|
}
|
|
|
|
|
2012-09-14 15:51:26 +00:00
|
|
|
if (vc->lastipts != MP_NOPTS_VALUE) {
|
|
|
|
frame = avcodec_alloc_frame();
|
|
|
|
|
|
|
|
// we have a valid image in lastimg
|
|
|
|
while (vc->lastipts < frameipts) {
|
|
|
|
int64_t thisduration = vc->harddup ? 1 : (frameipts - vc->lastipts);
|
|
|
|
AVPacket packet;
|
|
|
|
|
|
|
|
avcodec_get_frame_defaults(frame);
|
|
|
|
|
|
|
|
// this is a nop, unless the worst time base is the STREAM time base
|
|
|
|
frame->pts = av_rescale_q(vc->lastipts, vc->worst_time_base,
|
|
|
|
avc->time_base);
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
frame->data[i] = vc->lastimg->planes[i];
|
|
|
|
frame->linesize[i] = vc->lastimg->stride[i];
|
|
|
|
}
|
|
|
|
frame->quality = avc->global_quality;
|
|
|
|
|
|
|
|
av_init_packet(&packet);
|
|
|
|
packet.data = vc->buffer;
|
|
|
|
packet.size = vc->buffer_size;
|
|
|
|
size = encode_video(vo, frame, &packet);
|
|
|
|
write_packet(vo, size, &packet);
|
|
|
|
|
|
|
|
vc->lastipts += thisduration;
|
|
|
|
++vc->lastdisplaycount;
|
|
|
|
}
|
|
|
|
|
2012-11-03 17:06:23 +00:00
|
|
|
avcodec_free_frame(&frame);
|
2012-09-14 15:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!mpi) {
|
|
|
|
// finish encoding
|
|
|
|
do {
|
|
|
|
AVPacket packet;
|
|
|
|
av_init_packet(&packet);
|
|
|
|
packet.data = vc->buffer;
|
|
|
|
packet.size = vc->buffer_size;
|
|
|
|
size = encode_video(vo, NULL, &packet);
|
|
|
|
write_packet(vo, size, &packet);
|
|
|
|
} while (size > 0);
|
|
|
|
} else {
|
|
|
|
if (frameipts >= vc->lastframeipts) {
|
|
|
|
if (vc->lastframeipts != MP_NOPTS_VALUE && vc->lastdisplaycount != 1)
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_INFO,
|
|
|
|
"vo-lavc: Frame at pts %d got displayed %d times\n",
|
|
|
|
(int) vc->lastframeipts, vc->lastdisplaycount);
|
2012-12-22 20:46:28 +00:00
|
|
|
mp_image_setrefp(&vc->lastimg, mpi);
|
2012-10-24 17:25:24 +00:00
|
|
|
vc->lastimg_wants_osd = true;
|
2012-09-14 15:51:26 +00:00
|
|
|
|
|
|
|
vc->lastframeipts = vc->lastipts = frameipts;
|
|
|
|
if (ectx->options->rawts && vc->lastipts < 0) {
|
|
|
|
mp_msg(MSGT_ENCODE, MSGL_ERR, "vo-lavc: why does this happen? DEBUG THIS! vc->lastipts = %lld\n", (long long) vc->lastipts);
|
|
|
|
vc->lastipts = -1;
|
|
|
|
}
|
|
|
|
vc->lastdisplaycount = 0;
|
2012-10-24 17:25:24 +00:00
|
|
|
} else {
|
2012-09-14 15:51:26 +00:00
|
|
|
mp_msg(MSGT_ENCODE, MSGL_INFO, "vo-lavc: Frame at pts %d got dropped "
|
|
|
|
"entirely because pts went backwards\n", (int) frameipts);
|
2012-10-24 17:25:24 +00:00
|
|
|
vc->lastimg_wants_osd = false;
|
|
|
|
}
|
2012-09-14 15:51:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-25 16:31:06 +00:00
|
|
|
static void flip_page_timed(struct vo *vo, int64_t pts_us, int duration)
|
2012-10-24 17:25:24 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2012-10-18 15:31:00 +00:00
|
|
|
static void draw_osd(struct vo *vo, struct osd_state *osd)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
|
|
|
|
if (vc->lastimg && vc->lastimg_wants_osd) {
|
|
|
|
struct aspect_data asp = vo->aspdat;
|
|
|
|
double sar = (double)asp.orgw / asp.orgh;
|
|
|
|
double dar = (double)asp.prew / asp.preh;
|
|
|
|
|
VO, sub: refactor
Remove VFCTRL_DRAW_OSD, VFCAP_EOSD_FILTER, VFCAP_EOSD_RGBA, VFCAP_EOSD,
VOCTRL_DRAW_EOSD, VOCTRL_GET_EOSD_RES, VOCTRL_QUERY_EOSD_FORMAT.
Remove draw_osd_with_eosd(), which rendered the OSD by calling
VOCTRL_DRAW_EOSD. Change VOs to call osd_draw() directly, which takes
a callback as argument. (This basically works like the old OSD API,
except multiple OSD bitmap formats are supported and caching is
possible.)
Remove all mentions of "eosd". It's simply "osd" now.
Make OSD size per-OSD-object, as they can be different when using
vf_sub. Include display_par/video_par in resolution change detection.
Fix the issue with margin borders in vo_corevideo.
2012-10-19 17:25:18 +00:00
|
|
|
struct mp_osd_res dim = {
|
|
|
|
.w = asp.orgw,
|
|
|
|
.h = asp.orgh,
|
|
|
|
.display_par = sar / dar,
|
|
|
|
.video_par = dar / sar,
|
2012-10-18 15:31:00 +00:00
|
|
|
};
|
|
|
|
|
2012-10-27 16:06:09 +00:00
|
|
|
mp_image_set_colorspace_details(vc->lastimg, &vc->colorspace);
|
|
|
|
|
|
|
|
osd_draw_on_image(osd, dim, osd->vo_pts, OSD_DRAW_SUB_ONLY, vc->lastimg);
|
2012-10-18 15:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-14 15:51:26 +00:00
|
|
|
static int control(struct vo *vo, uint32_t request, void *data)
|
|
|
|
{
|
|
|
|
struct priv *vc = vo->priv;
|
|
|
|
switch (request) {
|
|
|
|
case VOCTRL_SET_YUV_COLORSPACE:
|
|
|
|
vc->colorspace = *(struct mp_csp_details *)data;
|
|
|
|
if (vc->stream) {
|
|
|
|
encode_lavc_set_csp(vo->encode_lavc_ctx, vc->stream, vc->colorspace.format);
|
|
|
|
encode_lavc_set_csp_levels(vo->encode_lavc_ctx, vc->stream, vc->colorspace.levels_out);
|
|
|
|
vc->colorspace.format = encode_lavc_get_csp(vo->encode_lavc_ctx, vc->stream);
|
|
|
|
vc->colorspace.levels_out = encode_lavc_get_csp_levels(vo->encode_lavc_ctx, vc->stream);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
case VOCTRL_GET_YUV_COLORSPACE:
|
|
|
|
*(struct mp_csp_details *)data = vc->colorspace;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return VO_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct vo_driver video_out_lavc = {
|
|
|
|
.buffer_frames = false,
|
2013-02-06 21:54:03 +00:00
|
|
|
.encode = true,
|
2012-09-14 15:51:26 +00:00
|
|
|
.info = &(const struct vo_info_s){
|
|
|
|
"video encoding using libavcodec",
|
|
|
|
"lavc",
|
|
|
|
"Nicolas George <george@nsup.org>, Rudolf Polzer <divVerent@xonotic.org>",
|
|
|
|
""
|
|
|
|
},
|
|
|
|
.preinit = preinit,
|
2012-11-04 15:24:18 +00:00
|
|
|
.query_format = query_format,
|
2012-09-14 15:51:26 +00:00
|
|
|
.config = config,
|
|
|
|
.control = control,
|
|
|
|
.uninit = uninit,
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
.draw_image = draw_image,
|
2012-10-18 15:31:00 +00:00
|
|
|
.draw_osd = draw_osd,
|
2012-09-14 15:51:26 +00:00
|
|
|
.flip_page_timed = flip_page_timed,
|
|
|
|
};
|
|
|
|
|
2012-10-24 17:25:24 +00:00
|
|
|
// vim: sw=4 ts=4 et tw=80
|