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.

1 files changed, 192 insertions, 230 deletions

diff --git a/video/img_format.h b/video/img_format.h
index 48780cc694..1f617b573b 100644
--- a/video/img_format.h
+++ b/video/img_format.h
@@ -19,12 +19,20 @@
 #ifndef MPLAYER_IMG_FORMAT_H
 #define MPLAYER_IMG_FORMAT_H
 
+#include <inttypes.h>
 #include <sys/types.h>
-#include "config.h"
 #include "core/bstr.h"
 
+#if BYTE_ORDER == BIG_ENDIAN
+#define MP_SELECT_LE_BE(LE, BE) BE
+#else
+#define MP_SELECT_LE_BE(LE, BE) LE
+#endif
+
 #define MP_MAX_PLANES 4
 
+// All pixels start in byte boundaries
+#define MP_IMGFLAG_BYTE_ALIGNED 0x1
 // set if (possibly) alpha is included (might be not definitive for packed RGB)
 #define MP_IMGFLAG_ALPHA 0x80
 // set if number of planes > 1
@@ -33,14 +41,18 @@
 #define MP_IMGFLAG_YUV 0x200
 // set if it's swapped (BGR or YVU) plane/byteorder
 #define MP_IMGFLAG_SWAPPED 0x400
-// set if the format is standard YUV format:
+// set if the format is in a 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
+// set if in little endian, or endian independent
+#define MP_IMGFLAG_LE 0x2000
+// set if in big endian, or endian independent
+#define MP_IMGFLAG_BE 0x4000
+// set if in native (host) endian, or endian independent
+#define MP_IMGFLAG_NE MP_SELECT_LE_BE(MP_IMGFLAG_LE, MP_IMGFLAG_BE)
 
 #define MP_IMGFLAG_FMT_MASK 0x3FFF
 
@@ -49,92 +61,181 @@ struct mp_imgfmt_desc {
     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
+    int8_t num_planes;
+    int8_t chroma_xs, chroma_ys; // chroma shift (i.e. log2 of chroma pixel size)
+    int8_t avg_bpp;
+    int8_t bytes[MP_MAX_PLANES]; // bytes per pixel (MP_IMGFLAG_BYTE_ALIGNED)
+    int8_t bpp[MP_MAX_PLANES];   // bits per pixel
+    int8_t 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];
+    int8_t xs[MP_MAX_PLANES];
+    int8_t ys[MP_MAX_PLANES];
 };
 
 struct mp_imgfmt_desc mp_imgfmt_get_desc(unsigned int out_fmt);
 
