misc/winutils/include/libavutil/rational.h
changeset 15409 262003f2e19a
parent 15408 90a79670de52
child 15410 7718bdf60d45
equal deleted inserted replaced
15408:90a79670de52 15409:262003f2e19a
     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 */