RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity

video: use libavutil pixel format descriptors 

Replace the internal pixel format stuff with code that queries the
libavutil list of pixel format descriptors.

Trying to map IMGFMT_IS_RGB() etc. turned out extremely hacky.
This commit is contained in:
wm4 2012-12-31 01:58:25 +01:00
parent 6e0b730044
commit 00653a3eb0
4 changed files with 307 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

312
video/img_format.c
View File

@ -16,122 +16,18 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <assert.h>
#include <libavutil/pixfmt.h>
#include <libavutil/pixdesc.h>
#include "config.h"
#include "video/img_format.h"
#include "stdio.h"
#include "compat/mpbswap.h"
#include "video/mp_image.h"
#include "video/fmt-conversion.h"
#include <string.h>
const char *vo_format_name(int format)
{
const char *name = mp_imgfmt_to_name(format);
if (name)
return name;
static char unknown_format[20];
snprintf(unknown_format, 20, "Unknown 0x%04x", format);
return unknown_format;
}
int mp_get_chroma_shift(int format, int *x_shift, int *y_shift,
int *component_bits)
{
int xs = 0, ys = 0;
int bpp;
int err = 0;
int bits = 8;
if ((format & 0xff0000f0) == 0x34000050)
format = bswap_32(format);
if ((format & 0xf00000ff) == 0x50000034) {
switch (format >> 24) {
case 0x50:
break;
case 0x51:
bits = 16;
break;
case 0x55:
bits = 14;
break;
case 0x54:
bits = 12;
break;
case 0x52:
bits = 10;
break;
case 0x53:
bits = 9;
break;
default:
err = 1;
break;
}
switch (format & 0x00ffffff) {
case 0x00343434: // 444
xs = 0;
ys = 0;
break;
case 0x00323234: // 422
xs = 1;
ys = 0;
break;
case 0x00303234: // 420
xs = 1;
ys = 1;
break;
case 0x00313134: // 411
xs = 2;
ys = 0;
break;
case 0x00303434: // 440
xs = 0;
ys = 1;
break;
default:
err = 1;
break;
}
} else
switch (format) {
case IMGFMT_420A:
case IMGFMT_I420:
case IMGFMT_IYUV:
case IMGFMT_YV12:
xs = 1;
ys = 1;
break;
case IMGFMT_IF09:
case IMGFMT_YVU9:
xs = 2;
ys = 2;
break;
case IMGFMT_Y8:
case IMGFMT_Y800:
xs = 31;
ys = 31;
break;
case IMGFMT_Y16BE:
case IMGFMT_Y16LE:
bits = 16;
xs = 31;
ys = 31;
break;
default:
err = 1;
break;
}
if (x_shift)
*x_shift = xs;
if (y_shift)
*y_shift = ys;
if (component_bits)
*component_bits = bits;
bpp = 8 + ((16 >> xs) >> ys);
if (format == IMGFMT_420A)
bpp += 8;
bpp *= (bits + 7) >> 3;
return err ? 0 : bpp;
}
struct mp_imgfmt_entry mp_imgfmt_list[] = {
{"444p16le", IMGFMT_444P16_LE},
{"444p16be", IMGFMT_444P16_BE},
@ -237,6 +133,32 @@ struct mp_imgfmt_entry mp_imgfmt_list[] = {
{0}
};
const char *vo_format_name(int format)
{
const char *name = mp_imgfmt_to_name(format);
if (name)
return name;
static char unknown_format[20];
snprintf(unknown_format, 20, "Unknown 0x%04x", format);
return unknown_format;
}
int mp_get_chroma_shift(int format, int *x_shift, int *y_shift,
int *component_bits)
{
struct mp_imgfmt_desc fmt = mp_imgfmt_get_desc(format);
if (fmt.id && (fmt.flags & MP_IMGFLAG_YUV_P)) {
if (x_shift)
*x_shift = fmt.xs[1];
if (y_shift)
*y_shift = fmt.ys[1];
if (component_bits)
*component_bits = fmt.plane_bits;
return fmt.avg_bpp;
}
return 0;
}
unsigned int mp_imgfmt_from_name(bstr name, bool allow_hwaccel)
{
if (bstr_startswith0(name, "0x")) {
@ -264,3 +186,171 @@ const char *mp_imgfmt_to_name(unsigned int fmt)
}
return NULL;
}
static int comp_bit_order(const AVPixFmtDescriptor *pd, int bpp, int c)
{
int el_size = (pd->flags & PIX_FMT_BITSTREAM) ? 1 : 8;
// NOTE: offset_plus1 can be 0
int offset = (((int)pd->comp[c].offset_plus1) - 1) * el_size;
int read_depth = pd->comp[c].shift + pd->comp[c].depth_minus1 + 1;
if (read_depth <= 8 && !(pd->flags & PIX_FMT_BITSTREAM))
offset += 8 * !!(pd->flags & PIX_FMT_BE);
offset += pd->comp[c].shift;
// revert ffmpeg's bullshit hack that mixes byte and bit access
if ((pd->flags & PIX_FMT_BE) && bpp <= 16 && read_depth <= 8)
offset = (8 + offset) % 16;
return offset;
}
static struct mp_imgfmt_desc get_avutil_fmt(enum PixelFormat fmt)
{
const AVPixFmtDescriptor *pd = &av_pix_fmt_descriptors[fmt];
int mpfmt = pixfmt2imgfmt(fmt);
if (!pd || !mpfmt)
return (struct mp_imgfmt_desc) {0};
struct mp_imgfmt_desc desc = {
.id = mpfmt,
.avformat = fmt,
.name = mp_imgfmt_to_name(desc.id),
.chroma_xs = pd->log2_chroma_w,
.chroma_ys = pd->log2_chroma_h,
};
int planedepth[4] = {0};
int xs[4] = {0, pd->log2_chroma_w, pd->log2_chroma_w, 0};
int ys[4] = {0, pd->log2_chroma_h, pd->log2_chroma_h, 0};
int el_size = (pd->flags & PIX_FMT_BITSTREAM) ? 1 : 8;
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;
}
int avgbpp16 = 0;
for (int p = 0; p < 4; p++)
avgbpp16 += (16 * desc.bpp[p]) >> xs[p] >> ys[p];
desc.avg_bpp = avgbpp16 / 16;
//assert(desc.avg_bpp == av_get_padded_bits_per_pixel(pd));
for (int p = 0; p < 4; p++) {
if (desc.bpp[p])
desc.num_planes++;
}
if (desc.bpp[0] <= 8 || !(pd->flags & PIX_FMT_BE))
desc.flags |= MP_IMGFLAG_NE;
desc.plane_bits = planedepth[0];
if (!(pd->flags & PIX_FMT_RGB) && !(pd->flags & PIX_FMT_HWACCEL) &&
fmt != PIX_FMT_MONOWHITE && fmt != PIX_FMT_MONOBLACK &&
fmt != PIX_FMT_PAL8)
{
desc.flags |= MP_IMGFLAG_YUV;
}
#ifdef PIX_FMT_ALPHA
if (pd->flags & PIX_FMT_ALPHA)
desc.flags |= MP_IMGFLAG_ALPHA;
#else
if (desc.num_planes > 3)
desc.flags |= MP_IMGFLAG_ALPHA;
#endif
if (desc.num_planes > 1)
desc.flags |= MP_IMGFLAG_PLANAR;
if (desc.flags & MP_IMGFLAG_YUV) {
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;
}
if ((pd->flags & PIX_FMT_RGB) && desc.num_planes == 1
&& pd->nb_components >= 3)
{
// RGB vs. BGR component order, as distinguished by mplayer:
// - for byte accessed formats (RGB24, RGB48), the order of bytes
// determines RGB/BGR (e.g. R is first byte -> RGB)
// - for bit accessed formats (RGB32, RGB16, etc.), the order of bits
// determines BGR/RGB (e.g. R is LSB -> RGB)
// - formats like IMGFMT_RGBA are aliases to allow byte access to bit-
// accessed formats (IMGFMT_RGBA is RGB32 on LE, BGR32|128 on BE)
// (ffmpeg does it the other way around, and defines bit-access
// aliases to byte-accessed formats)
int b = desc.bpp[0];
bool swap = comp_bit_order(pd, b, 0) > comp_bit_order(pd, b, 1);
if ((desc.bpp[0] == 24 || desc.bpp[0] > 32) && BYTE_ORDER == BIG_ENDIAN)
swap = !swap; // byte accessed
if (swap)
desc.flags |= MP_IMGFLAG_SWAPPED;
}
// compatibility with old mp_image_setfmt()
switch (desc.id) {
case IMGFMT_I420:
case IMGFMT_IYUV:
desc.flags |= MP_IMGFLAG_SWAPPED; // completely pointless
break;
case IMGFMT_UYVY:
desc.flags |= MP_IMGFLAG_SWAPPED; // for vf_mpi_clear()
/* fallthrough */
case IMGFMT_YUY2:
desc.chroma_ys = 1; // ???
break;
case IMGFMT_Y8:
case IMGFMT_Y800:
case IMGFMT_Y16LE:
case IMGFMT_Y16BE:
// probably for vo_opengl, and possibly more code using Y8
desc.chroma_xs = desc.chroma_ys = 31;
break;
case IMGFMT_NV12:
desc.flags |= MP_IMGFLAG_SWAPPED; // completely pointless
/* fallthrough */
case IMGFMT_NV21:
// some hack to make cropping code etc. work? (doesn't work anyway)
desc.chroma_xs = 0;
desc.chroma_ys = 1;
break;
case IMGFMT_RGB4:
case IMGFMT_BGR4:
case IMGFMT_BGR1:
desc.flags ^= MP_IMGFLAG_SWAPPED; // ???
break;
case IMGFMT_BGR0:
desc.flags &= ~MP_IMGFLAG_SWAPPED; // not covered by IS_RGB/IS_BGR
break;
}
if (pd->flags & PIX_FMT_HWACCEL)
desc.chroma_xs = desc.chroma_ys = 0;
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;
}
return desc;
}
struct mp_imgfmt_desc mp_imgfmt_get_desc(unsigned int out_fmt)
{
struct mp_imgfmt_desc fmt = {0};
enum PixelFormat avfmt = imgfmt2pixfmt(out_fmt);
if (avfmt != PIX_FMT_NONE)
fmt = get_avutil_fmt(avfmt);
if (!fmt.id) {
mp_msg(MSGT_DECVIDEO, MSGL_V, "mp_image: unknown out_fmt: 0x%X\n",
out_fmt);
}
return fmt;
}

