Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 0 insertions, 536 deletions

diff --git a/kfile-plugins/jpeg/kfile_setcomment.cpp b/kfile-plugins/jpeg/kfile_setcomment.cpp
deleted file mode 100644
index 07dca273..00000000
--- a/kfile-plugins/jpeg/kfile_setcomment.cpp
+++ /dev/null
@@ -1,536 +0,0 @@
-/*
- * setcomment.cpp
- *
- * Copyright 2002 Bryce Nesbitt
- *
- * Based on wrjpgcom.c, Copyright (C) 1994-1997, Thomas G. Lane.
- * Part of the Independent JPEG Group's software release 6b of 27-Mar-1998
- *
- * This file contains a very simple stand-alone application that inserts
- * user-supplied text as a COM (comment) marker in a JPEG/JFIF file.
- * This may be useful as an example of the minimum logic needed to parse
- * JPEG markers.
- *
- * There can be an arbitrary number of COM blocks in each jpeg file, with
- * up to 64K of data each.  We, however, write just one COM and blow away
- * the rest.
- *
- *****************
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License as published by the Free Software Foundation version 2.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#undef  STANDALONE_COMPILE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <string.h>
-#include "config.h"
-
-extern int safe_copy_and_modify( const char * original_filename, const char * comment );
-    
-#ifdef DONT_USE_B_MODE          /* define mode parameters for fopen() */
-#define READ_BINARY     "r"
-#define WRITE_BINARY    "w"
-#else
-#ifdef VMS                      /* VMS is very nonstandard */
-#define READ_BINARY     "rb", "ctx=stm"
-#define WRITE_BINARY    "wb", "ctx=stm"
-#else                           /* standard ANSI-compliant case */
-#define READ_BINARY     "rb"
-#define WRITE_BINARY    "wb"
-#endif
-#endif
-
-#define WARNING_GARBAGE     1   /* Original file had some unspecified content */
-#define ERROR_NOT_A_JPEG    5   /* Original file not a proper jpeg (must be 1st) */
-#define ERROR_TEMP_FILE     6   /* Problem writing temporay file */
-#define ERROR_SCREWUP       7   /* Original file is now damaged.  Ooops. */
-#define ERROR_PREMATURE_EOF 8   /* Unexpected end of file */
-#define ERROR_BAD_MARKER    9   /* Marker with illegal length */
-#define ERROR_MARKER_ORDER  10  /* File seems to be mixed up */
-
-static int          global_error;   /* global error flag.  Once set, we're dead. */
-
-/****************************************************************************/
-/*
- * These macros are used to read the input file and write the output file.
- * To reuse this code in another application, you might need to change these.
- */
-static FILE * infile;           /* input JPEG file */
-
-/* Return next input byte, or EOF if no more */
-#define NEXTBYTE()  getc(infile)
-
-static FILE * outfile;          /* output JPEG file */
-
-/* Emit an output byte */
-#define PUTBYTE(x)  putc((x), outfile)
-
-
-/****************************************************************************/
-/* Read one byte, testing for EOF */
-static int
-read_1_byte (void)
-{
-  int c;
-
-  c = NEXTBYTE();
-  if (c == EOF) {
-    global_error = ERROR_PREMATURE_EOF;
-    }
-  return c;
-}
-
-/* Read 2 bytes, convert to unsigned int */
-/* All 2-byte quantities in JPEG markers are MSB first */
-static unsigned int
-read_2_bytes (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  if (c1 == EOF)
-    global_error = ERROR_PREMATURE_EOF;
-  c2 = NEXTBYTE();
-  if (c2 == EOF)
-    global_error = ERROR_PREMATURE_EOF;
-  return (((unsigned int) c1) << 8) + ((unsigned int) c2);
-}
-
-
-/****************************************************************************/
-/* Routines to write data to output file */
-static void
-write_1_byte (int c)
-{
-  PUTBYTE(c);
-}
-
-static void
-write_2_bytes (unsigned int val)
-{
-  PUTBYTE((val >> 8) & 0xFF);
-  PUTBYTE(val & 0xFF);
-}
-
-static void
-write_marker (int marker)
-{
-  PUTBYTE(0xFF);
-  PUTBYTE(marker);
-}
-
-static void
-copy_rest_of_file (void)
-{
-  int c;
-
-  while ((c = NEXTBYTE()) != EOF)
-    PUTBYTE(c);
-}
-
-
-/****************************************************************************/
-/*
- * JPEG markers consist of one or more 0xFF bytes, followed by a marker
- * code byte (which is not an FF).  Here are the marker codes of interest
- * in this program.  (See jdmarker.c for a more complete list.)
- */
-
-#define M_SOF0  0xC0            /* Start Of Frame N */
-#define M_SOF1  0xC1            /* N indicates which compression process */
-#define M_SOF2  0xC2            /* Only SOF0-SOF2 are now in common use */
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5            /* NB: codes C4 and CC are NOT SOF markers */
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8            /* Start Of Image (beginning of datastream) */
-#define M_EOI   0xD9            /* End Of Image (end of datastream) */
-#define M_SOS   0xDA            /* Start Of Scan (begins compressed data) */
-#define M_COM   0xFE            /* COMment */
-
-
-/*
- * Find the next JPEG marker and return its marker code.
- * We expect at least one FF byte, possibly more if the compressor used FFs
- * to pad the file.  (Padding FFs will NOT be replicated in the output file.)
- * There could also be non-FF garbage between markers.  The treatment of such
- * garbage is unspecified; we choose to skip over it but emit a warning msg.
- * NB: this routine must not be used after seeing SOS marker, since it will
- * not deal correctly with FF/00 sequences in the compressed image data...
- */
-static int
-next_marker (void)
-{
-  int c;
-  int discarded_bytes = 0;
-
-  /* Find 0xFF byte; count and skip any non-FFs. */
-  c = read_1_byte();
-  while (c != 0xFF) {
-    discarded_bytes++;
-    c = read_1_byte();
-  }
-  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
-   * are legal as pad bytes, so don't count them in discarded_bytes.
-   */
-  do {
-    c = read_1_byte();
-  } while (c == 0xFF);
-
-  if (discarded_bytes != 0) {
-    global_error = WARNING_GARBAGE;
-  }
-
-  return c;
-}
-
-
-/*
- * Most types of marker are followed by a variable-length parameter segment.
- * This routine skips over the parameters for any marker we don't otherwise
- * want to process.
- * Note that we MUST skip the parameter segment explicitly in order not to
- * be fooled by 0xFF bytes that might appear within the parameter segment;
- * such bytes do NOT introduce new markers.
- */
-static void
-copy_variable (void)
-/* Copy an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  write_2_bytes(length);
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2) {
-    global_error = ERROR_BAD_MARKER;
-    length = 2;
-    }
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    write_1_byte(read_1_byte());
-    length--;
-  }
-}
-
-static void
-skip_variable (void)
-/* Skip over an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2) {
-    global_error = ERROR_BAD_MARKER;
-    length = 2;
-    }
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    (void) read_1_byte();
-    length--;
-  }
-}
-
-
-static int
-scan_JPEG_header (int keep_COM)
-/*
- * Parse & copy the marker stream until SOFn or EOI is seen;
- * copy data to output, but discard COM markers unless keep_COM is true.
- */
-{
-  int c1, c2;
-  int marker;
-
-  /*
-   * Read the initial marker, which should be SOI.
-   * For a JFIF file, the first two bytes of the file should be literally
-   * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
-   * input file weren't actually JPEG at all, next_marker might read the whole
-   * file and then return a misleading error message...
-   */
-  c1 = NEXTBYTE();
-  c2 = NEXTBYTE();
-  if (c1 != 0xFF || c2 != M_SOI) {
-    global_error = ERROR_NOT_A_JPEG;
-    return EOF;
-    }
-
-  write_marker(M_SOI);
-
-  /* Scan miscellaneous markers until we reach SOFn. */
-  for (;;) {
-    marker = next_marker();
-    switch (marker) {
-      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
-       * treated as SOFn.  C4 in particular is actually DHT.
-       */
-      case M_SOF0:                /* Baseline */
-      case M_SOF1:                /* Extended sequential, Huffman */
-      case M_SOF2:                /* Progressive, Huffman */
-      case M_SOF3:                /* Lossless, Huffman */
-      case M_SOF5:                /* Differential sequential, Huffman */
-      case M_SOF6:                /* Differential progressive, Huffman */
-      case M_SOF7:                /* Differential lossless, Huffman */
-      case M_SOF9:                /* Extended sequential, arithmetic */
-      case M_SOF10:               /* Progressive, arithmetic */
-      case M_SOF11:               /* Lossless, arithmetic */
-      case M_SOF13:               /* Differential sequential, arithmetic */
-      case M_SOF14:               /* Differential progressive, arithmetic */
-      case M_SOF15:               /* Differential lossless, arithmetic */
-      return marker;
-
-    case M_SOS:                 /* should not see compressed data before SOF */
-      global_error = ERROR_MARKER_ORDER;
-      break;
-
-    case M_EOI:                 /* in case it's a tables-only JPEG stream */
-      return marker;
-
-    case M_COM:                 /* Existing COM: conditionally discard */
-      if (keep_COM) {
-        write_marker(marker);
-        copy_variable();
-      } else {
-        skip_variable();
-      }
-      break;
-
-    default:                    /* Anything else just gets copied */
-      write_marker(marker);
-      copy_variable();          /* we assume it has a parameter count... */
-      break;
-    }
-  } /* end loop */
-}
-
-
-/****************************************************************************/
-/*
-    Verify we know how to set the comment on this type of file.
-
-    TODO: The actual check!  This should verify
-    the image size promised in the headers matches the file,
-    and that all markers are properly formatted.
-*/
-static int validate_image_file( const char * filename )
-{
-int status = 1;
-int c1, c2;
-
-  if ( (infile = fopen(filename, READ_BINARY)) ) {
-    c1 = NEXTBYTE();
-    c2 = NEXTBYTE();
-    if (c1 != 0xFF || c2 != M_SOI) 
-      status = ERROR_NOT_A_JPEG;
-    else 
-      status = 0;
-    fclose( infile ); 
-  }
-  return( status );
-}
-
-
-/****************************************************************************/
-/*
-    Modify the file in place, but be paranoid and safe about it.
-    It's worth a few extra CPU cycles to make sure we never
-    destory an original image:
-    1) Validate the input file.
-    2) Open a temporary file.
-    3) Copy the data, writing a new comment block.
-    4) Validate the temporary file.
-    5) Move the temporary file over the original.
-
-    To be even more paranoid & safe we could:
-    5) Rename the original to a different temporary name.
-    6) Rename the temporary to the original.
-    7) Delete the original.
-*/
-extern int safe_copy_and_modify( const char * original_filename, const char * comment )
-{
-char *       temp_filename;
-int          temp_filename_length;
-int          comment_length  = 0;
-int          marker;
-int          i;
-struct stat  statbuf;
-
-  global_error  = 0;
-
-  /*
-   * Make sure we're dealing with a proper input file.  Safety first!
-   */
-  if( validate_image_file( original_filename ) ) {
-    fprintf(stderr, "error validating original file %s\n", original_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-
-  /* Get a unique temporary file in the same directory.  Hopefully 
-   * if things go wrong, this file will still be left for recovery purposes.
-   *
-   * NB: I hate these stupid string functions in C... the buffer length is too
-   * hard to manage...
-   */
-  outfile = NULL;
-  temp_filename_length = strlen( original_filename) + 4;
-  temp_filename = (char *)calloc( temp_filename_length, 1 );
-  for( i=0; i<10; i++ ) {
-    snprintf( temp_filename, temp_filename_length, "%s%d", original_filename, i );
-    if( stat( temp_filename, &statbuf ) ) {
-        outfile = fopen(temp_filename, WRITE_BINARY);
-        break;
-        }
-    }
-  if( !outfile ) {
-    fprintf(stderr, "failed opening temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-
-  /*
-   * Let's rock and roll! 
-   */
-  if ((infile = fopen(original_filename, READ_BINARY)) == NULL) {
-    fprintf(stderr, "can't open input file %s\n", original_filename);
-    free(temp_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-  /* Copy JPEG headers until SOFn marker;
-   * we will insert the new comment marker just before SOFn.
-   * This (a) causes the new comment to appear after, rather than before,
-   * existing comments; and (b) ensures that comments come after any JFIF
-   * or JFXX markers, as required by the JFIF specification.
-   */
-  marker = scan_JPEG_header(0);
-  /* Insert the new COM marker, but only if nonempty text has been supplied */
-  if (comment) {
-    comment_length = strlen( comment );
-    }
-  if (comment_length > 0) {
-    write_marker(M_COM);
-    write_2_bytes(comment_length + 2);
-    while (comment_length > 0) {
-      write_1_byte(*comment++);
-      comment_length--;
-      }
-    }
-  /* Duplicate the remainder of the source file.
-   * Note that any COM markers occurring after SOF will not be touched.
-   *
-   * :TODO: Discard COM markers occurring after SOF
-   */
-  write_marker(marker);
-  copy_rest_of_file();
-  fclose( infile );
-  fsync( fileno( outfile) );    /* Make sure its really on disk first.  !!!VERY IMPORTANT!!! */
-  if ( fclose( outfile ) ) {
-    fprintf(stderr, "error in temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-
-  /*
-   * Make sure we did it right.  We've already fsync()'ed the file.  Safety first!
-   */
-  if( validate_image_file( temp_filename ) ) {
-    fprintf(stderr, "error in temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-  if( global_error >= ERROR_NOT_A_JPEG ) {
-    fprintf(stderr, "error %d processing %s\n", global_error, original_filename);
-    free(temp_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-
-  if( rename( temp_filename, original_filename ) ) {
-    fprintf(stderr, "error renaming %s to %s\n", temp_filename, original_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-  free(temp_filename);
-
-  return(0);
-}
-
-
-#ifdef  STANDALONE_COMPILE
-int
-main (int argc, char **argv)
-{
-    char * progname;       /* program name for error messages */
-    char * filename;
-    char * comment;
-    FILE * fp;
-    int    error;
-
-    /* Process command line arguments... */
-    progname = argv[0];
-    if (progname == NULL || progname[0] == 0)
-        progname = "writejpgcomment";  /* in case C library doesn't provide it */
-    if( argc != 3) {
-        fprintf(stderr, "Usage: %s <filename> \"<comment>\"\nOverwrites the comment in a image file with the given comment.\n", progname);
-        return(5);
-        }
-    filename = argv[1];
-    comment  = argv[2];
-
-
-    /* Check if file is readable... */
-    if ((fp = fopen(filename, READ_BINARY)) == NULL) {
-      fprintf(stderr, "Error: Can't open file %s\n", filename);
-      fclose(fp);
-      return(5);
-    }
-    fclose(fp);
-
-    /* Check if we really have a commentable image file here... */
-    if( validate_image_file( filename ) ) {
-      fprintf(stderr, "Error: file %s is not of a supported type\n", filename);
-      return(5);
-      }
-
-    /* Lets do it... modify the comment in place */
-    if ((error = safe_copy_and_modify( filename, comment ) )) {
-        fprintf(stderr, "Error: %d setting jpg comment\n", error);
-        return(10);
-    }
-
-
-    /* TODO: Read comment back out of jpg and display it */
-    return( 0 );
-}
-#endif