2010-01-30 16:57:40 +00:00
|
|
|
/*
|
2015-04-13 07:36:54 +00:00
|
|
|
* This file is part of mpv.
|
2010-01-30 16:57:40 +00:00
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is free software; you can redistribute it and/or modify
|
2010-01-30 16:57:40 +00:00
|
|
|
* 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.
|
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is distributed in the hope that it will be useful,
|
2010-01-30 16:57:40 +00:00
|
|
|
* 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
|
2015-04-13 07:36:54 +00:00
|
|
|
* with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2010-01-30 16:57:40 +00:00
|
|
|
*/
|
|
|
|
|
2002-03-06 20:54:43 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <assert.h>
|
2002-07-28 15:54:26 +00:00
|
|
|
#include <time.h>
|
2010-01-20 14:31:13 +00:00
|
|
|
#include <stdbool.h>
|
2012-07-31 21:37:56 +00:00
|
|
|
#include <sys/types.h>
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2012-01-28 11:41:36 +00:00
|
|
|
#include <libavutil/common.h>
|
|
|
|
#include <libavutil/opt.h>
|
2012-02-01 18:01:16 +00:00
|
|
|
#include <libavutil/intreadwrite.h>
|
2012-12-11 17:16:42 +00:00
|
|
|
#include <libavutil/pixdesc.h>
|
2012-01-28 11:41:36 +00:00
|
|
|
|
2010-10-16 01:33:38 +00:00
|
|
|
#include "talloc.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
#include "config.h"
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/msg.h"
|
2013-12-17 01:02:25 +00:00
|
|
|
#include "options/options.h"
|
2014-08-29 10:09:04 +00:00
|
|
|
#include "misc/bstr.h"
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/av_common.h"
|
|
|
|
#include "common/codecs.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/fmt-conversion.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2009-11-21 18:53:10 +00:00
|
|
|
#include "vd.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/img_format.h"
|
2012-11-04 16:17:11 +00:00
|
|
|
#include "video/filter/vf.h"
|
2013-11-03 23:00:18 +00:00
|
|
|
#include "video/decode/dec_video.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "demux/stheader.h"
|
2013-11-18 17:46:44 +00:00
|
|
|
#include "demux/packet.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/csputils.h"
|
2015-02-06 22:20:41 +00:00
|
|
|
#include "video/sws_utils.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2012-12-11 17:27:34 +00:00
|
|
|
#include "lavc.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
mp_image: simplify image allocation
mp_image_alloc_planes() allocated images with minimal stride, even if
the resulting stride was unaligned. It was the responsibility of
vf_get_image() to set an image's width to something larger than
required to get an aligned stride, and then crop it. Always allocate
with aligned strides instead.
Get rid of IMGFMT_IF09 special handling. This format is not used
anymore. (IF09 has 4x4 chroma sub-sampling, and that is what it was
mainly used for - this is still supported.) Get rid of swapped chroma
plane allocation. This is not used anywhere, and VOs like vo_xv,
vo_direct3d and vo_sdl do their own swapping.
Always round chroma width/height up instead of down. Consider 4:2:0 and
an uneven image size. For luma, the size was left uneven, and the chroma
size was rounded down. This doesn't make sense, because chroma would be
missing for the bottom/right border.
Remove mp_image_new_empty() and mp_image_alloc_planes(), they were not
used anymore, except in draw_bmp.c. (It's still allowed to setup
mp_images manually, you just can't allocate image data with them
anymore - this is also done in draw_bmp.c.)
2012-12-19 11:04:32 +00:00
|
|
|
#if AVPALETTE_SIZE != MP_PALETTE_SIZE
|
|
|
|
#error palette too large, adapt video/mp_image.h:MP_PALETTE_SIZE
|
2009-12-26 11:51:19 +00:00
|
|
|
#endif
|
|
|
|
|
2013-12-17 01:02:25 +00:00
|
|
|
#include "options/m_option.h"
|
2002-06-02 12:48:55 +00:00
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static void init_avctx(struct dec_video *vd, const char *decoder,
|
2013-08-11 21:23:12 +00:00
|
|
|
struct vd_lavc_hwdec *hwdec);
|
2013-11-23 20:36:20 +00:00
|
|
|
static void uninit_avctx(struct dec_video *vd);
|
2002-07-16 00:56:12 +00:00
|
|
|
|
2014-03-16 08:21:21 +00:00
|
|
|
static int get_buffer2_hwdec(AVCodecContext *avctx, AVFrame *pic, int flags);
|
2013-11-29 16:39:57 +00:00
|
|
|
static enum AVPixelFormat get_format_hwdec(struct AVCodecContext *avctx,
|
|
|
|
const enum AVPixelFormat *pix_fmt);
|
2012-11-06 14:27:44 +00:00
|
|
|
|
2014-06-10 23:35:39 +00:00
|
|
|
#define OPT_BASE_STRUCT struct vd_lavc_params
|
|
|
|
|
|
|
|
struct vd_lavc_params {
|
|
|
|
int fast;
|
|
|
|
int show_all;
|
2014-06-13 00:03:45 +00:00
|
|
|
int skip_loop_filter;
|
|
|
|
int skip_idct;
|
|
|
|
int skip_frame;
|
2014-08-08 22:35:25 +00:00
|
|
|
int framedrop;
|
2014-06-10 23:35:39 +00:00
|
|
|
int threads;
|
|
|
|
int bitexact;
|
|
|
|
int check_hw_profile;
|
2014-08-02 01:12:09 +00:00
|
|
|
char **avopts;
|
2014-06-10 23:35:39 +00:00
|
|
|
};
|
|
|
|
|
2014-06-13 00:03:45 +00:00
|
|
|
static const struct m_opt_choice_alternatives discard_names[] = {
|
|
|
|
{"none", AVDISCARD_NONE},
|
|
|
|
{"default", AVDISCARD_DEFAULT},
|
|
|
|
{"nonref", AVDISCARD_NONREF},
|
|
|
|
{"bidir", AVDISCARD_BIDIR},
|
|
|
|
{"nonkey", AVDISCARD_NONKEY},
|
|
|
|
{"all", AVDISCARD_ALL},
|
|
|
|
{0}
|
|
|
|
};
|
|
|
|
#define OPT_DISCARD(name, field, flags) \
|
|
|
|
OPT_GENERAL(int, name, field, flags, .type = CONF_TYPE_CHOICE, \
|
|
|
|
.priv = (void *)discard_names)
|
|
|
|
|
2014-06-10 23:35:39 +00:00
|
|
|
const struct m_sub_options vd_lavc_conf = {
|
|
|
|
.opts = (const m_option_t[]){
|
2014-06-13 00:08:48 +00:00
|
|
|
OPT_FLAG("fast", fast, 0),
|
2014-06-10 23:35:39 +00:00
|
|
|
OPT_FLAG("show-all", show_all, 0),
|
2014-06-13 00:03:45 +00:00
|
|
|
OPT_DISCARD("skiploopfilter", skip_loop_filter, 0),
|
|
|
|
OPT_DISCARD("skipidct", skip_idct, 0),
|
|
|
|
OPT_DISCARD("skipframe", skip_frame, 0),
|
2014-08-08 22:35:25 +00:00
|
|
|
OPT_DISCARD("framedrop", framedrop, 0),
|
2015-07-23 15:17:26 +00:00
|
|
|
OPT_INT("threads", threads, M_OPT_MIN, .min = 0),
|
2014-06-13 00:08:48 +00:00
|
|
|
OPT_FLAG("bitexact", bitexact, 0),
|
2014-06-10 23:35:39 +00:00
|
|
|
OPT_FLAG("check-hw-profile", check_hw_profile, 0),
|
2014-08-02 01:12:09 +00:00
|
|
|
OPT_KEYVALUELIST("o", avopts, 0),
|
2014-06-10 23:35:39 +00:00
|
|
|
{0}
|
|
|
|
},
|
|
|
|
.size = sizeof(struct vd_lavc_params),
|
|
|
|
.defaults = &(const struct vd_lavc_params){
|
|
|
|
.show_all = 0,
|
|
|
|
.check_hw_profile = 1,
|
2014-06-13 00:03:45 +00:00
|
|
|
.skip_loop_filter = AVDISCARD_DEFAULT,
|
|
|
|
.skip_idct = AVDISCARD_DEFAULT,
|
|
|
|
.skip_frame = AVDISCARD_DEFAULT,
|
2014-08-08 22:35:25 +00:00
|
|
|
.framedrop = AVDISCARD_NONREF,
|
2014-06-10 23:35:39 +00:00
|
|
|
},
|
2002-06-02 12:48:55 +00:00
|
|
|
};
|
|
|
|
|
2013-08-11 21:23:12 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_vdpau;
|
2013-08-14 13:47:18 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_vda;
|
2015-07-11 15:21:39 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_videotoolbox;
|
video: add vaapi decode and output support
This is based on the MPlayer VA API patches. To be exact it's based on
a very stripped down version of commit f1ad459a263f8537f6c from
git://gitorious.org/vaapi/mplayer.git.
This doesn't contain useless things like benchmarking hacks and the
demo code for GLX interop. Also, unlike in the original patch, decoding
and video output are split into separate source files (the separation
between decoding and display also makes pixel format hacks unnecessary).
On the other hand, some features not present in the original patch were
added, like screenshot support.
VA API is rather bad for actual video output. Dealing with older libva
versions or the completely broken vdpau backend doesn't help. OSD is
low quality and should be rather slow. In some cases, only either OSD
or subtitles can be shown at the same time (because OSD is drawn first,
OSD is prefered).
Also, libva can't decide whether it accepts straight or premultiplied
alpha for OSD sub-pictures: the vdpau backend seems to assume
premultiplied, while a native vaapi driver uses straight. So I picked
straight alpha. It doesn't matter much, because the blending code for
straight alpha I added to img_convert.c is probably buggy, and ASS
subtitles might be blended incorrectly.
Really good video output with VA API would probably use OpenGL and the
GL interop features, but at this point you might just use vo_opengl.
(Patches for making HW decoding with vo_opengl have a chance of being
accepted.)
Despite these issues, decoding seems to work ok. I still got tearing
on the Intel system I tested (Intel(R) Core(TM) i3-2350M). It was also
tested with the vdpau vaapi wrapper on a nvidia system; however this
was rather broken. (Fortunately, there is no reason to use mpv's VAAPI
support over native VDPAU.)
2013-08-09 12:01:30 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_vaapi;
|
2013-09-22 20:47:50 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_vaapi_copy;
|
2014-10-25 17:23:46 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_dxva2_copy;
|
2015-03-29 13:12:11 +00:00
|
|
|
const struct vd_lavc_hwdec mp_vd_lavc_rpi;
|
2013-08-11 21:23:12 +00:00
|
|
|
|
2014-06-10 21:56:05 +00:00
|
|
|
static const struct vd_lavc_hwdec *const hwdec_list[] = {
|
2015-03-29 13:12:11 +00:00
|
|
|
#if HAVE_RPI
|
|
|
|
&mp_vd_lavc_rpi,
|
|
|
|
#endif
|
2013-07-16 11:28:28 +00:00
|
|
|
#if HAVE_VDPAU_HWACCEL
|
2013-08-11 21:23:12 +00:00
|
|
|
&mp_vd_lavc_vdpau,
|
2013-07-16 11:28:28 +00:00
|
|
|
#endif
|
2015-07-11 15:21:39 +00:00
|
|
|
#if HAVE_VIDEOTOOLBOX_HWACCEL
|
|
|
|
&mp_vd_lavc_videotoolbox,
|
|
|
|
#endif
|
2013-07-16 11:28:28 +00:00
|
|
|
#if HAVE_VDA_HWACCEL
|
2013-08-11 21:23:12 +00:00
|
|
|
&mp_vd_lavc_vda,
|
2013-08-14 13:47:18 +00:00
|
|
|
#endif
|
2013-07-16 11:28:28 +00:00
|
|
|
#if HAVE_VAAPI_HWACCEL
|
2015-03-05 12:02:30 +00:00
|
|
|
&mp_vd_lavc_vaapi,
|
2015-06-29 13:14:38 +00:00
|
|
|
&mp_vd_lavc_vaapi_copy,
|
2014-10-25 17:23:46 +00:00
|
|
|
#endif
|
|
|
|
#if HAVE_DXVA2_HWACCEL
|
|
|
|
&mp_vd_lavc_dxva2_copy,
|
video: add vaapi decode and output support
This is based on the MPlayer VA API patches. To be exact it's based on
a very stripped down version of commit f1ad459a263f8537f6c from
git://gitorious.org/vaapi/mplayer.git.
This doesn't contain useless things like benchmarking hacks and the
demo code for GLX interop. Also, unlike in the original patch, decoding
and video output are split into separate source files (the separation
between decoding and display also makes pixel format hacks unnecessary).
On the other hand, some features not present in the original patch were
added, like screenshot support.
VA API is rather bad for actual video output. Dealing with older libva
versions or the completely broken vdpau backend doesn't help. OSD is
low quality and should be rather slow. In some cases, only either OSD
or subtitles can be shown at the same time (because OSD is drawn first,
OSD is prefered).
Also, libva can't decide whether it accepts straight or premultiplied
alpha for OSD sub-pictures: the vdpau backend seems to assume
premultiplied, while a native vaapi driver uses straight. So I picked
straight alpha. It doesn't matter much, because the blending code for
straight alpha I added to img_convert.c is probably buggy, and ASS
subtitles might be blended incorrectly.
Really good video output with VA API would probably use OpenGL and the
GL interop features, but at this point you might just use vo_opengl.
(Patches for making HW decoding with vo_opengl have a chance of being
accepted.)
Despite these issues, decoding seems to work ok. I still got tearing
on the Intel system I tested (Intel(R) Core(TM) i3-2350M). It was also
tested with the vdpau vaapi wrapper on a nvidia system; however this
was rather broken. (Fortunately, there is no reason to use mpv's VAAPI
support over native VDPAU.)
2013-08-09 12:01:30 +00:00
|
|
|
#endif
|
2013-08-11 21:23:12 +00:00
|
|
|
NULL
|
2012-12-11 17:16:42 +00:00
|
|
|
};
|
|
|
|
|
2013-08-11 21:23:12 +00:00
|
|
|
static struct vd_lavc_hwdec *find_hwcodec(enum hwdec_type api)
|
2012-12-11 17:16:42 +00:00
|
|
|
{
|
2013-08-11 21:23:12 +00:00
|
|
|
for (int n = 0; hwdec_list[n]; n++) {
|
|
|
|
if (hwdec_list[n]->type == api)
|
|
|
|
return (struct vd_lavc_hwdec *)hwdec_list[n];
|
2012-12-11 17:16:42 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static bool hwdec_codec_allowed(struct dec_video *vd, const char *codec)
|
2013-05-03 19:00:05 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
bstr s = bstr0(vd->opts->hwdec_codecs);
|
2013-05-03 19:00:05 +00:00
|
|
|
while (s.len) {
|
|
|
|
bstr item;
|
|
|
|
bstr_split_tok(s, ",", &item, &s);
|
2013-08-11 21:23:12 +00:00
|
|
|
if (bstr_equals0(item, "all") || bstr_equals0(item, codec))
|
2013-05-03 19:00:05 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-08-21 20:04:25 +00:00
|
|
|
static void hwdec_lock(struct lavc_ctx *ctx)
|
|
|
|
{
|
|
|
|
if (ctx->hwdec && ctx->hwdec->lock)
|
|
|
|
ctx->hwdec->lock(ctx);
|
|
|
|
}
|
|
|
|
static void hwdec_unlock(struct lavc_ctx *ctx)
|
|
|
|
{
|
|
|
|
if (ctx->hwdec && ctx->hwdec->unlock)
|
|
|
|
ctx->hwdec->unlock(ctx);
|
|
|
|
}
|
|
|
|
|
2013-11-01 16:14:05 +00:00
|
|
|
// Find the correct profile entry for the current codec and profile.
|
|
|
|
// Assumes the table has higher profiles first (for each codec).
|
|
|
|
const struct hwdec_profile_entry *hwdec_find_profile(
|
|
|
|
struct lavc_ctx *ctx, const struct hwdec_profile_entry *table)
|
|
|
|
{
|
|
|
|
assert(AV_CODEC_ID_NONE == 0);
|
2014-06-10 23:35:39 +00:00
|
|
|
struct vd_lavc_params *lavc_param = ctx->opts->vd_lavc_params;
|
2013-11-01 16:14:05 +00:00
|
|
|
enum AVCodecID codec = ctx->avctx->codec_id;
|
|
|
|
int profile = ctx->avctx->profile;
|
|
|
|
// Assume nobody cares about these aspects of the profile
|
2013-11-14 18:24:20 +00:00
|
|
|
if (codec == AV_CODEC_ID_H264) {
|
|
|
|
if (profile == FF_PROFILE_H264_CONSTRAINED_BASELINE)
|
|
|
|
profile = FF_PROFILE_H264_MAIN;
|
|
|
|
}
|
2013-11-01 16:14:05 +00:00
|
|
|
for (int n = 0; table[n].av_codec; n++) {
|
|
|
|
if (table[n].av_codec == codec) {
|
|
|
|
if (table[n].ff_profile == FF_PROFILE_UNKNOWN ||
|
|
|
|
profile == FF_PROFILE_UNKNOWN ||
|
|
|
|
table[n].ff_profile == profile ||
|
|
|
|
!lavc_param->check_hw_profile)
|
|
|
|
return &table[n];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check codec support, without checking the profile.
|
|
|
|
bool hwdec_check_codec_support(const char *decoder,
|
|
|
|
const struct hwdec_profile_entry *table)
|
|
|
|
{
|
|
|
|
enum AVCodecID codec = mp_codec_to_av_codec_id(decoder);
|
|
|
|
for (int n = 0; table[n].av_codec; n++) {
|
|
|
|
if (table[n].av_codec == codec)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hwdec_get_max_refs(struct lavc_ctx *ctx)
|
|
|
|
{
|
2015-08-24 21:02:40 +00:00
|
|
|
if (ctx->avctx->codec_id == AV_CODEC_ID_H264 ||
|
|
|
|
ctx->avctx->codec_id == AV_CODEC_ID_HEVC)
|
|
|
|
return 16;
|
|
|
|
return 2;
|
2013-11-01 16:14:05 +00:00
|
|
|
}
|
|
|
|
|
2013-11-03 23:00:18 +00:00
|
|
|
void hwdec_request_api(struct mp_hwdec_info *info, const char *api_name)
|
|
|
|
{
|
|
|
|
if (info && info->load_api)
|
|
|
|
info->load_api(info, api_name);
|
|
|
|
}
|
|
|
|
|
2013-08-11 21:23:12 +00:00
|
|
|
static int hwdec_probe(struct vd_lavc_hwdec *hwdec, struct mp_hwdec_info *info,
|
2014-03-16 08:21:21 +00:00
|
|
|
const char *decoder)
|
2013-08-11 21:23:12 +00:00
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
if (hwdec->probe)
|
|
|
|
r = hwdec->probe(hwdec, info, decoder);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-03-16 08:21:21 +00:00
|
|
|
static struct vd_lavc_hwdec *probe_hwdec(struct dec_video *vd, bool autoprobe,
|
|
|
|
enum hwdec_type api,
|
|
|
|
const char *decoder)
|
2013-08-11 21:23:12 +00:00
|
|
|
{
|
|
|
|
struct vd_lavc_hwdec *hwdec = find_hwcodec(api);
|
|
|
|
if (!hwdec) {
|
2014-05-27 23:37:53 +00:00
|
|
|
MP_VERBOSE(vd, "Requested hardware decoder not compiled.\n");
|
2014-03-16 08:21:21 +00:00
|
|
|
return NULL;
|
2013-08-11 21:23:12 +00:00
|
|
|
}
|
2014-08-11 21:08:35 +00:00
|
|
|
int r = hwdec_probe(hwdec, vd->hwdec_info, decoder);
|
2014-05-27 23:37:53 +00:00
|
|
|
if (r == HWDEC_ERR_EMULATED) {
|
|
|
|
if (autoprobe)
|
|
|
|
return NULL;
|
|
|
|
// User requested this explicitly.
|
|
|
|
MP_WARN(vd, "Using emulated hardware decoding API.\n");
|
|
|
|
r = 0;
|
|
|
|
}
|
2013-08-11 21:23:12 +00:00
|
|
|
if (r >= 0) {
|
2014-03-16 08:21:21 +00:00
|
|
|
return hwdec;
|
2013-08-11 21:23:12 +00:00
|
|
|
} else if (r == HWDEC_ERR_NO_CODEC) {
|
2015-06-20 20:26:57 +00:00
|
|
|
MP_VERBOSE(vd, "Hardware decoder '%s' not found in libavcodec.\n",
|
|
|
|
decoder);
|
2013-08-11 21:23:12 +00:00
|
|
|
} else if (r == HWDEC_ERR_NO_CTX && !autoprobe) {
|
2015-06-20 20:26:57 +00:00
|
|
|
MP_WARN(vd, "VO does not support requested hardware decoder, or "
|
|
|
|
"loading it failed.\n");
|
2013-08-11 21:23:12 +00:00
|
|
|
}
|
2014-03-16 08:21:21 +00:00
|
|
|
return NULL;
|
2013-08-11 21:23:12 +00:00
|
|
|
}
|
|
|
|
|
2014-09-29 18:37:12 +00:00
|
|
|
static void uninit(struct dec_video *vd)
|
|
|
|
{
|
|
|
|
uninit_avctx(vd);
|
|
|
|
talloc_free(vd->priv);
|
|
|
|
}
|
2013-08-11 21:23:12 +00:00
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static int init(struct dec_video *vd, const char *decoder)
|
2011-10-22 00:51:37 +00:00
|
|
|
{
|
2002-03-23 17:29:35 +00:00
|
|
|
vd_ffmpeg_ctx *ctx;
|
2013-11-23 20:36:20 +00:00
|
|
|
ctx = vd->priv = talloc_zero(NULL, vd_ffmpeg_ctx);
|
2013-12-21 16:47:38 +00:00
|
|
|
ctx->log = vd->log;
|
2013-11-23 20:36:20 +00:00
|
|
|
ctx->opts = vd->opts;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
if (bstr_endswith0(bstr0(decoder), "_vdpau")) {
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_WARN(vd, "VDPAU decoder '%s' was requested. "
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
"This way of enabling hardware\ndecoding is not supported "
|
|
|
|
"anymore. Use --hwdec=vdpau instead.\nThe --hwdec-codec=... "
|
|
|
|
"option can be used to restrict which codecs are\nenabled, "
|
|
|
|
"otherwise all hardware decoding is tried for all codecs.\n",
|
|
|
|
decoder);
|
2013-11-23 20:36:20 +00:00
|
|
|
uninit(vd);
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-11 21:23:12 +00:00
|
|
|
struct vd_lavc_hwdec *hwdec = NULL;
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
if (hwdec_codec_allowed(vd, decoder)) {
|
|
|
|
if (vd->opts->hwdec_api == HWDEC_AUTO) {
|
2013-08-11 21:23:12 +00:00
|
|
|
for (int n = 0; hwdec_list[n]; n++) {
|
2014-03-16 08:21:21 +00:00
|
|
|
hwdec = probe_hwdec(vd, true, hwdec_list[n]->type, decoder);
|
|
|
|
if (hwdec)
|
2013-08-11 21:23:12 +00:00
|
|
|
break;
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
}
|
2013-11-23 20:36:20 +00:00
|
|
|
} else if (vd->opts->hwdec_api != HWDEC_NONE) {
|
2014-03-16 08:21:21 +00:00
|
|
|
hwdec = probe_hwdec(vd, false, vd->opts->hwdec_api, decoder);
|
2012-12-11 17:16:42 +00:00
|
|
|
}
|
2013-08-11 21:23:12 +00:00
|
|
|
} else {
|
2015-03-20 21:14:14 +00:00
|
|
|
MP_VERBOSE(vd, "Not trying to use hardware decoding: codec %s is not "
|
|
|
|
"on whitelist, or does not support hardware acceleration.\n",
|
|
|
|
decoder);
|
2013-08-11 21:23:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hwdec) {
|
|
|
|
ctx->software_fallback_decoder = talloc_strdup(ctx, decoder);
|
2015-03-29 13:12:11 +00:00
|
|
|
if (hwdec->get_codec)
|
|
|
|
decoder = hwdec->get_codec(ctx);
|
2015-03-17 21:33:31 +00:00
|
|
|
MP_INFO(vd, "Using hardware decoding.\n");
|
2013-11-23 20:36:20 +00:00
|
|
|
} else if (vd->opts->hwdec_api != HWDEC_NONE) {
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_INFO(vd, "Using software decoding.\n");
|
2012-12-11 17:16:42 +00:00
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
init_avctx(vd, decoder, hwdec);
|
2013-04-27 11:36:09 +00:00
|
|
|
if (!ctx->avctx) {
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
if (ctx->software_fallback_decoder) {
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_ERR(vd, "Error initializing hardware decoding, "
|
|
|
|
"falling back to software decoding.\n");
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
decoder = ctx->software_fallback_decoder;
|
|
|
|
ctx->software_fallback_decoder = NULL;
|
2013-11-23 20:36:20 +00:00
|
|
|
init_avctx(vd, decoder, NULL);
|
2013-04-27 11:36:09 +00:00
|
|
|
}
|
|
|
|
if (!ctx->avctx) {
|
2013-11-23 20:36:20 +00:00
|
|
|
uninit(vd);
|
2013-04-27 11:36:09 +00:00
|
|
|
return 0;
|
2012-12-11 17:16:42 +00:00
|
|
|
}
|
|
|
|
}
|
2014-05-27 14:45:19 +00:00
|
|
|
|
2012-12-11 17:16:42 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static void init_avctx(struct dec_video *vd, const char *decoder,
|
2013-08-11 21:23:12 +00:00
|
|
|
struct vd_lavc_hwdec *hwdec)
|
2012-12-11 17:16:42 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2014-06-10 23:35:39 +00:00
|
|
|
struct vd_lavc_params *lavc_param = vd->opts->vd_lavc_params;
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
bool mp_rawvideo = false;
|
2013-11-23 20:36:20 +00:00
|
|
|
struct sh_stream *sh = vd->header;
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
|
2013-04-27 11:36:09 +00:00
|
|
|
assert(!ctx->avctx);
|
|
|
|
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
if (strcmp(decoder, "mp-rawvideo") == 0) {
|
|
|
|
mp_rawvideo = true;
|
|
|
|
decoder = "rawvideo";
|
|
|
|
}
|
2012-12-11 17:16:42 +00:00
|
|
|
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
AVCodec *lavc_codec = avcodec_find_decoder_by_name(decoder);
|
|
|
|
if (!lavc_codec)
|
2013-04-27 11:36:09 +00:00
|
|
|
return;
|
2012-07-24 06:01:47 +00:00
|
|
|
|
2014-08-11 21:08:35 +00:00
|
|
|
ctx->hwdec_info = vd->hwdec_info;
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
|
2013-11-29 16:39:57 +00:00
|
|
|
ctx->pix_fmt = AV_PIX_FMT_NONE;
|
2012-12-11 17:16:42 +00:00
|
|
|
ctx->hwdec = hwdec;
|
2014-03-10 21:36:23 +00:00
|
|
|
ctx->hwdec_fmt = 0;
|
2012-01-28 11:41:36 +00:00
|
|
|
ctx->avctx = avcodec_alloc_context3(lavc_codec);
|
2012-12-11 17:16:42 +00:00
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2014-12-12 16:28:22 +00:00
|
|
|
if (!ctx->avctx)
|
2014-12-13 21:00:42 +00:00
|
|
|
goto error;
|
2013-11-23 20:36:20 +00:00
|
|
|
avctx->opaque = vd;
|
2011-04-19 23:59:45 +00:00
|
|
|
avctx->codec_type = AVMEDIA_TYPE_VIDEO;
|
2009-09-23 19:21:38 +00:00
|
|
|
avctx->codec_id = lavc_codec->id;
|
2002-07-16 00:56:12 +00:00
|
|
|
|
2013-10-31 17:12:39 +00:00
|
|
|
avctx->refcounted_frames = 1;
|
|
|
|
ctx->pic = av_frame_alloc();
|
2014-12-12 16:28:22 +00:00
|
|
|
if (!ctx->pic)
|
2014-12-13 21:00:42 +00:00
|
|
|
goto error;
|
2013-10-31 17:12:39 +00:00
|
|
|
|
2013-12-04 19:58:06 +00:00
|
|
|
if (ctx->hwdec) {
|
2012-11-05 22:57:02 +00:00
|
|
|
avctx->thread_count = 1;
|
2013-12-04 19:58:06 +00:00
|
|
|
avctx->get_format = get_format_hwdec;
|
2015-03-29 13:12:11 +00:00
|
|
|
if (ctx->hwdec->allocate_image)
|
|
|
|
avctx->get_buffer2 = get_buffer2_hwdec;
|
2014-12-13 21:00:42 +00:00
|
|
|
if (ctx->hwdec->init(ctx) < 0)
|
|
|
|
goto error;
|
2013-03-09 19:21:12 +00:00
|
|
|
} else {
|
2015-01-05 11:17:55 +00:00
|
|
|
mp_set_avcodec_threads(vd->log, avctx, lavc_param->threads);
|
2010-12-20 03:53:28 +00:00
|
|
|
}
|
2002-09-06 22:53:26 +00:00
|
|
|
|
2014-06-13 00:08:48 +00:00
|
|
|
avctx->flags |= lavc_param->bitexact ? CODEC_FLAG_BITEXACT : 0;
|
|
|
|
avctx->flags2 |= lavc_param->fast ? CODEC_FLAG2_FAST : 0;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2013-12-29 13:07:08 +00:00
|
|
|
if (lavc_param->show_all) {
|
|
|
|
#ifdef CODEC_FLAG2_SHOW_ALL
|
|
|
|
avctx->flags2 |= CODEC_FLAG2_SHOW_ALL; // ffmpeg only?
|
|
|
|
#endif
|
|
|
|
#ifdef CODEC_FLAG_OUTPUT_CORRUPT
|
|
|
|
avctx->flags |= CODEC_FLAG_OUTPUT_CORRUPT; // added with Libav 10
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-06-13 00:03:45 +00:00
|
|
|
avctx->skip_loop_filter = lavc_param->skip_loop_filter;
|
|
|
|
avctx->skip_idct = lavc_param->skip_idct;
|
|
|
|
avctx->skip_frame = lavc_param->skip_frame;
|
2008-05-10 18:55:31 +00:00
|
|
|
|
2014-08-02 01:12:09 +00:00
|
|
|
mp_set_avopts(vd->log, avctx, lavc_param->avopts);
|
2008-05-10 18:55:31 +00:00
|
|
|
|
2011-07-09 10:50:16 +00:00
|
|
|
// Do this after the above avopt handling in case it changes values
|
|
|
|
ctx->skip_frame = avctx->skip_frame;
|
|
|
|
|
2015-06-21 14:56:35 +00:00
|
|
|
avctx->codec_tag = sh->codec_tag;
|
2013-11-23 20:36:20 +00:00
|
|
|
avctx->coded_width = sh->video->disp_w;
|
|
|
|
avctx->coded_height = sh->video->disp_h;
|
2014-09-24 22:59:15 +00:00
|
|
|
avctx->bits_per_coded_sample = sh->video->bits_per_coded_sample;
|
|
|
|
|
2015-06-21 16:06:14 +00:00
|
|
|
mp_lavc_set_extradata(avctx, sh->extradata, sh->extradata_size);
|
2002-08-28 22:02:38 +00:00
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
if (mp_rawvideo) {
|
2015-06-21 14:56:35 +00:00
|
|
|
avctx->pix_fmt = imgfmt2pixfmt(sh->codec_tag);
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
avctx->codec_tag = 0;
|
2015-06-21 14:56:35 +00:00
|
|
|
if (avctx->pix_fmt == AV_PIX_FMT_NONE && sh->codec_tag)
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_ERR(vd, "Image format %s not supported by lavc.\n",
|
2015-06-21 14:56:35 +00:00
|
|
|
mp_imgfmt_to_name(sh->codec_tag));
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
if (sh->lav_headers)
|
|
|
|
mp_copy_lav_codec_headers(avctx, sh->lav_headers);
|
demux_lavf, ad_lavc, vd_lavc: pass codec header data directly
Instead of putting codec header data into WAVEFORMATEX and
BITMAPINFOHEADER, pass it directly via AVCodecContext. To do this, we
add mp_copy_lav_codec_headers(), which copies the codec header data
from one AVCodecContext to another (originally, the plan was to use
avcodec_copy_context() for this, but it looks like this would turn
decoder initialization into an even worse mess).
Get rid of the silly CodecID <-> codec_tag mapping. This was originally
needed for codecs.conf: codec tags were used to identify codecs, but
libavformat didn't always return useful codec tags (different file
formats can have different, overlapping tag numbers). Since we don't
go through WAVEFORMATEX etc. and pass all header data directly via
AVCodecContext, we can be absolutely sure that the codec tag mapping is
not needed anymore.
Note that this also destroys the "standard" MPlayer method of exporting
codec header data. WAVEFORMATEX and BITMAPINFOHEADER made sure that
other non-libavcodec decoders could be initialized. However, all these
decoders have been removed, so this is just cruft full of old hacks that
are not needed anymore. There's still ad_spdif and ad_mpg123, bu neither
of these need codec header data. Should we ever add non-libavcodec
decoders, better data structures without the past hacks could be added
to export the headers.
2013-02-09 14:15:37 +00:00
|
|
|
|
2002-03-06 20:54:43 +00:00
|
|
|
/* open it */
|
2014-12-13 21:00:42 +00:00
|
|
|
if (avcodec_open2(avctx, lavc_codec, NULL) < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
|
|
|
MP_ERR(vd, "Could not open codec.\n");
|
|
|
|
uninit_avctx(vd);
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static void uninit_avctx(struct dec_video *vd)
|
2011-10-22 00:51:37 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2002-03-23 17:29:35 +00:00
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2007-02-03 13:19:21 +00:00
|
|
|
if (avctx) {
|
2007-02-03 13:20:31 +00:00
|
|
|
if (avctx->codec && avcodec_close(avctx) < 0)
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_ERR(vd, "Could not close codec.\n");
|
2002-05-02 12:24:53 +00:00
|
|
|
|
2007-02-03 13:20:31 +00:00
|
|
|
av_freep(&avctx->extradata);
|
|
|
|
av_freep(&avctx->slice_offset);
|
2007-02-03 13:19:21 +00:00
|
|
|
}
|
2005-01-08 19:16:21 +00:00
|
|
|
|
2015-02-14 15:45:01 +00:00
|
|
|
if (ctx->hwdec && ctx->hwdec->uninit)
|
|
|
|
ctx->hwdec->uninit(ctx);
|
|
|
|
|
2013-04-27 11:36:09 +00:00
|
|
|
av_freep(&ctx->avctx);
|
2012-12-11 23:43:50 +00:00
|
|
|
|
2013-10-31 17:12:39 +00:00
|
|
|
av_frame_free(&ctx->pic);
|
vd_lavc: make hardware decoding fallback less violent
Most of hardware decoding is initialized lazily. When the first packet
is parsed, libavcodec will call get_format() to check whether hw or sw
decoding is wanted. Until now, we've returned AV_PIX_FMT_NONE from
get_format() if hw decoder initialization failed. This caused the
avcodec_decode_video2() call to fail, which in turn let us trigger the
fallback. We didn't return a sw format from get_format(), because we
didn't want to continue decoding at all. (The reason being that full
reinitialization is more robust when continuing sw decoding.)
This has some disadvantages. libavcodec vomited some unwanted error
messages. Sometimes the failures are more severe, like it happened with
HEVC. In this case, the error code path simply acted up in a way that
was extremely inconvenient (and had to be fixed by myself). In general,
libavcodec is not designed to fallback this way.
Make it a bit less violent from the API usage point of view. Return a sw
format if hw decoder initialization fails. In this case, we let
get_buffer2() call avcodec_default_get_buffer2() as well. libavcodec is
allowed to perform its own sw fallback. But once the decode function
returns, we do the full reinitialization we wanted to do.
The result is that the fallback is more robust, and doesn't trigger any
decoder error codepaths or messages either. Change our own fallback
message to a warning, since there are no other messages with error
severity anymore.
2015-05-28 19:52:04 +00:00
|
|
|
|
|
|
|
ctx->hwdec_failed = false;
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2013-12-10 18:07:29 +00:00
|
|
|
static void update_image_params(struct dec_video *vd, AVFrame *frame,
|
|
|
|
struct mp_image_params *out_params)
|
2012-12-11 17:16:42 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2014-05-24 12:08:39 +00:00
|
|
|
struct MPOpts *opts = ctx->opts;
|
2012-12-20 12:28:39 +00:00
|
|
|
int width = frame->width;
|
|
|
|
int height = frame->height;
|
|
|
|
float aspect = av_q2d(frame->sample_aspect_ratio) * width / height;
|
2013-01-24 11:43:36 +00:00
|
|
|
int pix_fmt = frame->format;
|
|
|
|
|
2013-11-23 20:40:51 +00:00
|
|
|
if (pix_fmt != ctx->pix_fmt) {
|
2013-01-24 11:43:36 +00:00
|
|
|
ctx->pix_fmt = pix_fmt;
|
|
|
|
ctx->best_csp = pixfmt2imgfmt(pix_fmt);
|
2013-12-21 16:47:38 +00:00
|
|
|
if (!ctx->best_csp)
|
|
|
|
MP_ERR(vd, "lavc pixel format %s not supported.\n",
|
|
|
|
av_get_pix_fmt_name(pix_fmt));
|
2002-04-13 13:40:26 +00:00
|
|
|
}
|
2013-11-23 20:40:51 +00:00
|
|
|
|
|
|
|
int d_w, d_h;
|
|
|
|
vf_set_dar(&d_w, &d_h, width, height, aspect);
|
|
|
|
|
2013-12-10 18:07:29 +00:00
|
|
|
*out_params = (struct mp_image_params) {
|
2013-11-23 20:40:51 +00:00
|
|
|
.imgfmt = ctx->best_csp,
|
|
|
|
.w = width,
|
|
|
|
.h = height,
|
|
|
|
.d_w = d_w,
|
|
|
|
.d_h = d_h,
|
|
|
|
.colorspace = avcol_spc_to_mp_csp(ctx->avctx->colorspace),
|
|
|
|
.colorlevels = avcol_range_to_mp_csp_levels(ctx->avctx->color_range),
|
2014-03-26 00:46:38 +00:00
|
|
|
.primaries = avcol_pri_to_mp_csp_prim(ctx->avctx->color_primaries),
|
Revert "Revert recent vo_opengl related commits"
Omitted a simple, but devastasting check. Fixed the relevant commits
now.
This reverts commit 8d24e9d9b8ad1b5d82139980eca148dc0f4a1eab.
diff --git a/video/out/gl_video.c b/video/out/gl_video.c
index 9c8a643..f1ea03e 100644
--- a/video/out/gl_video.c
+++ b/video/out/gl_video.c
@@ -1034,9 +1034,9 @@ static void compile_shaders(struct gl_video *p)
shader_def_opt(&header_conv, "USE_CONV_GAMMA", use_conv_gamma);
shader_def_opt(&header_conv, "USE_CONST_LUMA", use_const_luma);
shader_def_opt(&header_conv, "USE_LINEAR_LIGHT_BT1886",
- gamma_fun == MP_CSP_TRC_BT_1886);
+ use_linear_light && gamma_fun == MP_CSP_TRC_BT_1886);
shader_def_opt(&header_conv, "USE_LINEAR_LIGHT_SRGB",
- gamma_fun == MP_CSP_TRC_SRGB);
+ use_linear_light && gamma_fun == MP_CSP_TRC_SRGB);
shader_def_opt(&header_conv, "USE_SIGMOID", use_sigmoid);
if (p->opts.alpha_mode > 0 && p->has_alpha && p->plane_count > 3)
shader_def(&header_conv, "USE_ALPHA_PLANE", "3");
2015-02-28 19:15:12 +00:00
|
|
|
.gamma = avcol_trc_to_mp_csp_trc(ctx->avctx->color_trc),
|
2013-11-23 20:40:51 +00:00
|
|
|
.chroma_location =
|
|
|
|
avchroma_location_to_mp(ctx->avctx->chroma_sample_location),
|
2014-04-20 19:29:22 +00:00
|
|
|
.rotate = vd->header->video->rotate,
|
2014-08-30 21:24:46 +00:00
|
|
|
.stereo_in = vd->header->video->stereo_mode,
|
2013-11-23 20:40:51 +00:00
|
|
|
};
|
2014-05-24 12:08:39 +00:00
|
|
|
|
|
|
|
if (opts->video_rotate < 0) {
|
|
|
|
out_params->rotate = 0;
|
|
|
|
} else {
|
|
|
|
out_params->rotate = (out_params->rotate + opts->video_rotate) % 360;
|
|
|
|
}
|
2014-08-30 21:24:46 +00:00
|
|
|
out_params->stereo_out = opts->video_stereo_mode;
|
2002-07-14 19:44:40 +00:00
|
|
|
}
|
|
|
|
|
2013-11-29 16:39:57 +00:00
|
|
|
static enum AVPixelFormat get_format_hwdec(struct AVCodecContext *avctx,
|
|
|
|
const enum AVPixelFormat *fmt)
|
2012-11-06 14:27:44 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
struct dec_video *vd = avctx->opaque;
|
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2012-11-06 14:27:44 +00:00
|
|
|
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_VERBOSE(vd, "Pixel formats supported by decoder:");
|
2013-11-29 16:39:57 +00:00
|
|
|
for (int i = 0; fmt[i] != AV_PIX_FMT_NONE; i++)
|
2013-12-21 16:47:38 +00:00
|
|
|
MP_VERBOSE(vd, " %s", av_get_pix_fmt_name(fmt[i]));
|
|
|
|
MP_VERBOSE(vd, "\n");
|
2012-12-11 17:16:42 +00:00
|
|
|
|
2013-08-11 21:23:12 +00:00
|
|
|
assert(ctx->hwdec);
|
2012-12-11 17:16:42 +00:00
|
|
|
|
2014-03-16 08:21:21 +00:00
|
|
|
if (ctx->hwdec->image_format) {
|
|
|
|
for (int i = 0; fmt[i] != AV_PIX_FMT_NONE; i++) {
|
|
|
|
if (ctx->hwdec->image_format == pixfmt2imgfmt(fmt[i])) {
|
2014-03-17 17:19:03 +00:00
|
|
|
// There could be more reasons for a change, and it's possible
|
|
|
|
// that we miss some. (Might also depend on the hwaccel type.)
|
2014-03-16 13:54:21 +00:00
|
|
|
bool change =
|
2015-05-28 19:55:16 +00:00
|
|
|
ctx->hwdec_w != avctx->coded_width ||
|
|
|
|
ctx->hwdec_h != avctx->coded_height ||
|
2014-03-17 17:19:03 +00:00
|
|
|
ctx->hwdec_fmt != ctx->hwdec->image_format ||
|
2015-05-28 19:56:13 +00:00
|
|
|
ctx->hwdec_profile != avctx->profile ||
|
|
|
|
ctx->hwdec_request_reinit;
|
2015-05-28 19:55:16 +00:00
|
|
|
ctx->hwdec_w = avctx->coded_width;
|
|
|
|
ctx->hwdec_h = avctx->coded_height;
|
2014-03-16 08:21:21 +00:00
|
|
|
ctx->hwdec_fmt = ctx->hwdec->image_format;
|
2014-03-17 17:19:03 +00:00
|
|
|
ctx->hwdec_profile = avctx->profile;
|
2015-05-28 19:56:13 +00:00
|
|
|
ctx->hwdec_request_reinit = false;
|
2015-08-19 19:33:18 +00:00
|
|
|
if (change) {
|
|
|
|
if (ctx->hwdec->init_decoder(ctx, ctx->hwdec_w, ctx->hwdec_h) < 0)
|
2014-03-10 21:36:23 +00:00
|
|
|
{
|
|
|
|
ctx->hwdec_fmt = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
return fmt[i];
|
2014-03-10 21:36:23 +00:00
|
|
|
}
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
}
|
2012-11-06 14:27:44 +00:00
|
|
|
}
|
2012-12-11 17:16:42 +00:00
|
|
|
|
vd_lavc: make hardware decoding fallback less violent
Most of hardware decoding is initialized lazily. When the first packet
is parsed, libavcodec will call get_format() to check whether hw or sw
decoding is wanted. Until now, we've returned AV_PIX_FMT_NONE from
get_format() if hw decoder initialization failed. This caused the
avcodec_decode_video2() call to fail, which in turn let us trigger the
fallback. We didn't return a sw format from get_format(), because we
didn't want to continue decoding at all. (The reason being that full
reinitialization is more robust when continuing sw decoding.)
This has some disadvantages. libavcodec vomited some unwanted error
messages. Sometimes the failures are more severe, like it happened with
HEVC. In this case, the error code path simply acted up in a way that
was extremely inconvenient (and had to be fixed by myself). In general,
libavcodec is not designed to fallback this way.
Make it a bit less violent from the API usage point of view. Return a sw
format if hw decoder initialization fails. In this case, we let
get_buffer2() call avcodec_default_get_buffer2() as well. libavcodec is
allowed to perform its own sw fallback. But once the decode function
returns, we do the full reinitialization we wanted to do.
The result is that the fallback is more robust, and doesn't trigger any
decoder error codepaths or messages either. Change our own fallback
message to a warning, since there are no other messages with error
severity anymore.
2015-05-28 19:52:04 +00:00
|
|
|
ctx->hwdec_failed = true;
|
2015-05-29 12:17:51 +00:00
|
|
|
for (int i = 0; fmt[i] != AV_PIX_FMT_NONE; i++) {
|
|
|
|
const AVPixFmtDescriptor *d = av_pix_fmt_desc_get(fmt[i]);
|
|
|
|
if (d && !(d->flags & AV_PIX_FMT_FLAG_HWACCEL))
|
|
|
|
return fmt[i];
|
|
|
|
}
|
|
|
|
return AV_PIX_FMT_NONE;
|
2012-11-06 14:27:44 +00:00
|
|
|
}
|
|
|
|
|
2015-05-28 19:53:37 +00:00
|
|
|
static int get_buffer2_hwdec(AVCodecContext *avctx, AVFrame *pic, int flags)
|
|
|
|
{
|
|
|
|
struct dec_video *vd = avctx->opaque;
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2012-11-06 14:27:44 +00:00
|
|
|
|
2015-05-28 19:53:37 +00:00
|
|
|
if (ctx->hwdec_failed)
|
|
|
|
return avcodec_default_get_buffer2(avctx, pic, flags);
|
|
|
|
|
2012-12-11 17:16:42 +00:00
|
|
|
/* Decoders using ffmpeg's hwaccel architecture (everything except vdpau)
|
|
|
|
* can fall back to software decoding automatically. However, we don't
|
|
|
|
* want that: multithreading was already disabled. ffmpeg's fallback
|
|
|
|
* isn't really useful, and causes more trouble than it helps.
|
|
|
|
*
|
|
|
|
* Instead of trying to "adjust" the thread_count fields in avctx, let
|
|
|
|
* decoding fail hard. Then decode_with_fallback() will do our own software
|
|
|
|
* fallback. Fully reinitializing the decoder is saner, and will probably
|
|
|
|
* save us from other weird corner cases, like having to "reroute" the
|
|
|
|
* get_buffer callback.
|
|
|
|
*/
|
2012-12-20 12:28:39 +00:00
|
|
|
int imgfmt = pixfmt2imgfmt(pic->format);
|
2014-03-10 21:36:23 +00:00
|
|
|
if (!IMGFMT_IS_HWACCEL(imgfmt) || !ctx->hwdec)
|
2015-05-28 19:53:37 +00:00
|
|
|
return -1;
|
2012-11-06 14:27:44 +00:00
|
|
|
|
2015-05-28 19:55:16 +00:00
|
|
|
// We expect it to use the exact size used to create the hw decoder in
|
|
|
|
// get_format_hwdec(). For cropped video, this is expected to be the
|
|
|
|
// uncropped size (usually coded_width/coded_height).
|
|
|
|
int w = pic->width;
|
|
|
|
int h = pic->height;
|
2013-08-15 16:20:15 +00:00
|
|
|
|
2015-08-19 19:33:18 +00:00
|
|
|
if (imgfmt != ctx->hwdec_fmt && w != ctx->hwdec_w && h != ctx->hwdec_h)
|
|
|
|
return -1;
|
2014-03-10 21:36:23 +00:00
|
|
|
|
2015-08-19 19:33:18 +00:00
|
|
|
struct mp_image *mpi = ctx->hwdec->allocate_image(ctx, w, h);
|
2013-03-09 19:50:06 +00:00
|
|
|
if (!mpi)
|
|
|
|
return -1;
|
|
|
|
|
video: replace our own refcounting with libavutil's
mpv had refcounted frames before libav*, so we were not using
libavutil's facilities. Change this and drop our own code.
Since AVFrames are not actually refcounted, and only the image data
they reference, the semantics change a bit. This affects mainly
mp_image_pool, which was operating on whole images instead of buffers.
While we could work on AVBufferRefs instead (and use AVBufferPool),
this doesn't work for use with hardware decoding, which doesn't
map cleanly to FFmpeg's reference counting. But it worked out. One
weird consequence is that we still need our custom image data
allocation function (for normal image data), because AVFrame's uses
multiple buffers.
There also seems to be a timing-dependent problem with vaapi (the
pool appears to be "leaking" surfaces). I don't know if this is a new
problem, or whether the code changes just happened to cause it more
often. Raising the number of reserved surfaces seemed to fix it, but
since it appears to be timing dependent, and I couldn't find anything
wrong with the code, I'm just going to assume it's not a new bug.
2015-07-05 21:56:00 +00:00
|
|
|
for (int i = 0; i < 4; i++) {
|
2015-05-28 19:53:37 +00:00
|
|
|
pic->data[i] = mpi->planes[i];
|
video: replace our own refcounting with libavutil's
mpv had refcounted frames before libav*, so we were not using
libavutil's facilities. Change this and drop our own code.
Since AVFrames are not actually refcounted, and only the image data
they reference, the semantics change a bit. This affects mainly
mp_image_pool, which was operating on whole images instead of buffers.
While we could work on AVBufferRefs instead (and use AVBufferPool),
this doesn't work for use with hardware decoding, which doesn't
map cleanly to FFmpeg's reference counting. But it worked out. One
weird consequence is that we still need our custom image data
allocation function (for normal image data), because AVFrame's uses
multiple buffers.
There also seems to be a timing-dependent problem with vaapi (the
pool appears to be "leaking" surfaces). I don't know if this is a new
problem, or whether the code changes just happened to cause it more
often. Raising the number of reserved surfaces seemed to fix it, but
since it appears to be timing dependent, and I couldn't find anything
wrong with the code, I'm just going to assume it's not a new bug.
2015-07-05 21:56:00 +00:00
|
|
|
pic->buf[i] = mpi->bufs[i];
|
|
|
|
mpi->bufs[i] = NULL;
|
|
|
|
}
|
|
|
|
talloc_free(mpi);
|
2013-03-09 19:50:06 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static int decode(struct dec_video *vd, struct demux_packet *packet,
|
2013-11-25 22:08:29 +00:00
|
|
|
int flags, struct mp_image **out_image)
|
2009-11-21 18:53:10 +00:00
|
|
|
{
|
2011-10-22 00:51:37 +00:00
|
|
|
int got_picture = 0;
|
2002-07-14 19:44:40 +00:00
|
|
|
int ret;
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2002-07-14 19:44:40 +00:00
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2014-08-08 22:35:25 +00:00
|
|
|
struct vd_lavc_params *lavc_param = ctx->opts->vd_lavc_params;
|
2009-06-01 22:25:10 +00:00
|
|
|
AVPacket pkt;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2014-08-08 22:35:25 +00:00
|
|
|
if (flags) {
|
|
|
|
// hr-seek framedrop vs. normal framedrop
|
|
|
|
avctx->skip_frame = flags == 2 ? AVDISCARD_NONREF : lavc_param->framedrop;
|
|
|
|
} else {
|
|
|
|
// normal playback
|
2011-07-09 10:50:16 +00:00
|
|
|
avctx->skip_frame = ctx->skip_frame;
|
2014-08-08 22:35:25 +00:00
|
|
|
}
|
2002-07-14 19:44:40 +00:00
|
|
|
|
av_common: add timebase parameter to mp_set_av_packet()
If the timebase is set, it's used for converting the packet timestamps.
Otherwise, the previous method of reinterpret-casting the mpv style
double timestamps to libavcodec style int64_t timestamps is used.
Also replace the kind of awkward mp_get_av_frame_pkt_ts() function by
mp_pts_from_av(), which simply converts timestamps in a way the old
function did. (Plus it takes a timebase parameter, similar to the
addition to mp_set_av_packet().)
Note that this should not change anything yet. The code in ad_lavc.c and
vd_lavc.c passes NULL for the timebase parameters. We could set
AVCodecContext.pkt_timebase and use that if we want to give libavcodec
"proper" timestamps.
This could be important for ad_lavc.c: some codecs (opus, probably mp3
and aac too) have weird requirements about doing decoding preroll on the
container level, and thus require adjusting the audio start timestamps
in some cases. libavcodec doesn't tell us how much was skipped, so we
either get shifted timestamps (by the length of the skipped data), or we
give it proper timestamps. (Note: libavcodec interprets or changes
timestamps only if pkt_timebase is set, which by default it is not.)
This would require selecting a timebase though, so I feel uncomfortable
with the idea. At least this change paves the way, and will allow some
testing.
2013-12-04 19:12:14 +00:00
|
|
|
mp_set_av_packet(&pkt, packet, NULL);
|
2013-06-02 23:55:48 +00:00
|
|
|
|
2014-08-21 20:04:25 +00:00
|
|
|
hwdec_lock(ctx);
|
2013-11-25 22:08:29 +00:00
|
|
|
ret = avcodec_decode_video2(avctx, ctx->pic, &got_picture, &pkt);
|
2014-08-21 20:04:25 +00:00
|
|
|
hwdec_unlock(ctx);
|
vd_lavc: make hardware decoding fallback less violent
Most of hardware decoding is initialized lazily. When the first packet
is parsed, libavcodec will call get_format() to check whether hw or sw
decoding is wanted. Until now, we've returned AV_PIX_FMT_NONE from
get_format() if hw decoder initialization failed. This caused the
avcodec_decode_video2() call to fail, which in turn let us trigger the
fallback. We didn't return a sw format from get_format(), because we
didn't want to continue decoding at all. (The reason being that full
reinitialization is more robust when continuing sw decoding.)
This has some disadvantages. libavcodec vomited some unwanted error
messages. Sometimes the failures are more severe, like it happened with
HEVC. In this case, the error code path simply acted up in a way that
was extremely inconvenient (and had to be fixed by myself). In general,
libavcodec is not designed to fallback this way.
Make it a bit less violent from the API usage point of view. Return a sw
format if hw decoder initialization fails. In this case, we let
get_buffer2() call avcodec_default_get_buffer2() as well. libavcodec is
allowed to perform its own sw fallback. But once the decode function
returns, we do the full reinitialization we wanted to do.
The result is that the fallback is more robust, and doesn't trigger any
decoder error codepaths or messages either. Change our own fallback
message to a warning, since there are no other messages with error
severity anymore.
2015-05-28 19:52:04 +00:00
|
|
|
|
|
|
|
if (ctx->hwdec_failed || ret < 0) {
|
|
|
|
if (ret < 0)
|
|
|
|
MP_WARN(vd, "Error while decoding frame!\n");
|
2012-12-11 17:16:42 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2003-04-06 23:37:56 +00:00
|
|
|
|
2015-05-28 19:56:13 +00:00
|
|
|
if (ctx->hwdec_request_reinit)
|
|
|
|
avcodec_flush_buffers(avctx);
|
|
|
|
|
2013-11-24 11:22:25 +00:00
|
|
|
// Skipped frame, or delayed output due to multithreaded decoding.
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!got_picture)
|
2013-11-24 11:22:25 +00:00
|
|
|
return 0;
|
2002-07-15 21:33:46 +00:00
|
|
|
|
2013-12-10 18:07:29 +00:00
|
|
|
struct mp_image_params params;
|
|
|
|
update_image_params(vd, ctx->pic, ¶ms);
|
av_common: add timebase parameter to mp_set_av_packet()
If the timebase is set, it's used for converting the packet timestamps.
Otherwise, the previous method of reinterpret-casting the mpv style
double timestamps to libavcodec style int64_t timestamps is used.
Also replace the kind of awkward mp_get_av_frame_pkt_ts() function by
mp_pts_from_av(), which simply converts timestamps in a way the old
function did. (Plus it takes a timebase parameter, similar to the
addition to mp_set_av_packet().)
Note that this should not change anything yet. The code in ad_lavc.c and
vd_lavc.c passes NULL for the timebase parameters. We could set
AVCodecContext.pkt_timebase and use that if we want to give libavcodec
"proper" timestamps.
This could be important for ad_lavc.c: some codecs (opus, probably mp3
and aac too) have weird requirements about doing decoding preroll on the
container level, and thus require adjusting the audio start timestamps
in some cases. libavcodec doesn't tell us how much was skipped, so we
either get shifted timestamps (by the length of the skipped data), or we
give it proper timestamps. (Note: libavcodec interprets or changes
timestamps only if pkt_timebase is set, which by default it is not.)
This would require selecting a timebase though, so I feel uncomfortable
with the idea. At least this change paves the way, and will allow some
testing.
2013-12-04 19:12:14 +00:00
|
|
|
vd->codec_pts = mp_pts_from_av(ctx->pic->pkt_pts, NULL);
|
|
|
|
vd->codec_dts = mp_pts_from_av(ctx->pic->pkt_dts, NULL);
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2014-03-16 08:21:21 +00:00
|
|
|
struct mp_image *mpi = mp_image_from_av_frame(ctx->pic);
|
|
|
|
av_frame_unref(ctx->pic);
|
2014-03-16 00:34:48 +00:00
|
|
|
if (!mpi)
|
video: introduce failure path for image allocations
Until now, failure to allocate image data resulted in a crash (i.e.
abort() was called). This was intentional, because it's pretty silly to
degrade playback, and in almost all situations, the OOM will probably
kill you anyway. (And then there's the standard Linux overcommit
behavior, which also will kill you at some point.)
But I changed my opinion, so here we go. This change does not affect
_all_ memory allocations, just image data. Now in most failure cases,
the output will just be skipped. For video filters, this coincidentally
means that failure is treated as EOF (because the playback core assumes
EOF if nothing comes out of the video filter chain). In other
situations, output might be in some way degraded, like skipping frames,
not scaling OSD, and such.
Functions whose return values changed semantics:
mp_image_alloc
mp_image_new_copy
mp_image_new_ref
mp_image_make_writeable
mp_image_setrefp
mp_image_to_av_frame_and_unref
mp_image_from_av_frame
mp_image_new_external_ref
mp_image_new_custom_ref
mp_image_pool_make_writeable
mp_image_pool_get
mp_image_pool_new_copy
mp_vdpau_mixed_frame_create
vf_alloc_out_image
vf_make_out_image_writeable
glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
|
|
|
return 0; // mpi==NULL, or OOM
|
2014-03-23 18:20:43 +00:00
|
|
|
assert(mpi->planes[0] || mpi->planes[3]);
|
2013-12-10 18:07:29 +00:00
|
|
|
mp_image_set_params(mpi, ¶ms);
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2013-08-15 16:21:54 +00:00
|
|
|
if (ctx->hwdec && ctx->hwdec->process_image)
|
2013-08-14 13:47:18 +00:00
|
|
|
mpi = ctx->hwdec->process_image(ctx, mpi);
|
vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API
Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").
Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)
Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.
Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)
Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.
Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.
Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).
2013-07-27 23:49:45 +00:00
|
|
|
|
2015-02-06 22:20:41 +00:00
|
|
|
*out_image = mp_img_swap_to_native(mpi);
|
2012-12-11 17:16:42 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-10 18:07:29 +00:00
|
|
|
static int force_fallback(struct dec_video *vd)
|
2012-12-11 17:16:42 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
if (ctx->software_fallback_decoder) {
|
2013-11-23 20:36:20 +00:00
|
|
|
uninit_avctx(vd);
|
vd_lavc: make hardware decoding fallback less violent
Most of hardware decoding is initialized lazily. When the first packet
is parsed, libavcodec will call get_format() to check whether hw or sw
decoding is wanted. Until now, we've returned AV_PIX_FMT_NONE from
get_format() if hw decoder initialization failed. This caused the
avcodec_decode_video2() call to fail, which in turn let us trigger the
fallback. We didn't return a sw format from get_format(), because we
didn't want to continue decoding at all. (The reason being that full
reinitialization is more robust when continuing sw decoding.)
This has some disadvantages. libavcodec vomited some unwanted error
messages. Sometimes the failures are more severe, like it happened with
HEVC. In this case, the error code path simply acted up in a way that
was extremely inconvenient (and had to be fixed by myself). In general,
libavcodec is not designed to fallback this way.
Make it a bit less violent from the API usage point of view. Return a sw
format if hw decoder initialization fails. In this case, we let
get_buffer2() call avcodec_default_get_buffer2() as well. libavcodec is
allowed to perform its own sw fallback. But once the decode function
returns, we do the full reinitialization we wanted to do.
The result is that the fallback is more robust, and doesn't trigger any
decoder error codepaths or messages either. Change our own fallback
message to a warning, since there are no other messages with error
severity anymore.
2015-05-28 19:52:04 +00:00
|
|
|
MP_WARN(vd, "Hardware decoding failed,"
|
|
|
|
" falling back to software decoding.\n");
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
const char *decoder = ctx->software_fallback_decoder;
|
|
|
|
ctx->software_fallback_decoder = NULL;
|
2013-11-23 20:36:20 +00:00
|
|
|
init_avctx(vd, decoder, NULL);
|
2013-12-10 18:07:29 +00:00
|
|
|
return ctx->avctx ? CONTROL_OK : CONTROL_ERROR;
|
|
|
|
}
|
|
|
|
return CONTROL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct mp_image *decode_with_fallback(struct dec_video *vd,
|
|
|
|
struct demux_packet *packet, int flags)
|
|
|
|
{
|
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
|
|
|
if (!ctx->avctx)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
struct mp_image *mpi = NULL;
|
|
|
|
int res = decode(vd, packet, flags, &mpi);
|
|
|
|
if (res < 0) {
|
|
|
|
// Failed hardware decoding? Try again in software.
|
|
|
|
if (force_fallback(vd) == CONTROL_OK)
|
2013-11-25 22:08:29 +00:00
|
|
|
decode(vd, packet, flags, &mpi);
|
2012-12-11 17:16:42 +00:00
|
|
|
}
|
|
|
|
|
2013-12-10 18:07:29 +00:00
|
|
|
return mpi;
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2013-11-23 20:36:20 +00:00
|
|
|
static int control(struct dec_video *vd, int cmd, void *arg)
|
2011-11-14 18:12:20 +00:00
|
|
|
{
|
2013-11-23 20:36:20 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = vd->priv;
|
2011-11-14 18:12:20 +00:00
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
|
|
|
switch (cmd) {
|
2013-11-27 19:54:07 +00:00
|
|
|
case VDCTRL_RESET:
|
2011-11-14 18:12:20 +00:00
|
|
|
avcodec_flush_buffers(avctx);
|
|
|
|
return CONTROL_TRUE;
|
|
|
|
case VDCTRL_QUERY_UNSEEN_FRAMES:;
|
|
|
|
int delay = avctx->has_b_frames;
|
2013-02-24 22:15:11 +00:00
|
|
|
assert(delay >= 0);
|
2012-02-03 18:03:00 +00:00
|
|
|
if (avctx->active_thread_type & FF_THREAD_FRAME)
|
|
|
|
delay += avctx->thread_count - 1;
|
2013-02-24 22:15:11 +00:00
|
|
|
*(int *)arg = delay;
|
|
|
|
return CONTROL_TRUE;
|
2014-04-22 23:17:28 +00:00
|
|
|
case VDCTRL_GET_HWDEC: {
|
2015-05-25 19:17:48 +00:00
|
|
|
int hwdec = ctx->hwdec ? ctx->hwdec->type : 0;
|
2014-04-22 23:17:28 +00:00
|
|
|
if (!ctx->software_fallback_decoder)
|
|
|
|
hwdec = 0;
|
|
|
|
*(int *)arg = hwdec;
|
|
|
|
return CONTROL_TRUE;
|
|
|
|
}
|
2013-12-10 18:07:29 +00:00
|
|
|
case VDCTRL_FORCE_HWDEC_FALLBACK:
|
|
|
|
return force_fallback(vd);
|
2011-11-14 18:12:20 +00:00
|
|
|
}
|
|
|
|
return CONTROL_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
static void add_decoders(struct mp_decoder_list *list)
|
|
|
|
{
|
|
|
|
mp_add_lavc_decoders(list, AVMEDIA_TYPE_VIDEO);
|
|
|
|
mp_add_decoder(list, "lavc", "mp-rawvideo", "mp-rawvideo",
|
|
|
|
"raw video");
|
|
|
|
}
|
|
|
|
|
2009-11-21 18:53:10 +00:00
|
|
|
const struct vd_functions mpcodecs_vd_ffmpeg = {
|
core: redo how codecs are mapped, remove codecs.conf
Use codec names instead of FourCCs to identify codecs. Rewrite how
codecs are selected and initialized. Now each decoder exports a list
of decoders (and the codec it supports) via add_decoders(). The order
matters, and the first decoder for a given decoder is preferred over
the other decoders. E.g. all ad_mpg123 decoders are preferred over
ad_lavc, because it comes first in the mpcodecs_ad_drivers array.
Likewise, decoders within ad_lavc that are enumerated first by
libavcodec (using av_codec_next()) are preferred. (This is actually
critical to select h264 software decoding by default instead of vdpau.
libavcodec and ffmpeg/avconv use the same method to select decoders by
default, so we hope this is sane.)
The codec names follow libavcodec's codec names as defined by
AVCodecDescriptor.name (see libavcodec/codec_desc.c). Some decoders
have names different from the canonical codec name. The AVCodecDescriptor
API is relatively new, so we need a compatibility layer for older
libavcodec versions for codec names that are referenced internally,
and which are different from the decoder name. (Add a configure check
for that, because checking versions is getting way too messy.)
demux/codec_tags.c is generated from the former codecs.conf (minus
"special" decoders like vdpau, and excluding the mappings that are the
same as the mappings libavformat's exported RIFF tables). It contains
all the mappings from FourCCs to codec name. This is needed for
demux_mkv, demux_mpg, demux_avi and demux_asf. demux_lavf will set the
codec as determined by libavformat, while the other demuxers have to do
this on their own, using the mp_set_audio/video_codec_from_tag()
functions. Note that the sh_audio/video->format members don't uniquely
identify the codec anymore, and sh->codec takes over this role.
Replace the --ac/--vc/--afm/--vfm with new --vd/--ad options, which
provide cover the functionality of the removed switched.
Note: there's no CODECS_FLAG_FLIP flag anymore. This means some obscure
container/video combinations (e.g. the sample Film_200_zygo_pro.mov)
are played flipped. ffplay/avplay doesn't handle this properly either,
so we don't care and blame ffmeg/libav instead.
2013-02-09 14:15:19 +00:00
|
|
|
.name = "lavc",
|
|
|
|
.add_decoders = add_decoders,
|
2009-11-21 18:53:10 +00:00
|
|
|
.init = init,
|
|
|
|
.uninit = uninit,
|
|
|
|
.control = control,
|
2012-12-11 17:16:42 +00:00
|
|
|
.decode = decode_with_fallback,
|
2009-11-21 18:53:10 +00:00
|
|
|
};
|