Eliminate support for direct_8x8_inference=0
[x262.git] / tools / regression-test.pl
1 #!/bin/env perl
2
3 # regression-test.pl: tests different versions of x264
4 # by Alex Izvorski & Loren Merrit 2007
5 # GPL
6
7 $^W=1;
8
9 use Getopt::Long;
10 use File::Path;
11 use File::Copy;
12 use File::Basename;
13
14 # prerequisites: 
15 # - perl > 5.8.0
16 # - svn
17 # - net access
18 # - linux/unix
19 # - gcc
20
21 # the following require a make testclean
22 # - changing x264 option sets and or adding/removing option sets
23 # - changing configure options
24 # - changing CFLAGS or other variables that affect compilation
25 # - a newer head revision
26
27 # the following do not require a make testclean, but may cause some tests to be rerun unnecessarily:
28 # - adding/removing input files 
29 # - adding/removing versions
30
31 @versions = ();
32 @input_files = ();
33 @option_sets = ();
34
35 GetOptions ("version=s" => \@versions,
36             "input=s" => \@input_files,
37             "options=s" => \@option_sets,
38             );
39
40 # TODO check inputs
41 # TODO some way to give make options
42 # TODO some way to give configure options
43
44 if (scalar(@versions) == 0)
45 {
46     @versions = ('rHEAD', 'current');
47 }
48
49 if (scalar(@option_sets) == 0 ||
50     scalar(@input_files) == 0)
51 {
52     print "Regression test for x264\n";
53     print "Usage:\n  perl tools/regression-test.pl --version=623 --version=624 --input=football_720x480p.yuv --input=foreman_352x288p.yuv --options='--me=dia --subme=2 --no-cabac'\n";
54     print "Any number of versions, option sets, and input files may be given.\n";
55     print "Versions may be any svn revision, a comma-separated list of revisions, or 'current' for the version in the current directory.\n";
56     exit;
57 }
58
59 mkpath("test");
60
61 @versions = map { split m![,\s]\s*! } @versions;
62
63 foreach my $version (@versions)
64 {
65     $version =~ s!^head$!rHEAD!i;
66     $version =~ s!^current$!current!i;
67     $version =~ s!^(\d+)$!r$1!;
68
69     if (-e "test/x264-$version/x264" && ($version ne "current"))
70     {
71         print("have version: $version\n");
72         next;
73     }
74     print("building version: $version\n");
75     if ($version eq "current")
76     {
77         system("(./configure && make) &> test/build.log");
78         mkpath("test/x264-$version");
79         if (! -e "x264") { print("build failed \n"); exit 1; }
80         copy("x264", "test/x264-$version/x264");
81         chmod(0755, "test/x264-$version/x264");
82         next;
83     }
84     system("svn checkout -$version svn://svn.videolan.org/x264/trunk/ test/x264-$version >/dev/null");
85     chdir("test/x264-$version");
86     system("(./configure && make) &> build.log");
87     chdir("../..");
88     if (! -e "test/x264-$version/x264") { print("build failed \n"); exit 1; }
89 }
90
91 $any_diff = 0;
92 foreach my $i (0 .. scalar(@option_sets)-1)
93 {
94     $opt = $option_sets[$i];
95     print("options: $opt \n");
96     foreach my $j (0 .. scalar(@input_files)-1)
97     {
98         my $file = $input_files[$j];
99         print("input file: $file \n");
100
101         my $outfile = basename($file);
102         $outfile =~ s!\.yuv$!!;
103         $outfile = "test/opt$i-$outfile$j";
104
105         foreach my $k (0 .. scalar(@versions)-1)
106         {
107             my $version = $versions[$k];
108
109             if (-e "$outfile-$version.log" && ($version ne "current"))
110             {
111                 print("have results for version: $version\n");
112             }
113             else
114             {
115                 print("running version: $version \n");
116                 # verbose option is required for frame-by-frame comparison
117                 system("test/x264-$version/x264 --verbose $opt $file -o $outfile-$version.264 > $outfile-$version.log 2>&1");
118             }
119
120             # TODO check for crashes
121             # TODO if (read_file("$outfile-$version.log") =~  m!could not open input file!) ...
122             # TODO check decompression with jm
123             # TODO dump (and check) frames
124
125             if ($k > 0)
126             {
127                 my $baseversion = $versions[$k - 1];
128                 print("comparing $version with $baseversion: ");
129                 $is_diff = 0;
130                 $is_diff ||= compare_logs("$outfile-$version.log", "$outfile-$baseversion.log");
131                 $is_diff ||= compare_raw264("$outfile-$version.264", "$outfile-$baseversion.264");
132                 if (! $is_diff) { print("identical \n"); }
133                 $any_diff ||= $is_diff;
134             }
135         }
136     }
137 }
138
139 print "\n";
140 if (! $any_diff) { print "no differences found\n"; }
141 else { print "some differences found\n"; exit 1; }
142
143
144 sub compare_logs
145 {
146     my ($log1, $log2) = @_;
147
148     my $logdata1 = read_file($log1);
149     my $logdata2 = read_file($log2);
150
151     # FIXME comparing versions with different log output format will fail
152     $logdata1 = join("\n", grep { m!frame=! } split(m!\n!, $logdata1));
153     $logdata2 = join("\n", grep { m!frame=! } split(m!\n!, $logdata2));
154
155     my $is_diff = 0;
156     if ($logdata1 ne $logdata2)
157     {
158         print("log files differ \n");
159         $is_diff = 1;
160     }
161
162     my $stats1 = parse_log_overall_stats($log1);
163     my $stats2 = parse_log_overall_stats($log2);
164
165     if ($stats1->{psnr_y} != $stats2->{psnr_y})
166     {
167         printf("psnr change: %+f dB \n", $stats1->{psnr_y} - $stats2->{psnr_y});
168         $is_diff = 1;
169     }
170     if ($stats1->{bitrate} != $stats2->{bitrate})
171     {
172         printf("bitrate change: %+f kb/s \n", $stats1->{bitrate} - $stats2->{bitrate});
173         $is_diff = 1;
174     }
175
176     #arbitrarily set cutoff to 3% change
177     #$speed_change_min = 0.03;
178     #if (abs($stats1->{fps} - $stats2->{fps}) > $speed_change_min * ($stats1->{fps} + $stats2->{fps})/2)
179     #{
180     #    printf("speed change: %+f fps \n", $stats1->{fps} - $stats2->{fps}); 
181     #    $is_diff = 1;
182     #}
183
184     return $is_diff;
185
186     # TODO compare frame by frame PSNR/SSIM, record improved or unimproved ranges
187     #parse_log_frame_stats($log1);
188     #parse_log_frame_stats($log2);
189
190     # TODO compare actual run times
191 }
192
193 sub compare_raw264
194 {
195     my ($raw1, $raw2) = @_;
196     
197     # FIXME this may use a lot of memory
198     my $rawdata1 = read_file($raw1);
199     my $rawdata2 = read_file($raw2);
200     
201     # remove first NAL, it is a version-specific SEI NAL
202     my $pat = chr(0).chr(0).chr(1);
203     $rawdata1 =~ s!^.*?$pat.*?$pat!$pat!;
204     $rawdata2 =~ s!^.*?$pat.*?$pat!$pat!;
205
206     if ($rawdata1 ne $rawdata2)
207     {
208         print("compressed files differ \n");
209         return 1;
210     }
211
212     return 0;
213 }
214
215 sub parse_log_frame_stats
216 {
217     my ($log) = @_;
218     my $logtext = read_file($log);
219
220     my @frames = ();
221     while ($logtext =~ m!x264 \[debug]: (frame=.*)!g)
222     {
223         my $line = $1;
224         if ($line !~ m!frame=\s*(\d+)\s* QP=\s*(\d+)\s* NAL=(\d+)\s* Slice:(\w)\s* Poc:(\d+)\s* I:(\d+)\s* P:(\d+)\s* SKIP:(\d+)\s* size=(\d+) bytes PSNR Y:(\d+\.\d+) U:(\d+\.\d+) V:(\d+\.\d+)!)
225         {
226             print "error: unparseable log line: $line \n"; next;
227         }
228         
229         my $frame = 
230             +{
231                 num=>$1,
232                 qp=>$2,
233                 nal=>$3,
234                 slice=>$4,
235                 poc=>$5,
236                 count_i=>$6,
237                 count_p=>$7,
238                 count_skip=>$8,
239                 size=>$9,
240                 psnr_y=>$10,
241                 psnr_u=>$11,
242                 psnr_v=>$12,
243             };
244
245         if ($line =~ m!SSIM Y:(\d+\.\d+)!)
246         {
247             $frame->{ssim} = $1;
248         }
249
250         push(@frames, $frame);
251     }
252
253     return @frames;
254 }
255
256 sub parse_log_overall_stats
257 {
258     my ($log) = @_;
259     my $logtext = read_file($log);
260
261     if ($logtext !~ m!x264 \[info\]: PSNR Mean Y:(\d+\.\d+) U:(\d+\.\d+) V:(\d+\.\d+) Avg:(\d+\.\d+) Global:(\d+\.\d+) kb/s:(\d+\.\d+)!)
262     {
263         print "error: unparseable log summary info \n"; return +{};
264     }
265     my $stats = 
266         +{ 
267             psnr_y=>$1,
268             psnr_u=>$2,
269             psnr_v=>$3,
270             psnr_avg=>$4,
271             psnr_global=>$5,
272             bitrate=>$6,
273         };
274     
275     if ($logtext !~ m!encoded (\d+) frames, (\d+\.\d+) fps!)
276     {
277         print "error: unparseable log summary info \n"; return +{};
278     }
279     $stats->{num_frames} = $1;
280     $stats->{fps} = $2;
281
282     return $stats;
283 }
284
285 sub read_file
286 {
287     my ($file) = @_;
288     open(F, $file) || die "could not open $file: $!";
289     undef $/;
290     my $data = <F>;
291     $/ = "\n";
292     close(F);
293     return $data;
294 }
295
296 sub write_file
297 {
298     my ($file, $data) = @_;
299     open(F, ">".$file) || die "could not open $file: $!";
300     print F $data;
301     close(F);
302 }