Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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-2007             *
  9.  * by the Xiph.Org Foundation https://xiph.org/                     *
  10.  *                                                                  *
  11.  ********************************************************************
  12.  
  13.  function: illustrate seeking, and test it too
  14.  
  15.  ********************************************************************/
  16.  
  17. #include <stdlib.h>
  18. #include <stdio.h>
  19. #include "vorbis/codec.h"
  20. #include "vorbis/vorbisfile.h"
  21.  
  22. #ifdef _WIN32 /* We need the following two to set stdin/stdout to binary */
  23. # include <io.h>
  24. # include <fcntl.h>
  25. #endif
  26.  
  27. void _verify(OggVorbis_File *ov,
  28.              ogg_int64_t val,ogg_int64_t pcmval,double timeval,
  29.              ogg_int64_t pcmlength,
  30.              char *bigassbuffer){
  31.   off_t i;
  32.   int j;
  33.   long bread;
  34.   char buffer[4096];
  35.   int dummy;
  36.   ogg_int64_t pos;
  37.   int hs = ov_halfrate_p(ov);
  38.  
  39.   /* verify the raw position, the pcm position and position decode */
  40.   if(val!=-1 && ov_raw_tell(ov)<val){
  41.     fprintf(stderr,"raw position out of tolerance: requested %ld, got %ld\n",
  42.            (long)val,(long)ov_raw_tell(ov));
  43.     exit(1);
  44.   }
  45.   if(pcmval!=-1 && ov_pcm_tell(ov)>pcmval){
  46.     fprintf(stderr,"pcm position out of tolerance: requested %ld, got %ld\n",
  47.            (long)pcmval,(long)ov_pcm_tell(ov));
  48.     exit(1);
  49.   }
  50.   if(timeval!=-1 && ov_time_tell(ov)>timeval){
  51.     fprintf(stderr,"time position out of tolerance: requested %f, got %f\n",
  52.            timeval,ov_time_tell(ov));
  53.     exit(1);
  54.   }
  55.   pos=ov_pcm_tell(ov);
  56.   if(pos<0 || pos>pcmlength){
  57.     fprintf(stderr,"pcm position out of bounds: got %ld\n",(long)pos);
  58.     exit(1);
  59.   }
  60.   bread=ov_read(ov,buffer,4096,1,1,1,&dummy);
  61.   for(j=0;j<bread;j++){
  62.     if(buffer[j]!=bigassbuffer[j+((pos>>hs)*2)]){
  63.       fprintf(stderr,"data after seek doesn't match declared pcm position %ld\n",(long)pos);
  64.  
  65.       for(i=0;i<(pcmlength>>hs)*2-bread;i++){
  66.         for(j=0;j<bread;j++)
  67.           if(buffer[j] != bigassbuffer[i+j])break;
  68.         if(j==bread){
  69.           fprintf(stderr,"data after seek appears to match position %ld\n",(long)((i/2)<<hs));
  70.         }
  71.       }
  72.       {
  73.         FILE *f=fopen("a.m","w");
  74.         for(j=0;j<bread;j++)fprintf(f,"%d %d\n",j,(int)buffer[j]);
  75.         fclose(f);
  76.         f=fopen("b.m","w");
  77.         for(j=-4096;j<bread+4096;j++)
  78.           if(j+((pos*2)>>hs)>=0 && (j+((pos*2)>>hs))<(pcmlength>>hs)*2)
  79.              fprintf(f,"%d %d\n",j,(int)bigassbuffer[j+((pos*2)>>hs)]);
  80.         fclose(f);
  81.       }
  82.  
  83.       exit(1);
  84.     }
  85.   }
  86. }
  87.  
  88. int main(){
  89.   OggVorbis_File ov;
  90.   int i,ret;
  91.   ogg_int64_t pcmlength;
  92.   double timelength;
  93.   char *bigassbuffer;
  94.   int dummy;
  95.   int hs=0;
  96.  
  97. #ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
  98.   _setmode( _fileno( stdin ), _O_BINARY );
  99. #endif
  100.  
  101.  
  102.   /* open the file/pipe on stdin */
  103.   if(ov_open_callbacks(stdin,&ov,NULL,-1,OV_CALLBACKS_NOCLOSE)<0){
  104.     fprintf(stderr,"Could not open input as an OggVorbis file.\n\n");
  105.     exit(1);
  106.   }
  107.  
  108. #if 0 /*enable this code to test seeking with halfrate decode */
  109.   if(ov_halfrate(&ov,1)){
  110.     fprintf(stderr,"Sorry; unable to set half-rate decode.\n\n");
  111.     exit(1);
  112.   }else
  113.     hs=1;
  114. #endif
  115.  
  116.   if(ov_seekable(&ov)){
  117.  
  118.     /* to simplify our own lives, we want to assume the whole file is
  119.        stereo.  Verify this to avoid potentially mystifying users
  120.        (pissing them off is OK, just don't confuse them) */
  121.     for(i=0;i<ov.links;i++){
  122.       vorbis_info *vi=ov_info(&ov,i);
  123.       if(vi->channels!=2){
  124.         fprintf(stderr,"Sorry; right now seeking_test can only use Vorbis files\n"
  125.                "that are entirely stereo.\n\n");
  126.         exit(1);
  127.       }
  128.     }
  129.  
  130.     /* because we want to do sample-level verification that the seek
  131.        does what it claimed, decode the entire file into memory */
  132.     pcmlength=ov_pcm_total(&ov,-1);
  133.     timelength=ov_time_total(&ov,-1);
  134.     bigassbuffer=malloc((pcmlength>>hs)*2); /* w00t */
  135.     i=0;
  136.     while(i<(pcmlength>>hs)*2){
  137.       int ret=ov_read(&ov,bigassbuffer+i,((pcmlength>>hs)*2)-i,1,1,1,&dummy);
  138.       if(ret<0){
  139.         fprintf(stderr,"Error reading file.\n");
  140.         exit(1);
  141.       }
  142.       if(ret){
  143.         i+=ret;
  144.       }else{
  145.         pcmlength=(i/2)<<hs;
  146.       }
  147.       fprintf(stderr,"\rloading.... [%ld left]              ",
  148.               (long)((pcmlength>>hs)*2-i));
  149.     }
  150.  
  151.     {
  152.       ogg_int64_t length=ov.end;
  153.       fprintf(stderr,"\rtesting raw seeking to random places in %ld bytes....\n",
  154.              (long)length);
  155.  
  156.       for(i=0;i<1000;i++){
  157.         ogg_int64_t val=(double)rand()/RAND_MAX*length;
  158.         fprintf(stderr,"\r\t%d [raw position %ld]...     ",i,(long)val);
  159.         ret=ov_raw_seek(&ov,val);
  160.         if(ret<0){
  161.           fprintf(stderr,"seek failed: %d\n",ret);
  162.           exit(1);
  163.         }
  164.  
  165.         _verify(&ov,val,-1,-1.,pcmlength,bigassbuffer);
  166.  
  167.       }
  168.     }
  169.  
  170.     fprintf(stderr,"\r");
  171.     {
  172.       fprintf(stderr,"testing pcm page seeking to random places in %ld samples....\n",
  173.              (long)pcmlength);
  174.  
  175.       for(i=0;i<1000;i++){
  176.         ogg_int64_t val= i==0?(ogg_int64_t)0:(double)rand()/RAND_MAX*pcmlength;
  177.         fprintf(stderr,"\r\t%d [pcm position %ld]...     ",i,(long)val);
  178.         ret=ov_pcm_seek_page(&ov,val);
  179.         if(ret<0){
  180.           fprintf(stderr,"seek failed: %d\n",ret);
  181.           exit(1);
  182.         }
  183.  
  184.         _verify(&ov,-1,val,-1.,pcmlength,bigassbuffer);
  185.  
  186.       }
  187.     }
  188.  
  189.     fprintf(stderr,"\r");
  190.     {
  191.       fprintf(stderr,"testing pcm exact seeking to random places in %f seconds....\n",
  192.              timelength);
  193.       for(i=0;i<1000;i++){
  194.         ogg_int64_t val= i==0?(ogg_int64_t)0:(double)rand()/RAND_MAX*pcmlength;
  195.         fprintf(stderr,"\r\t%d [pcm position %ld]...     ",i,(long)val);
  196.         ret=ov_pcm_seek(&ov,val);
  197.         if(ret<0){
  198.           fprintf(stderr,"seek failed: %d\n",ret);
  199.           exit(1);
  200.         }
  201.         if(ov_pcm_tell(&ov)!=((val>>hs)<<hs)){
  202.           fprintf(stderr,"Declared position didn't perfectly match request: %ld != %ld\n",
  203.                  (long)val,(long)ov_pcm_tell(&ov));
  204.           exit(1);
  205.         }
  206.  
  207.         _verify(&ov,-1,val,-1.,pcmlength,bigassbuffer);
  208.  
  209.       }
  210.     }
  211.  
  212.     fprintf(stderr,"\r");
  213.     {
  214.       fprintf(stderr,"testing time page seeking to random places in %f seconds....\n",
  215.              timelength);
  216.  
  217.       for(i=0;i<1000;i++){
  218.         double val=(double)rand()/RAND_MAX*timelength;
  219.         fprintf(stderr,"\r\t%d [time position %f]...     ",i,val);
  220.         ret=ov_time_seek_page(&ov,val);
  221.         if(ret<0){
  222.           fprintf(stderr,"seek failed: %d\n",ret);
  223.           exit(1);
  224.         }
  225.  
  226.         _verify(&ov,-1,-1,val,pcmlength,bigassbuffer);
  227.  
  228.       }
  229.     }
  230.  
  231.     fprintf(stderr,"\r");
  232.     {
  233.       fprintf(stderr,"testing time exact seeking to random places in %f seconds....\n",
  234.              timelength);
  235.  
  236.       for(i=0;i<1000;i++){
  237.         double val=(double)rand()/RAND_MAX*timelength;
  238.         fprintf(stderr,"\r\t%d [time position %f]...     ",i,val);
  239.         ret=ov_time_seek(&ov,val);
  240.         if(ret<0){
  241.           fprintf(stderr,"seek failed: %d\n",ret);
  242.           exit(1);
  243.         }
  244.         if(ov_time_tell(&ov)<val-1 || ov_time_tell(&ov)>val+1){
  245.           fprintf(stderr,"Declared position didn't perfectly match request: %f != %f\n",
  246.                  val,ov_time_tell(&ov));
  247.           exit(1);
  248.         }
  249.  
  250.         _verify(&ov,-1,-1,val,pcmlength,bigassbuffer);
  251.  
  252.       }
  253.     }
  254.  
  255.     fprintf(stderr,"\r                                           \nOK.\n\n");
  256.  
  257.  
  258.   }else{
  259.     fprintf(stderr,"Standard input was not seekable.\n");
  260.   }
  261.  
  262.   ov_clear(&ov);
  263.   return 0;
  264. }
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278.