tools.pm

JVT-Z203_jsvm.rar

  ::PrintLog(" Create Sequences          .......... ");

  #build new original if needed
  if ($simu->{origname} ne $simu->{original})
  {

    unless(-f $simu->{origname})
    {
      my $essopt= ((defined $simu->{croptype}) and ($simu->{croptype}==2))? 2:1;
      my $temporatio = ($simu->{originalframerate}/$simu->{framerate});
      my $nbfr = $simu->{nbframes};
      if (!($temporatio == 1)) {$nbfr = int(($nbfr+($temporatio-1))/$temporatio);}
      
      External::Resize($param,
                      $simu->{logname},
                      $simu->{original},
                      $simu->{originalwidth},
                      $simu->{originalheight},
                      $simu->{originalframerate},
                      $simu->{origname},
                      $simu->{width},
                      $simu->{height},
                      $simu->{framerate},
                      $simu->{phasemode},
                      $essopt,
                      $nbfr,
                      $simu->{cropfilename},
                      $simu->{resamplemode});
    }
  }

  # build layers references
  my $reforigname= $simu->{origname};
  my $refwidth   = $simu->{width};
  my $refheight   = $simu->{height};
  my $refframerate   = $simu->{framerate};
  my $origframerate;
  if ($simu->{originalframerate}>$simu->{framerate})
  {
    $origframerate = $simu->{originalframerate};
  }
  else
  {
    $origframerate = $simu->{framerate};
  }

  my $nblayer = $#{$simu->{layers}};
  my @layers = @{$simu->{layers}};
  while($nblayer>=0)
  {
    my $layer=@layers[$nblayer];
    my $essopt= ((defined $layer->{croptype}) and ($layer->{croptype}==2))? 2:1;

    unless(-f $layer->{origname})
    {
      my $temporatio = ($origframerate/$layer->{framerate});
      my $nbfr = $simu->{nbframes};
      if (!($temporatio == 1)){$nbfr = int(($nbfr+($temporatio-1))/$temporatio);}
      
      External::Resize($param,
                        $simu->{logname},
                        $reforigname,
                        $refwidth,
                        $refheight,
                        $refframerate,
                        $layer->{origname},
                        $layer->{width},
                        $layer->{height},
                        $layer->{framerate},
                        $simu->{phasemode},
                        $essopt,
                        $nbfr,
                        $layer->{cropfilename},
                        $layer->{resamplemode});
    }
    $reforigname    = $layer->{origname};
    $refwidth       = $layer->{width};
    $refheight      = $layer->{height};
    $refframerate   = $layer->{framerate};

    $nblayer--;
  }

  # build tests references
  foreach my $test (@{$simu->{tests}})
  {
    my $essopt= ((defined $test->{croptype}) and ($test->{croptype}==2))? 2:1;

    print "$simu->{origname} $simu->{original} \n ";

    unless(-f $test->{origname})
    {
      my $refl= $test->{refl};
      my $temporatio = ($origframerate/$test->{framerate});
      my $nbfr = $simu->{nbframes};
      if (!($temporatio == 1)){$nbfr = int(($nbfr+($temporatio-1))/$temporatio);}
 
      External::Resize($param,
                      $simu->{logname},
                      $refl->{origname},
                      $refl->{width},
                      $refl->{height},
                      $refl->{framerate},
                      $test->{origname},
                      $test->{width},
                      $test->{height},
                      $test->{framerate},
                      $simu->{phasemode},
                      $essopt,
                      $nbfr,
                      $test->{cropfilename},
                      $test->{resamplemode});
    }
  }
  return 1;
}

