Fix gtk-doc warnings. Also don't misuse api-doc comments for normal comments.

Original commit message from CVS:
* docs/plugins/gst-plugins-bad-plugins-sections.txt:
* examples/app/appsrc-ra.c:
* examples/app/appsrc-seekable.c:
* examples/app/appsrc-stream.c:
* examples/app/appsrc-stream2.c:
* ext/directfb/dfbvideosink.h:
* ext/metadata/gstbasemetadata.c:
* ext/metadata/gstbasemetadata.h:
* ext/metadata/metadata.c:
* ext/metadata/metadataexif.c:
* ext/theora/theoradec.h:
* gst/deinterlace2/gstdeinterlace2.h:
* gst/deinterlace2/tvtime/speedy.c:
* gst/deinterlace2/tvtime/speedy.h:
* gst/deinterlace2/tvtime/vfir.c:
Fix gtk-doc warnings. Also don't misuse api-doc comments for normal
comments.

4 files changed, 92 insertions, 92 deletions

diff --git a/gst/deinterlace2/gstdeinterlace2.h b/gst/deinterlace2/gstdeinterlace2.h
index 0f19484f..b15fa2f0 100644
--- a/gst/deinterlace2/gstdeinterlace2.h
+++ b/gst/deinterlace2/gstdeinterlace2.h
@@ -50,7 +50,7 @@ typedef struct deinterlace_method_s deinterlace_method_t;
 typedef struct deinterlace_scanline_data_s deinterlace_scanline_data_t;
 typedef struct deinterlace_frame_data_s deinterlace_frame_data_t;
 
-/**
+/*
  * There are two scanline functions that every deinterlacer plugin
  * must implement to do its work: one for a 'copy' and one for
  * an 'interpolate' for the currently active field.  This so so that
@@ -70,7 +70,7 @@ struct deinterlace_scanline_data_s
   int bottom_field;
 };
 
-/**
+/*
  * |   t-3       t-2       t-1       t
  * | Field 3 | Field 2 | Field 1 | Field 0 |
  * |  TT3    |         |   TT1   |         |
@@ -87,7 +87,7 @@ struct deinterlace_scanline_data_s
  */
 typedef void (*deinterlace_interp_scanline_t) (GstDeinterlace2 * object,
     deinterlace_scanline_data_t * data, guint8 * output);
-/**
+/*
  * For the copy scanline, the API is basically the same, except that
  * we're given a scanline to 'copy'.
  *
@@ -102,7 +102,7 @@ typedef void (*deinterlace_interp_scanline_t) (GstDeinterlace2 * object,
 typedef void (*deinterlace_copy_scanline_t) (GstDeinterlace2 * object,
     deinterlace_scanline_data_t * data, guint8 * output);
 
-/**
+/*
  * The frame function is for deinterlacing plugins that can only act
  * on whole frames, rather than on a scanline at a time.
  */
@@ -117,7 +117,7 @@ struct deinterlace_frame_data_s
 typedef void (*deinterlace_frame_t) (GstDeinterlace2 * object);
 
 
-/**
+/*
  * This structure defines the deinterlacer plugin.
  */
 struct deinterlace_method_s
diff --git a/gst/deinterlace2/tvtime/speedy.c b/gst/deinterlace2/tvtime/speedy.c
index 821cc254..d19d917f 100644
--- a/gst/deinterlace2/tvtime/speedy.c
+++ b/gst/deinterlace2/tvtime/speedy.c
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright (c) 2002, 2003 Billy Biggs <vektor@dumbterm.net>.
  * Copyright (C) 2001 Matthew J. Marjanovic <maddog@mir.com>
  *
@@ -17,7 +17,7 @@
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-/**
+/*
  * Includes 420to422, 422to444 scaling filters from the MPEG2 reference
  * implementation.  The v12 source code indicates that they were written
  * by Cheung Auyeung <auyeung@mot.com>.  The file they were in was:
@@ -49,7 +49,7 @@
  *
  */
 
