Misplaced Pages

#3996

58-579: The Android-targeted implementation of the Fraunhofer AAC encoder uses fixed-point math and is optimized for encoding on embedded devices/mobile phones. The library is currently limited to 16-bit PCM input. Other versions of the Fraunhofer encoder, like the one included in Winamp , are optimized for encoding music on desktop-class processors. Those versions of the encoder, however, are not open-source and require

116-405: A /10 , such as 1/100 or 37/1000, can be exactly represented in fixed point with a power-of-ten scaling factor 1/10 with any n ≥ m . This decimal format can also represent any binary fraction a /2 , such as 1/8 (0.125) or 17/32 (0.53125). More generally, a rational number a / b , with a and b relatively prime and b positive, can be exactly represented in binary fixed point only if b

174-457: A commercial license. Version 2 of the library, introduced with Android P, also includes support for xHE-AAC and AAC-ELD v2. xHE-AAC extends the operating range of the codec from 12 to 300 kb/s for stereo signals and allows seamless switching between bitrates over this range for adaptive bitrate delivery (using standards such as MPEG-DASH or HLS for example). xHE-AAC also includes MPEG-D DRC mandatory loudness control to playback content at

232-439: A consistent volume and offers new dynamic range control profiles for listening in noisy situations. The FDK AAC encoder employs a more aggressive default low-pass filter than is used in other codecs. Higher frequencies are removed so that more bits are available to better describe sounds of lower frequencies, improving the overall quality for most combinations of recordings and listeners. In some, not completely rare, combinations

290-482: A fee for distributing the library, which runs counter to the "No Discrimination Against Fields of Endeavor" rule in Debian Free Software Guidelines . The license was classified as free by Fedora after a review by the legal department at Red Hat , though it's no longer classified as "allowed" due Fedora adopting a more defensive posture toward patents. However, Fedora states that this will not affect

348-411: A fixed number of digits of their fractional part. Dollar amounts, for example, are often stored with exactly two fractional digits, representing the cents (1/100 of dollar). More generally, the term may refer to representing fractional values as integer multiples of some fixed small unit, e.g. a fractional amount of hours as an integer multiple of ten-minute intervals. Fixed-point number representation

406-549: A fixed-point representation can have error less than 1.2 × 10 , whereas the standard floating-point representation may have error up to 596 × 10 — because 9 of the bits are wasted with the sign and exponent of the dynamic scaling factor. Specifically, comparing 32-bit fixed-point to floating-point audio, a recording requiring less than 40 dB of headroom has a higher signal-to-noise ratio using 32-bit fixed. Programs using fixed-point computations are usually more portable than those using floating-point, since they do not depend on

464-407: A fractional amount of hours may be represented as an integer number of seconds; that is, as a fixed-point number with scale factor of 1/3600. Even with the most careful rounding, fixed-point values represented with a scaling factor S may have an error of up to ±0.5 in the stored integer, that is, ±0.5 S in the value. Therefore, smaller scaling factors generally produce more accurate results. On

522-496: A multiply instruction that includes renormalization—the scaling conversion of the product from 2 n −2 to n −1 fraction bits. If the CPU does not provide that feature, the programmer must save the product in a large enough register or temporary variable, and code the renormalization explicitly. Overflow happens when the result of an arithmetic operation is too large to be stored in the designated destination area. In addition and subtraction,

580-428: A signed integer in two's complement representation with an implicit scaling factor as above. The sign of the value will always be indicated by the first stored bit (1 = negative, 0 = non-negative), even if the number of fraction bits is greater than or equal to the total number of bits. For example, the 8-bit signed binary integer (11110101) 2 = −11, taken with -3, +5, and +12 implied fraction bits, would represent

