bitrate.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238
  1. /********************************************************************
  2. * *
  3. * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
  4. * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
  5. * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  6. * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
  7. * *
  8. * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
  9. * by the XIPHOPHORUS Company http://www.xiph.org/ *
  10. * *
  11. ********************************************************************
  12. function: bitrate tracking and management
  13. last mod: $Id: bitrate.c,v 1.23 2003/12/30 13:17:20 xiphmont Exp $
  14. ********************************************************************/
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <math.h>
  18. #include <ogg/ogg.h>
  19. #include "vorbis/codec.h"
  20. #include "codec_internal.h"
  21. #include "os.h"
  22. #include "misc.h"
  23. #include "bitrate.h"
  24. /* compute bitrate tracking setup, allocate circular packet size queue */
  25. void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){
  26. codec_setup_info *ci=vi->codec_setup;
  27. bitrate_manager_info *bi=&ci->bi;
  28. memset(bm,0,sizeof(*bm));
  29. if(bi && (bi->reservoir_bits>0)){
  30. long ratesamples=vi->rate;
  31. int halfsamples=ci->blocksizes[0]>>1;
  32. bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0];
  33. bm->managed=1;
  34. bm->avg_bitsper= rint(1.*bi->avg_rate*halfsamples/ratesamples);
  35. bm->min_bitsper= rint(1.*bi->min_rate*halfsamples/ratesamples);
  36. bm->max_bitsper= rint(1.*bi->max_rate*halfsamples/ratesamples);
  37. bm->avgfloat=PACKETBLOBS/2;
  38. }
  39. }
  40. void vorbis_bitrate_clear(bitrate_manager_state *bm){
  41. memset(bm,0,sizeof(*bm));
  42. return;
  43. }
  44. int vorbis_bitrate_managed(vorbis_block *vb){
  45. vorbis_dsp_state *vd=vb->vd;
  46. private_state *b=vd->backend_state;
  47. bitrate_manager_state *bm=&b->bms;
  48. if(bm && bm->managed)return(1);
  49. return(0);
  50. }
  51. /* finish taking in the block we just processed */
  52. int vorbis_bitrate_addblock(vorbis_block *vb){
  53. vorbis_block_internal *vbi=vb->internal;
  54. vorbis_dsp_state *vd=vb->vd;
  55. private_state *b=vd->backend_state;
  56. bitrate_manager_state *bm=&b->bms;
  57. vorbis_info *vi=vd->vi;
  58. codec_setup_info *ci=vi->codec_setup;
  59. bitrate_manager_info *bi=&ci->bi;
  60. int choice=rint(bm->avgfloat);
  61. long this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  62. long min_target_bits=(vb->W?bm->min_bitsper*bm->short_per_long:bm->min_bitsper);
  63. long max_target_bits=(vb->W?bm->max_bitsper*bm->short_per_long:bm->max_bitsper);
  64. int samples=ci->blocksizes[vb->W]>>1;
  65. long desired_fill=bi->reservoir_bits*bi->reservoir_bias;
  66. if(!bm->managed){
  67. /* not a bitrate managed stream, but for API simplicity, we'll
  68. buffer one packet to keep the code path clean */
  69. if(bm->vb)return(-1); /* one has been submitted without
  70. being claimed */
  71. bm->vb=vb;
  72. return(0);
  73. }
  74. bm->vb=vb;
  75. /* look ahead for avg floater */
  76. if(bm->avg_bitsper>0){
  77. double slew=0.;
  78. long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
  79. double slewlimit= 15./bi->slew_damp;
  80. /* choosing a new floater:
  81. if we're over target, we slew down
  82. if we're under target, we slew up
  83. choose slew as follows: look through packetblobs of this frame
  84. and set slew as the first in the appropriate direction that
  85. gives us the slew we want. This may mean no slew if delta is
  86. already favorable.
  87. Then limit slew to slew max */
  88. if(bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
  89. while(choice>0 && this_bits>avg_target_bits &&
  90. bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
  91. choice--;
  92. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  93. }
  94. }else if(bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
  95. while(choice+1<PACKETBLOBS && this_bits<avg_target_bits &&
  96. bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
  97. choice++;
  98. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  99. }
  100. }
  101. slew=rint(choice-bm->avgfloat)/samples*vi->rate;
  102. if(slew<-slewlimit)slew=-slewlimit;
  103. if(slew>slewlimit)slew=slewlimit;
  104. choice=rint(bm->avgfloat+= slew/vi->rate*samples);
  105. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  106. }
  107. /* enforce min(if used) on the current floater (if used) */
  108. if(bm->min_bitsper>0){
  109. /* do we need to force the bitrate up? */
  110. if(this_bits<min_target_bits){
  111. while(bm->minmax_reservoir-(min_target_bits-this_bits)<0){
  112. choice++;
  113. if(choice>=PACKETBLOBS)break;
  114. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  115. }
  116. }
  117. }
  118. /* enforce max (if used) on the current floater (if used) */
  119. if(bm->max_bitsper>0){
  120. /* do we need to force the bitrate down? */
  121. if(this_bits>max_target_bits){
  122. while(bm->minmax_reservoir+(this_bits-max_target_bits)>bi->reservoir_bits){
  123. choice--;
  124. if(choice<0)break;
  125. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  126. }
  127. }
  128. }
  129. /* Choice of packetblobs now made based on floater, and min/max
  130. requirements. Now boundary check extreme choices */
  131. if(choice<0){
  132. /* choosing a smaller packetblob is insufficient to trim bitrate.
  133. frame will need to be truncated */
  134. long maxsize=(max_target_bits+(bi->reservoir_bits-bm->minmax_reservoir))/8;
  135. bm->choice=choice=0;
  136. if(oggpack_bytes(vbi->packetblob[choice])>maxsize){
  137. oggpack_writetrunc(vbi->packetblob[choice],maxsize*8);
  138. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  139. }
  140. }else{
  141. long minsize=(min_target_bits-bm->minmax_reservoir+7)/8;
  142. if(choice>=PACKETBLOBS)
  143. choice=PACKETBLOBS-1;
  144. bm->choice=choice;
  145. /* prop up bitrate according to demand. pad this frame out with zeroes */
  146. minsize-=oggpack_bytes(vbi->packetblob[choice]);
  147. while(minsize-->0)oggpack_write(vbi->packetblob[choice],0,8);
  148. this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
  149. }
  150. /* now we have the final packet and the final packet size. Update statistics */
  151. /* min and max reservoir */
  152. if(bm->min_bitsper>0 || bm->max_bitsper>0){
  153. if(max_target_bits>0 && this_bits>max_target_bits){
  154. bm->minmax_reservoir+=(this_bits-max_target_bits);
  155. }else if(min_target_bits>0 && this_bits<min_target_bits){
  156. bm->minmax_reservoir+=(this_bits-min_target_bits);
  157. }else{
  158. /* inbetween; we want to take reservoir toward but not past desired_fill */
  159. if(bm->minmax_reservoir>desired_fill){
  160. bm->minmax_reservoir+=(this_bits-max_target_bits);
  161. if(bm->minmax_reservoir<desired_fill)bm->minmax_reservoir=desired_fill;
  162. }else{
  163. bm->minmax_reservoir+=(this_bits-min_target_bits);
  164. if(bm->minmax_reservoir>desired_fill)bm->minmax_reservoir=desired_fill;
  165. }
  166. }
  167. }
  168. /* avg reservoir */
  169. if(bm->avg_bitsper>0){
  170. long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
  171. bm->avg_reservoir+=this_bits-avg_target_bits;
  172. }
  173. return(0);
  174. }
  175. int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){
  176. private_state *b=vd->backend_state;
  177. bitrate_manager_state *bm=&b->bms;
  178. vorbis_block *vb=bm->vb;
  179. int choice=PACKETBLOBS/2;
  180. if(!vb)return 0;
  181. if(op){
  182. vorbis_block_internal *vbi=vb->internal;
  183. if(vorbis_bitrate_managed(vb))
  184. choice=bm->choice;
  185. op->packet=oggpack_get_buffer(vbi->packetblob[choice]);
  186. op->bytes=oggpack_bytes(vbi->packetblob[choice]);
  187. op->b_o_s=0;
  188. op->e_o_s=vb->eofflag;
  189. op->granulepos=vb->granulepos;
  190. op->packetno=vb->sequence; /* for sake of completeness */
  191. }
  192. bm->vb=0;
  193. return(1);
  194. }