79
video/img_format.h
View File

@ -23,6 +23,46 @@
#include "config.h"
#include "core/bstr.h"
#define MP_MAX_PLANES 4
// set if (possibly) alpha is included (might be not definitive for packed RGB)
#define MP_IMGFLAG_ALPHA 0x80
// set if number of planes > 1
#define MP_IMGFLAG_PLANAR 0x100
// set if it's YUV colorspace
#define MP_IMGFLAG_YUV 0x200
// set if it's swapped (BGR or YVU) plane/byteorder
#define MP_IMGFLAG_SWAPPED 0x400
// set if you want memory for palette allocated and managed by vf_get_image etc.
#define MP_IMGFLAG_RGB_PALETTE 0x800
// set if the format is standard YUV format:
// - planar and yuv colorspace
// - chroma shift 0-2
// - 1-4 planes (1: gray, 2: gray/alpha, 3: yuv, 4: yuv/alpha)
// - 8-16 bit per pixel/plane, all planes have same depth
#define MP_IMGFLAG_YUV_P 0x1000
// set if format is in native endian, or <= 8 bit per pixel/plane
#define MP_IMGFLAG_NE 0x2000
#define MP_IMGFLAG_FMT_MASK 0x3FFF
struct mp_imgfmt_desc {
int id; // IMGFMT_*
int avformat; // AV_PIX_FMT_* (or AV_PIX_FMT_NONE)
const char *name; // e.g. "420p16"
int flags; // MP_IMGFLAG_* bitfield
int num_planes;
int chroma_xs, chroma_ys; // chroma shift (i.e. log2 of chroma pixel size)
int avg_bpp;
int bpp[MP_MAX_PLANES];
int plane_bits; // number of bits in use for plane 0
// chroma shifts per plane (provided for convenience with planar formats)
int xs[MP_MAX_PLANES];
int ys[MP_MAX_PLANES];
};
struct mp_imgfmt_desc mp_imgfmt_get_desc(unsigned int out_fmt);
/* RGB/BGR Formats */
#define IMGFMT_RGB_MASK 0xFFFFFF00
@ -95,14 +135,26 @@
#define IMGFMT_RG4B IMGFMT_RGB4_CHAR
#define IMGFMT_BG4B IMGFMT_BGR4_CHAR
#define IMGFMT_IS_RGB(fmt) (((fmt)&IMGFMT_RGB_MASK)==IMGFMT_RGB)
#define IMGFMT_IS_BGR(fmt) (((fmt)&IMGFMT_BGR_MASK)==IMGFMT_BGR)
#define IMGFMT_RGB_DEPTH(fmt) ((fmt)&0x3F)
#define IMGFMT_BGR_DEPTH(fmt) ((fmt)&0x3F)
// AV_PIX_FMT_BGR0
#define IMGFMT_BGR0 0x1DC70000
static inline bool IMGFMT_IS_RGB(unsigned int fmt)
{
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(fmt);
return !(desc.flags & MP_IMGFLAG_YUV) && !(desc.flags & MP_IMGFLAG_SWAPPED)
&& desc.num_planes == 1 && desc.id != IMGFMT_BGR0;
}
static inline bool IMGFMT_IS_BGR(unsigned int fmt)
{
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(fmt);
return !(desc.flags & MP_IMGFLAG_YUV) && (desc.flags & MP_IMGFLAG_SWAPPED)
&& desc.num_planes == 1 && desc.id != IMGFMT_BGR0;
}
#define IMGFMT_RGB_DEPTH(fmt) (mp_imgfmt_get_desc(fmt).plane_bits)
#define IMGFMT_BGR_DEPTH(fmt) (mp_imgfmt_get_desc(fmt).plane_bits)
// AV_PIX_FMT_GRAY16LE
#define IMGFMT_Y16LE 0x1DC70001
// AV_PIX_FMT_GRAY16BE
@ -203,9 +255,20 @@
#define IMGFMT_IS_YUVP16_NE(fmt) IMGFMT_IS_YUVP16_LE(fmt)
#endif
// These macros are misnamed - they actually match 9 to 16 bits (inclusive)
#define IMGFMT_IS_YUVP16_LE(fmt) (((fmt - 0x51000034) & 0xf80000ff) == 0 || fmt == IMGFMT_Y16LE)
#define IMGFMT_IS_YUVP16_BE(fmt) (((fmt - 0x34000051) & 0xff0000f8) == 0 || fmt == IMGFMT_Y16BE)
// These functions are misnamed - they actually match 9 to 16 bits (inclusive)
static inline bool IMGFMT_IS_YUVP16_LE(int fmt) {
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(fmt);
bool le_is_ne = BYTE_ORDER == LITTLE_ENDIAN;
return (desc.flags & MP_IMGFLAG_YUV_P) && desc.plane_bits > 8 &&
(le_is_ne == !!(desc.flags & MP_IMGFLAG_NE));
}
static inline bool IMGFMT_IS_YUVP16_BE(int fmt) {
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(fmt);
bool be_is_ne = BYTE_ORDER == BIG_ENDIAN;
return (desc.flags & MP_IMGFLAG_YUV_P) && desc.plane_bits > 8 &&
(be_is_ne == !!(desc.flags & MP_IMGFLAG_NE));
}
#define IMGFMT_IS_YUVP16(fmt) (IMGFMT_IS_YUVP16_LE(fmt) || IMGFMT_IS_YUVP16_BE(fmt))
/* Packed YUV Formats */