######################################################################################
# Function         : CheckRange($;$;[$])
######################################################################################
sub CheckRange
{
  my $value = shift;
  my $ref   = shift;
  my $range = ( $#_ >= 0 ) ? shift : 0.05;
  my $up    = 1. + $range;
  my $down  = 1. - $range;

  if ($value<$down*$ref) {return 0;}
  if ($value>$up*$ref) {return 0;}
  return 1;
}

###############################################################################
# Function         : CheckResults ($$$$$$$$$$)
###############################################################################
sub CheckResults
{
  my ($simu,$test,$res_rate,$res_psnrY,$res_psnrCb,$res_psnrCr,$res_rate2,$res_psnrY2,$res_psnrCb2,$res_psnrCr2)= @_;

  my $expectedBitrate =$test->{bitrate};
  my $expextedPSNR    =$test->{psnr};
  my $result = 1;

  if (($res_rate == 0 and $res_rate ne "0") | ($res_psnrY == 0 and $res_psnrY ne "0"))
  {
    #not a number
    ::PrintLog("\t\t\t\t\tFailed (No results)\n");
    $result = 0;
  }
  else
  {
    #check bitrate
    #----------------
    ::PrintLog("\tRate\t(${res_rate})\t\t");
    ($test->{mode}==2) and (($res_rate == $res_rate2) or ::PrintLog("Failed (Rate = $res_rate and Rate2 = $res_rate2 )\n"));
    if (($expectedBitrate == 0 and $res_rate>0)
    or  ($expectedBitrate != 0 and CheckRange($res_rate,$expectedBitrate,$simu->{bitratecheckrange})))
    {
      ::PrintLog("Passed\n");
      $result = 1;
    }
    else
    {
      ::PrintLog("Failed (Result = $res_rate - Target: $expectedBitrate)\n");
      $result = 0;
    };

    #Check PSNR
    #----------------
    ::PrintLog("\tPSNR\t($res_psnrY)\t\t");
    ($test->{mode}==2) and (($res_psnrY == $res_psnrY2) or ::PrintLog("Failed (PSNRY = $res_psnrY and PSNRY2 = $res_psnrY2 )\n"));
    if (($res_psnrY>=$expextedPSNR) or  CheckRange($res_psnrY,$expextedPSNR,$simu->{psnrcheckrange}))
    {
      ::PrintLog("Passed\n");
      $result &= 1;
    }
    else
    {
      ::PrintLog("Failed (result = $res_psnrY - Target: $expextedPSNR)\n");
      $result &= 0;
    }
  }

  return $result;
}

###############################################################################
# Function         : CheckPerfectMatch ($$$$)
###############################################################################
sub CheckPerfectMatch ($$$)
{
  my ($psnrY,$psnrCb,$psnrCr)= @_;

  #check Mismatch
  #---------------
  if(($psnrY==99.99)and ($psnrCr==99.99) and ($psnrCb==99.99))
  {
    ::PrintLog("Passed\n");
    return 1;
  }
  else
  {
    ::PrintLog("Failed ($psnrY $psnrCb $psnrCr)\n");
    return 0;
  }
}

###############################################################################
# Function         : ApplyTests ($;$)
###############################################################################
sub ApplyTests ($;$)
{
  my $simu  = shift;
  my $param = shift;

  ::PrintLog(" Run Tests\t\t.......... \n\n");

  my $nbtest =$simu->{tests};
  ($nbtest) or die "No test defined for simu ".$simu->{name}."\n";

  my ($res_rate,$res_psnrY,$res_psnrCb,$res_psnrCr);
  my ($res_rate2,$res_psnrY2,$res_psnrCb2,$res_psnrCr2);

  my $result = 1;

  foreach my $test (@{$simu->{tests}})
  {
    ::PrintLog("-----------------------------------------------\n");
    ::PrintLog($test->{name}." :: (".$test->{width}."x".$test->{height}.", ".$test->{framerate}.") -> ".$test->{bitrate}." - ".$test->{psnr}."\n");
    ::PrintLog("-----------------------------------------------\n");

    if ($test->{mode}==0) #decode only
    {
      #print Dumper($test);
      ($test->{packetlossrate})  and External::LossSimulator($simu,$param,$test);
      ($res_rate, $res_psnrY, $res_psnrCb, $res_psnrCr) = External::Decode($simu,$test,$param);
    }
    elsif ($test->{mode}==1) #extract+decode
    {
      External::Extract($simu,$test,$param);
      ($test->{packetlossrate})  and External::LossSimulator($simu,$param,$test);
      ($res_rate, $res_psnrY, $res_psnrCb, $res_psnrCr) = External::Decode($simu,$test,$param);
    }
    elsif ($test->{mode}==2) #doublecheck (extract+decode)
    {
      External::Extract($simu,$test,$param);
      ($test->{packetlossrate})  and External::LossSimulator($simu,$param,$test);
      ($res_rate, $res_psnrY, $res_psnrCb, $res_psnrCr) = External::Decode($simu,$test,$param);
      External::Extract($simu,$test,$param);
      ($test->{packetlossrate})  and External::LossSimulator($simu,$param,$test);
      ($res_rate2, $res_psnrY2, $res_psnrCb2, $res_psnrCr2) = External::Decode($simu,$test,$param);
    }
    elsif ($test->{mode}==11) #decode+rewrite
    {
      External::Extract($simu,$test,$param);
      ($test->{packetlossrate})  and External::LossSimulator($simu,$param,$test);
      ($res_rate, $res_psnrY, $res_psnrCb, $res_psnrCr) = External::Rewrite($simu,$test,$param);      
    }    
    else #extract + utilisation pour le prochain test
    {
      External::Extract($simu,$test,$param);
      next;
    }

    #Check bitrate and/or PSNR
    $result &= CheckResults($simu,$test,$res_rate, $res_psnrY, $res_psnrCb, $res_psnrCr,$res_rate2, $res_psnrY2, $res_psnrCb2, $res_psnrCr2);

    #Check encoder/decoder matching
    if($test->{encdecmatch})
    {
      my($rate, $psnrY, $psnrCb, $psnrCr)=External::ComputePSNR($param->{path_bin},$simu->{logname},$test->{width},$test->{height},$test->{decodedname},$test->{reconname},$test->{extractedname},$test->{framerate},$param->{path_tmp}."psnr.dat");
    	::PrintLog("\tEncoder/Decoder match\t\t");
      $result &= CheckPerfectMatch ($psnrY, $psnrCb, $psnrCr);
    }

    #Check decoder/rewriter matching
    if ($test->{mode}==11)
    {
      my($rate, $psnrY, $psnrCb, $psnrCr)=External::ComputePSNR($param->{path_bin},$simu->{logname},$test->{width},$test->{height},$test->{decodedname},"Rewriting.yuv","Rewriting.264",$test->{framerate},$param->{path_tmp}."psnr.dat");
    	::PrintLog("\tDecoder/Rewriter match\t\t");
      $result &= CheckPerfectMatch ($psnrY, $psnrCb, $psnrCr);
    }

    if($test->{jmmatch})
    {
      External::JMDecode($simu,$test,$param);
      my($rate, $psnrY, $psnrCb, $psnrCr)=External::ComputePSNR($param->{path_bin},$simu->{logname},$test->{width},$test->{height},$test->{decodedname},$test->{jmdecodedname},$test->{extractedname},$test->{framerate},$param->{path_tmp}."psnr.dat");
      ::PrintLog("\tJM Decoder match\t\t");
      $result &= CheckPerfectMatch ($psnrY, $psnrCb, $psnrCr);
    }

  } #foreach

  return $result;
}





1;
__END__