← Back to branch summary

~ubuntu-branches/ubuntu/lucid/schroedinger/lucid

« back to all changes in this revision

Viewing changes to schroedinger/schroquantiser.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2009-10-03 18:49:33 UTC
  • mfrom: (1.1.7 upstream) (6.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20091003184933-mmkb7rff1nblsq6m
Tags: 1.0.8-2
* debian/control:
  + Build-depend on pkg-config to fix FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
schroedinger/schroquantiser.c
787
787
schro_encoder_entropy_to_lambda (SchroEncoderFrame *frame, double entropy)
788
788
{
789
789
  int j;
790
 
  double log_lambda_hi, log_lambda_lo, log_lambda_mid;
 
790
  double lambda_hi, lambda_lo, lambda_mid;
791
791
  double entropy_hi, entropy_lo, entropy_mid;
792
792
 
793
 
  log_lambda_hi = log(1);
794
 
  entropy_hi = schro_encoder_lambda_to_entropy (frame, exp(log_lambda_hi));
795
 
  SCHRO_DEBUG("start target=%g log_lambda=%g entropy=%g",
796
 
      entropy, log_lambda_hi, entropy_hi, log_lambda_hi, entropy);
 
793
  lambda_hi = 1;
 
794
  entropy_hi = schro_encoder_lambda_to_entropy (frame, lambda_hi);
 
795
  SCHRO_DEBUG("start target=%g lambda=%g entropy=%g",
 
796
      entropy, lambda_hi, entropy_hi);
797
797
 
798
798
  if (entropy_hi < entropy) {
799
799
    entropy_lo = entropy_hi;
800
 
    log_lambda_lo = log_lambda_hi;
 
800
    lambda_lo = lambda_hi;
801
801
 
802
802
    for(j=0;j<5;j++) {
803
 
      log_lambda_hi = log_lambda_lo + log(100);
804
 
      entropy_hi = schro_encoder_lambda_to_entropy (frame, exp(log_lambda_hi));
 
803
      lambda_hi = lambda_lo*100;
 
804
      entropy_hi = schro_encoder_lambda_to_entropy (frame, lambda_hi);
805
805
 
806
 
      SCHRO_DEBUG("have: log_lambda=[%g,%g] entropy=[%g,%g] target=%g",
807
 
          log_lambda_lo, log_lambda_hi, entropy_lo, entropy_hi, entropy);
 
806
      SCHRO_DEBUG("have: lambda=[%g,%g] entropy=[%g,%g] target=%g",
 
807
          lambda_lo, lambda_hi, entropy_lo, entropy_hi, entropy);
808
808
      if (entropy_hi > entropy) break;
809
809
 
810
810
      SCHRO_DEBUG("--> step up");
811
811
 
812
812
      entropy_lo = entropy_hi;
813
 
      log_lambda_lo = log_lambda_hi;
 
813
      lambda_lo = lambda_hi;
814
814
    }
815
815
    SCHRO_DEBUG("--> stopping");
816
816
  } else {
817
817
    for(j=0;j<5;j++) {
818
 
      log_lambda_lo = log_lambda_hi - log(100);
819
 
      entropy_lo = schro_encoder_lambda_to_entropy (frame, exp(log_lambda_lo));
 
818
      lambda_lo = lambda_hi*0.01;
 
819
      entropy_lo = schro_encoder_lambda_to_entropy (frame, lambda_lo);
820
820
 
821
 
      SCHRO_DEBUG("have: log_lambda=[%g,%g] entropy=[%g,%g] target=%g",
822
 
          log_lambda_lo, log_lambda_hi, entropy_lo, entropy_hi, entropy);
 
821
      SCHRO_DEBUG("have: lambda=[%g,%g] entropy=[%g,%g] target=%g",
 
822
          lambda_lo, lambda_hi, entropy_lo, entropy_hi, entropy);
823
823
 
824
824
      SCHRO_DEBUG("--> step down");
825
825
      if (entropy_lo < entropy) break;
826
826
 
827
827
      entropy_hi = entropy_lo;
828
 
      log_lambda_hi = log_lambda_lo;
 
828
      lambda_hi = lambda_lo;
829
829
    }
830
830
    SCHRO_DEBUG("--> stopping");
831
831
  }
832
832
  if (entropy_lo == entropy_hi) {
833
 
    return exp(0.5*(log_lambda_lo + log_lambda_hi));
 
833
    return sqrt(lambda_lo*lambda_hi);
834
834
  }
835
835
 
836
836
  if (entropy_lo > entropy || entropy_hi < entropy) {
837
837
    SCHRO_ERROR("entropy not bracketed");
838
838
  }
839
839
 
840
 
  for(j=0;j<14;j++){
 
840
  for(j=0;j<7;j++){
841
841
    if (entropy_hi == entropy_lo) break;
842
842
 
843
 
    SCHRO_DEBUG("have: log_lambda=[%g,%g] entropy=[%g,%g] target=%g",
844
 
        log_lambda_lo, log_lambda_hi, entropy_lo, entropy_hi, entropy);
845
 
 
846
 
    log_lambda_mid = log_lambda_lo + (log_lambda_hi - log_lambda_lo) * 0.5;
847
 
    entropy_mid = schro_encoder_lambda_to_entropy (frame, exp(log_lambda_mid));
848
 
 
849
 
    SCHRO_DEBUG("picking log_lambda_mid=%g entropy=%g",
850
 
        log_lambda_mid, entropy_mid);
 
843
    SCHRO_DEBUG("have: lambda=[%g,%g] entropy=[%g,%g] target=%g",
 
844
        lambda_lo, lambda_hi, entropy_lo, entropy_hi, entropy);
 
845
 
 
846
    lambda_mid = sqrt(lambda_lo * lambda_hi);
 
847
    entropy_mid = schro_encoder_lambda_to_entropy (frame, lambda_mid);
 
848
 
 
849
    SCHRO_DEBUG("picking lambda_mid=%g entropy=%g",
 
850
        lambda_mid, entropy_mid);
851
851
 
852
852
    if (entropy_mid > entropy) {
853
 
      log_lambda_hi = log_lambda_mid;
 
853
      lambda_hi = lambda_mid;
854
854
      entropy_hi = entropy_mid;
855
855
      SCHRO_DEBUG("--> focus up");
856
856
    } else {
857
 
      log_lambda_lo = log_lambda_mid;
 
857
      lambda_lo = lambda_mid;
858
858
      entropy_lo = entropy_mid;
859
859
      SCHRO_DEBUG("--> focus down");
860
860
    }
861
861
  }
862
862
 
863
 
  log_lambda_mid = 0.5*(log_lambda_hi + log_lambda_lo);
864
 
  SCHRO_DEBUG("done %g", exp(log_lambda_mid));
865
 
  return exp(log_lambda_mid);
 
863
  lambda_mid = sqrt(lambda_hi * lambda_lo);
 
864
  SCHRO_DEBUG("done %g", lambda_mid);
 
865
  return lambda_mid;
866
866
}
867
867
 
868
868
static double
905
905
schro_encoder_error_to_lambda (SchroEncoderFrame *frame, double error)
906
906
{
907
907
  int j;
908
 
  double log_lambda_hi, log_lambda_lo, log_lambda_mid;
 
908
  double lambda_hi, lambda_lo, lambda_mid;
909
909
  double error_hi, error_lo, error_mid;
910
910
 
911
 
  log_lambda_lo = log(1);
912
 
  error_lo = schro_encoder_lambda_to_error (frame, exp(log_lambda_lo));
913
 
  SCHRO_DEBUG("start target=%g log_lambda=%g error=%g",
914
 
      error, log_lambda_lo, error_lo, log_lambda_lo, error);
 
911
  lambda_lo = 1;
 
912
  error_lo = schro_encoder_lambda_to_error (frame, lambda_lo);
 
913
  SCHRO_DEBUG("start target=%g lambda=%g error=%g",
 
914
      error, lambda_lo, error_lo, lambda_lo, error);
915
915
 
916
916
  if (error < error_lo) {
917
917
    error_hi = error_lo;
918
 
    log_lambda_hi = log_lambda_lo;
 
918
    lambda_hi = lambda_lo;
919
919
 
920
920
    for(j=0;j<5;j++) {
921
 
      log_lambda_lo = log_lambda_hi + log(100);
922
 
      error_lo = schro_encoder_lambda_to_error (frame, exp(log_lambda_lo));
 
921
      lambda_lo = lambda_hi * 100;
 
922
      error_lo = schro_encoder_lambda_to_error (frame, lambda_lo);
923
923
 
924
 
      SCHRO_DEBUG("have: log_lambda=[%g,%g] error=[%g,%g] target=%g",
925
 
          log_lambda_lo, log_lambda_hi, error_lo, error_hi, error);
 
924
      SCHRO_DEBUG("have: lambda=[%g,%g] error=[%g,%g] target=%g",
 
925
          lambda_lo, lambda_hi, error_lo, error_hi, error);
926
926
      if (error > error_lo) break;
927
927
 
928
928
      SCHRO_DEBUG("--> step up");
929
929
 
930
930
      error_hi = error_lo;
931
 
      log_lambda_hi = log_lambda_lo;
 
931
      lambda_hi = lambda_lo;
932
932
    }
933
933
    SCHRO_DEBUG("--> stopping");
934
934
  } else {
935
935
    for(j=0;j<5;j++) {
936
 
      log_lambda_hi = log_lambda_lo - log(100);
937
 
      error_hi = schro_encoder_lambda_to_error (frame, exp(log_lambda_hi));
 
936
      lambda_hi = lambda_lo * 0.01;
 
937
      error_hi = schro_encoder_lambda_to_error (frame, lambda_hi);
938
938
 
939
 
      SCHRO_DEBUG("have: log_lambda=[%g,%g] error=[%g,%g] target=%g",
940
 
          log_lambda_lo, log_lambda_hi, error_lo, error_hi, error);
 
939
      SCHRO_DEBUG("have: lambda=[%g,%g] error=[%g,%g] target=%g",
 
940
          lambda_lo, lambda_hi, error_lo, error_hi, error);
941
941
 
942
942
      SCHRO_DEBUG("--> step down");
943
943
      if (error < error_hi) break;
944
944
 
945
945
      error_lo = error_hi;
946
 
      log_lambda_lo = log_lambda_hi;
 
946
      lambda_lo = lambda_hi;
947
947
    }
948
948
    SCHRO_DEBUG("--> stopping");
949
949
  }
950
950
  if (error_lo == error_hi) {
951
 
    return exp(0.5*(log_lambda_lo + log_lambda_hi));
 
951
    return sqrt(lambda_lo * lambda_hi);
952
952
  }
953
953
 
954
954
  if (error_lo > error || error_hi < error) {
958
958
  for(j=0;j<14;j++){
959
959
    if (error_hi == error_lo) break;
960
960
 
961
 
    SCHRO_DEBUG("have: log_lambda=[%g,%g] error=[%g,%g] target=%g",
962
 
        log_lambda_lo, log_lambda_hi, error_lo, error_hi, error);
963
 
 
964
 
    log_lambda_mid = log_lambda_lo + (log_lambda_hi - log_lambda_lo) * 0.5;
965
 
    error_mid = schro_encoder_lambda_to_error (frame, exp(log_lambda_mid));
966
 
 
967
 
    SCHRO_DEBUG("picking log_lambda_mid=%g error=%g",
968
 
        log_lambda_mid, error_mid);
 
961
    SCHRO_DEBUG("have: lambda=[%g,%g] error=[%g,%g] target=%g",
 
962
        lambda_lo, lambda_hi, error_lo, error_hi, error);
 
963
 
 
964
    lambda_mid = sqrt(lambda_lo * lambda_hi);
 
965
    error_mid = schro_encoder_lambda_to_error (frame, lambda_mid);
 
966
 
 
967
    SCHRO_DEBUG("picking lambda_mid=%g error=%g",
 
968
        lambda_mid, error_mid);
969
969
 
970
970
    if (error_mid > error) {
971
 
      log_lambda_hi = log_lambda_mid;
 
971
      lambda_hi = lambda_mid;
972
972
      error_hi = error_mid;
973
973
      SCHRO_DEBUG("--> focus up");
974
974
    } else {
975
 
      log_lambda_lo = log_lambda_mid;
 
975
      lambda_lo = lambda_mid;
976
976
      error_lo = error_mid;
977
977
      SCHRO_DEBUG("--> focus down");
978
978
    }
979
979
  }
980
980
 
981
 
  log_lambda_mid = 0.5*(log_lambda_hi + log_lambda_lo);
982
 
  SCHRO_DEBUG("done %g", exp(log_lambda_mid));
983
 
  return exp(log_lambda_mid);
 
981
  lambda_mid = sqrt(lambda_hi * lambda_lo);
 
982
  SCHRO_DEBUG("done %g", lambda_mid);
 
983
  return lambda_mid;
984
984
}
985
985
 
986
986
void