149
video/mp_image.c
View File

@ -23,16 +23,16 @@
#include <string.h>
#include <assert.h>
#include <libavutil/mem.h>
#include <libavutil/common.h>
#include "talloc.h"
#include "video/img_format.h"
#include "video/mp_image.h"
#include "video/sws_utils.h"
#include "video/filter/vf.h"
#include "video/memcpy_pic.h"
#include "libavutil/mem.h"
#include "libavutil/common.h"
struct m_refcount {
void *arg;
@ -161,129 +161,18 @@ void mp_image_copy_attributes(struct mp_image *dmpi, struct mp_image *mpi)
vf_clone_mpi_attributes(dmpi, mpi);
}
void mp_image_setfmt(mp_image_t* mpi,unsigned int out_fmt){
mpi->flags&=~(MP_IMGFLAG_PLANAR|MP_IMGFLAG_YUV|MP_IMGFLAG_SWAPPED);
mpi->imgfmt=out_fmt;
// compressed formats
if(IMGFMT_IS_HWACCEL(out_fmt)){
mpi->bpp=0;
return;
}
mpi->num_planes=1;
if (IMGFMT_IS_RGB(out_fmt)) {
if (IMGFMT_RGB_DEPTH(out_fmt) < 8 && !(out_fmt&128))
mpi->bpp = IMGFMT_RGB_DEPTH(out_fmt);
else
mpi->bpp=(IMGFMT_RGB_DEPTH(out_fmt)+7)&(~7);
return;
}
if (IMGFMT_IS_BGR(out_fmt)) {
if (IMGFMT_BGR_DEPTH(out_fmt) < 8 && !(out_fmt&128))
mpi->bpp = IMGFMT_BGR_DEPTH(out_fmt);
else
mpi->bpp=(IMGFMT_BGR_DEPTH(out_fmt)+7)&(~7);
mpi->flags|=MP_IMGFLAG_SWAPPED;
return;
}
switch (out_fmt) {
case IMGFMT_BGR0:
mpi->bpp = 32;
return;
}
mpi->num_planes=3;
if (out_fmt == IMGFMT_GBRP) {
mpi->bpp=24;
mpi->flags|=MP_IMGFLAG_PLANAR;
mpi->chroma_x_shift = 0;
mpi->chroma_y_shift = 0;
mpi->chroma_width=mpi->w;
mpi->chroma_height=mpi->h;
return;
}
mpi->flags|=MP_IMGFLAG_YUV;
if (mp_get_chroma_shift(out_fmt, NULL, NULL, NULL)) {
mpi->flags|=MP_IMGFLAG_PLANAR;
mpi->bpp = mp_get_chroma_shift(out_fmt, &mpi->chroma_x_shift, &mpi->chroma_y_shift, NULL);
mpi->chroma_width = mpi->w >> mpi->chroma_x_shift;
mpi->chroma_height = mpi->h >> mpi->chroma_y_shift;
}
switch(out_fmt){
case IMGFMT_I420:
case IMGFMT_IYUV:
mpi->flags|=MP_IMGFLAG_SWAPPED;
case IMGFMT_YV12:
return;
case IMGFMT_420A:
case IMGFMT_IF09:
mpi->num_planes=4;
case IMGFMT_YVU9:
case IMGFMT_444P:
case IMGFMT_422P:
case IMGFMT_411P:
case IMGFMT_440P:
case IMGFMT_444P16_LE:
case IMGFMT_444P16_BE:
case IMGFMT_444P14_LE:
case IMGFMT_444P14_BE:
case IMGFMT_444P12_LE:
case IMGFMT_444P12_BE:
case IMGFMT_444P10_LE:
case IMGFMT_444P10_BE:
case IMGFMT_444P9_LE:
case IMGFMT_444P9_BE:
case IMGFMT_422P16_LE:
case IMGFMT_422P16_BE:
case IMGFMT_422P14_LE:
case IMGFMT_422P14_BE:
case IMGFMT_422P12_LE:
case IMGFMT_422P12_BE:
case IMGFMT_422P10_LE:
case IMGFMT_422P10_BE:
case IMGFMT_422P9_LE:
case IMGFMT_422P9_BE:
case IMGFMT_420P16_LE:
case IMGFMT_420P16_BE:
case IMGFMT_420P14_LE:
case IMGFMT_420P14_BE:
case IMGFMT_420P12_LE:
case IMGFMT_420P12_BE:
case IMGFMT_420P10_LE:
case IMGFMT_420P10_BE:
case IMGFMT_420P9_LE:
case IMGFMT_420P9_BE:
return;
case IMGFMT_Y800:
case IMGFMT_Y8:
case IMGFMT_Y16LE:
case IMGFMT_Y16BE:
/* they're planar ones, but for easier handling use them as packed */
mpi->flags&=~MP_IMGFLAG_PLANAR;
mpi->num_planes=1;
return;
case IMGFMT_UYVY:
mpi->flags|=MP_IMGFLAG_SWAPPED;
case IMGFMT_YUY2:
mpi->chroma_x_shift = 1;
mpi->chroma_y_shift = 1;
mpi->chroma_width=(mpi->w>>1);
mpi->chroma_height=(mpi->h>>1);
mpi->bpp=16;
mpi->num_planes=1;
return;
case IMGFMT_NV12:
mpi->flags|=MP_IMGFLAG_SWAPPED;
case IMGFMT_NV21:
mpi->flags|=MP_IMGFLAG_PLANAR;
mpi->bpp=12;
mpi->num_planes=2;
mpi->chroma_width=(mpi->w>>0);
mpi->chroma_height=(mpi->h>>1);
mpi->chroma_x_shift=0;
mpi->chroma_y_shift=1;
return;
}
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"mp_image: unknown out_fmt: 0x%X\n",out_fmt);
mpi->bpp=0;
void mp_image_setfmt(struct mp_image *mpi, unsigned int out_fmt)
{
mpi->flags &= ~MP_IMGFLAG_FMT_MASK;
struct mp_imgfmt_desc fmt = mp_imgfmt_get_desc(out_fmt);
mpi->fmt = fmt;
mpi->flags |= fmt.flags;
mpi->imgfmt = fmt.id;
mpi->bpp = fmt.avg_bpp;
mpi->chroma_x_shift = fmt.chroma_xs;
mpi->chroma_y_shift = fmt.chroma_ys;
mpi->num_planes = fmt.num_planes;
mp_image_set_size(mpi, mpi->w, mpi->h);
}
static int mp_image_destructor(void *ptr)
@ -318,8 +207,12 @@ void mp_image_set_size(struct mp_image *mpi, int w, int h)
{
mpi->w = w;
mpi->h = h;
mpi->chroma_width = mpi->w >> mpi->chroma_x_shift;
mpi->chroma_height = mpi->h >> mpi->chroma_y_shift;
for (int n = 0; n < mpi->num_planes; n++) {
mpi->plane_w[n] = mpi->w >> mpi->fmt.xs[n];
mpi->plane_h[n] = mpi->h >> mpi->fmt.ys[n];
}
mpi->chroma_width = mpi->plane_w[1];
mpi->chroma_height = mpi->plane_h[1];
mpi->display_w = mpi->display_h = 0;
}