638-415: A string of digits d 1 ... d n denotes the number d 1 b + d 2 b + … + d n b , where 0 ≤ d i < b . In contrast to decimal, or radix 10, which has a ones' place, tens' place, hundreds' place, and so on, radix b would have a ones' place, then a b s' place, a b s' place, etc. For example, if b = 12, a string of digits such as 59A (where the letter "A" represents

SECTION 10

#1732880509004

696-407: A variable or formula may not appear explicitly in the program. Good programming practice then requires that it be provided in the documentation , at least as a comment in the source code . For greater efficiency, scaling factors are often chosen to be powers (positive or negative) of the base b used to represent the integers internally. However, often the best scaling factor is dictated by

754-423: Is 22×32/100 = 7.04. If the result is not exact, the error introduced by the rounding can be reduced or even eliminated by converting the dividend to a smaller scaling factor. For example, if r = 1.23 is represented as 123 with scaling 1/100, and s = 6.25 is represented as 6250 with scaling 1/1000, then simple division of the integers yields 123÷6250 = 0 (rounded) with scaling factor (1/100)/(1/1000) = 10. If r

812-488: Is a fixed-point environment having each array (block) of fixed-point data be scaled with a common exponent in a single word. A common use of decimal fixed-point is for storing monetary values, for which the complicated rounding rules of floating-point numbers are often a liability. For example, the open-source money management application GnuCash , written in C, switched from floating-point to fixed-point as of version 1.6, for this reason. Binary fixed-point (binary scaling)

870-421: Is a power of 2; and in decimal fixed point only if b has no prime factors other than 2 and/or 5. Fixed-point computations can be faster and/or use less hardware than floating-point ones. If the range of the values to be represented is known in advance and is sufficiently limited, fixed point can make better use of the available bits. For example, if 32 bits are available to represent a number between 0 and 1,

928-505: Is binary 111 1000 2 . Similarly, every octal digit corresponds to a unique sequence of three binary digits, since eight is the cube of two. This representation is unique. Let b be a positive integer greater than 1. Then every positive integer a can be expressed uniquely in the form where m is a nonnegative integer and the r' s are integers such that Radices are usually natural numbers . However, other positional systems are possible, for example, golden ratio base (whose radix

986-437: Is first converted to 1,230,000 with scaling factor 1/1000000, the result will be 1,230,000÷6250 = 197 (rounded) with scale factor 1/1000 (0.197). The exact value 1.23/6.25 is 0.1968. In fixed-point computing it is often necessary to convert a value to a different scaling factor. This operation is necessary, for example: To convert a number from a fixed point type with scaling factor R to another type with scaling factor S ,

1044-405: Is generally easier and safer to select scaling factors and word sizes so as to exclude the possibility of overflow, or to check the operands for excessive values before executing the operation. Number base In a positional numeral system , the radix ( pl. :   radices ) or base is the number of unique digits , including the digit zero, used to represent numbers. For example, for

1102-406: Is more natural for the problem. Examples of the latter are accounting of dollar amounts, when fractions of cents must be rounded to whole cents in strictly prescribed ways; and the evaluation of functions by table lookup , or any application where rational numbers need to be represented without rounding errors (which fixed-point does but floating-point cannot). Fixed-point representation is still

1160-608: Is no separation, and the distinction between the two groups of digits is defined only by the programs that handle such numbers. Fixed-point representation was the norm in mechanical calculators . Since most modern processors have fast floating-point unit (FPU), fixed-point representations in processor-based implementations are now used only in special situations, such as in low-cost embedded microprocessors and microcontrollers ; in applications that demand high speed or low power consumption or small chip area, like image , video , and digital signal processing ; or when their use

1218-437: Is often contrasted to the more complicated and computationally demanding floating-point representation . In the fixed-point representation, the fraction is often expressed in the same number base as the integer part, but using negative powers of the base b . The most common variants are decimal (base 10) and binary (base 2). The latter is commonly known also as binary scaling . Thus, if n fraction digits are stored,

SECTION 20

#1732880509004

1276-408: Is possible by adding a 'rounding addend' of half of the scaling factor before shifting; The proof: round(x/y) = floor(x/y + 0.5) = floor((x + y/2)/y) = shift-of-n(x + 2^(n-1)) A similar method is usable in any scaling. To divide two fixed-point numbers, one takes the integer quotient of their underlying integers, and assumes that the scaling factor is the quotient of their scaling factors. In general,

1334-399: The decimal system (the most common system in use today) the radix is ten, because it uses the ten digits from 0 through 9. In any standard positional numeral system, a number is conventionally written as ( x ) y with x as the string of digits and y as its base, although for base ten the subscript is usually assumed (and omitted, together with the pair of parentheses ), as it is

1392-546: The discrete cosine transform algorithms used to compress JPEG images. Electronic instruments such as electricity meters and digital clocks often use polynomials to compensate for introduced errors, e.g. from temperature or power supply voltage. The coefficients are produced by polynomial regression . Binary fixed-point polynomials can utilize more bits of precision than floating-point, and do so in fast code using inexpensive CPUs. Accuracy, crucial for instruments, compares well to equivalent-bit floating-point calculations, if

1450-605: The FDK library source code allows redistribution in source or binary forms, but does not license patented technologies described by the code. The license states that the library may only be used for purposes as authorized by patent licenses. Via Licensing administers a patent pool that includes patent licenses for the AAC codecs, including xHE-AAC and MPEG-D DRC. The FDK license also states that "most manufacturers of Android devices already license these patent claims through Via Licensing or directly from

1508-449: The accuracy δ = S /2 of values that could be represented in 16-bit signed binary fixed point format, depending on the number f of implied fraction bits. Fixed-point formats with scaling factors of the form 2 -1 (namely 1, 3, 7, 15, 31, etc.) have been said to be appropriate for image processing and other digital signal processing tasks. They are supposed to provide more consistent conversions between fixed- and floating-point values than

1566-488: The application. Thus one often uses scaling factors that are powers of 10 (e.g. 1/100 for dollar values), for human convenience, even when the integers are represented internally in binary. Decimal scaling factors also mesh well with the metric (SI) system , since the choice of the fixed-point scaling factor is often equivalent to the choice of a unit of measure (like centimeters or microns instead of meters ). However, other scaling factors may be used occasionally, e.g.

1624-628: The availability of an FPU. This advantage was particularly strong before the IEEE Floating Point Standard was widely adopted, when floating-point computations with the same data would yield different results depending on the manufacturer, and often on the computer model. Many embedded processors lack an FPU, because integer arithmetic units require substantially fewer logic gates and consume much smaller chip area than an FPU; and software emulation of floating-point on low-speed devices would be too slow for most applications. CPU chips for

1682-427: The base b ; whereas their absolute resolution varies by many orders of magnitude, like the values themselves. In many cases, the rounding and truncation errors of fixed-point computations are easier to analyze than those of the equivalent floating-point computations. Applying linearization techniques to truncation, such as dithering and/or noise shaping is more straight-forward within fixed-point arithmetic. On

1740-455: The earlier personal computers and game consoles , like the Intel 386 and 486SX , also lacked an FPU. The absolute resolution (difference between successive values) of any fixed-point format is constant over the whole range, namely the scaling factor S . In contrast, the relative resolution of a floating-point format is approximately constant over their whole range, varying within a factor of

1798-418: The fdk-aac-free package, which enables only the commonly used "Low Complexity AAC" profile, which is what most people use. The US patents on LC-AAC have expired. The FSF also considers it to be free, though discourages its use due to the explicit lack of a patent grant. Fixed-point arithmetic In computing , fixed-point is a method of representing fractional (non-integer) numbers by storing

Fraunhofer FDK AAC - Misplaced Pages Continue

1856-477: The first division requires rounding and therefore the result is not exact. For example, division of 3456 scaled by 1/100 (34.56) and 1234 scaled by 1/1000 (1.234) yields the integer 3456÷1234 = 3 (rounded) with scale factor (1/100)/(1/1000) = 10, that is, 30. As another example, the division of the first number by 155 implicitly scaled by 1/32 (155/32 = 4.84375) yields the integer 3456÷155 = 22 (rounded) with implicit scaling factor (1/100)/(1/32) = 32/100 = 8/25, that

1914-407: The first number by 155 implicitly scaled by 1/32 (155/32 = 4.84375) yields the integer 123×155 = 19065 with implicit scaling factor (1/1000)×(1/32) = 1/32000, that is 19065/32000 = 0.59578125. In binary, it is common to use a scaling factor that is a power of two. After the multiplication, the scaling factor can be divided away by shifting right. Shifting is simple and fast in most computers. Rounding

1972-444: The fixed-point polynomials are evaluated using Horner's method (e.g. y = (( ax + b ) x + c ) x + d ) to reduce the number of times that rounding occurs, and the fixed-point multiplications utilize rounding addends. To add or subtract two values with the same implicit scaling factor, it is sufficient to add or subtract the underlying integers; the result will have their common implicit scaling factor, can thus can be stored in

2030-406: The integer 3075 then must be multiplied by 1/100, that is, divided by 100, to yield either 31 (0.31) or 30 (0.30), depending on the rounding policy used. Similarly, the operation r ← r / s will require dividing the integers and explicitly multiplying the quotient by S . Rounding and/or overflow may occur here too. To convert a number from floating point to fixed point, one may multiply it by

2088-461: The integer, or appending zero digits. However, this operation must preserve the sign of the number. In two's complement representation, that means extending the sign bit as in arithmetic shift operations. If S does not divide R (in particular, if the new scaling factor S is greater than the original R ), the new integer may have to be rounded . In particular, if r and s are fixed-point variables with implicit scaling factors R and S ,

2146-464: The last 3 decimal digits are implicitly assumed to be a decimal fraction), and the value 1 230 000 can be represented as 1230 with an implicit scaling factor of 1000 (with "minus 3" implied decimal fraction digits, that is, with 3 implicit zero digits at right). This representation allows standard integer arithmetic logic units to perform rational number calculations. Negative values are usually represented in binary fixed-point format as

