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

audio: remove bitmask format definition mess 

Audio formats used a semi-clever schema to encode the properties of the
PCM encoding as bitfields into the format integer value.

The af_fmt_change_bits() implementation becomes a bit weird, but it's
an improvement to the rest of the code.

(I've always disliked it, so why not get rid of it.)
This commit is contained in:
wm4 2015-06-26 23:05:16 +02:00
parent 554b4217a0
commit efb50cabe6
2 changed files with 80 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
audio/format.c
View File

@ -29,13 +29,16 @@
int af_fmt2bps(int format) int af_fmt2bps(int format)
{ {
switch (format & AF_FORMAT_BITS_MASK) { switch (af_fmt_from_planar(format)) {
case AF_FORMAT_8BIT: return 1; case AF_FORMAT_U8: return 1;
case AF_FORMAT_16BIT: return 2; case AF_FORMAT_S16: return 2;
case AF_FORMAT_24BIT: return 3; case AF_FORMAT_S24: return 3;
case AF_FORMAT_32BIT: return 4; case AF_FORMAT_S32: return 4;
case AF_FORMAT_64BIT: return 8; case AF_FORMAT_FLOAT: return 4;
case AF_FORMAT_DOUBLE: return 8;
} }
if (af_fmt_is_spdif(format))
return 2;
return 0; return 0;
} }
@ -44,25 +47,18 @@ int af_fmt2bits(int format)
return af_fmt2bps(format) * 8; return af_fmt2bps(format) * 8;
} }
static int bits_to_mask(int bits)
{
switch (bits) {
case 8: return AF_FORMAT_8BIT;
case 16: return AF_FORMAT_16BIT;
case 24: return AF_FORMAT_24BIT;
case 32: return AF_FORMAT_32BIT;
case 64: return AF_FORMAT_64BIT;
}
return 0;
}
int af_fmt_change_bits(int format, int bits) int af_fmt_change_bits(int format, int bits)
{ {
if (!af_fmt_is_valid(format)) if (!af_fmt_is_valid(format) || !bits)
return 0; return 0;
int mask = bits_to_mask(bits); for (int fmt = 1; fmt < AF_FORMAT_COUNT; fmt++) {
format = (format & ~AF_FORMAT_BITS_MASK) | mask; if (af_fmt2bits(fmt) == bits &&
return af_fmt_is_valid(format) ? format : 0; af_fmt_is_float(fmt) == af_fmt_is_float(format) &&
af_fmt_is_planar(fmt) == af_fmt_is_planar(format) &&
af_fmt_is_spdif(fmt) == af_fmt_is_planar(format))
return fmt;
}
return 0;
} }
// All formats are considered signed, except explicitly unsigned int formats. // All formats are considered signed, except explicitly unsigned int formats.
@ -71,6 +67,29 @@ bool af_fmt_unsigned(int format)
return format == AF_FORMAT_U8 || format == AF_FORMAT_U8P; return format == AF_FORMAT_U8 || format == AF_FORMAT_U8P;
} }
bool af_fmt_is_float(int format)
{
format = af_fmt_from_planar(format);
return format == AF_FORMAT_FLOAT || format == AF_FORMAT_DOUBLE;
}
// true for both unsigned and signed ints
bool af_fmt_is_int(int format)
{
return format && !af_fmt_is_spdif(format) && !af_fmt_is_float(format);
}
// false for interleaved and AF_FORMAT_UNKNOWN
bool af_fmt_is_planar(int format)
{
return format && af_fmt_to_planar(format) == format;
}
bool af_fmt_is_spdif(int format)
{
return af_format_sample_alignment(format) > 1;
}
static const int planar_formats[][2] = { static const int planar_formats[][2] = {
{AF_FORMAT_U8P, AF_FORMAT_U8}, {AF_FORMAT_U8P, AF_FORMAT_U8},
{AF_FORMAT_S16P, AF_FORMAT_S16}, {AF_FORMAT_S16P, AF_FORMAT_S16},
@ -132,11 +151,7 @@ const struct af_fmt_entry af_fmtstr_table[] = {
bool af_fmt_is_valid(int format) bool af_fmt_is_valid(int format)
{ {
for (int i = 0; af_fmtstr_table[i].name; i++) { return format > 0 && format < AF_FORMAT_COUNT;
if (af_fmtstr_table[i].format == format)
return true;
}
return false;
} }
const char *af_fmt_to_str(int format) const char *af_fmt_to_str(int format)
@ -190,28 +205,27 @@ int af_format_conversion_score(int dst_format, int src_format)
if (AF_FORMAT_IS_SPECIAL(dst_format) || AF_FORMAT_IS_SPECIAL(src_format)) if (AF_FORMAT_IS_SPECIAL(dst_format) || AF_FORMAT_IS_SPECIAL(src_format))
return INT_MIN; return INT_MIN;
int score = 1024; int score = 1024;
if (FMT_DIFF(AF_FORMAT_INTERLEAVING_MASK, dst_format, src_format)) if (af_fmt_is_planar(dst_format) != af_fmt_is_planar(src_format))
score -= 1; // has to (de-)planarize score -= 1; // has to (de-)planarize
if (FMT_DIFF(AF_FORMAT_TYPE_MASK, dst_format, src_format)) { if (af_fmt_is_float(dst_format) != af_fmt_is_float(src_format)) {
int dst_bits = dst_format & AF_FORMAT_BITS_MASK; int dst_bits = af_fmt2bits(dst_format);
if ((dst_format & AF_FORMAT_TYPE_MASK) == AF_FORMAT_F) { if (af_fmt_is_float(dst_format)) {
// For int->float, always prefer 32 bit float. // For int->float, always prefer 32 bit float.
score -= dst_bits == AF_FORMAT_32BIT ? 8 : 0; score -= dst_bits == 32 ? 8 : 0;
} else { } else {
// For float->int, always prefer highest bit depth int // For float->int, always prefer highest bit depth int
score -= 8 * (AF_FORMAT_64BIT - dst_bits); score -= 8 * (64 - dst_bits);
} }
// Has to convert float<->int - Consider this the worst case.
score -= 2048;
} else { } else {
int bits = FMT_DIFF(AF_FORMAT_BITS_MASK, dst_format, src_format); int bits = af_fmt2bits(dst_format) - af_fmt2bits(src_format);
if (bits > 0) { if (bits > 0) {
score -= 8 * bits; // has to add padding score -= 8 * bits; // has to add padding
} else if (bits < 0) { } else if (bits < 0) {
score -= 1024 - 8 * bits; // has to reduce bit depth score -= 1024 - 8 * bits; // has to reduce bit depth
} }
} }
// Consider this the worst case.
if (FMT_DIFF(AF_FORMAT_TYPE_MASK, dst_format, src_format))
score -= 2048; // has to convert float<->int
return score; return score;
} }

84
audio/format.h
View File

@ -26,69 +26,39 @@
#include "misc/bstr.h" #include "misc/bstr.h"
// Bits used
// Some code assumes they're sorted by size.
#define AF_FORMAT_8BIT (0<<1)
#define AF_FORMAT_16BIT (1<<1)
#define AF_FORMAT_24BIT (2<<1)
#define AF_FORMAT_32BIT (3<<1)
#define AF_FORMAT_64BIT (4<<1)
#define AF_FORMAT_BITS_MASK (7<<1)
// Fixed/floating point/special
#define AF_FORMAT_I (1<<4) // Int
#define AF_FORMAT_F (2<<4) // Foating point
#define AF_FORMAT_S (4<<4) // special (IEC61937)
#define AF_FORMAT_TYPE_MASK (7<<4)
// Interleaving (planar formats have data for each channel in separate planes)
#define AF_FORMAT_INTERLEAVED (0<<7) // must be 0
#define AF_FORMAT_PLANAR (1<<7)
#define AF_FORMAT_INTERLEAVING_MASK (1<<7)
#define AF_FORMAT_S_CODEC(n) ((n)<<8)
#define AF_FORMAT_S_CODEC_MASK (15 <<8) // 16 codecs max.
#define AF_FORMAT_MASK ((1<<12)-1)
#define AF_INTP (AF_FORMAT_I|AF_FORMAT_PLANAR)
#define AF_FLTP (AF_FORMAT_F|AF_FORMAT_PLANAR)
#define AF_FORMAT_S_(n) (AF_FORMAT_S_CODEC(n)|AF_FORMAT_S|AF_FORMAT_16BIT)
// actual sample formats
enum af_format { enum af_format {
AF_FORMAT_UNKNOWN = 0, AF_FORMAT_UNKNOWN = 0,
AF_FORMAT_U8 = AF_FORMAT_I|AF_FORMAT_8BIT, AF_FORMAT_U8,
AF_FORMAT_S16 = AF_FORMAT_I|AF_FORMAT_16BIT, AF_FORMAT_S16,
AF_FORMAT_S24 = AF_FORMAT_I|AF_FORMAT_24BIT, AF_FORMAT_S24,
AF_FORMAT_S32 = AF_FORMAT_I|AF_FORMAT_32BIT, AF_FORMAT_S32,
AF_FORMAT_FLOAT,
AF_FORMAT_FLOAT = AF_FORMAT_F|AF_FORMAT_32BIT, AF_FORMAT_DOUBLE,
AF_FORMAT_DOUBLE = AF_FORMAT_F|AF_FORMAT_64BIT,
// Planar variants // Planar variants
AF_FORMAT_U8P = AF_INTP|AF_FORMAT_8BIT, AF_FORMAT_U8P,
AF_FORMAT_S16P = AF_INTP|AF_FORMAT_16BIT, AF_FORMAT_S16P,
AF_FORMAT_S32P = AF_INTP|AF_FORMAT_32BIT, AF_FORMAT_S32P,
AF_FORMAT_FLOATP = AF_FLTP|AF_FORMAT_32BIT, AF_FORMAT_FLOATP,
AF_FORMAT_DOUBLEP = AF_FLTP|AF_FORMAT_64BIT, AF_FORMAT_DOUBLEP,
// All of these use IEC61937 framing, and otherwise pretend to be like PCM. // All of these use IEC61937 framing, and otherwise pretend to be like PCM.
AF_FORMAT_S_AAC = AF_FORMAT_S_(0), AF_FORMAT_S_AAC,
AF_FORMAT_S_AC3 = AF_FORMAT_S_(1), AF_FORMAT_S_AC3,
AF_FORMAT_S_DTS = AF_FORMAT_S_(2), AF_FORMAT_S_DTS,
AF_FORMAT_S_DTSHD = AF_FORMAT_S_(3), AF_FORMAT_S_DTSHD,
AF_FORMAT_S_EAC3 = AF_FORMAT_S_(4), AF_FORMAT_S_EAC3,
AF_FORMAT_S_MP3 = AF_FORMAT_S_(5), AF_FORMAT_S_MP3,
AF_FORMAT_S_TRUEHD = AF_FORMAT_S_(6), AF_FORMAT_S_TRUEHD,
AF_FORMAT_COUNT
}; };
#define AF_FORMAT_IS_IEC61937(f) (((f) & AF_FORMAT_TYPE_MASK) == AF_FORMAT_S) #define AF_FORMAT_IS_IEC61937(f) af_fmt_is_spdif(f)
#define AF_FORMAT_IS_SPECIAL(f) AF_FORMAT_IS_IEC61937(f) #define AF_FORMAT_IS_SPECIAL(f) af_fmt_is_spdif(f)
#define AF_FORMAT_IS_FLOAT(f) (!!((f) & AF_FORMAT_F)) #define AF_FORMAT_IS_FLOAT(f) af_fmt_is_float(f)
// false for interleaved and AF_FORMAT_UNKNOWN #define AF_FORMAT_IS_PLANAR(f) af_fmt_is_planar(f)
#define AF_FORMAT_IS_PLANAR(f) (!!((f) & AF_FORMAT_PLANAR))
struct af_fmt_entry { struct af_fmt_entry {
const char *name; const char *name;
@ -105,6 +75,10 @@ int af_fmt2bits(int format);
int af_fmt_change_bits(int format, int bits); int af_fmt_change_bits(int format, int bits);
bool af_fmt_unsigned(int format); bool af_fmt_unsigned(int format);
bool af_fmt_is_float(int format);
bool af_fmt_is_int(int format);
bool af_fmt_is_planar(int format);
bool af_fmt_is_spdif(int format);
int af_fmt_to_planar(int format); int af_fmt_to_planar(int format);
int af_fmt_from_planar(int format); int af_fmt_from_planar(int format);