-/* RGB/BGR Formats */
-
-#define IMGFMT_RGB_MASK 0xFFFFFF00
-#define IMGFMT_RGB (('R'<<24)|('G'<<16)|('B'<<8))
-#define IMGFMT_RGB1  (IMGFMT_RGB|1)
-#define IMGFMT_RGB4  (IMGFMT_RGB|4)
-#define IMGFMT_RGB4_CHAR  (IMGFMT_RGB|4|128) // RGB4 with 1 pixel per byte
-#define IMGFMT_RGB8  (IMGFMT_RGB|8)
-#define IMGFMT_RGB12 (IMGFMT_RGB|12)
-#define IMGFMT_RGB15 (IMGFMT_RGB|15)
-#define IMGFMT_RGB16 (IMGFMT_RGB|16)
-#define IMGFMT_RGB24 (IMGFMT_RGB|24)
-#define IMGFMT_RGB32 (IMGFMT_RGB|32)
-#define IMGFMT_RGB48LE (IMGFMT_RGB|48)
-#define IMGFMT_RGB48BE (IMGFMT_RGB|48|128)
-
-#define IMGFMT_BGR_MASK 0xFFFFFF00
-#define IMGFMT_BGR (('B'<<24)|('G'<<16)|('R'<<8))
-#define IMGFMT_BGR1 (IMGFMT_BGR|1)
-#define IMGFMT_BGR4 (IMGFMT_BGR|4)
-#define IMGFMT_BGR4_CHAR (IMGFMT_BGR|4|128) // BGR4 with 1 pixel per byte
-#define IMGFMT_BGR8 (IMGFMT_BGR|8)
-#define IMGFMT_BGR12 (IMGFMT_BGR|12)
-#define IMGFMT_BGR15 (IMGFMT_BGR|15)
-#define IMGFMT_BGR16 (IMGFMT_BGR|16)
-#define IMGFMT_BGR24 (IMGFMT_BGR|24)
-#define IMGFMT_BGR32 (IMGFMT_BGR|32)
-
-#define IMGFMT_GBRP (('G'<<24)|('B'<<16)|('R'<<8)|24)
-
-#if BYTE_ORDER == BIG_ENDIAN
-#define IMGFMT_ABGR IMGFMT_RGB32
-#define IMGFMT_BGRA (IMGFMT_RGB32|128)
-#define IMGFMT_ARGB IMGFMT_BGR32
-#define IMGFMT_RGBA (IMGFMT_BGR32|128)
-#define IMGFMT_RGB48NE IMGFMT_RGB48BE
-#define IMGFMT_RGB12BE IMGFMT_RGB12
-#define IMGFMT_RGB12LE (IMGFMT_RGB12|128)
-#define IMGFMT_RGB15BE IMGFMT_RGB15
-#define IMGFMT_RGB15LE (IMGFMT_RGB15|128)
-#define IMGFMT_RGB16BE IMGFMT_RGB16
-#define IMGFMT_RGB16LE (IMGFMT_RGB16|128)
-#define IMGFMT_BGR12BE IMGFMT_BGR12
-#define IMGFMT_BGR12LE (IMGFMT_BGR12|128)
-#define IMGFMT_BGR15BE IMGFMT_BGR15
-#define IMGFMT_BGR15LE (IMGFMT_BGR15|128)
-#define IMGFMT_BGR16BE IMGFMT_BGR16
-#define IMGFMT_BGR16LE (IMGFMT_BGR16|128)
-#else
-#define IMGFMT_ABGR (IMGFMT_BGR32|128)
-#define IMGFMT_BGRA IMGFMT_BGR32
-#define IMGFMT_ARGB (IMGFMT_RGB32|128)
-#define IMGFMT_RGBA IMGFMT_RGB32
-#define IMGFMT_RGB48NE IMGFMT_RGB48LE
-#define IMGFMT_RGB12BE (IMGFMT_RGB12|128)
-#define IMGFMT_RGB12LE IMGFMT_RGB12
-#define IMGFMT_RGB15BE (IMGFMT_RGB15|128)
-#define IMGFMT_RGB15LE IMGFMT_RGB15
-#define IMGFMT_RGB16BE (IMGFMT_RGB16|128)
-#define IMGFMT_RGB16LE IMGFMT_RGB16
-#define IMGFMT_BGR12BE (IMGFMT_BGR12|128)
-#define IMGFMT_BGR12LE IMGFMT_BGR12
-#define IMGFMT_BGR15BE (IMGFMT_BGR15|128)
-#define IMGFMT_BGR15LE IMGFMT_BGR15
-#define IMGFMT_BGR16BE (IMGFMT_BGR16|128)
-#define IMGFMT_BGR16LE IMGFMT_BGR16
-#endif
-
-/* old names for compatibility */
-#define IMGFMT_RG4B  IMGFMT_RGB4_CHAR
-#define IMGFMT_BG4B  IMGFMT_BGR4_CHAR
-
-// AV_PIX_FMT_BGR0
-#define IMGFMT_BGR0  0x1DC70000
+enum mp_imgfmt {
+    IMGFMT_NONE = 0,
+
+    // Offset to make confusing with ffmpeg formats harder
+    IMGFMT_START = 1000,
+
+    // Planar YUV formats
+
+    IMGFMT_444P,                // 1x1
+    IMGFMT_422P,                // 2x1
+    IMGFMT_440P,                // 1x2
+    IMGFMT_420P,                // 2x2
+    IMGFMT_411P,                // 4x1
+    IMGFMT_410P,                // 4x4
+
+    // YUV formats with 2 bytes per plane-pixel. Formats with 9-15 bits pad the
+    // most significant bits with 0 (use shifts to expand them to 16 bits).
+
+    IMGFMT_444P16_LE,
+    IMGFMT_444P16_BE,
+    IMGFMT_444P14_LE,
+    IMGFMT_444P14_BE,
+    IMGFMT_444P12_LE,
+    IMGFMT_444P12_BE,
+    IMGFMT_444P10_LE,
+    IMGFMT_444P10_BE,
+    IMGFMT_444P9_LE,
+    IMGFMT_444P9_BE,
+
+    IMGFMT_422P16_LE,
+    IMGFMT_422P16_BE,
+    IMGFMT_422P14_LE,
+    IMGFMT_422P14_BE,
+    IMGFMT_422P12_LE,
+    IMGFMT_422P12_BE,
+    IMGFMT_422P10_LE,
+    IMGFMT_422P10_BE,
+    IMGFMT_422P9_LE,
+    IMGFMT_422P9_BE,
+
+    IMGFMT_420P16_LE,
+    IMGFMT_420P16_BE,
+    IMGFMT_420P14_LE,
+    IMGFMT_420P14_BE,
+    IMGFMT_420P12_LE,
+    IMGFMT_420P12_BE,
+    IMGFMT_420P10_LE,
+    IMGFMT_420P10_BE,
+    IMGFMT_420P9_LE,
+    IMGFMT_420P9_BE,
+
+    // Planar YUV with alpha (4th plane)
+    IMGFMT_420AP,
+
+    // Gray
+    IMGFMT_Y8,
+    IMGFMT_Y16_LE,
+    IMGFMT_Y16_BE,
+
+    // Packed YUV formats (components are byte-accessed)
+    IMGFMT_YUYV,                // Y0 U  Y1 V
+    IMGFMT_UYVY,                // U  Y0 V  Y1
+
+    // Y plane + packed plane for chroma
+    IMGFMT_NV12,
+    IMGFMT_NV21,
+
+    // RGB/BGR Formats
+
+    // Byte accessed (low address to high address)
+    IMGFMT_ARGB,
+    IMGFMT_BGRA,
+    IMGFMT_BGR0,
+    IMGFMT_ABGR,
+    IMGFMT_RGBA,
+    IMGFMT_BGR24,
+    IMGFMT_RGB24,
+    IMGFMT_RGB48_LE,
+    IMGFMT_RGB48_BE,
+
+    // Accessed with bit-shifts (components ordered from LSB to MSB)
+    IMGFMT_RGB8,                // r3 g3 b2
+    IMGFMT_BGR8,
+    IMGFMT_RGB4_BYTE,           // r1 g2 b1 with 1 pixel per byte
+    IMGFMT_BGR4_BYTE,
+    IMGFMT_RGB4,                // r1 g2 b1, bit-packed
+    IMGFMT_BGR4,
+    IMGFMT_MONO,                // 1 bit per pixel, bit-packed
+
+    // Accessed with bit-shifts after endian-swapping the uint16_t pixel
+    IMGFMT_RGB12_LE,            // 4r 4g 4b 4a  (LSB to MSB)
+    IMGFMT_RGB12_BE,
+    IMGFMT_RGB15_LE,            // 5r 5g 5b 1a
+    IMGFMT_RGB15_BE,
+    IMGFMT_RGB16_LE,            // 5r 6g 5b
+    IMGFMT_RGB16_BE,
+    IMGFMT_BGR12_LE,            // 4b 4r 4g 4a
+    IMGFMT_BGR12_BE,
+    IMGFMT_BGR15_LE,            // 5b 5g 5r 1a
+    IMGFMT_BGR15_BE,
+    IMGFMT_BGR16_LE,            // 5b 6g 5r
+    IMGFMT_BGR16_BE,
+
+    IMGFMT_PAL8,                // Palette entries are IMGFMT_BGR32
+
+    // Planar RGB (planes are shuffled: plane 0 is G, etc.)
+    IMGFMT_GBRP,
+
+    // Hardware acclerated formats. Plane data points to special data
+    // structures, instead of pixel data.
+
+    IMGFMT_VDPAU_MPEG1,
+    IMGFMT_VDPAU_MPEG2,
+    IMGFMT_VDPAU_H264,
+    IMGFMT_VDPAU_WMV3,
+    IMGFMT_VDPAU_VC1,
+    IMGFMT_VDPAU_MPEG4,
+
+    IMGFMT_VDPAU_FIRST = IMGFMT_VDPAU_MPEG1,
+    IMGFMT_VDPAU_LAST  = IMGFMT_VDPAU_MPEG4,
+
+    IMGFMT_END,
+
+    // Redundant format aliases for native endian access
+    // For all formats that have _LE/_BE, define a native-endian entry without
+    // the suffix.
+
+    // The IMGFMT_RGB32 and IMGFMT_BGR32 formats provide bit-shift access to
+    // normally byte-accessed formats:
+    // IMGFMT_RGB32 = r | (g << 8) | (b << 16) | (a << 24)
+    // IMGFMT_BGR32 = b | (g << 8) | (r << 16) | (a << 24)
+    IMGFMT_RGB32   = MP_SELECT_LE_BE(IMGFMT_RGBA, IMGFMT_ABGR),
+    IMGFMT_BGR32   = MP_SELECT_LE_BE(IMGFMT_BGRA, IMGFMT_ARGB),
+
+    IMGFMT_RGB12   = MP_SELECT_LE_BE(IMGFMT_RGB12_LE, IMGFMT_RGB12_BE),
+    IMGFMT_RGB15   = MP_SELECT_LE_BE(IMGFMT_RGB15_LE, IMGFMT_RGB15_BE),
+    IMGFMT_RGB16   = MP_SELECT_LE_BE(IMGFMT_RGB16_LE, IMGFMT_RGB16_BE),
+    IMGFMT_BGR12   = MP_SELECT_LE_BE(IMGFMT_BGR12_LE, IMGFMT_BGR12_BE),
+    IMGFMT_BGR15   = MP_SELECT_LE_BE(IMGFMT_BGR15_LE, IMGFMT_BGR15_BE),
+    IMGFMT_BGR16   = MP_SELECT_LE_BE(IMGFMT_BGR16_LE, IMGFMT_BGR16_BE),
+    IMGFMT_RGB48   = MP_SELECT_LE_BE(IMGFMT_RGB48_LE, IMGFMT_RGB48_BE),
+
+    IMGFMT_444P16  = MP_SELECT_LE_BE(IMGFMT_444P16_LE, IMGFMT_444P16_BE),
+    IMGFMT_444P14  = MP_SELECT_LE_BE(IMGFMT_444P14_LE, IMGFMT_444P14_BE),
+    IMGFMT_444P12  = MP_SELECT_LE_BE(IMGFMT_444P12_LE, IMGFMT_444P12_BE),
+    IMGFMT_444P10  = MP_SELECT_LE_BE(IMGFMT_444P10_LE, IMGFMT_444P10_BE),
+    IMGFMT_444P9   = MP_SELECT_LE_BE(IMGFMT_444P9_LE, IMGFMT_444P9_BE),
+
+    IMGFMT_422P16  = MP_SELECT_LE_BE(IMGFMT_422P16_LE, IMGFMT_422P16_BE),
+    IMGFMT_422P14  = MP_SELECT_LE_BE(IMGFMT_422P14_LE, IMGFMT_422P14_BE),
+    IMGFMT_422P12  = MP_SELECT_LE_BE(IMGFMT_422P12_LE, IMGFMT_422P12_BE),
+    IMGFMT_422P10  = MP_SELECT_LE_BE(IMGFMT_422P10_LE, IMGFMT_422P10_BE),
+    IMGFMT_422P9   = MP_SELECT_LE_BE(IMGFMT_422P9_LE, IMGFMT_422P9_BE),
+
+    IMGFMT_420P16  = MP_SELECT_LE_BE(IMGFMT_420P16_LE, IMGFMT_420P16_BE),
+    IMGFMT_420P14  = MP_SELECT_LE_BE(IMGFMT_420P14_LE, IMGFMT_420P14_BE),
+    IMGFMT_420P12  = MP_SELECT_LE_BE(IMGFMT_420P12_LE, IMGFMT_420P12_BE),
+    IMGFMT_420P10  = MP_SELECT_LE_BE(IMGFMT_420P10_LE, IMGFMT_420P10_BE),
+    IMGFMT_420P9   = MP_SELECT_LE_BE(IMGFMT_420P9_LE, IMGFMT_420P9_BE),
+
+    IMGFMT_Y16     = MP_SELECT_LE_BE(IMGFMT_Y16_LE, IMGFMT_Y16_BE),
+};
 
 static inline bool IMGFMT_IS_RGB(unsigned int fmt)
 {
@@ -152,172 +253,31 @@ static inline bool IMGFMT_IS_BGR(unsigned int fmt)
 #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
-#define IMGFMT_Y16BE 0x1DC70002
-// AV_PIX_FMT_PAL8
-#define IMGFMT_PAL8  0x1DC70003
-
 #if BYTE_ORDER == BIG_ENDIAN
-#define IMGFMT_Y16 IMGFMT_Y16BE
-#else
-#define IMGFMT_Y16 IMGFMT_Y16LE
-#endif
-
-/* Planar YUV Formats */
-
-#define IMGFMT_YVU9 0x39555659
-#define IMGFMT_IF09 0x39304649
-#define IMGFMT_YV12 0x32315659
-#define IMGFMT_I420 0x30323449
-#define IMGFMT_IYUV 0x56555949
-#define IMGFMT_CLPL 0x4C504C43
-#define IMGFMT_Y800 0x30303859
-#define IMGFMT_Y8   0x20203859
-#define IMGFMT_NV12 0x3231564E
-#define IMGFMT_NV21 0x3132564E
-
-/* unofficial Planar Formats, FIXME if official 4CC exists */
-#define IMGFMT_444P 0x50343434
-#define IMGFMT_422P 0x50323234
-#define IMGFMT_411P 0x50313134
-#define IMGFMT_440P 0x50303434
-#define IMGFMT_HM12 0x32314D48
-
-// 4:2:0 planar with alpha
-#define IMGFMT_420A 0x41303234
-
-#define IMGFMT_444P16_LE 0x51343434
-#define IMGFMT_444P16_BE 0x34343451
-#define IMGFMT_444P10_LE 0x52343434
-#define IMGFMT_444P10_BE 0x34343452
-#define IMGFMT_444P9_LE 0x53343434
-#define IMGFMT_444P9_BE 0x34343453
-#define IMGFMT_444P12_LE 0x54343434
-#define IMGFMT_444P12_BE 0x34343454
-#define IMGFMT_444P14_LE 0x55343434
-#define IMGFMT_444P14_BE 0x34343455
-#define IMGFMT_422P16_LE 0x51323234
-#define IMGFMT_422P16_BE 0x34323251
-#define IMGFMT_422P10_LE 0x52323234
-#define IMGFMT_422P10_BE 0x34323252
-#define IMGFMT_422P9_LE  0x53323234
-#define IMGFMT_422P9_BE  0x34323253
-#define IMGFMT_422P12_LE  0x54323234
-#define IMGFMT_422P12_BE  0x34323254
-#define IMGFMT_422P14_LE  0x55323234
-#define IMGFMT_422P14_BE  0x34323255
-#define IMGFMT_420P16_LE 0x51303234
-#define IMGFMT_420P16_BE 0x34323051
-#define IMGFMT_420P10_LE 0x52303234
-#define IMGFMT_420P10_BE 0x34323052
-#define IMGFMT_420P9_LE 0x53303234
-#define IMGFMT_420P9_BE 0x34323053
-#define IMGFMT_420P12_LE 0x54303234
-#define IMGFMT_420P12_BE 0x34323054
-#define IMGFMT_420P14_LE 0x55303234
-#define IMGFMT_420P14_BE 0x34323055
-#if BYTE_ORDER == BIG_ENDIAN
-#define IMGFMT_444P16 IMGFMT_444P16_BE
-#define IMGFMT_444P14 IMGFMT_444P14_BE
-#define IMGFMT_444P12 IMGFMT_444P12_BE
-#define IMGFMT_444P10 IMGFMT_444P10_BE
-#define IMGFMT_444P9 IMGFMT_444P9_BE
-#define IMGFMT_422P16 IMGFMT_422P16_BE
-#define IMGFMT_422P14 IMGFMT_422P14_BE
-#define IMGFMT_422P12 IMGFMT_422P12_BE
-#define IMGFMT_422P10 IMGFMT_422P10_BE
-#define IMGFMT_422P9  IMGFMT_422P9_BE
-#define IMGFMT_420P16 IMGFMT_420P16_BE
-#define IMGFMT_420P14 IMGFMT_420P14_BE
-#define IMGFMT_420P12 IMGFMT_420P12_BE
-#define IMGFMT_420P10 IMGFMT_420P10_BE
-#define IMGFMT_420P9 IMGFMT_420P9_BE
 #define IMGFMT_IS_YUVP16_NE(fmt) IMGFMT_IS_YUVP16_BE(fmt)
 #else
-#define IMGFMT_444P16 IMGFMT_444P16_LE
-#define IMGFMT_444P14 IMGFMT_444P14_LE
-#define IMGFMT_444P12 IMGFMT_444P12_LE
-#define IMGFMT_444P10 IMGFMT_444P10_LE
-#define IMGFMT_444P9 IMGFMT_444P9_LE
-#define IMGFMT_422P16 IMGFMT_422P16_LE
-#define IMGFMT_422P14 IMGFMT_422P14_LE
-#define IMGFMT_422P12 IMGFMT_422P12_LE
-#define IMGFMT_422P10 IMGFMT_422P10_LE
-#define IMGFMT_422P9  IMGFMT_422P9_LE
-#define IMGFMT_420P16 IMGFMT_420P16_LE
-#define IMGFMT_420P14 IMGFMT_420P14_LE
-#define IMGFMT_420P12 IMGFMT_420P12_LE
-#define IMGFMT_420P10 IMGFMT_420P10_LE
-#define IMGFMT_420P9 IMGFMT_420P9_LE
 #define IMGFMT_IS_YUVP16_NE(fmt) IMGFMT_IS_YUVP16_LE(fmt)
 #endif
 
 // 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));
+           (desc.flags & MP_IMGFLAG_LE);
 }
 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));
