开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
timer.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：10k
源码类别：

VC书籍

开发平台：

Visual C++

timer.c：源码内容
  1. /*
  2.  * libmad - MPEG audio decoder library
  3.  
  4.  */
  6. # ifdef HAVE_CONFIG_H
  7. #  include "config.h"
  8. # endif
  10. # include "global.h"
  12. # include <stdio.h>
  14. # ifdef HAVE_ASSERT_H
  15. #  include <assert.h>
  16. # endif
  18. # include "timer.h"
  20. mad_timer_t const mad_timer_zero = { 0, 0 };
  22. /*
  23.  * NAME: timer->compare()
  24.  * DESCRIPTION: indicate relative order of two timers
  25.  */
  26. int mad_timer_compare(mad_timer_t timer1, mad_timer_t timer2)
  27. {
  28.   signed long diff;
  30.   diff = timer1.seconds - timer2.seconds;
  31.   if (diff < 0)
  32.     return -1;
  33.   else if (diff > 0)
  34.     return +1;
  36.   diff = timer1.fraction - timer2.fraction;
  37.   if (diff < 0)
  38.     return -1;
  39.   else if (diff > 0)
  40.     return +1;
  42.   return 0;
  43. }
  45. /*
  46.  * NAME: timer->negate()
  47.  * DESCRIPTION: invert the sign of a timer
  48.  */
  49. void mad_timer_negate(mad_timer_t *timer)
  50. {
  51.   timer->seconds = -timer->seconds;
  53.   if (timer->fraction) {
  54.     timer->seconds -= 1;
  55.     timer->fraction = MAD_TIMER_RESOLUTION - timer->fraction;
  56.   }
  57. }
  59. /*
  60.  * NAME: timer->abs()
  61.  * DESCRIPTION: return the absolute value of a timer
  62.  */
  63. mad_timer_t mad_timer_abs(mad_timer_t timer)
  64. {
  65.   if (mad_timer_sign(timer) < 0)
  66.     mad_timer_negate(&timer);
  68.   return timer;
  69. }
  71. /*
  72.  * NAME: reduce_timer()
  73.  * DESCRIPTION: carry timer fraction into seconds
  74.  */
  75. static
  76. void reduce_timer(mad_timer_t *timer)
  77. {
  78.   timer->seconds  += timer->fraction / MAD_TIMER_RESOLUTION;
  79.   timer->fraction %= MAD_TIMER_RESOLUTION;
  80. }
  82. /*
  83.  * NAME: gcd()
  84.  * DESCRIPTION: compute greatest common denominator
  85.  */
  86. static
  87. unsigned long gcd(unsigned long num1, unsigned long num2)
  88. {
  89.   unsigned long tmp;
  91.   while (num2) {
  92.     tmp  = num2;
  93.     num2 = num1 % num2;
  94.     num1 = tmp;
  95.   }
  97.   return num1;
  98. }
  100. /*
  101.  * NAME: reduce_rational()
  102.  * DESCRIPTION: convert rational expression to lowest terms
  103.  */
  104. static
  105. void reduce_rational(unsigned long *numer, unsigned long *denom)
  106. {
  107.   unsigned long factor;
  109.   factor = gcd(*numer, *denom);
  111.   assert(factor != 0);
  113.   *numer /= factor;
  114.   *denom /= factor;
  115. }
  117. /*
  118.  * NAME: scale_rational()
  119.  * DESCRIPTION: solve numer/denom == ?/scale avoiding overflowing
  120.  */
  121. static
  122. unsigned long scale_rational(unsigned long numer, unsigned long denom,
  123.      unsigned long scale)
  124. {
  125.   reduce_rational(&numer, &denom);
  126.   reduce_rational(&scale, &denom);
  128.   assert(denom != 0);
  130.   if (denom < scale)
  131.     return numer * (scale / denom) + numer * (scale % denom) / denom;
  132.   if (denom < numer)
  133.     return scale * (numer / denom) + scale * (numer % denom) / denom;
  135.   return numer * scale / denom;
  136. }
  138. /*
  139.  * NAME: timer->set()
  140.  * DESCRIPTION: set timer to specific (positive) value
  141.  */
  142. void mad_timer_set(mad_timer_t *timer, unsigned long seconds,
  143.    unsigned long numer, unsigned long denom)
  144. {
  145.   timer->seconds = seconds;
  146.   if (numer >= denom && denom > 0) {
  147.     timer->seconds += numer / denom;
  148.     numer %= denom;
  149.   }
  151.   switch (denom) {
  152.   case 0:
  153.   case 1:
  154.     timer->fraction = 0;
  155.     break;
  157.   case MAD_TIMER_RESOLUTION:
  158.     timer->fraction = numer;
  159.     break;
  161.   case 1000:
  162.     timer->fraction = numer * (MAD_TIMER_RESOLUTION /  1000);
  163.     break;
  165.   case 8000:
  166.     timer->fraction = numer * (MAD_TIMER_RESOLUTION /  8000);
  167.     break;
  169.   case 11025:
  170.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 11025);
  171.     break;
  173.   case 12000:
  174.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 12000);
  175.     break;
  177.   case 16000:
  178.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 16000);
  179.     break;
  181.   case 22050:
  182.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 22050);
  183.     break;
  185.   case 24000:
  186.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 24000);
  187.     break;
  189.   case 32000:
  190.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 32000);
  191.     break;
  193.   case 44100:
  194.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 44100);
  195.     break;
  197.   case 48000:
  198.     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 48000);
  199.     break;
  201.   default:
  202.     timer->fraction = scale_rational(numer, denom, MAD_TIMER_RESOLUTION);
  203.     break;
  204.   }
  206.   if (timer->fraction >= MAD_TIMER_RESOLUTION)
  207.     reduce_timer(timer);
  208. }
  210. /*
  211.  * NAME: timer->add()
  212.  * DESCRIPTION: add one timer to another
  213.  */
  214. void mad_timer_add(mad_timer_t *timer, mad_timer_t incr)
  215. {
  216.   timer->seconds  += incr.seconds;
  217.   timer->fraction += incr.fraction;
  219.   if (timer->fraction >= MAD_TIMER_RESOLUTION)
  220.     reduce_timer(timer);
  221. }
  223. /*
  224.  * NAME: timer->multiply()
  225.  * DESCRIPTION: multiply a timer by a scalar value
  226.  */
  227. void mad_timer_multiply(mad_timer_t *timer, signed long scalar)
  228. {
  229.   mad_timer_t addend;
  230.   unsigned long factor;
  232.   factor = scalar;
  233.   if (scalar < 0) {
  234.     factor = -scalar;
  235.     mad_timer_negate(timer);
  236.   }
  238.   addend = *timer;
  239.   *timer = mad_timer_zero;
  241.   while (factor) {
  242.     if (factor & 1)
  243.       mad_timer_add(timer, addend);
  245.     mad_timer_add(&addend, addend);
  246.     factor >>= 1;
  247.   }
  248. }
  250. /*
  251.  * NAME: timer->count()
  252.  * DESCRIPTION: return timer value in selected units
  253.  */
  254. signed long mad_timer_count(mad_timer_t timer, enum mad_units units)
  255. {
  256.   switch (units) {
  257.   case MAD_UNITS_HOURS:
  258.     return timer.seconds / 60 / 60;
  260.   case MAD_UNITS_MINUTES:
  261.     return timer.seconds / 60;
  263.   case MAD_UNITS_SECONDS:
  264.     return timer.seconds;
  266.   case MAD_UNITS_DECISECONDS:
  267.   case MAD_UNITS_CENTISECONDS:
  268.   case MAD_UNITS_MILLISECONDS:
  270.   case MAD_UNITS_8000_HZ:
  271.   case MAD_UNITS_11025_HZ:
  272.   case MAD_UNITS_12000_HZ:
  273.   case MAD_UNITS_16000_HZ:
  274.   case MAD_UNITS_22050_HZ:
  275.   case MAD_UNITS_24000_HZ:
  276.   case MAD_UNITS_32000_HZ:
  277.   case MAD_UNITS_44100_HZ:
  278.   case MAD_UNITS_48000_HZ:
  280.   case MAD_UNITS_24_FPS:
  281.   case MAD_UNITS_25_FPS:
  282.   case MAD_UNITS_30_FPS:
  283.   case MAD_UNITS_48_FPS:
  284.   case MAD_UNITS_50_FPS:
  285.   case MAD_UNITS_60_FPS:
  286.   case MAD_UNITS_75_FPS:
  287.     return timer.seconds * (signed long) units +
  288.       (signed long) scale_rational(timer.fraction, MAD_TIMER_RESOLUTION,
  289.    units);
  291.   case MAD_UNITS_23_976_FPS:
  292.   case MAD_UNITS_24_975_FPS:
  293.   case MAD_UNITS_29_97_FPS:
  294.   case MAD_UNITS_47_952_FPS:
  295.   case MAD_UNITS_49_95_FPS:
  296.   case MAD_UNITS_59_94_FPS:
  297.     return (mad_timer_count(timer, -units) + 1) * 1000 / 1001;
  298.   }
  300.   /* unsupported units */
  301.   return 0;
  302. }
  304. /*
  305.  * NAME: timer->fraction()
  306.  * DESCRIPTION: return fractional part of timer in arbitrary terms
  307.  */
  308. unsigned long mad_timer_fraction(mad_timer_t timer, unsigned long denom)
  309. {
  310.   timer = mad_timer_abs(timer);
  312.   switch (denom) {
  313.   case 0:
  314.     return MAD_TIMER_RESOLUTION / timer.fraction;
  316.   case MAD_TIMER_RESOLUTION:
  317.     return timer.fraction;
  319.   default:
  320.     return scale_rational(timer.fraction, MAD_TIMER_RESOLUTION, denom);
  321.   }
  322. }
  324. /*
  325.  * NAME: timer->string()
  326.  * DESCRIPTION: write a string representation of a timer using a template
  327.  */
  328. void mad_timer_string(mad_timer_t timer,
  329.       char *dest, char const *format, enum mad_units units,
  330.       enum mad_units fracunits, unsigned long subparts)
  331. {
  332.   unsigned long hours, minutes, seconds, sub;
  333.   unsigned int frac;
  335.   timer = mad_timer_abs(timer);
  337.   seconds = timer.seconds;
  338.   frac = sub = 0;
  340.   switch (fracunits) {
  341.   case MAD_UNITS_HOURS:
  342.   case MAD_UNITS_MINUTES:
  343.   case MAD_UNITS_SECONDS:
  344.     break;
  346.   case MAD_UNITS_DECISECONDS:
  347.   case MAD_UNITS_CENTISECONDS:
  348.   case MAD_UNITS_MILLISECONDS:
  350.   case MAD_UNITS_8000_HZ:
  351.   case MAD_UNITS_11025_HZ:
  352.   case MAD_UNITS_12000_HZ:
  353.   case MAD_UNITS_16000_HZ:
  354.   case MAD_UNITS_22050_HZ:
  355.   case MAD_UNITS_24000_HZ:
  356.   case MAD_UNITS_32000_HZ:
  357.   case MAD_UNITS_44100_HZ:
  358.   case MAD_UNITS_48000_HZ:
  360.   case MAD_UNITS_24_FPS:
  361.   case MAD_UNITS_25_FPS:
  362.   case MAD_UNITS_30_FPS:
  363.   case MAD_UNITS_48_FPS:
  364.   case MAD_UNITS_50_FPS:
  365.   case MAD_UNITS_60_FPS:
  366.   case MAD_UNITS_75_FPS:
  367.     {
  368.       unsigned long denom;
  370.       denom = MAD_TIMER_RESOLUTION / fracunits;
  372.       frac = timer.fraction / denom;
  373.       sub  = scale_rational(timer.fraction % denom, denom, subparts);
  374.     }
  375.     break;
  377.   case MAD_UNITS_23_976_FPS:
  378.   case MAD_UNITS_24_975_FPS:
  379.   case MAD_UNITS_29_97_FPS:
  380.   case MAD_UNITS_47_952_FPS:
  381.   case MAD_UNITS_49_95_FPS:
  382.   case MAD_UNITS_59_94_FPS:
  383.     /* drop-frame encoding */
  384.     /* N.B. this is only well-defined for MAD_UNITS_29_97_FPS */
  385.     {
  386.       unsigned long frame, cycle, d, m;
  388.       frame = mad_timer_count(timer, fracunits);
  390.       cycle = -fracunits * 60 * 10 - (10 - 1) * 2;
  392.       d = frame / cycle;
  393.       m = frame % cycle;
  394.       frame += (10 - 1) * 2 * d;
  395.       if (m > 2)
  396. frame += 2 * ((m - 2) / (cycle / 10));
  398.       frac    = frame % -fracunits;
  399.       seconds = frame / -fracunits;
  400.     }
  401.     break;
  402.   }
  404.   switch (units) {
  405.   case MAD_UNITS_HOURS:
  406.     minutes = seconds / 60;
  407.     hours   = minutes / 60;
  409.     sprintf(dest, format,
  410.     hours,
  411.     (unsigned int) (minutes % 60),
  412.     (unsigned int) (seconds % 60),
  413.     frac, sub);
  414.     break;
  416.   case MAD_UNITS_MINUTES:
  417.     minutes = seconds / 60;
  419.     sprintf(dest, format,
  420.     minutes,
  421.     (unsigned int) (seconds % 60),
  422.     frac, sub);
  423.     break;
  425.   case MAD_UNITS_SECONDS:
  426.     sprintf(dest, format,
  427.     seconds,
  428.     frac, sub);
  429.     break;
  431.   case MAD_UNITS_23_976_FPS:
  432.   case MAD_UNITS_24_975_FPS:
  433.   case MAD_UNITS_29_97_FPS:
  434.   case MAD_UNITS_47_952_FPS:
  435.   case MAD_UNITS_49_95_FPS:
  436.   case MAD_UNITS_59_94_FPS:
  437.     if (fracunits < 0) {
  438.       /* not yet implemented */
  439.       sub = 0;
  440.     }
  442.     /* fall through */
  444.   case MAD_UNITS_DECISECONDS:
  445.   case MAD_UNITS_CENTISECONDS:
  446.   case MAD_UNITS_MILLISECONDS:
  448.   case MAD_UNITS_8000_HZ:
  449.   case MAD_UNITS_11025_HZ:
  450.   case MAD_UNITS_12000_HZ:
  451.   case MAD_UNITS_16000_HZ:
  452.   case MAD_UNITS_22050_HZ:
  453.   case MAD_UNITS_24000_HZ:
  454.   case MAD_UNITS_32000_HZ:
  455.   case MAD_UNITS_44100_HZ:
  456.   case MAD_UNITS_48000_HZ:
  458.   case MAD_UNITS_24_FPS:
  459.   case MAD_UNITS_25_FPS:
  460.   case MAD_UNITS_30_FPS:
  461.   case MAD_UNITS_48_FPS:
  462.   case MAD_UNITS_50_FPS:
  463.   case MAD_UNITS_60_FPS:
  464.   case MAD_UNITS_75_FPS:
  465.     sprintf(dest, format, mad_timer_count(timer, units), sub);
  466.     break;
  467.   }
  468. }