2204-529: The missing high frequencies are noticeable. The library allows overriding the low-pass filter setting, and in the highest VBR mode effectively applies no filter at all. A cross-platform source distribution is maintained by Martin Storsjö as part of the opencore-amr project under the name fdk-aac. The code compiles into a shared library, libfdk-aac. The media frameworks FFmpeg and Libav support audio encoding through libfdk-aac. The license included by Fraunhofer in

2262-426: The most common way to express value . For example, (100) 10 is equivalent to 100 (the decimal system is implied in the latter) and represents the number one hundred, while (100) 2 (in the binary system with base 2) represents the number four. Radix is a Latin word for "root". Root can be considered a synonym for base, in the arithmetical sense. Generally, in a system with radix b ( b > 1 ),

2320-451: The norm for field-programmable gate array (FPGA) implementations, as floating-point support in an FPGA requires significantly more resources than fixed-point support. A fixed-point representation of a fractional number is essentially an integer that is to be implicitly multiplied by a fixed scaling factor. For example, the value 1.23 can be stored in a variable as the integer value 1230 with implicit scaling factor of 1/1000 (meaning that

2378-403: The operation r ← r × s require multiplying the respective integers and explicitly dividing the result by S . The result may have to be rounded, and overflow may occur. For example, if the common scaling factor is 1/100, multiplying 1.23 by 0.25 entails multiplying 123 by 25 to yield 3075 with an intermediate scaling factor of 1/10000. In order to return to the original scaling factor 1/100,

Fraunhofer FDK AAC - Misplaced Pages Continue

2436-462: The other hand, a smaller scaling factor means a smaller range of the values that can be stored in a given program variable. The maximum fixed-point value that can be stored into a variable is the largest integer value that can be stored into it, multiplied by the scaling factor; and similarly for the minimum value. For example, the table below gives the implied scaling factor S , the minimum and maximum representable values V min and V max , and

2494-432: The other hand, the use of fixed point requires greater care by the programmer. Avoidance of overflow requires much tighter estimates for the ranges of variables and all intermediate values in the computation, and often also extra code to adjust their scaling factors. Fixed-point programming normally requires the use of integer types of different widths . Fixed-point applications can make use of block floating point , which

2552-469: The patent owners, and therefore FDK AAC Codec software may already be covered under those patent licenses when it is used for those licensed purposes only." There is no license fee required for using an AAC codec such as FDK AAC, only for manufacturing an "end-user" codec such as producing a phone loaded with AAC software. Debian considers the FDK AAC license non-free because it prohibits people from charging

2610-401: The result may require one bit more than the operands. In multiplication of two unsigned integers with m and n bits, the result may have m + n bits. In case of overflow, the high-order bits are usually lost, as the un-scaled integer gets reduced modulo 2 where n is the size of the storage area. The sign bit, in particular, is lost, which may radically change the sign and the magnitude of

2668-411: The same program variables as the operands. These operations yield the exact mathematical result, as long as no overflow occurs—that is, as long as the resulting integer can be stored in the receiving program variable . If the operands have different scaling factors, then they must be converted to a common scaling factor before the operation. To multiply two fixed-point numbers, it suffices to multiply

2726-409: The scaling factor S , then round the result to the nearest integer. Care must be taken to ensure that the result fits in the destination variable or register. Depending on the scaling factor and storage size, and on the range input numbers, the conversion may not entail any rounding. To convert a fixed-point number to floating-point, one may convert the integer to floating-point and then divide it by

2784-657: The scaling factor S . This conversion may entail rounding if the integer's absolute value is greater than 2 (for binary single-precision IEEE floating point) or of 2 (for double-precision). Overflow or underflow may occur if | S | is very large or very small, respectively. Typical processors do not have specific support for fixed-point arithmetic. However, most computers with binary arithmetic have fast bit shift instructions that can multiply or divide an integer by any power of 2; in particular, an arithmetic shift instruction. These instructions can be used to quickly change scaling factors that are powers of 2, while preserving

2842-737: The sign of the number. Early computers like the IBM 1620 and the Burroughs B3500 used a binary-coded decimal (BCD) representation for integers, namely base 10 where each decimal digit was independently encoded with 4 bits. Some processors, such as microcontrollers, may still use it. In such machines, conversion of decimal scaling factors can be performed by bit shifts and/or by memory address manipulation. Some DSP architectures offer native support for specific fixed-point formats, for example, signed n -bit numbers with n −1 fraction bits (whose values may range between −1 and almost +1). The support may include

2900-450: The two underlying integers, and assume that the scaling factor of the result is the product of their scaling factors. The result will be exact, with no rounding, provided that it does not overflow the receiving variable. For example, multiplying the numbers 123 scaled by 1/1000 (0.123) and 25 scaled by 1/10 (2.5) yields the integer 123×25 = 3075 scaled by (1/1000)×(1/10) = 1/10000, that is 3075/10000 = 0.3075. As another example, multiplying

2958-448: The underlying integer must be multiplied by the ratio R / S . Thus, for example, to convert the value 1.23 = 123/100 from scaling factor R =1/100 to one with scaling factor S =1/1000, the integer 123 must be multiplied by (1/100)/(1/1000) = 10, yielding the representation 1230/1000. If the scaling factor is a power of the base used internally to represent the integer, changing the scaling factor requires only dropping low-order digits of

SECTION 50

#1732880509004

3016-410: The usual 2 scaling. The Julia programming language implements both versions. Any binary fraction a /2 , such as 1/16 or 17/32, can be exactly represented in fixed-point, with a power-of-two scaling factor 1/2 with any n ≥ m . However, most decimal fractions like 0.1 or 0.123 are infinite repeating fractions in base 2. and hence cannot be represented that way. Similarly, any decimal fraction

3074-404: The value of ten) would represent the value 5 × 12 + 9 × 12 + 10 × 12 = 838 in base 10. Commonly used numeral systems include: The octal and hexadecimal systems are often used in computing because of their ease as shorthand for binary. Every hexadecimal digit corresponds to a sequence of four binary digits, since sixteen is the fourth power of two; for example, hexadecimal 78 16