+           (desc.flags & MP_IMGFLAG_BE);
 }
 
 #define IMGFMT_IS_YUVP16(fmt)    (IMGFMT_IS_YUVP16_LE(fmt) || IMGFMT_IS_YUVP16_BE(fmt))
 
-/* Packed YUV Formats */
-
-#define IMGFMT_IUYV 0x56595549 // Interlaced UYVY
-#define IMGFMT_IY41 0x31435949 // Interlaced Y41P
-#define IMGFMT_IYU1 0x31555949
-#define IMGFMT_IYU2 0x32555949
-#define IMGFMT_UYVY 0x59565955
-#define IMGFMT_UYNV 0x564E5955 // Exactly same as UYVY
-#define IMGFMT_cyuv 0x76757963 // upside-down UYVY
-#define IMGFMT_Y422 0x32323459 // Exactly same as UYVY
-#define IMGFMT_YUY2 0x32595559
-#define IMGFMT_YUNV 0x564E5559 // Exactly same as YUY2
-#define IMGFMT_YVYU 0x55595659
-#define IMGFMT_Y41P 0x50313459
-#define IMGFMT_Y211 0x31313259
-#define IMGFMT_Y41T 0x54313459 // Y41P, Y lsb = transparency
-#define IMGFMT_Y42T 0x54323459 // UYVY, Y lsb = transparency
-#define IMGFMT_V422 0x32323456 // upside-down UYVY?
-#define IMGFMT_V655 0x35353656
-#define IMGFMT_CLJR 0x524A4C43
-#define IMGFMT_YUVP 0x50565559 // 10-bit YUYV
-#define IMGFMT_UYVP 0x50565955 // 10-bit UYVY
-
-/* Compressed Formats */
-#define IMGFMT_MJPEG (('M')|('J'<<8)|('P'<<16)|('G'<<24))
-
-// VDPAU specific format.
-#define IMGFMT_VDPAU               0x1DC80000
-#define IMGFMT_VDPAU_MASK          0xFFFF0000
-#define IMGFMT_IS_VDPAU(fmt)       (((fmt)&IMGFMT_VDPAU_MASK)==IMGFMT_VDPAU)
-#define IMGFMT_VDPAU_MPEG1         (IMGFMT_VDPAU|0x01)
-#define IMGFMT_VDPAU_MPEG2         (IMGFMT_VDPAU|0x02)
-#define IMGFMT_VDPAU_H264          (IMGFMT_VDPAU|0x03)
-#define IMGFMT_VDPAU_WMV3          (IMGFMT_VDPAU|0x04)
-#define IMGFMT_VDPAU_VC1           (IMGFMT_VDPAU|0x05)
-#define IMGFMT_VDPAU_MPEG4         (IMGFMT_VDPAU|0x06)
+#define IMGFMT_IS_VDPAU(fmt) \
+    (((fmt) >= IMGFMT_VDPAU_FIRST) && ((fmt) <= IMGFMT_VDPAU_LAST))
 
 #define IMGFMT_IS_HWACCEL(fmt) IMGFMT_IS_VDPAU(fmt)
 
-typedef struct {
-    void* data;
-    int size;
-    int id;        // stream id. usually 0x1E0
-    int timestamp; // pts, 90000 Hz counter based
-} vo_mpegpes_t;
-
-const char *vo_format_name(int format);
-
 /**
  * Calculates the scale shifts for the chroma planes for planar YUV
  *
@@ -336,4 +296,6 @@ extern struct mp_imgfmt_entry mp_imgfmt_list[];
 unsigned int mp_imgfmt_from_name(bstr name, bool allow_hwaccel);
 const char *mp_imgfmt_to_name(unsigned int fmt);
 
+#define vo_format_name mp_imgfmt_to_name
+
 #endif /* MPLAYER_IMG_FORMAT_H */