1 /*

     2  * rational numbers

     3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>

     4  *

     5  * This file is part of Libav.

     6  *

     7  * Libav is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Lesser General Public

     9  * License as published by the Free Software Foundation; either

    10  * version 2.1 of the License, or (at your option) any later version.

    11  *

    12  * Libav is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Lesser General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Lesser General Public

    18  * License along with Libav; if not, write to the Free Software

    19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

    20  */

    21 

    22 /**

    23  * @file

    24  * rational numbers

    25  * @author Michael Niedermayer <michaelni@gmx.at>

    26  */

    27 

    28 #ifndef AVUTIL_RATIONAL_H

    29 #define AVUTIL_RATIONAL_H

    30 

    31 #include <stdint.h>

    32 #include <limits.h>

    33 #include "attributes.h"

    34 

    35 /**

    36  * @addtogroup lavu_math

    37  * @{

    38  */

    39 

    40 /**

    41  * rational number numerator/denominator

    42  */

    43 typedef struct AVRational{

    44     int num; ///< numerator

    45     int den; ///< denominator

    46 } AVRational;

    47 

    48 /**

    49  * Compare two rationals.

    50  * @param a first rational

    51  * @param b second rational

    52  * @return 0 if a==b, 1 if a>b, -1 if a<b, and INT_MIN if one of the

    53  * values is of the form 0/0

    54  */

    55 static inline int av_cmp_q(AVRational a, AVRational b){

    56     const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;

    57 

    58     if(tmp) return ((tmp ^ a.den ^ b.den)>>63)|1;

    59     else if(b.den && a.den) return 0;

    60     else if(a.num && b.num) return (a.num>>31) - (b.num>>31);

    61     else                    return INT_MIN;

    62 }

    63 

    64 /**

    65  * Convert rational to double.

    66  * @param a rational to convert

    67  * @return (double) a

    68  */

    69 static inline double av_q2d(AVRational a){

    70     return a.num / (double) a.den;

    71 }

    72 

    73 /**

    74  * Reduce a fraction.

    75  * This is useful for framerate calculations.

    76  * @param dst_num destination numerator

    77  * @param dst_den destination denominator

    78  * @param num source numerator

    79  * @param den source denominator

    80  * @param max the maximum allowed for dst_num & dst_den

    81  * @return 1 if exact, 0 otherwise

    82  */

    83 int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max);

    84 

    85 /**

    86  * Multiply two rationals.

    87  * @param b first rational

    88  * @param c second rational

    89  * @return b*c

    90  */

    91 AVRational av_mul_q(AVRational b, AVRational c) av_const;

    92 

    93 /**

    94  * Divide one rational by another.

    95  * @param b first rational

    96  * @param c second rational

    97  * @return b/c

    98  */

    99 AVRational av_div_q(AVRational b, AVRational c) av_const;

   100 

   101 /**

   102  * Add two rationals.

   103  * @param b first rational

   104  * @param c second rational

   105  * @return b+c

   106  */

   107 AVRational av_add_q(AVRational b, AVRational c) av_const;

   108 

   109 /**

   110  * Subtract one rational from another.

   111  * @param b first rational

   112  * @param c second rational

   113  * @return b-c

   114  */

   115 AVRational av_sub_q(AVRational b, AVRational c) av_const;

   116 

   117 /**

   118  * Invert a rational.

   119  * @param q value

   120  * @return 1 / q

   121  */

   122 static av_always_inline AVRational av_inv_q(AVRational q)

   123 {

   124     AVRational r = { q.den, q.num };

   125     return r;

   126 }

   127 

   128 /**

   129  * Convert a double precision floating point number to a rational.

   130  * inf is expressed as {1,0} or {-1,0} depending on the sign.

   131  *

   132  * @param d double to convert

   133  * @param max the maximum allowed numerator and denominator

   134  * @return (AVRational) d

   135  */

   136 AVRational av_d2q(double d, int max) av_const;

   137 

   138 /**

   139  * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer

   140  * than q1, 0 if they have the same distance.

   141  */

   142 int av_nearer_q(AVRational q, AVRational q1, AVRational q2);

   143 

   144 /**

   145  * Find the nearest value in q_list to q.

   146  * @param q_list an array of rationals terminated by {0, 0}

   147  * @return the index of the nearest value found in the array

   148  */

   149 int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);

   150 

   151 /**

   152  * @}

   153  */

   154 

   155 #endif /* AVUTIL_RATIONAL_H */