[cvs] / xvidcore / src / xvid.c Repository:
ViewVC logotype

Diff of /xvidcore/src/xvid.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.11, Sat Apr 13 16:30:01 2002 UTC revision 1.40, Sun Feb 9 19:32:52 2003 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      native api   *  - Native API implementation  -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2001-2002 Peter Ross <pross@xvid.org>
  *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending  
  *      to use this software module in hardware or software products are  
  *      advised that its use may infringe existing patents or copyrights, and  
  *      any such use would be at such party's own risk.  The original  
  *      developer of this software module and his/her company, and subsequent  
  *      editors and their companies, will have no liability for use of this  
  *      software or modifications or derivatives thereof.  
7   *   *
8   *      This program is free software; you can redistribute it and/or modify   *  This file is part of XviD, a free MPEG-4 video encoder/decoder
9   *      it under the terms of the GNU General Public License as published by   *
10     *  XviD is free software; you can redistribute it and/or modify it
11     *  under the terms of the GNU General Public License as published by
12   *      the Free Software Foundation; either version 2 of the License, or   *      the Free Software Foundation; either version 2 of the License, or
13   *      (at your option) any later version.   *      (at your option) any later version.
14   *   *
# Line 24  Line 19 
19   *   *
20   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
21   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
22   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23   *   *
24   *************************************************************************/   *  Under section 8 of the GNU General Public License, the copyright
25     *  holders of XVID explicitly forbid distribution in the following
26  /**************************************************************************   *  countries:
27   *   *
28   *      History:   *    - Japan
29     *    - United States of America
30   *   *
31   *      17.03.2002      Added interpolate8x8_halfpel_hv_xmm   *  Linking XviD statically or dynamically with other modules is making a
32   *  22.12.2001  API change: added xvid_init() - Isibaar   *  combined work based on XviD.  Thus, the terms and conditions of the
33   *      16.12.2001      inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>   *  GNU General Public License cover the whole combination.
34   *   *
35   *************************************************************************/   *  As a special exception, the copyright holders of XviD give you
36     *  permission to link XviD with independent modules that communicate with
37     *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38     *  license terms of these independent modules, and to copy and distribute
39     *  the resulting combined work under terms of your choice, provided that
40     *  every copy of the combined work is accompanied by a complete copy of
41     *  the source code of XviD (the version of XviD used to produce the
42     *  combined work), being distributed under the terms of the GNU General
43     *  Public License plus this exception.  An independent module is a module
44     *  which is not derived from or based on XviD.
45     *
46     *  Note that people who make modified versions of XviD are not obligated
47     *  to grant this special exception for their modified versions; it is
48     *  their choice whether to do so.  The GNU General Public License gives
49     *  permission to release a modified version without this exception; this
50     *  exception also makes it possible to release a modified version which
51     *  carries forward this exception.
52     *
53     * $Id$
54     *
55     ****************************************************************************/
56    
57  #include "xvid.h"  #include "xvid.h"
58  #include "decoder.h"  #include "decoder.h"
# Line 50  Line 65 
65  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
66  #include "quant/quant_h263.h"  #include "quant/quant_h263.h"
67  #include "quant/quant_mpeg4.h"  #include "quant/quant_mpeg4.h"
68    #include "motion/motion.h"
69  #include "motion/sad.h"  #include "motion/sad.h"
70  #include "utils/emms.h"  #include "utils/emms.h"
71  #include "utils/timer.h"  #include "utils/timer.h"
72  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
73    
74  int xvid_init(void *handle, int opt, void *param1, void *param2)  #if defined(ARCH_IS_IA32) && defined(EXPERIMENTAL_SSE2_CODE)
75    
76    #ifdef _MSC_VER
77    #include <windows.h>
78    #else
79    #include <signal.h>
80    #include <setjmp.h>
81    #endif
82    
83    
84    #ifndef _MSC_VER
85    
86    static jmp_buf mark;
87    
88    static void
89    sigill_handler(int signal)
90    {
91       longjmp(mark, 1);
92    }
93    #endif
94    
95    
96    /*
97     * Calls the funcptr, and returns whether SIGILL (illegal instruction) was signalled
98     * Return values:
99     * -1 : could not determine
100     * 0  : SIGILL was *not* signalled
101     * 1  : SIGILL was signalled
102     */
103    
104    int
105    sigill_check(void (*func)())
106    {
107    #ifdef _MSC_VER
108            _try {
109                    func();
110            }
111            _except(EXCEPTION_EXECUTE_HANDLER) {
112    
113                    if (_exception_code() == STATUS_ILLEGAL_INSTRUCTION)
114                            return 1;
115            }
116            return 0;
117    #else
118        void * old_handler;
119        int jmpret;
120    
121    
122        old_handler = signal(SIGILL, sigill_handler);
123        if (old_handler == SIG_ERR)
124        {
125            return -1;
126        }
127    
128        jmpret = setjmp(mark);
129        if (jmpret == 0)
130        {
131            func();
132        }
133    
134        signal(SIGILL, old_handler);
135    
136        return jmpret;
137    #endif
138    }
139    #endif
140    
141    /*****************************************************************************
142     * XviD Init Entry point
143     *
144     * Well this function initialize all internal function pointers according
145     * to the CPU features forced by the library client or autodetected (depending
146     * on the XVID_CPU_FORCE flag). It also initializes vlc coding tables and all
147     * image colorspace transformation tables.
148     *
149     * Returned value : XVID_ERR_OK
150     *                  + API_VERSION in the input XVID_INIT_PARAM structure
151     *                  + core build  "   "    "       "               "
152     *
153     ****************************************************************************/
154    
155    int
156    xvid_init(void *handle,
157                      int opt,
158                      void *param1,
159                      void *param2)
160  {  {
161          int cpu_flags;          int cpu_flags;
162          XVID_INIT_PARAM *init_param;          XVID_INIT_PARAM *init_param;
163    
164          init_param = (XVID_INIT_PARAM *) param1;          init_param = (XVID_INIT_PARAM *) param1;
165    
166          // force specific cpu settings?          /* Inform the client the API version */
167          if((init_param->cpu_flags & XVID_CPU_FORCE) > 0)          init_param->api_version = API_VERSION;
168    
169            /* Inform the client the core build - unused because we're still alpha */
170            init_param->core_build = 1000;
171    
172            /* Do we have to force CPU features  ? */
173            if ((init_param->cpu_flags & XVID_CPU_FORCE)) {
174    
175                  cpu_flags = init_param->cpu_flags;                  cpu_flags = init_param->cpu_flags;
         else {  
176    
177  #ifdef ARCH_X86          } else {
178    
179                  cpu_flags = check_cpu_features();                  cpu_flags = check_cpu_features();
180  #else  
181                  cpu_flags = 0;  #if defined(ARCH_IS_IA32) && defined(EXPERIMENTAL_SSE2_CODE)
182                    if ((cpu_flags & XVID_CPU_SSE) && sigill_check(sse_os_trigger))
183                            cpu_flags &= ~XVID_CPU_SSE;
184    
185                    if ((cpu_flags & XVID_CPU_SSE2) && sigill_check(sse2_os_trigger))
186                            cpu_flags &= ~XVID_CPU_SSE2;
187  #endif  #endif
188            }
189    
190            if ((init_param->cpu_flags & XVID_CPU_CHKONLY))
191            {
192                  init_param->cpu_flags = cpu_flags;                  init_param->cpu_flags = cpu_flags;
193                    return XVID_ERR_OK;
194          }          }
195    
196          // initialize the function pointers          init_param->cpu_flags = cpu_flags;
197    
198    
199            /* Initialize the function pointers */
200          idct_int32_init();          idct_int32_init();
201          init_vlc_tables();          init_vlc_tables();
202    
203            /* Fixed Point Forward/Inverse DCT transformations */
204          fdct = fdct_int32;          fdct = fdct_int32;
205          idct = idct_int32;          idct = idct_int32;
206    
207            /* Only needed on PPC Altivec archs */
208          sadInit = 0;          sadInit = 0;
209    
210            /* Restore FPU context : emms_c is a nop functions */
211          emms = emms_c;          emms = emms_c;
212    
213            /* Quantization functions */
214          quant_intra = quant_intra_c;          quant_intra = quant_intra_c;
215          dequant_intra = dequant_intra_c;          dequant_intra = dequant_intra_c;
216          quant_inter = quant_inter_c;          quant_inter = quant_inter_c;
# Line 96  Line 221 
221          quant4_inter = quant4_inter_c;          quant4_inter = quant4_inter_c;
222          dequant4_inter = dequant4_inter_c;          dequant4_inter = dequant4_inter_c;
223    
224            /* Block transfer related functions */
225          transfer_8to16copy = transfer_8to16copy_c;          transfer_8to16copy = transfer_8to16copy_c;
226          transfer_16to8copy = transfer_16to8copy_c;          transfer_16to8copy = transfer_16to8copy_c;
227          transfer_8to16sub = transfer_8to16sub_c;          transfer_8to16sub = transfer_8to16sub_c;
# Line 103  Line 229 
229          transfer_16to8add = transfer_16to8add_c;          transfer_16to8add = transfer_16to8add_c;
230          transfer8x8_copy = transfer8x8_copy_c;          transfer8x8_copy = transfer8x8_copy_c;
231    
232            /* Image interpolation related functions */
233          interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_c;          interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_c;
234          interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_c;          interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_c;
235          interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_c;          interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_c;
236    
237            /* Initialize internal colorspace transformation tables */
238          colorspace_init();          colorspace_init();
239    
240            /* All colorspace transformation functions User Format->YV12 */
241          rgb555_to_yv12 = rgb555_to_yv12_c;          rgb555_to_yv12 = rgb555_to_yv12_c;
242          rgb565_to_yv12 = rgb565_to_yv12_c;          rgb565_to_yv12 = rgb565_to_yv12_c;
243          rgb24_to_yv12 = rgb24_to_yv12_c;          rgb24_to_yv12 = rgb24_to_yv12_c;
# Line 117  Line 246 
246          yuyv_to_yv12 = yuyv_to_yv12_c;          yuyv_to_yv12 = yuyv_to_yv12_c;
247          uyvy_to_yv12 = uyvy_to_yv12_c;          uyvy_to_yv12 = uyvy_to_yv12_c;
248    
249            /* All colorspace transformation functions YV12->User format */
250          yv12_to_rgb555 = yv12_to_rgb555_c;          yv12_to_rgb555 = yv12_to_rgb555_c;
251          yv12_to_rgb565 = yv12_to_rgb565_c;          yv12_to_rgb565 = yv12_to_rgb565_c;
252          yv12_to_rgb24 = yv12_to_rgb24_c;          yv12_to_rgb24 = yv12_to_rgb24_c;
# Line 125  Line 255 
255          yv12_to_yuyv = yv12_to_yuyv_c;          yv12_to_yuyv = yv12_to_yuyv_c;
256          yv12_to_uyvy = yv12_to_uyvy_c;          yv12_to_uyvy = yv12_to_uyvy_c;
257    
258            /* Functions used in motion estimation algorithms */
259          calc_cbp = calc_cbp_c;          calc_cbp = calc_cbp_c;
260          sad16 = sad16_c;          sad16 = sad16_c;
         sad16bi = sad16bi_c;  
261          sad8 = sad8_c;          sad8 = sad8_c;
262            sad16bi  = sad16bi_c;
263            sad8bi   = sad8bi_c;
264          dev16 = dev16_c;          dev16 = dev16_c;
265    
266  #ifdef ARCH_X86          Halfpel8_Refine = Halfpel8_Refine_c;
267    
268    #ifdef ARCH_IS_IA32
269          if((cpu_flags & XVID_CPU_MMX) > 0) {          if((cpu_flags & XVID_CPU_MMX) > 0) {
270    
271                    /* Forward and Inverse Discrete Cosine Transformation functions */
272                  fdct = fdct_mmx;                  fdct = fdct_mmx;
273                  idct = idct_mmx;                  idct = idct_mmx;
274    
275                    /* To restore FPU context after mmx use */
276                  emms = emms_mmx;                  emms = emms_mmx;
277    
278                    /* Quantization related functions */
279                  quant_intra = quant_intra_mmx;                  quant_intra = quant_intra_mmx;
280                  dequant_intra = dequant_intra_mmx;                  dequant_intra = dequant_intra_mmx;
281                  quant_inter = quant_inter_mmx;                  quant_inter = quant_inter_mmx;
# Line 148  Line 286 
286                  quant4_inter = quant4_inter_mmx;                  quant4_inter = quant4_inter_mmx;
287                  dequant4_inter = dequant4_inter_mmx;                  dequant4_inter = dequant4_inter_mmx;
288    
289                    /* Block related functions */
290                  transfer_8to16copy = transfer_8to16copy_mmx;                  transfer_8to16copy = transfer_8to16copy_mmx;
291                  transfer_16to8copy = transfer_16to8copy_mmx;                  transfer_16to8copy = transfer_16to8copy_mmx;
292                  transfer_8to16sub = transfer_8to16sub_mmx;                  transfer_8to16sub = transfer_8to16sub_mmx;
293                    transfer_8to16sub2 = transfer_8to16sub2_mmx;
294                  transfer_16to8add = transfer_16to8add_mmx;                  transfer_16to8add = transfer_16to8add_mmx;
295                  transfer8x8_copy = transfer8x8_copy_mmx;                  transfer8x8_copy = transfer8x8_copy_mmx;
296    
297    
298                    /* Image Interpolation related functions */
299                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_mmx;                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_mmx;
300                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_mmx;                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_mmx;
301                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_mmx;                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_mmx;
302    
303                    /* Image RGB->YV12 related functions */
304                  rgb24_to_yv12 = rgb24_to_yv12_mmx;                  rgb24_to_yv12 = rgb24_to_yv12_mmx;
305                  rgb32_to_yv12 = rgb32_to_yv12_mmx;                  rgb32_to_yv12 = rgb32_to_yv12_mmx;
306                  yuv_to_yv12 = yuv_to_yv12_mmx;                  yuv_to_yv12 = yuv_to_yv12_mmx;
307                  yuyv_to_yv12 = yuyv_to_yv12_mmx;                  yuyv_to_yv12 = yuyv_to_yv12_mmx;
308                  uyvy_to_yv12 = uyvy_to_yv12_mmx;                  uyvy_to_yv12 = uyvy_to_yv12_mmx;
309    
310                    /* Image YV12->RGB related functions */
311                  yv12_to_rgb24 = yv12_to_rgb24_mmx;                  yv12_to_rgb24 = yv12_to_rgb24_mmx;
312                  yv12_to_rgb32 = yv12_to_rgb32_mmx;                  yv12_to_rgb32 = yv12_to_rgb32_mmx;
313                  yv12_to_yuyv = yv12_to_yuyv_mmx;                  yv12_to_yuyv = yv12_to_yuyv_mmx;
314                  yv12_to_uyvy = yv12_to_uyvy_mmx;                  yv12_to_uyvy = yv12_to_uyvy_mmx;
315    
316                    /* Motion estimation related functions */
317                  calc_cbp = calc_cbp_mmx;                  calc_cbp = calc_cbp_mmx;
318                  sad16 = sad16_mmx;                  sad16 = sad16_mmx;
319                  sad8 = sad8_mmx;                  sad8 = sad8_mmx;
320                    sad16bi = sad16bi_mmx;
321                    sad8bi  = sad8bi_mmx;
322                  dev16 = dev16_mmx;                  dev16 = dev16_mmx;
323    
324          }          }
325    
326            /* these 3dnow functions are faster than mmx, but slower than xmm. */
327            if ((cpu_flags & XVID_CPU_3DNOW) > 0) {
328    
329                    /* ME functions */
330                    sad16bi = sad16bi_3dn;
331                    sad8bi  = sad8bi_3dn;
332            }
333    
334    
335          if((cpu_flags & XVID_CPU_MMXEXT) > 0) {          if((cpu_flags & XVID_CPU_MMXEXT) > 0) {
336    
337                    /* Inverse DCT */
338                  idct = idct_xmm;                  idct = idct_xmm;
339    
340                    /* Interpolation */
341                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_xmm;                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_xmm;
342                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_xmm;                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_xmm;
343                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_xmm;                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_xmm;
344    
345                    /* Quantization */
346                    dequant_intra = dequant_intra_xmm;
347                    dequant_inter = dequant_inter_xmm;
348    
349                    /* Buffer transfer */
350                    transfer_8to16sub2 = transfer_8to16sub2_xmm;
351    
352                    /* Colorspace transformation */
353                  yuv_to_yv12 = yuv_to_yv12_xmm;                  yuv_to_yv12 = yuv_to_yv12_xmm;
354    
355                    /* ME functions */
356                  sad16 = sad16_xmm;                  sad16 = sad16_xmm;
357                  sad8 = sad8_xmm;                  sad8 = sad8_xmm;
358                    sad16bi = sad16bi_xmm;
359                    sad8bi  = sad8bi_xmm;
360                  dev16 = dev16_xmm;                  dev16 = dev16_xmm;
361    
362          }          }
363    
364          if((cpu_flags & XVID_CPU_3DNOW) > 0) {          if((cpu_flags & XVID_CPU_3DNOW) > 0) {
365    
366                    /* Interpolation */
367                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_3dn;                  interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_3dn;
368                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_3dn;                  interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_3dn;
369                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_3dn;                  interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_3dn;
370          }          }
371    
372            if ((cpu_flags & XVID_CPU_SSE2) > 0) {
373    #ifdef EXPERIMENTAL_SSE2_CODE
374    
375                    calc_cbp = calc_cbp_sse2;
376    
377                    /* Quantization */
378                    quant_intra   = quant_intra_sse2;
379                    dequant_intra = dequant_intra_sse2;
380                    quant_inter   = quant_inter_sse2;
381                    dequant_inter = dequant_inter_sse2;
382    
383                    /* ME */
384                    sad16    = sad16_sse2;
385                    dev16    = dev16_sse2;
386    
387                    /* Forward and Inverse DCT */
388                    idct  = idct_sse2;
389                    fdct = fdct_sse2;
390    #endif
391            }
392    
393  #endif  #endif
394  #ifdef ARCH_PPC  
395  #ifdef ARCH_PPC_ALTIVEC  #ifdef ARCH_IS_IA64
396            if ((cpu_flags & XVID_CPU_IA64) > 0) { //use assembler routines?
397              idct_ia64_init();
398              fdct = fdct_ia64;
399              idct = idct_ia64;
400              interpolate8x8_halfpel_h = interpolate8x8_halfpel_h_ia64;
401              interpolate8x8_halfpel_v = interpolate8x8_halfpel_v_ia64;
402              interpolate8x8_halfpel_hv = interpolate8x8_halfpel_hv_ia64;
403              sad16 = sad16_ia64;
404              sad16bi = sad16bi_ia64;
405              sad8 = sad8_ia64;
406              dev16 = dev16_ia64;
407              Halfpel8_Refine = Halfpel8_Refine_ia64;
408              quant_intra = quant_intra_ia64;
409              dequant_intra = dequant_intra_ia64;
410              quant_inter = quant_inter_ia64;
411              dequant_inter = dequant_inter_ia64;
412              transfer_8to16copy = transfer_8to16copy_ia64;
413              transfer_16to8copy = transfer_16to8copy_ia64;
414              transfer_8to16sub = transfer_8to16sub_ia64;
415              transfer_8to16sub2 = transfer_8to16sub2_ia64;
416              transfer_16to8add = transfer_16to8add_ia64;
417              transfer8x8_copy = transfer8x8_copy_ia64;
418    //        DEBUG("Using IA-64 assembler routines.\n");
419            }
420    #endif
421    
422    #ifdef ARCH_IS_PPC
423    #ifdef ARCH_IS_PPC_ALTIVEC
424          calc_cbp = calc_cbp_altivec;          calc_cbp = calc_cbp_altivec;
425          fdct = fdct_altivec;          fdct = fdct_altivec;
426          idct = idct_altivec;          idct = idct_altivec;
# Line 210  Line 433 
433  #endif  #endif
434  #endif  #endif
435    
         // API version  
         init_param->api_version = API_VERSION;  
   
         // something clever has to be done for this  
         init_param->core_build = 1000;  
   
436          return XVID_ERR_OK;          return XVID_ERR_OK;
437  }  }
438    
439  int xvid_decore(void * handle, int opt, void * param1, void * param2)  /*****************************************************************************
440  {   * XviD Native decoder entry point
441          switch (opt)   *
442     * This function is just a wrapper to all the option cases.
443     *
444     * Returned values : XVID_ERR_FAIL when opt is invalid
445     *                   else returns the wrapped function result
446     *
447     ****************************************************************************/
448    
449    int
450    xvid_decore(void *handle,
451                            int opt,
452                            void *param1,
453                            void *param2)
454          {          {
455            switch (opt) {
456          case XVID_DEC_DECODE :          case XVID_DEC_DECODE :
457          return decoder_decode((DECODER *) handle, (XVID_DEC_FRAME *) param1);          return decoder_decode((DECODER *) handle, (XVID_DEC_FRAME *) param1);
458    
# Line 238  Line 468 
468  }  }
469    
470    
471  int xvid_encore(void * handle, int opt, void * param1, void * param2)  /*****************************************************************************
472  {   * XviD Native encoder entry point
473          switch (opt)   *
474     * This function is just a wrapper to all the option cases.
475     *
476     * Returned values : XVID_ERR_FAIL when opt is invalid
477     *                   else returns the wrapped function result
478     *
479     ****************************************************************************/
480    
481    int
482    xvid_encore(void *handle,
483                            int opt,
484                            void *param1,
485                            void *param2)
486          {          {
487            switch (opt) {
488          case XVID_ENC_ENCODE :          case XVID_ENC_ENCODE :
489          return encoder_encode((Encoder *) handle, (XVID_ENC_FRAME *) param1, (XVID_ENC_STATS *) param2);                  return encoder_encode((Encoder *) handle, (XVID_ENC_FRAME *) param1,
490                                                              (XVID_ENC_STATS *) param2);
491    
492          case XVID_ENC_CREATE :          case XVID_ENC_CREATE :
493          return encoder_create((XVID_ENC_PARAM *) param1);          return encoder_create((XVID_ENC_PARAM *) param1);

Legend:
Removed from v.1.11  
changed lines
  Added in v.1.40

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4