3132-536: The value will always be an integer multiple of b . Fixed-point representation can also be used to omit the low-order digits of integer values, e.g. when representing large dollar values as multiples of $ 1000. When decimal fixed-point numbers are displayed for human reading, the fraction digits are usually separated from those of the integer part by a radix character (usually '.' in English, but ',' or some other symbol in many other languages). Internally, however, there

3190-433: The value. Some processors can set a hardware overflow flag and/or generate an exception on the occurrence of an overflow. Some processors may instead provide saturation arithmetic : if the result of an addition or subtraction were to overflow, they store instead the value with the largest magnitude that can fit in the receiving area and has the correct sign. However, these features are not very useful in practice; it

3248-501: The values −11/2 = −88, −11/2 = −0. 343 75 , and −11/2 = −0. 002 685 546 875 , respectively. Alternatively, negative values can be represented by an integer in the sign-magnitude format, in which case the sign is never included in the number of implied fraction bits. This variant is more commonly used in decimal fixed-point arithmetic. Thus the signed 5-digit decimal integer (−00025) 10 , taken with -3, +5, and +12 implied decimal fraction digits, would represent

3306-449: The values −25/10 = −25000, −25/10 = −0.00025, and −25/10 = −0. 000 000 000 025 , respectively. A program will usually assume that all fixed-point values that will be stored into a given variable, or will be produced by a given instruction , will have the same scaling factor. This parameter can usually be chosen by the programmer depending on the precision needed and range of values to be stored. The scaling factor of

3364-463: Was widely used from the late 1960s to the 1980s for real-time computing that was mathematically intensive, such as flight simulation and in nuclear power plant control algorithms. It is still used in many DSP applications and custom-made microprocessors. Computations involving angles would use binary angular measurement . Binary fixed point is used in the STM32G4 series CORDIC co-processors and in

#3996