-/**
+/*
  * Code for the UYVY to YUYV routine comes from rivatv:
  *
  *   rivatv-convert.c video image conversion routines
@@ -157,7 +157,7 @@ void (*convert_uyvy_to_yuyv_scanline) (uint8_t * uyvy_buf, uint8_t * yuyv_buf,
 void (*composite_colour4444_alpha_to_packed422_scanline) (uint8_t * output,
     uint8_t * input, int af, int y, int cb, int cr, int width, int alpha);
 
-/**
+/*
  * result = (1 - alpha)B + alpha*F
  *        =  B - alpha*B + alpha*F
  *        =  B + alpha*(F - B)
@@ -574,7 +574,7 @@ packed422_to_packed444_scanline_c (uint8_t * output, uint8_t * input, int width)
   }
 }
 
-/**
+/*
  * For the middle pixels, the filter kernel is:
  *
  * [-1 3 -6 12 -24 80 80 -24 12 -6 3 -1]
@@ -1290,7 +1290,7 @@ blit_colour_packed4444_scanline_mmxext (uint8_t * output, int width,
 #endif
 
 
-/**
+/*
  * Some memcpy code inspired by the xine code which originally came
  * from mplayer.
  */
@@ -1450,12 +1450,12 @@ composite_colour4444_alpha_to_packed422_scanline_c (uint8_t * output,
     int i;
 
     for (i = 0; i < width; i++) {
-            /**
-             * (1 - alpha)*B + alpha*F
-             * (1 - af*a)*B + af*a*F
-             *  B - af*a*B + af*a*F
-             *  B + a*(af*F - af*B)
-             */
+      /*
+       * (1 - alpha)*B + alpha*F
+       * (1 - af*a)*B + af*a*F
+       *  B - af*a*B + af*a*F
+       *  B + a*(af*F - af*B)
+       */
 
       output[0] =
           input[0] + ((alpha * (y - multiply_alpha (af,
@@ -1463,17 +1463,17 @@ composite_colour4444_alpha_to_packed422_scanline_c (uint8_t * output,
 
       if ((i & 1) == 0) {
 
-                    /**
-                     * At first I thought I was doing this incorrectly, but
-                     * the following math has convinced me otherwise.
-                     *
-                     * C_r = (1 - alpha)*B + alpha*F
-                     * C_r = B - af*a*B + af*a*F
-                     *
-                     * C_r = 128 + ((1 - af*a)*(B - 128) + a*af*(F - 128))
-                     * C_r = 128 + (B - af*a*B - 128 + af*a*128 + a*af*F - a*af*128)
-                     * C_r = B - af*a*B + a*af*F
-                     */
+        /*
+         * At first I thought I was doing this incorrectly, but
+         * the following math has convinced me otherwise.
+         *
+         * C_r = (1 - alpha)*B + alpha*F
+         * C_r = B - af*a*B + af*a*F
+         *
+         * C_r = 128 + ((1 - af*a)*(B - 128) + a*af*(F - 128))
+         * C_r = 128 + (B - af*a*B - 128 + af*a*128 + a*af*F - a*af*128)
+         * C_r = B - af*a*B + a*af*F
+         */
 
         output[1] =
             input[1] + ((alpha * (cb - multiply_alpha (af,
@@ -1604,12 +1604,12 @@ composite_packed4444_alpha_to_packed422_scanline_c (uint8_t * output,
           output[3] = foreground[3];
         }
       } else if (a) {
-                /**
-                 * (1 - alpha)*B + alpha*F
-                 * (1 - af*a)*B + af*a*F
-                 *  B - af*a*B + af*a*F
-                 *  B + a*(af*F - af*B)
-                 */
+        /*
+         * (1 - alpha)*B + alpha*F
+         * (1 - af*a)*B + af*a*F
+         *  B - af*a*B + af*a*F
+         *  B + a*(af*F - af*B)
+         */
 
         output[0] = input[0]
             + ((alpha * (foreground[1]
@@ -1617,17 +1617,17 @@ composite_packed4444_alpha_to_packed422_scanline_c (uint8_t * output,
 
         if ((i & 1) == 0) {
 
-                    /**
-                     * At first I thought I was doing this incorrectly, but
-                     * the following math has convinced me otherwise.
-                     *
-                     * C_r = (1 - alpha)*B + alpha*F
-                     * C_r = B - af*a*B + af*a*F
-                     *
-                     * C_r = 128 + ((1 - af*a)*(B - 128) + a*af*(F - 128))
-                     * C_r = 128 + (B - af*a*B - 128 + af*a*128 + a*af*F - a*af*128)
-                     * C_r = B - af*a*B + a*af*F
-                     */
+          /*
+           * At first I thought I was doing this incorrectly, but
+           * the following math has convinced me otherwise.
+           *
+           * C_r = (1 - alpha)*B + alpha*F
+           * C_r = B - af*a*B + af*a*F
+           *
+           * C_r = 128 + ((1 - af*a)*(B - 128) + a*af*(F - 128))
+           * C_r = 128 + (B - af*a*B - 128 + af*a*128 + a*af*F - a*af*128)
+           * C_r = B - af*a*B + a*af*F
+           */
 
           output[1] = input[1] + ((alpha * (foreground[2]
                       - multiply_alpha (foreground[0], input[1])) + 0x80) >> 8);
@@ -1762,20 +1762,20 @@ composite_packed4444_to_packed422_scanline_c (uint8_t * output, uint8_t * input,
         output[3] = foreground[3];
       }
     } else if (a) {
-            /**
-             * (1 - alpha)*B + alpha*F
-             *  B + af*F - af*B
-             */
+      /*
+       * (1 - alpha)*B + alpha*F
+       *  B + af*F - af*B
+       */
 
       output[0] =
           input[0] + foreground[1] - multiply_alpha (foreground[0], input[0]);
 
       if ((i & 1) == 0) {
 
-                /**
-                 * C_r = (1 - af)*B + af*F
-                 * C_r = B - af*B + af*F
-                 */
+        /*
+         * C_r = (1 - af)*B + af*F
+         * C_r = B - af*B + af*F
+         */
 
         output[1] =
             input[1] + foreground[2] - multiply_alpha (foreground[0], input[1]);
@@ -1887,7 +1887,7 @@ composite_packed4444_to_packed422_scanline_mmxext (uint8_t * output,
 }
 #endif
 
-/**
+/*
  * um... just need some scrap paper...
  *   D = (1 - alpha)*B + alpha*F
  *   D = (1 - a)*B + a*textluma
@@ -2287,7 +2287,7 @@ a8_subpix_blit_scanline_c (uint8_t * output, uint8_t * input,
   }
 }
 
-/**
+/*
  * These are from lavtools in mjpegtools:
  *
  * colorspace.c:  Routines to perform colorspace conversions.
@@ -2552,7 +2552,7 @@ packed444_to_rgb24_rec601_scanline_c (uint8_t * output, uint8_t * input,
   }
 }
 
-/**
+/*
  * 601 numbers:
  *
  * Y' =  0.299*R' + 0.587*G' + 0.114*B' (in  0.0 to  1.0)
diff --git a/gst/deinterlace2/tvtime/speedy.h b/gst/deinterlace2/tvtime/speedy.h
index fb833ff1..37293bba 100644
--- a/gst/deinterlace2/tvtime/speedy.h
+++ b/gst/deinterlace2/tvtime/speedy.h
@@ -37,7 +37,7 @@
 extern "C" {
 #endif
 
-/**
+/*
  * Speedy is a collection of optimized functions plus their C fallbacks.
  * This includes a simple system to select which functions to use
  * at runtime.
@@ -50,7 +50,7 @@ extern "C" {
  * implementation of each function.
  */
 
-/**
+/*
  * Struct for pulldown detection metrics.
  */
 typedef struct pulldown_metrics_s {
@@ -60,19 +60,19 @@ typedef struct pulldown_metrics_s {
     int t, s, p;
 } pulldown_metrics_t;
 
-/**
+/*
  * Interpolates a packed 4:2:2 scanline using linear interpolation.
  */
 extern void (*interpolate_packed422_scanline)( uint8_t *output, uint8_t *top,
                                                uint8_t *bot, int width );
 
-/**
+/*
  * Blits a colour to a packed 4:2:2 scanline.
  */
 extern void (*blit_colour_packed422_scanline)( uint8_t *output,
                                                int width, int y, int cb, int cr );
 
-/**
+/*
  * Blits a colour to a packed 4:4:4:4 scanline.  I use luma/cb/cr instead of
  * RGB but this will of course work for either.
  */
@@ -80,19 +80,19 @@ extern void (*blit_colour_packed4444_scanline)( uint8_t *output,
                                                 int width, int alpha, int luma,
                                                 int cb, int cr );
 
-/**
+/*
  * Blit from and to packed 4:2:2 scanline.
  */
 extern void (*blit_packed422_scanline)( uint8_t *dest, const uint8_t *src, int width );
 
-/**
+/*
  * Composites a premultiplied 4:4:4:4 pixel onto a packed 4:2:2 scanline.
  */
 extern void (*composite_colour4444_alpha_to_packed422_scanline)( uint8_t *output, uint8_t *input,
                                                                  int af, int y, int cb, int cr,
                                                                  int width, int alpha );
 
-/**
+/*
  * Composites a packed 4:4:4:4 scanline onto a packed 4:2:2 scanline.
  * Chroma is downsampled by dropping samples (nearest neighbour).
  */
@@ -101,7 +101,7 @@ extern void (*composite_packed4444_to_packed422_scanline)( uint8_t *output,
                                                            uint8_t *foreground,
                                                            int width );
 
-/**
+/*
  * Composites a packed 4:4:4:4 scanline onto a packed 4:2:2 scanline.
  * Chroma is downsampled by dropping samples (nearest neighbour).  The
  * alpha value provided is in the range 0-256 and is first applied to
@@ -112,7 +112,7 @@ extern void (*composite_packed4444_alpha_to_packed422_scanline)( uint8_t *output
                                                                  uint8_t *foreground,
                                                                  int width, int alpha );
 
-/**
+/*
  * Takes an alphamask and the given colour (in Y'CbCr) and composites it
  * onto a packed 4:4:4:4 scanline.
  */
@@ -122,7 +122,7 @@ extern void (*composite_alphamask_to_packed4444_scanline)( uint8_t *output,
                                                            int textluma, int textcb,
                                                            int textcr );
 
-/**
+/*
  * Takes an alphamask and the given colour (in Y'CbCr) and composites it
  * onto a packed 4:4:4:4 scanline.  The alpha value provided is in the
  * range 0-256 and is first applied to the input (for fadeouts).
@@ -133,13 +133,13 @@ extern void (*composite_alphamask_alpha_to_packed4444_scanline)( uint8_t *output
                                                                  int textluma, int textcb,
                                                                  int textcr, int alpha );
 
-/**
+/*
  * Premultiplies the colour by the alpha channel in a packed 4:4:4:4
  * scanline.
  */
 extern void (*premultiply_packed4444_scanline)( uint8_t *output, uint8_t *input, int width );
 
-/**
+/*
  * Blend between two packed 4:2:2 scanline.  Pos is the fade value in
  * the range 0-256.  A value of 0 gives 100% src1, and a value of 256
  * gives 100% src2.  Anything in between gives the appropriate faded
@@ -148,14 +148,14 @@ extern void (*premultiply_packed4444_scanline)( uint8_t *output, uint8_t *input,
 extern void (*blend_packed422_scanline)( uint8_t *output, uint8_t *src1,
                                          uint8_t *src2, int width, int pos );
 
-/**
+/*
  * Calculates the 'difference factor' for two scanlines.  This is a
  * metric where higher values indicate that the two scanlines are more
  * different.
  */
 extern unsigned int (*diff_factor_packed422_scanline)( uint8_t *cur, uint8_t *old, int width );
 
-/**
+/*
  * Calculates the 'comb factor' for a set of three scanlines.  This is a
  * metric where higher values indicate a more likely chance that the two
  * fields are at separate points in time.
@@ -163,68 +163,68 @@ extern unsigned int (*diff_factor_packed422_scanline)( uint8_t *cur, uint8_t *ol
 extern unsigned int (*comb_factor_packed422_scanline)( uint8_t *top, uint8_t *mid,
                                                        uint8_t *bot, int width );
 
-/**
+/*
  * Vertical [1 2 1] chroma filter.
  */
 extern void (*vfilter_chroma_121_packed422_scanline)( uint8_t *output, int width,
                                                       uint8_t *m, uint8_t *t, uint8_t *b );
 
-/**
+/*
  * Vertical [3 3 2] chroma filter.
  */
 extern void (*vfilter_chroma_332_packed422_scanline)( uint8_t *output, int width,
                                                       uint8_t *m, uint8_t *t, uint8_t *b );
 
-/**
+/*
  * Sets the chroma of the scanline to neutral (128) in-place.
  */
 extern void (*kill_chroma_packed422_inplace_scanline)( uint8_t *data, int width );
 
-/**
+/*
  * Mirrors the scanline in-place.
  */
 extern void (*mirror_packed422_inplace_scanline)( uint8_t *data, int width );
 
-/**
+/*
  * Inverts the colours on a scanline in-place.
  */
 extern void (*invert_colour_packed422_inplace_scanline)( uint8_t *data, int width );
 
-/**
+/*
  * Fast memcpy function, used by all of the blit functions.  Won't blit
  * anything if dest == src.
  */
 extern void (*speedy_memcpy)( void *output, const void *input, size_t size );
 
-/**
+/*
  * Calculates the block difference metrics for dalias' pulldown
  * detection algorithm.
  */
 extern void (*diff_packed422_block8x8)( pulldown_metrics_t *m, uint8_t *old,
                                         uint8_t *new, int os, int ns );
 
-/**
+/*
  * Takes an alpha mask and subpixelly blits it using linear
  * interpolation.
  */
 extern void (*a8_subpix_blit_scanline)( uint8_t *output, uint8_t *input,
                                         int lasta, int startpos, int width );
 
-/**
+/*
  * 1/4 vertical subpixel blit for packed 4:2:2 scanlines using linear
  * interpolation.
  */
 extern void (*quarter_blit_vertical_packed422_scanline)( uint8_t *output, uint8_t *one,
                                                          uint8_t *three, int width );
 
-/**
+/*
  * Vertical subpixel blit for packed 4:2:2 scanlines using linear
  * interpolation.
  */
 extern void (*subpix_blit_vertical_packed422_scanline)( uint8_t *output, uint8_t *top,
                                                         uint8_t *bot, int subpixpos, int width );
 
-/**
+/*
  * Simple function to convert a 4:4:4 scanline to a 4:4:4:4 scanline by
  * adding an alpha channel.  Result is non-premultiplied.
  */
@@ -232,7 +232,7 @@ extern void (*packed444_to_nonpremultiplied_packed4444_scanline)( uint8_t *outpu
                                                                   uint8_t *input,
                                                                   int width, int alpha );
 
-/**
+/*
  * I think this function needs to be rethought and renamed, but here
  * it is for now.  This function horizontally resamples a scanline
  * using linear interpolation to compensate for a change in pixel
@@ -243,7 +243,7 @@ extern void (*aspect_adjust_packed4444_scanline)( uint8_t *output,
                                                   int width,
                                                   double pixel_aspect );
 
-/**
+/*
  * Convert a packed 4:4:4 surface to a packed 4:2:2 surface using
  * nearest neighbour chroma downsampling.
  */
@@ -251,7 +251,7 @@ extern void (*packed444_to_packed422_scanline)( uint8_t *output,
                                                 uint8_t *input,
                                                 int width );
 
-/**
+/*
  * Converts packed 4:2:2 to packed 4:4:4 scanlines using nearest
  * neighbour chroma upsampling.
  */
@@ -259,7 +259,7 @@ extern void (*packed422_to_packed444_scanline)( uint8_t *output,
                                                 uint8_t *input,
                                                 int width );
 
-/**
+/*
  * This filter actually does not meet the spec so calling it rec601
  * is a bit of a lie.  I got the filter from Poynton's site.  This
  * converts a scanline from packed 4:2:2 to packed 4:4:4.  But this
@@ -269,7 +269,7 @@ extern void (*packed422_to_packed444_rec601_scanline)( uint8_t *dest,
                                                        uint8_t *src,
                                                        int width );
 
-/**
+/*
  * Conversions between Y'CbCr and R'G'B'.  We use Rec.601 numbers
  * since our source is broadcast video, but I think there is an
  * argument to be made for switching to Rec.709.
@@ -284,19 +284,19 @@ extern void (*rgba32_to_packed4444_rec601_scanline)( uint8_t *output,
                                                      uint8_t *input,
                                                      int width );
 
-/**
+/*
  * Convert from 4:2:2 with UYVY ordering to 4:2:2 with YUYV ordering.
  */
 extern void (*convert_uyvy_to_yuyv_scanline)( uint8_t *uyvy_buf,
                                               uint8_t *yuyv_buf, int width );
 
-/**
+/*
  * Sets up the function pointers to point at the fastest function
  * available.  Requires accelleration settings (see mm_accel.h).
  */
 void setup_speedy_calls( uint32_t accel, int verbose );
 
-/**
+/*
  * Returns a bitfield of what accellerations were used when speedy was
  * initialized.  See mm_accel.h.
  */
diff --git a/gst/deinterlace2/tvtime/vfir.c b/gst/deinterlace2/tvtime/vfir.c
index bb42f5d3..e9b57b96 100644
--- a/gst/deinterlace2/tvtime/vfir.c
+++ b/gst/deinterlace2/tvtime/vfir.c
@@ -43,7 +43,7 @@
 #include "speedy.h"
 #include "gstdeinterlace2.h"
 
-/**
+/*
  * The MPEG2 spec uses a slightly harsher filter, they specify
  * [-1 8 2 8 -1].  ffmpeg uses a similar filter but with more of
  * a tendancy to blur than to use the local information.  The
@@ -118,7 +118,7 @@ deinterlace_line (uint8_t * dst, uint8_t * lum_m4,
 }
 
 
-/**
+/*
  * The commented-out method below that uses the bottom_field member is more
  * like the filter as specified in the MPEG2 spec, but it doesn't seem to
  * have the desired effect.