2010-01-30 16:57:40 +00:00
|
|
|
/*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* MPlayer is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2012-12-31 00:58:25 +00:00
|
|
|
#include <assert.h>
|
video: decouple internal pixel formats from FourCCs
mplayer's video chain traditionally used FourCCs for pixel formats. For
example, it used IMGFMT_YV12 for 4:2:0 YUV, which was defined to the
string 'YV12' interpreted as unsigned int. Additionally, it used to
encode information into the numeric values of some formats. The RGB
formats had their bit depth and endian encoded into the least
significant byte. Extended planar formats (420P10 etc.) had chroma
shift, endian, and component bit depth encoded. (This has been removed
in recent commits.)
Replace the FourCC mess with a simple enum. Remove all the redundant
formats like YV12/I420/IYUV. Replace some image format names by
something more intuitive, most importantly IMGFMT_YV12 -> IMGFMT_420P.
Add img_fourcc.h, which contains the old IDs for code that actually uses
FourCCs. Change the way demuxers, that output raw video, identify the
video format: they set either MP_FOURCC_RAWVIDEO or MP_FOURCC_IMGFMT to
request the rawvideo decoder, and sh_video->imgfmt specifies the pixel
format. Like the previous hack, this is supposed to avoid the need for
a complete codecs.cfg entry per format, or other lookup tables. (Note
that the RGB raw video FourCCs mostly rely on ffmpeg's mappings for NUT
raw video, but this is still considered better than adding a raw video
decoder - even if trivial, it would be full of annoying lookup tables.)
The TV code has not been tested.
Some corrective changes regarding endian and other image format flags
creep in.
2012-12-23 19:03:30 +00:00
|
|
|
#include <string.h>
|
2012-12-31 00:58:25 +00:00
|
|
|
|
vf_scale: replace ancient fallback image format selection
If video output and VO don't support the same format, a conversion
filter needs to be insert. Since a VO can support multiple formats, and
the filter chain also can deal with multiple formats, you basically have
to pick from a huge matrix of possible conversions.
The old MPlayer code had a quite naive algorithm: it first checked
whether any conversion from the list of preferred conversions matched,
and if not, it was falling back on checking a hardcoded list of output
formats (more or less sorted by quality). This had some unintended side-
effects, like not using obvious "replacement" formats, selecting the
wrong colorspace, selecting a bit depth that is too high or too low, and
more.
Use avcodec_find_best_pix_fmt_of_list() provided by FFmpeg instead. This
function was made for this purpose, and should select the "best" format.
Libav provides a similar function, but with a different name - there is
a function with the same name in FFmpeg, but it has different semantics
(I'm not sure if Libav or FFmpeg fucked up here).
This also removes handling of VFCAP_CSP_SUPPORTED vs.
VFCAP_CSP_SUPPORTED_BY_HW, which has no meaning anymore, except possibly
for filter chains with multiple scale filters.
Fixes #1494.
2015-01-21 17:33:47 +00:00
|
|
|
#include <libavcodec/avcodec.h>
|
2012-12-31 00:58:25 +00:00
|
|
|
#include <libavutil/pixfmt.h>
|
|
|
|
#include <libavutil/pixdesc.h>
|
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/img_format.h"
|
2012-12-31 00:58:25 +00:00
|
|
|
#include "video/mp_image.h"
|
|
|
|
#include "video/fmt-conversion.h"
|
2001-10-31 22:04:28 +00:00
|
|
|
|
2014-04-14 18:19:44 +00:00
|
|
|
struct mp_imgfmt_entry {
|
|
|
|
const char *name;
|
|
|
|
int fmt;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct mp_imgfmt_entry mp_imgfmt_list[] = {
|
2014-05-22 18:55:17 +00:00
|
|
|
// not in ffmpeg
|
2014-06-14 08:06:23 +00:00
|
|
|
{"vdpau_output", IMGFMT_VDPAU_OUTPUT},
|
2014-04-14 18:19:44 +00:00
|
|
|
// FFmpeg names have an annoying "_vld" suffix
|
2014-06-14 08:06:23 +00:00
|
|
|
{"vda", IMGFMT_VDA},
|
|
|
|
{"vaapi", IMGFMT_VAAPI},
|
2014-04-14 18:19:44 +00:00
|
|
|
// names below this are not preferred over the FFmpeg names
|
2014-06-14 07:58:48 +00:00
|
|
|
// the "none" entry makes mp_imgfmt_to_name prefer FFmpeg names
|
2014-06-14 08:06:23 +00:00
|
|
|
{"none", 0},
|
2014-04-14 18:19:44 +00:00
|
|
|
// endian-specific aliases (not in FFmpeg)
|
2014-06-14 08:06:23 +00:00
|
|
|
{"rgb32", IMGFMT_RGB32},
|
|
|
|
{"bgr32", IMGFMT_BGR32},
|
2014-04-14 18:19:44 +00:00
|
|
|
// old names we keep around
|
2014-06-14 08:06:23 +00:00
|
|
|
{"y8", IMGFMT_Y8},
|
|
|
|
{"420p", IMGFMT_420P},
|
|
|
|
{"yv12", IMGFMT_420P},
|
|
|
|
{"420p16", IMGFMT_420P16},
|
|
|
|
{"420p10", IMGFMT_420P10},
|
|
|
|
{"444p", IMGFMT_444P},
|
|
|
|
{"444p9", IMGFMT_444P9},
|
|
|
|
{"444p10", IMGFMT_444P10},
|
|
|
|
{"422p", IMGFMT_422P},
|
|
|
|
{"422p9", IMGFMT_422P9},
|
|
|
|
{"422p10", IMGFMT_422P10},
|
2012-08-28 21:58:48 +00:00
|
|
|
{0}
|
2012-08-21 17:20:36 +00:00
|
|
|
};
|
|
|
|
|
2014-04-14 18:19:44 +00:00
|
|
|
char **mp_imgfmt_name_list(void)
|
|
|
|
{
|
|
|
|
int count = IMGFMT_END - IMGFMT_START;
|
|
|
|
char **list = talloc_zero_array(NULL, char *, count + 1);
|
|
|
|
int num = 0;
|
|
|
|
for (int n = IMGFMT_START; n < IMGFMT_END; n++) {
|
|
|
|
const char *name = mp_imgfmt_to_name(n);
|
|
|
|
if (strcmp(name, "none") != 0 && strcmp(name, "unknown") != 0)
|
2014-06-14 07:58:48 +00:00
|
|
|
list[num++] = talloc_strdup(list, name);
|
2014-04-14 18:19:44 +00:00
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2014-03-17 17:19:57 +00:00
|
|
|
int mp_imgfmt_from_name(bstr name, bool allow_hwaccel)
|
2012-08-21 17:20:36 +00:00
|
|
|
{
|
2013-01-17 15:10:26 +00:00
|
|
|
int img_fmt = 0;
|
2014-04-14 18:19:44 +00:00
|
|
|
for (const struct mp_imgfmt_entry *p = mp_imgfmt_list; p->name; ++p) {
|
|
|
|
if (bstr_equals0(name, p->name)) {
|
2013-01-17 15:10:26 +00:00
|
|
|
img_fmt = p->fmt;
|
|
|
|
break;
|
2012-08-28 21:58:48 +00:00
|
|
|
}
|
2012-08-21 17:20:36 +00:00
|
|
|
}
|
2013-01-17 15:10:26 +00:00
|
|
|
if (!img_fmt) {
|
|
|
|
char *t = bstrdup0(NULL, name);
|
|
|
|
img_fmt = pixfmt2imgfmt(av_get_pix_fmt(t));
|
|
|
|
talloc_free(t);
|
|
|
|
}
|
|
|
|
if (!allow_hwaccel && IMGFMT_IS_HWACCEL(img_fmt))
|
|
|
|
return 0;
|
|
|
|
return img_fmt;
|
2012-08-21 17:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-06-14 07:58:48 +00:00
|
|
|
char *mp_imgfmt_to_name_buf(char *buf, size_t buf_size, int fmt)
|
2012-08-21 17:20:36 +00:00
|
|
|
{
|
2014-06-14 07:58:48 +00:00
|
|
|
const char *name = NULL;
|
2014-04-14 18:19:44 +00:00
|
|
|
const struct mp_imgfmt_entry *p = mp_imgfmt_list;
|
|
|
|
for (; p->fmt; p++) {
|
2014-06-14 07:58:48 +00:00
|
|
|
if (p->name && p->fmt == fmt) {
|
|
|
|
name = p->name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!name) {
|
|
|
|
const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(imgfmt2pixfmt(fmt));
|
|
|
|
if (pixdesc)
|
|
|
|
name = pixdesc->name;
|
2012-08-21 17:20:36 +00:00
|
|
|
}
|
2014-06-14 07:58:48 +00:00
|
|
|
if (!name)
|
|
|
|
name = "unknown";
|
|
|
|
snprintf(buf, buf_size, "%s", name);
|
|
|
|
int len = strlen(buf);
|
|
|
|
if (len > 2 && buf[len - 2] == MP_SELECT_LE_BE('l', 'b') && buf[len - 1] == 'e')
|
|
|
|
buf[len - 2] = '\0';
|
|
|
|
return buf;
|
2012-08-21 17:20:36 +00:00
|
|
|
}
|
2012-12-31 00:58:25 +00:00
|
|
|
|
2014-05-22 18:55:17 +00:00
|
|
|
static struct mp_imgfmt_desc mp_only_imgfmt_desc(int mpfmt)
|
|
|
|
{
|
|
|
|
switch (mpfmt) {
|
|
|
|
case IMGFMT_VDPAU_OUTPUT:
|
|
|
|
return (struct mp_imgfmt_desc) {
|
|
|
|
.id = mpfmt,
|
|
|
|
.avformat = AV_PIX_FMT_NONE,
|
2014-11-04 21:26:31 +00:00
|
|
|
.flags = MP_IMGFLAG_BE | MP_IMGFLAG_LE | MP_IMGFLAG_RGB |
|
|
|
|
MP_IMGFLAG_HWACCEL,
|
2014-05-22 18:55:17 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
return (struct mp_imgfmt_desc) {0};
|
|
|
|
}
|
|
|
|
|
2013-11-05 20:59:26 +00:00
|
|
|
struct mp_imgfmt_desc mp_imgfmt_get_desc(int mpfmt)
|
2012-12-31 00:58:25 +00:00
|
|
|
{
|
2013-11-29 16:39:57 +00:00
|
|
|
enum AVPixelFormat fmt = imgfmt2pixfmt(mpfmt);
|
|
|
|
const AVPixFmtDescriptor *pd = av_pix_fmt_desc_get(fmt);
|
video: passthrough unknown AVPixelFormats
This is a rather radical change: instead of maintaining a whitelist of
FFmpeg formats we support, we automatically support all formats.
In general, a format which doesn't have an explicit IMGFMT_* name will
be converted to a known format through libswscale, or will be handled
by code which can treat pixel formats in a generic way using the pixel
format description, like vo_opengl.
AV_PIX_FMT_UYYVYY411 is a special-case. It's packed YUV with chroma
subsampling by 4 in both directions. Its component order is documented
as "Cb Y0 Y1 Cr Y2 Y3", meaning there's one UV sample for 4 Y samples.
This means each pixel uses 1.5 bytes (4 pixels have 1 UV sample, so
4 bytes + 2 bytes). FFmpeg can actually handle this format with its
generic mechanism in an extremely awkward way, but it doesn't work for
us. Blacklist it, and hope no similar formats will be added in the
future.
Currently, the AV_PIX_FMT_*s allowed are limited to a numeric value of
500. More is not allowed, and there are some fixed size arrays that need
to contain any possible format (look for IMGFMT_END dependencies).
We could have this simpler by replacing IMGFMT_* with AV_PIX_FMT_*
through the whole codebase. But for now, this is better, because we
can compensate for formats missing in Libav or older FFmpeg versions,
like AV_PIX_FMT_RGB0 and others.
2014-11-04 22:32:02 +00:00
|
|
|
if (!pd || pd->nb_components > 4 || fmt == AV_PIX_FMT_NONE ||
|
|
|
|
fmt == AV_PIX_FMT_UYYVYY411)
|
2014-05-22 18:55:17 +00:00
|
|
|
return mp_only_imgfmt_desc(mpfmt);
|
2013-11-05 20:59:26 +00:00
|
|
|
|
2012-12-31 00:58:25 +00:00
|
|
|
struct mp_imgfmt_desc desc = {
|
|
|
|
.id = mpfmt,
|
|
|
|
.avformat = fmt,
|
|
|
|
.chroma_xs = pd->log2_chroma_w,
|
|
|
|
.chroma_ys = pd->log2_chroma_h,
|
2015-01-21 18:29:18 +00:00
|
|
|
.component_bits = pd->comp[0].depth_minus1 + 1,
|
2012-12-31 00:58:25 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
int planedepth[4] = {0};
|
2013-12-08 22:38:35 +00:00
|
|
|
int el_size = (pd->flags & AV_PIX_FMT_FLAG_BITSTREAM) ? 1 : 8;
|
2014-11-04 22:32:02 +00:00
|
|
|
bool need_endian = false; // single component is spread over >1 bytes
|
2012-12-31 00:58:25 +00:00
|
|
|
for (int c = 0; c < pd->nb_components; c++) {
|
|
|
|
AVComponentDescriptor d = pd->comp[c];
|
|
|
|
// multiple components per plane -> Y is definitive, ignore chroma
|
|
|
|
if (!desc.bpp[d.plane])
|
|
|
|
desc.bpp[d.plane] = (d.step_minus1 + 1) * el_size;
|
|
|
|
planedepth[d.plane] += d.depth_minus1 + 1;
|
2014-11-04 22:32:02 +00:00
|
|
|
need_endian |= (d.depth_minus1 + 1 + d.shift) > 8;
|
2015-01-21 18:29:18 +00:00
|
|
|
if (d.depth_minus1 + 1 != desc.component_bits)
|
|
|
|
desc.component_bits = 0;
|
2012-12-31 00:58:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (int p = 0; p < 4; p++) {
|
|
|
|
if (desc.bpp[p])
|
|
|
|
desc.num_planes++;
|
|
|
|
}
|
|
|
|
|
2014-11-04 22:32:02 +00:00
|
|
|
desc.plane_bits = planedepth[0];
|
|
|
|
|
|
|
|
// Check whether any components overlap other components (per plane).
|
|
|
|
// We're cheating/simplifying here: we assume that this happens if a shift
|
|
|
|
// is set - which is wrong in general (could be needed for padding, instead
|
|
|
|
// of overlapping bits of another component). Needed for rgb444le/be.
|
|
|
|
bool component_byte_overlap = false;
|
|
|
|
for (int c = 0; c < pd->nb_components; c++) {
|
|
|
|
AVComponentDescriptor d = pd->comp[c];
|
|
|
|
component_byte_overlap |= d.shift > 0 && planedepth[d.plane] > 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If every component sits in its own byte, or all components are within
|
|
|
|
// a single byte, no endian-dependent access is needed. If components
|
|
|
|
// stride bytes (like with packed 2 byte RGB formats), endian-dependent
|
|
|
|
// access is needed.
|
|
|
|
need_endian |= component_byte_overlap;
|
|
|
|
|
|
|
|
if (!need_endian) {
|
video: decouple internal pixel formats from FourCCs
mplayer's video chain traditionally used FourCCs for pixel formats. For
example, it used IMGFMT_YV12 for 4:2:0 YUV, which was defined to the
string 'YV12' interpreted as unsigned int. Additionally, it used to
encode information into the numeric values of some formats. The RGB
formats had their bit depth and endian encoded into the least
significant byte. Extended planar formats (420P10 etc.) had chroma
shift, endian, and component bit depth encoded. (This has been removed
in recent commits.)
Replace the FourCC mess with a simple enum. Remove all the redundant
formats like YV12/I420/IYUV. Replace some image format names by
something more intuitive, most importantly IMGFMT_YV12 -> IMGFMT_420P.
Add img_fourcc.h, which contains the old IDs for code that actually uses
FourCCs. Change the way demuxers, that output raw video, identify the
video format: they set either MP_FOURCC_RAWVIDEO or MP_FOURCC_IMGFMT to
request the rawvideo decoder, and sh_video->imgfmt specifies the pixel
format. Like the previous hack, this is supposed to avoid the need for
a complete codecs.cfg entry per format, or other lookup tables. (Note
that the RGB raw video FourCCs mostly rely on ffmpeg's mappings for NUT
raw video, but this is still considered better than adding a raw video
decoder - even if trivial, it would be full of annoying lookup tables.)
The TV code has not been tested.
Some corrective changes regarding endian and other image format flags
creep in.
2012-12-23 19:03:30 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_LE | MP_IMGFLAG_BE;
|
|
|
|
} else {
|
2013-12-08 22:38:35 +00:00
|
|
|
desc.flags |= (pd->flags & AV_PIX_FMT_FLAG_BE)
|
|
|
|
? MP_IMGFLAG_BE : MP_IMGFLAG_LE;
|
video: decouple internal pixel formats from FourCCs
mplayer's video chain traditionally used FourCCs for pixel formats. For
example, it used IMGFMT_YV12 for 4:2:0 YUV, which was defined to the
string 'YV12' interpreted as unsigned int. Additionally, it used to
encode information into the numeric values of some formats. The RGB
formats had their bit depth and endian encoded into the least
significant byte. Extended planar formats (420P10 etc.) had chroma
shift, endian, and component bit depth encoded. (This has been removed
in recent commits.)
Replace the FourCC mess with a simple enum. Remove all the redundant
formats like YV12/I420/IYUV. Replace some image format names by
something more intuitive, most importantly IMGFMT_YV12 -> IMGFMT_420P.
Add img_fourcc.h, which contains the old IDs for code that actually uses
FourCCs. Change the way demuxers, that output raw video, identify the
video format: they set either MP_FOURCC_RAWVIDEO or MP_FOURCC_IMGFMT to
request the rawvideo decoder, and sh_video->imgfmt specifies the pixel
format. Like the previous hack, this is supposed to avoid the need for
a complete codecs.cfg entry per format, or other lookup tables. (Note
that the RGB raw video FourCCs mostly rely on ffmpeg's mappings for NUT
raw video, but this is still considered better than adding a raw video
decoder - even if trivial, it would be full of annoying lookup tables.)
The TV code has not been tested.
Some corrective changes regarding endian and other image format flags
creep in.
2012-12-23 19:03:30 +00:00
|
|
|
}
|
2012-12-31 00:58:25 +00:00
|
|
|
|
2014-11-05 00:16:57 +00:00
|
|
|
if (fmt == AV_PIX_FMT_XYZ12LE || fmt == AV_PIX_FMT_XYZ12BE) {
|
2013-05-01 21:58:48 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_XYZ;
|
2013-12-08 22:38:35 +00:00
|
|
|
} else if (!(pd->flags & AV_PIX_FMT_FLAG_RGB) &&
|
|
|
|
fmt != AV_PIX_FMT_MONOBLACK &&
|
|
|
|
fmt != AV_PIX_FMT_PAL8)
|
2012-12-31 00:58:25 +00:00
|
|
|
{
|
|
|
|
desc.flags |= MP_IMGFLAG_YUV;
|
2012-12-24 00:10:57 +00:00
|
|
|
} else {
|
|
|
|
desc.flags |= MP_IMGFLAG_RGB;
|
2012-12-31 00:58:25 +00:00
|
|
|
}
|
|
|
|
|
2013-12-08 22:38:35 +00:00
|
|
|
if (pd->flags & AV_PIX_FMT_FLAG_ALPHA)
|
2012-12-31 00:58:25 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_ALPHA;
|
|
|
|
|
2013-11-05 20:59:26 +00:00
|
|
|
if (mpfmt >= IMGFMT_RGB0_START && mpfmt <= IMGFMT_RGB0_END)
|
|
|
|
desc.flags &= ~MP_IMGFLAG_ALPHA;
|
|
|
|
|
2012-12-26 22:12:30 +00:00
|
|
|
if (desc.num_planes == pd->nb_components)
|
2012-12-31 00:58:25 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_PLANAR;
|
|
|
|
|
2013-12-08 22:38:35 +00:00
|
|
|
if (!(pd->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
|
|
|
|
!(pd->flags & AV_PIX_FMT_FLAG_BITSTREAM))
|
|
|
|
{
|
2013-01-14 17:37:17 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_BYTE_ALIGNED;
|
|
|
|
for (int p = 0; p < desc.num_planes; p++)
|
|
|
|
desc.bytes[p] = desc.bpp[p] / 8;
|
|
|
|
}
|
|
|
|
|
2013-12-01 19:45:44 +00:00
|
|
|
// PSEUDOPAL is a complete braindeath nightmare, however it seems various
|
|
|
|
// parts of FFmpeg expect that it has a palette allocated.
|
2013-12-08 22:38:35 +00:00
|
|
|
if (pd->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL))
|
2013-12-01 19:45:44 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_PAL;
|
|
|
|
|
2013-01-14 17:37:17 +00:00
|
|
|
if ((desc.flags & MP_IMGFLAG_YUV) && (desc.flags & MP_IMGFLAG_BYTE_ALIGNED))
|
|
|
|
{
|
2012-12-31 00:58:25 +00:00
|
|
|
bool same_depth = true;
|
|
|
|
for (int p = 0; p < desc.num_planes; p++) {
|
|
|
|
same_depth &= planedepth[p] == planedepth[0] &&
|
|
|
|
desc.bpp[p] == desc.bpp[0];
|
|
|
|
}
|
|
|
|
if (same_depth && pd->nb_components == desc.num_planes)
|
|
|
|
desc.flags |= MP_IMGFLAG_YUV_P;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int p = 0; p < desc.num_planes; p++) {
|
|
|
|
desc.xs[p] = (p == 1 || p == 2) ? desc.chroma_xs : 0;
|
|
|
|
desc.ys[p] = (p == 1 || p == 2) ? desc.chroma_ys : 0;
|
|
|
|
}
|
|
|
|
|
2012-12-25 21:29:49 +00:00
|
|
|
desc.align_x = 1 << desc.chroma_xs;
|
|
|
|
desc.align_y = 1 << desc.chroma_ys;
|
|
|
|
|
|
|
|
if ((desc.bpp[0] % 8) != 0)
|
|
|
|
desc.align_x = 8 / desc.bpp[0]; // expect power of 2
|
|
|
|
|
2015-01-10 18:11:28 +00:00
|
|
|
if (pd->flags & AV_PIX_FMT_FLAG_HWACCEL) {
|
2014-11-04 21:26:31 +00:00
|
|
|
desc.flags |= MP_IMGFLAG_HWACCEL;
|
2015-01-10 18:11:28 +00:00
|
|
|
desc.plane_bits = 8; // usually restricted to 8 bit; may change
|
|
|
|
}
|
2014-11-04 21:26:31 +00:00
|
|
|
|
2012-12-31 00:58:25 +00:00
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
2012-12-25 13:54:42 +00:00
|
|
|
// Find a format that is MP_IMGFLAG_YUV_P with the following configuration.
|
|
|
|
int mp_imgfmt_find_yuv_planar(int xs, int ys, int planes, int component_bits)
|
|
|
|
{
|
|
|
|
for (int n = IMGFMT_START + 1; n < IMGFMT_END; n++) {
|
|
|
|
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(n);
|
|
|
|
if (desc.id && (desc.flags & MP_IMGFLAG_YUV_P)) {
|
|
|
|
if (desc.num_planes == planes && desc.chroma_xs == xs &&
|
|
|
|
desc.chroma_ys == ys && desc.plane_bits == component_bits &&
|
|
|
|
(desc.flags & MP_IMGFLAG_NE))
|
|
|
|
return desc.id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2014-11-04 22:52:29 +00:00
|
|
|
|
vf_scale: replace ancient fallback image format selection
If video output and VO don't support the same format, a conversion
filter needs to be insert. Since a VO can support multiple formats, and
the filter chain also can deal with multiple formats, you basically have
to pick from a huge matrix of possible conversions.
The old MPlayer code had a quite naive algorithm: it first checked
whether any conversion from the list of preferred conversions matched,
and if not, it was falling back on checking a hardcoded list of output
formats (more or less sorted by quality). This had some unintended side-
effects, like not using obvious "replacement" formats, selecting the
wrong colorspace, selecting a bit depth that is too high or too low, and
more.
Use avcodec_find_best_pix_fmt_of_list() provided by FFmpeg instead. This
function was made for this purpose, and should select the "best" format.
Libav provides a similar function, but with a different name - there is
a function with the same name in FFmpeg, but it has different semantics
(I'm not sure if Libav or FFmpeg fucked up here).
This also removes handling of VFCAP_CSP_SUPPORTED vs.
VFCAP_CSP_SUPPORTED_BY_HW, which has no meaning anymore, except possibly
for filter chains with multiple scale filters.
Fixes #1494.
2015-01-21 17:33:47 +00:00
|
|
|
#if LIBAVUTIL_VERSION_MICRO < 100
|
|
|
|
#define avcodec_find_best_pix_fmt_of_list avcodec_find_best_pix_fmt2
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Compare the dst image formats, and return the one which can carry more data
|
|
|
|
// (e.g. higher depth, more color components, lower chroma subsampling, etc.),
|
|
|
|
// with respect to what is required to keep most of the src format.
|
|
|
|
// Returns the imgfmt, or 0 on error.
|
|
|
|
int mp_imgfmt_select_best(int dst1, int dst2, int src)
|
|
|
|
{
|
|
|
|
enum AVPixelFormat dst1pxf = imgfmt2pixfmt(dst1);
|
|
|
|
enum AVPixelFormat dst2pxf = imgfmt2pixfmt(dst2);
|
|
|
|
enum AVPixelFormat srcpxf = imgfmt2pixfmt(src);
|
|
|
|
enum AVPixelFormat dstlist[] = {dst1pxf, dst2pxf, AV_PIX_FMT_NONE};
|
2015-01-21 20:49:15 +00:00
|
|
|
return pixfmt2imgfmt(avcodec_find_best_pix_fmt_of_list(dstlist, srcpxf, 1, 0));
|
vf_scale: replace ancient fallback image format selection
If video output and VO don't support the same format, a conversion
filter needs to be insert. Since a VO can support multiple formats, and
the filter chain also can deal with multiple formats, you basically have
to pick from a huge matrix of possible conversions.
The old MPlayer code had a quite naive algorithm: it first checked
whether any conversion from the list of preferred conversions matched,
and if not, it was falling back on checking a hardcoded list of output
formats (more or less sorted by quality). This had some unintended side-
effects, like not using obvious "replacement" formats, selecting the
wrong colorspace, selecting a bit depth that is too high or too low, and
more.
Use avcodec_find_best_pix_fmt_of_list() provided by FFmpeg instead. This
function was made for this purpose, and should select the "best" format.
Libav provides a similar function, but with a different name - there is
a function with the same name in FFmpeg, but it has different semantics
(I'm not sure if Libav or FFmpeg fucked up here).
This also removes handling of VFCAP_CSP_SUPPORTED vs.
VFCAP_CSP_SUPPORTED_BY_HW, which has no meaning anymore, except possibly
for filter chains with multiple scale filters.
Fixes #1494.
2015-01-21 17:33:47 +00:00
|
|
|
}
|
|
|
|
|
2014-11-04 22:52:29 +00:00
|
|
|
#if 0
|
|
|
|
|
|
|
|
#include <libavutil/frame.h>
|
|
|
|
#include "sws_utils.h"
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
const AVPixFmtDescriptor *avd = av_pix_fmt_desc_next(NULL);
|
|
|
|
for (; avd; avd = av_pix_fmt_desc_next(avd)) {
|
|
|
|
enum AVPixelFormat fmt = av_pix_fmt_desc_get_id(avd);
|
|
|
|
if (fmt == AV_PIX_FMT_YUVJ420P || fmt == AV_PIX_FMT_YUVJ422P ||
|
|
|
|
fmt == AV_PIX_FMT_YUVJ444P || fmt == AV_PIX_FMT_YUVJ440P)
|
|
|
|
continue;
|
|
|
|
printf("%s (%d)", avd->name, (int)fmt);
|
|
|
|
int mpfmt = pixfmt2imgfmt(fmt);
|
|
|
|
bool generic = mpfmt >= IMGFMT_AVPIXFMT_START &&
|
|
|
|
mpfmt < IMGFMT_AVPIXFMT_END;
|
|
|
|
printf(" mp=%d%s\n ", mpfmt, generic ? " [GENERIC]" : "");
|
|
|
|
struct mp_imgfmt_desc d = mp_imgfmt_get_desc(mpfmt);
|
|
|
|
if (d.id)
|
|
|
|
assert(d.avformat == fmt);
|
|
|
|
#define FLAG(t, c) if (d.flags & (t)) printf("[%s]", c);
|
|
|
|
FLAG(MP_IMGFLAG_BYTE_ALIGNED, "BA")
|
|
|
|
FLAG(MP_IMGFLAG_ALPHA, "a")
|
|
|
|
FLAG(MP_IMGFLAG_PLANAR, "P")
|
|
|
|
FLAG(MP_IMGFLAG_YUV_P, "YUVP")
|
|
|
|
FLAG(MP_IMGFLAG_YUV, "yuv")
|
|
|
|
FLAG(MP_IMGFLAG_RGB, "rgb")
|
|
|
|
FLAG(MP_IMGFLAG_XYZ, "xyz")
|
|
|
|
FLAG(MP_IMGFLAG_LE, "le")
|
|
|
|
FLAG(MP_IMGFLAG_BE, "be")
|
|
|
|
FLAG(MP_IMGFLAG_PAL, "pal")
|
|
|
|
FLAG(MP_IMGFLAG_HWACCEL, "hw")
|
|
|
|
printf("\n");
|
2015-01-21 18:29:18 +00:00
|
|
|
printf(" planes=%d, chroma=%d:%d align=%d:%d bits=%d cbits=%d\n",
|
|
|
|
d.num_planes, d.chroma_xs, d.chroma_ys, d.align_x, d.align_y,
|
|
|
|
d.plane_bits, d.component_bits);
|
2014-11-04 22:52:29 +00:00
|
|
|
printf(" {");
|
|
|
|
for (int n = 0; n < MP_MAX_PLANES; n++)
|
|
|
|
printf("%d/%d/[%d:%d] ", d.bytes[n], d.bpp[n], d.xs[n], d.ys[n]);
|
|
|
|
printf("}\n");
|
|
|
|
if (mpfmt && !(d.flags & MP_IMGFLAG_HWACCEL) && fmt != AV_PIX_FMT_UYYVYY411)
|
|
|
|
{
|
|
|
|
AVFrame *fr = av_frame_alloc();
|
|
|
|
fr->format = fmt;
|
|
|
|
fr->width = 128;
|
|
|
|
fr->height = 128;
|
|
|
|
int err = av_frame_get_buffer(fr, SWS_MIN_BYTE_ALIGN);
|
|
|
|
assert(err >= 0);
|
|
|
|
struct mp_image *mpi = mp_image_alloc(mpfmt, fr->width, fr->height);
|
|
|
|
assert(mpi);
|
|
|
|
// A rather fuzzy test, which might fail even if there's no bug.
|
|
|
|
for (int n = 0; n < 4; n++) {
|
|
|
|
assert(!!mpi->planes[n] == !!fr->data[n]);
|
|
|
|
assert(mpi->stride[n] == fr->linesize[n]);
|
|
|
|
}
|
|
|
|
talloc_free(mpi);
|
|
|
|
av_frame_free(&fr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|