31
video/mp_image.h
View File

@ -26,26 +26,14 @@
#include <inttypes.h>
#include "core/mp_msg.h"
#include "csputils.h"
#include "video/img_format.h"
// Minimum stride alignment in pixels
#define MP_STRIDE_ALIGNMENT 32
//--------- color info (filled by mp_image_setfmt() ) -----------
// set if number of planes > 1
#define MP_IMGFLAG_PLANAR 0x100
// set if it's YUV colorspace
#define MP_IMGFLAG_YUV 0x200
// set if it's swapped (BGR or YVU) plane/byteorder
#define MP_IMGFLAG_SWAPPED 0x400
// set if you want memory for palette allocated and managed by vf_get_image etc.
#define MP_IMGFLAG_RGB_PALETTE 0x800
// set if buffer is allocated (used in destination images):
#define MP_IMGFLAG_ALLOCATED 0x4000
#define MP_MAX_PLANES 4
#define MP_IMGFIELD_ORDERED 0x01
#define MP_IMGFIELD_TOP_FIRST 0x02
#define MP_IMGFIELD_REPEAT_FIRST 0x04
@ -71,23 +59,32 @@
*/
typedef struct mp_image {
unsigned int flags;
struct mp_imgfmt_desc fmt;
// fields redundant to fmt, for convenience or compatibility
unsigned char bpp; // bits/pixel. NOT depth! for RGB it will be n*8
unsigned int imgfmt;
int num_planes;
int chroma_x_shift; // horizontal
int chroma_y_shift; // vertical
int w,h; // visible dimensions
int display_w,display_h; // if set (!= 0), anamorphic size
uint8_t *planes[MP_MAX_PLANES];
int stride[MP_MAX_PLANES];
char * qscale;
int qstride;
int pict_type; // 0->unknown, 1->I, 2->P, 3->B
int fields;
int qscale_type; // 0->mpeg1/4/h263, 1->mpeg2
int num_planes;
/* these are only used by planar formats Y,U(Cb),V(Cr) */
/* redundant */
int chroma_width;
int chroma_height;
int chroma_x_shift; // horizontal
int chroma_y_shift; // vertical
int plane_w[MP_MAX_PLANES];
int plane_h[MP_MAX_PLANES];
enum mp_csp colorspace;
enum mp_csp_levels levels;
/* only inside filter chain */