├── docs
    ├── screenshot_1.png
    └── README.md
├── .gitmodules
├── ffmpeg.hpp
├── external
    └── fec
    │   ├── CMakeLists.txt
    │   ├── encode_rs_char.c
    │   ├── decode_rs_char.c
    │   ├── char.h
    │   ├── fixed.h
    │   ├── init_rs_char.c
    │   ├── rs-common.h
    │   ├── init_rs.c
    │   ├── sim.c
    │   ├── encode_rs.c
    │   ├── fec.c
    │   ├── rs_speedtest.c
    │   ├── configure.in
    │   ├── encode_rs.h
    │   ├── fec.h
    │   ├── init_rs.h
    │   ├── exercise.c
    │   ├── README
    │   ├── rstest.cpp
    │   ├── decode_rs.c
    │   ├── decode_rs.h
    │   └── config.guess
├── commandrunner.hpp
├── main.cpp
├── rsencoder.hpp
├── rsdecoder.hpp
├── imagereader.hpp
├── imagewriter.hpp
├── CMakeLists.txt
├── mainwindow.hpp
├── LICENSE.md
├── commandrunner.cpp
├── rscodec.hpp
├── .clang-format
├── rsencoder.cpp
├── imagereader.cpp
├── rsdecoder.cpp
├── mainwindow.cpp
├── imagewriter.cpp
└── PygaGui.glade


/docs/screenshot_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xhighway999/PygaMasher/HEAD/docs/screenshot_1.png


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "external/stb"]
2 | 	path = external/stb
3 | 	url = https://github.com/nothings/stb.git
4 | 


--------------------------------------------------------------------------------
/ffmpeg.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <string>
3 | #ifdef _WIN32
4 | static std::string ffmpegName = "ffmpeg.exe";
5 | #else
6 | static std::string ffmpegName = "ffmpeg";
7 | #endif
8 | 


--------------------------------------------------------------------------------
/external/fec/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | project(fec)
 2 | cmake_minimum_required(VERSION 2.6)
 3 | 
 4 | add_library(fec 
 5 | 	fec.h
 6 | 	fec.c
 7 | 	encode_rs_char.c
 8 | 	decode_rs_char.c
 9 | 	init_rs_char.c
10 | 	)
11 | 
12 | 


--------------------------------------------------------------------------------
/external/fec/encode_rs_char.c:
--------------------------------------------------------------------------------
 1 | /* Reed-Solomon encoder
 2 |  * Copyright 2002, Phil Karn, KA9Q
 3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 4 |  */
 5 | #include <string.h>
 6 | 
 7 | #include "char.h"
 8 | #include "rs-common.h"
 9 | 
10 | void encode_rs_char(void *p,data_t *data, data_t *parity){
11 |   struct rs *rs = (struct rs *)p;
12 | 
13 | #include "encode_rs.h"
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/commandrunner.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <string>
 7 | 
 8 | #ifndef __MINGW32__
 9 | #  include <fcntl.h>
10 | #  include <unistd.h>
11 | #endif
12 | class CommandRunner {
13 | public:
14 |   void        runCommand(const std::string &str);
15 |   bool        readable();
16 |   std::string readAvail();
17 |   void        close();
18 | 
19 | private:
20 |   FILE *fp;
21 |   int   d;
22 |   bool  closed = true;
23 | };
24 | 


--------------------------------------------------------------------------------
/external/fec/decode_rs_char.c:
--------------------------------------------------------------------------------
 1 | /* General purpose Reed-Solomon decoder for 8-bit symbols or less
 2 |  * Copyright 2003 Phil Karn, KA9Q
 3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 4 |  */
 5 | 
 6 | #ifdef DEBUG
 7 | #include <stdio.h>
 8 | #endif
 9 | 
10 | #include <string.h>
11 | 
12 | #include "char.h"
13 | #include "rs-common.h"
14 | 
15 | int decode_rs_char(void *p, data_t *data, int *eras_pos, int no_eras){
16 |   int retval;
17 |   struct rs *rs = (struct rs *)p;
18 |  
19 | #include "decode_rs.h"
20 |   
21 |   return retval;
22 | }
23 | 


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
 1 | PygaMasher
 2 | =====
 3 | 
 4 | PygaMasher is a small program to convert any file into a video. It is designed to convert (mash) and
 5 | recover videos even after they were uploaded to an online video platform like YouTube.
 6 | 
 7 | ![](screenshot_1.png)
 8 | ### Dependencies
 9 | ffmpeg, libgtkmm-3.0-dev
10 | 
11 | 
12 | ### Getting started 
13 | To compile and run PygaMasher execute the following commands:
14 | ```
15 | mkdir build
16 | cd build && cmake ../
17 | make
18 | cd ..
19 | build/PygaMasher
20 | ```
21 | 
22 | 
23 | ### TODO
24 | - Show progress to user
25 | - Expose more settings to the user
26 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "mainwindow.hpp"
 2 | 
 3 | #include <gtkmm.h>
 4 | 
 5 | #define STB_IMAGE_WRITE_IMPLEMENTATION
 6 | #include "stb/stb_image_write.h"
 7 | #define STB_IMAGE_IMPLEMENTATION
 8 | #include "stb/stb_image.h"
 9 | 
10 | int main(int argc, char *argv[]) {
11 |   MainWindow *                   window;
12 |   Glib::RefPtr<Gtk::Application> app =
13 |       Gtk::Application::create(argc, argv, "PygaMasher");
14 |   Glib::RefPtr<Gtk::Builder> builder =
15 |       Gtk::Builder::create_from_file("PygaGui.glade");
16 | 
17 |   builder->get_widget_derived("window", window);
18 | 
19 |   return app->run(*window);
20 | }
21 | 


--------------------------------------------------------------------------------
/rsencoder.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "rscodec.hpp"
 4 | 
 5 | #include <filesystem>
 6 | #include <fstream>
 7 | #include <mutex>
 8 | #include <thread>
 9 | 
10 | namespace fs = std::filesystem;
11 | class RsEncoder {
12 | public:
13 |   ~RsEncoder();
14 |   void  setInputFile(const fs::path &inputPath);
15 |   void  setOutputFile(const fs::path &outputPath);
16 |   void  start();
17 |   float getProgress();
18 |   bool  done();
19 | 
20 | private:
21 |   fs::path    m_inputPath, m_outputPath;
22 |   std::mutex  m_mutex;
23 |   std::thread m_thread;
24 |   float       m_progress;
25 |   bool        m_done = false;
26 | };
27 | 


--------------------------------------------------------------------------------
/external/fec/char.h:
--------------------------------------------------------------------------------
 1 | /* Stuff specific to the 8-bit symbol version of the general purpose RS codecs
 2 |  *
 3 |  * Copyright 2003, Phil Karn, KA9Q
 4 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 5 |  */
 6 | typedef unsigned char data_t;
 7 | 
 8 | #define MODNN(x) modnn(rs,x)
 9 | 
10 | #define MM (rs->mm)
11 | #define NN (rs->nn)
12 | #define ALPHA_TO (rs->alpha_to) 
13 | #define INDEX_OF (rs->index_of)
14 | #define GENPOLY (rs->genpoly)
15 | #define NROOTS (rs->nroots)
16 | #define FCR (rs->fcr)
17 | #define PRIM (rs->prim)
18 | #define IPRIM (rs->iprim)
19 | #define PAD (rs->pad)
20 | #define A0 (NN)
21 | 
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/rsdecoder.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "rscodec.hpp"
 4 | 
 5 | #include <filesystem>
 6 | #include <fstream>
 7 | #include <mutex>
 8 | #include <thread>
 9 | 
10 | namespace fs = std::filesystem;
11 | 
12 | class RsDecoder {
13 | public:
14 |   ~RsDecoder();
15 |   void   setInputFile(const fs::path &inputPath);
16 |   void   setOutputFile(const fs::path &outputPath);
17 |   void   start();
18 |   float  getProgress();
19 |   size_t getTotalErrors();
20 |   bool   done();
21 | 
22 | private:
23 |   fs::path    m_inputPath, m_outputPath;
24 |   std::mutex  m_mutex;
25 |   std::thread m_thread;
26 |   float       m_progress;
27 |   bool        m_done        = false;
28 |   size_t      m_totalErrors = 0;
29 | };
30 | 


--------------------------------------------------------------------------------
/imagereader.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "commandrunner.hpp"
 4 | #include "ffmpeg.hpp"
 5 | #include "stb/stb_image.h"
 6 | 
 7 | #include <algorithm>
 8 | #include <filesystem>
 9 | #include <fstream>
10 | #include <iostream>
11 | #include <string>
12 | class ImageReader {
13 | public:
14 |   ImageReader();
15 |   void setInputFile(const std::filesystem::path &path);
16 |   void setOutputFile(const std::filesystem::path &path);
17 |   void start();
18 | 
19 | private:
20 |   std::ofstream outFile;
21 |   void          readImage(const std::filesystem::path &path);
22 | 
23 |   std::filesystem::path inputVideo = "out.mp4";
24 |   std::filesystem::path cachePath  = "PygaMasher_wd";
25 |   std::filesystem::path outputPath = "file";
26 | 
27 |   size_t chunkSize = 8;
28 | };
29 | 


--------------------------------------------------------------------------------
/imagewriter.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "commandrunner.hpp"
 4 | #include "ffmpeg.hpp"
 5 | #include "stb/stb_image_write.h"
 6 | 
 7 | #include <algorithm>
 8 | #include <climits>
 9 | #include <dirent.h>
10 | #include <fcntl.h>
11 | #include <filesystem>
12 | #include <string>
13 | #include <unistd.h>
14 | #include <vector>
15 | class ImageWriter {
16 | public:
17 |   void start();
18 |   void writeData(char *data, size_t size);
19 |   void end();
20 | 
21 |   void setOutputFile(const std::string &path);
22 | 
23 | private:
24 |   void   flushImage();
25 |   size_t width = 1280, height = 720, chunkSize = 8, bytesPerImage, currentByte;
26 |   std::filesystem::path wd = "PygaMasher_wd";
27 |   std::filesystem::path fileOutputPath;
28 |   std::vector<uint8_t>  currentImageData;
29 |   size_t                currentImage;
30 |   CommandRunner         cmdRunner;
31 | };
32 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | project("PygaMasher")
 2 | cmake_minimum_required(VERSION 3.12)
 3 | set (CMAKE_CXX_STANDARD 17)
 4 | 
 5 | set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} -Wall)
 6 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 7 | set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
 8 | 
 9 | include(FindPkgConfig)
10 | find_package(PkgConfig)
11 | 
12 | pkg_check_modules(GTKMM gtkmm-3.0)
13 | 
14 | # Add fec
15 | add_subdirectory(external/fec)
16 | 
17 | add_executable(PygaMasher 
18 | 	commandrunner.cpp
19 | 	main.cpp
20 | 	mainwindow.cpp
21 | 	imagewriter.cpp
22 | 	imagereader.cpp 
23 | 	rsdecoder.cpp
24 | 	rsencoder.cpp
25 | 	)
26 | 
27 | 
28 | target_link_libraries(PygaMasher stdc++fs pthread fec)
29 | 
30 | link_directories(${GTKMM_LIBRARY_DIRS})
31 | 
32 | target_include_directories(PygaMasher PRIVATE ${GTKMM_INCLUDE_DIRS} external)
33 | 
34 | target_link_libraries(PygaMasher ${GTKMM_LIBRARIES})
35 | 


--------------------------------------------------------------------------------
/external/fec/fixed.h:
--------------------------------------------------------------------------------
 1 | /* Stuff specific to the CCSDS (255,223) RS codec
 2 |  * (255,223) code over GF(256). Note: the conventional basis is still
 3 |  * used; the dual-basis mappings are performed in [en|de]code_rs_ccsds.c
 4 |  *
 5 |  * Copyright 2003 Phil Karn, KA9Q
 6 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 7 |  */
 8 | typedef unsigned char data_t;
 9 | 
10 | static inline int mod255(int x){
11 |   while (x >= 255) {
12 |     x -= 255;
13 |     x = (x >> 8) + (x & 255);
14 |   }
15 |   return x;
16 | }
17 | #define MODNN(x) mod255(x)
18 | 
19 | extern data_t CCSDS_alpha_to[];
20 | extern data_t CCSDS_index_of[];
21 | extern data_t CCSDS_poly[];
22 | 
23 | #define MM 8
24 | #define NN 255
25 | #define ALPHA_TO CCSDS_alpha_to
26 | #define INDEX_OF CCSDS_index_of
27 | #define GENPOLY CCSDS_poly
28 | #define NROOTS 32
29 | #define FCR 112
30 | #define PRIM 11
31 | #define IPRIM 116
32 | #define PAD pad
33 | 
34 | 


--------------------------------------------------------------------------------
/mainwindow.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "imagereader.hpp"
 3 | #include "imagewriter.hpp"
 4 | #include "rsdecoder.hpp"
 5 | #include "rsencoder.hpp"
 6 | 
 7 | #include <gtkmm/builder.h>
 8 | #include <gtkmm/entry.h>
 9 | #include <gtkmm/filechooserbutton.h>
10 | #include <gtkmm/filechooserdialog.h>
11 | #include <gtkmm/label.h>
12 | #include <gtkmm/messagedialog.h>
13 | #include <gtkmm/radiobutton.h>
14 | #include <gtkmm/textview.h>
15 | #include <gtkmm/window.h>
16 | 
17 | class MainWindow : public Gtk::Window {
18 | public:
19 |   MainWindow(BaseObjectType *                  cobject,
20 |              const Glib::RefPtr<Gtk::Builder> &builder);
21 |   virtual ~MainWindow();
22 | 
23 | private:
24 |   void                    onFileSetClicked();
25 |   void                    onStartClicked();
26 |   Gtk::FileChooserButton *openButton;
27 |   Gtk::RadioButton *      mashRadio, *recoverRadio;
28 |   Gtk::Button *           startButton, *setPathButton;
29 |   Gtk::Entry *            savePathEntry;
30 | };
31 | 


--------------------------------------------------------------------------------
/external/fec/init_rs_char.c:
--------------------------------------------------------------------------------
 1 | /* Initialize a RS codec
 2 |  *
 3 |  * Copyright 2002 Phil Karn, KA9Q
 4 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 5 |  */
 6 | #include <stdlib.h>
 7 | 
 8 | #include "char.h"
 9 | #include "rs-common.h"
10 | 
11 | void free_rs_char(void *p){
12 |   struct rs *rs = (struct rs *)p;
13 | 
14 |   free(rs->alpha_to);
15 |   free(rs->index_of);
16 |   free(rs->genpoly);
17 |   free(rs);
18 | }
19 | 
20 | /* Initialize a Reed-Solomon codec
21 |  * symsize = symbol size, bits
22 |  * gfpoly = Field generator polynomial coefficients
23 |  * fcr = first root of RS code generator polynomial, index form
24 |  * prim = primitive element to generate polynomial roots
25 |  * nroots = RS code generator polynomial degree (number of roots)
26 |  * pad = padding bytes at front of shortened block
27 |  */
28 | void *init_rs_char(int symsize,int gfpoly,int fcr,int prim,
29 | 	int nroots,int pad){
30 |   struct rs *rs;
31 | 
32 | #include "init_rs.h"
33 | 
34 |   return rs;
35 | }
36 | 


--------------------------------------------------------------------------------
/external/fec/rs-common.h:
--------------------------------------------------------------------------------
 1 | /* Stuff common to all the general-purpose Reed-Solomon codecs
 2 |  * Copyright 2004 Phil Karn, KA9Q
 3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 4 |  */
 5 | 
 6 | /* Reed-Solomon codec control block */
 7 | struct rs {
 8 |   int mm;              /* Bits per symbol */
 9 |   data_t *alpha_to;     /* log lookup table */
10 |   data_t *index_of;     /* Antilog lookup table */
11 |   data_t *genpoly;      /* Generator polynomial */
12 |   int nn;              /* Symbols per block (= (1<<mm)-1) */
13 |   int nroots;     /* Number of generator roots = number of parity symbols */
14 |   int fcr;        /* First consecutive root, index form */
15 |   int prim;       /* Primitive element, index form */
16 |   int iprim;      /* prim-th root of 1, index form */
17 |   int pad;        /* Padding bytes in shortened block */
18 | };
19 | 
20 | static inline int modnn(struct rs *rs,int x){
21 |   while (x >= rs->nn) {
22 |     x -= rs->nn;
23 |     x = (x >> rs->mm) + (x & rs->nn);
24 |   }
25 |   return x;
26 | }
27 | 


--------------------------------------------------------------------------------
/external/fec/init_rs.c:
--------------------------------------------------------------------------------
 1 | /* Initialize a RS codec
 2 |  *
 3 |  * Copyright 2002 Phil Karn, KA9Q
 4 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 5 |  */
 6 | #include <stdlib.h>
 7 | #include "fec.h"
 8 | 
 9 | #if !defined(NULL)
10 | #define NULL ((void *)0)
11 | #endif
12 | 
13 | #include "rs-common.h"
14 | 
15 | void free_rs(void *p){
16 |   struct rs *rs = (struct rs *)p;
17 | 
18 |   free(rs->alpha_to);
19 |   free(rs->index_of);
20 |   free(rs->genpoly);
21 |   free(rs);
22 | }
23 | 
24 | /* Initialize a Reed-Solomon codec
25 |  * symsize = symbol size, bits
26 |  * gfpoly = Field generator polynomial coefficients
27 |  * fcr = first root of RS code generator polynomial, index form
28 |  * prim = primitive element to generate polynomial roots
29 |  * nroots = RS code generator polynomial degree (number of roots)
30 |  * pad = padding bytes at front of shortened block
31 |  */
32 | void *init_rs_common(int symsize,int gfpoly,int fcr,int prim,
33 | 	int nroots,int pad){
34 |   struct rs *rs;
35 | 
36 | #include "init_rs.h"
37 | 
38 |   return rs;
39 | }
40 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2019 xhighway999 (https://github.com/xhighway999)
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/commandrunner.cpp:
--------------------------------------------------------------------------------
 1 | #include "commandrunner.hpp"
 2 | 
 3 | void CommandRunner::runCommand(const std::string &str) {
 4 | #ifndef __MINGW32__
 5 |   fp = popen(str.c_str(), "r");
 6 |   d  = fileno(fp);
 7 |   fcntl(d, F_SETFL, O_NONBLOCK);
 8 |   if(fp == NULL) {
 9 |     printf("Failed to run command\n");
10 |     exit(1);
11 |   }
12 | #else
13 |   if((fp = _popen(str.c_str(), "r")) == NULL) {
14 |     exit(1);
15 |   }
16 | #endif
17 |   closed = false;
18 | }
19 | 
20 | bool CommandRunner::readable() { return !closed; }
21 | 
22 | std::string CommandRunner::readAvail() {
23 |   std::string availData;
24 |   bool        dataInPipe = true;
25 |   char        buf[1024];
26 |   size_t      count = 1024;
27 |   do {
28 |     ssize_t r = fread(buf, 1, count, fp);
29 |     if(r == -1 && errno == EAGAIN) {
30 |       // no data yet
31 |       dataInPipe = false;
32 |     } else if(r > 0) {
33 |       // received data
34 |       availData.append(buf, r);
35 |     } else {
36 |       // pipe closed
37 |       closed     = true;
38 |       dataInPipe = false;
39 |       return availData;
40 |     }
41 |     return availData;
42 |   } while(dataInPipe);
43 | }
44 | 
45 | void CommandRunner::close() { pclose(fp); }
46 | 


--------------------------------------------------------------------------------
/external/fec/sim.c:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdlib.h>
 3 | #include "fec.h"
 4 | 
 5 | #define	MAX_RANDOM	0x7fffffff
 6 | 
 7 | /* Generate gaussian random double with specified mean and std_dev */
 8 | double normal_rand(double mean, double std_dev)
 9 | {
10 |   double fac,rsq,v1,v2;
11 |   static double gset;
12 |   static int iset;
13 | 
14 |   if(iset){
15 |     /* Already got one */
16 |     iset = 0;
17 |     return mean + std_dev*gset;
18 |   }
19 |   /* Generate two evenly distributed numbers between -1 and +1
20 |    * that are inside the unit circle
21 |    */
22 |   do {
23 |     v1 = 2.0 * (double)random() / MAX_RANDOM - 1;
24 |     v2 = 2.0 * (double)random() / MAX_RANDOM - 1;
25 |     rsq = v1*v1 + v2*v2;
26 |   } while(rsq >= 1.0 || rsq == 0.0);
27 |   fac = sqrt(-2.0*log(rsq)/rsq);
28 |   gset = v1*fac;
29 |   iset++;
30 |   return mean + std_dev*v2*fac;
31 | }
32 | 
33 | unsigned char addnoise(int sym,double amp,double gain,double offset,int clip){
34 |   int sample;
35 |     
36 |   sample = offset + gain*normal_rand(sym?amp:-amp,1.0);
37 |   /* Clip to 8-bit offset range */
38 |   if(sample < 0)
39 |     sample = 0;
40 |   else if(sample > clip)
41 |     sample = clip;
42 |   return sample;
43 | }
44 | 


--------------------------------------------------------------------------------
/rscodec.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <array>
 4 | #include <iostream> //TODO remove
 5 | 
 6 | extern "C" {
 7 | #include "fec/fec.h"
 8 | };
 9 | 
10 | template<size_t symsize, size_t nroots>
11 | class RsCodec {
12 | public:
13 |   RsCodec(int genpoly = 0x187, int fcs = 112, int prim = 11) {
14 |     rs = init_rs_char(symsize, genpoly, fcs, prim, nroots, 0);
15 |   };
16 |   ~RsCodec() { free_rs_char(rs); }
17 | 
18 |   static constexpr int nn = (1 << symsize) - 1, kk = nn - nroots;
19 | 
20 |   void encode(std::array<unsigned char, nn> &block) {
21 |     encode_rs_char(rs, &block[0], &block[kk]);
22 |   }
23 |   void decode(std::array<unsigned char, nn> &block) {
24 |     errorStatistics.errlocs.fill(0);
25 |     errorStatistics.errors =
26 |         decode_rs_char(rs, &block[0], &errorStatistics.errlocs[0], 0);
27 |   }
28 | 
29 |   template<size_t nn>
30 |   struct ErrorStatistics {
31 |     std::array<int, nn> errlocs;
32 |     int                 errors;
33 |   };
34 | 
35 | private:
36 |   ErrorStatistics<nn>           errorStatistics;
37 |   void *                        rs;
38 |   std::array<unsigned char, nn> block;
39 | 
40 | public:
41 |   const ErrorStatistics<nn> &getErrorStatistics() { return errorStatistics; }
42 | };
43 | 
44 | 


--------------------------------------------------------------------------------
/external/fec/encode_rs.c:
--------------------------------------------------------------------------------
 1 | /* Reed-Solomon encoder
 2 |  * Copyright 2002, Phil Karn, KA9Q
 3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 4 |  */
 5 | #include <string.h>
 6 | 
 7 | #ifdef FIXED
 8 | #include "fixed.h"
 9 | #elif defined(BIGSYM)
10 | #include "int.h"
11 | #else
12 | #include "char.h"
13 | #endif
14 | 
15 | void ENCODE_RS(
16 | #ifdef FIXED
17 | data_t *data, data_t *bb,int pad){
18 | #else
19 | void *p,data_t *data, data_t *bb){
20 |   struct rs *rs = (struct rs *)p;
21 | #endif
22 |   int i, j;
23 |   data_t feedback;
24 | 
25 | #ifdef FIXED
26 |   /* Check pad parameter for validity */
27 |   if(pad < 0 || pad >= NN)
28 |     return;
29 | #endif
30 | 
31 |   memset(bb,0,NROOTS*sizeof(data_t));
32 | 
33 |   for(i=0;i<NN-NROOTS-PAD;i++){
34 |     feedback = INDEX_OF[data[i] ^ bb[0]];
35 |     if(feedback != A0){      /* feedback term is non-zero */
36 | #ifdef UNNORMALIZED
37 |       /* This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
38 |        * always be for the polynomials constructed by init_rs()
39 |        */
40 |       feedback = MODNN(NN - GENPOLY[NROOTS] + feedback);
41 | #endif
42 |       for(j=1;j<NROOTS;j++)
43 | 	bb[j] ^= ALPHA_TO[MODNN(feedback + GENPOLY[NROOTS-j])];
44 |     }
45 |     /* Shift */
46 |     memmove(&bb[0],&bb[1],sizeof(data_t)*(NROOTS-1));
47 |     if(feedback != A0)
48 |       bb[NROOTS-1] = ALPHA_TO[MODNN(feedback + GENPOLY[0])];
49 |     else
50 |       bb[NROOTS-1] = 0;
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/external/fec/fec.c:
--------------------------------------------------------------------------------
 1 | /* Utility routines for FEC support
 2 |  * Copyright 2004, Phil Karn, KA9Q
 3 |  */
 4 | 
 5 | #include <stdio.h>
 6 | #include "fec.h"
 7 | 
 8 | unsigned char Partab[256];
 9 | int P_init;
10 | 
11 | /* Create 256-entry odd-parity lookup table
12 |  * Needed only on non-ia32 machines
13 |  */
14 | void partab_init(void){
15 |   int i,cnt,ti;
16 | 
17 |   /* Initialize parity lookup table */
18 |   for(i=0;i<256;i++){
19 |     cnt = 0;
20 |     ti = i;
21 |     while(ti){
22 |       if(ti & 1)
23 | 	cnt++;
24 |       ti >>= 1;
25 |     }
26 |     Partab[i] = cnt & 1;
27 |   }
28 |   P_init=1;
29 | }
30 | 
31 | /* Lookup table giving count of 1 bits for integers 0-255 */
32 | int Bitcnt[] = {
33 |  0, 1, 1, 2, 1, 2, 2, 3,
34 |  1, 2, 2, 3, 2, 3, 3, 4,
35 |  1, 2, 2, 3, 2, 3, 3, 4,
36 |  2, 3, 3, 4, 3, 4, 4, 5,
37 |  1, 2, 2, 3, 2, 3, 3, 4,
38 |  2, 3, 3, 4, 3, 4, 4, 5,
39 |  2, 3, 3, 4, 3, 4, 4, 5,
40 |  3, 4, 4, 5, 4, 5, 5, 6,
41 |  1, 2, 2, 3, 2, 3, 3, 4,
42 |  2, 3, 3, 4, 3, 4, 4, 5,
43 |  2, 3, 3, 4, 3, 4, 4, 5,
44 |  3, 4, 4, 5, 4, 5, 5, 6,
45 |  2, 3, 3, 4, 3, 4, 4, 5,
46 |  3, 4, 4, 5, 4, 5, 5, 6,
47 |  3, 4, 4, 5, 4, 5, 5, 6,
48 |  4, 5, 5, 6, 5, 6, 6, 7,
49 |  1, 2, 2, 3, 2, 3, 3, 4,
50 |  2, 3, 3, 4, 3, 4, 4, 5,
51 |  2, 3, 3, 4, 3, 4, 4, 5,
52 |  3, 4, 4, 5, 4, 5, 5, 6,
53 |  2, 3, 3, 4, 3, 4, 4, 5,
54 |  3, 4, 4, 5, 4, 5, 5, 6,
55 |  3, 4, 4, 5, 4, 5, 5, 6,
56 |  4, 5, 5, 6, 5, 6, 6, 7,
57 |  2, 3, 3, 4, 3, 4, 4, 5,
58 |  3, 4, 4, 5, 4, 5, 5, 6,
59 |  3, 4, 4, 5, 4, 5, 5, 6,
60 |  4, 5, 5, 6, 5, 6, 6, 7,
61 |  3, 4, 4, 5, 4, 5, 5, 6,
62 |  4, 5, 5, 6, 5, 6, 6, 7,
63 |  4, 5, 5, 6, 5, 6, 6, 7,
64 |  5, 6, 6, 7, 6, 7, 7, 8,
65 | };
66 | 
67 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | ---
 2 | AlignAfterOpenBracket: Align
 3 | AlignConsecutiveAssignments: 'true'
 4 | AlignConsecutiveDeclarations: 'true'
 5 | AlignEscapedNewlines: Right
 6 | AlignOperands: 'true'
 7 | AlignTrailingComments: 'true'
 8 | AllowAllParametersOfDeclarationOnNextLine: 'false'
 9 | AllowShortBlocksOnASingleLine: 'false'
10 | AllowShortCaseLabelsOnASingleLine: 'false'
11 | AllowShortFunctionsOnASingleLine: All
12 | AlwaysBreakAfterReturnType: None
13 | AlwaysBreakBeforeMultilineStrings: 'false'
14 | AlwaysBreakTemplateDeclarations: 'true'
15 | BinPackArguments: 'false'
16 | BinPackParameters: 'false'
17 | BreakBeforeBinaryOperators: NonAssignment
18 | BreakBeforeBraces: Attach
19 | BreakBeforeInheritanceComma: 'true'
20 | BreakBeforeTernaryOperators: 'true'
21 | BreakConstructorInitializers: BeforeColon
22 | ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
23 | Cpp11BracedListStyle: 'true'
24 | ExperimentalAutoDetectBinPacking: 'true'
25 | FixNamespaceComments: 'true'
26 | IncludeBlocks: Regroup
27 | IndentCaseLabels: 'false'
28 | IndentPPDirectives: AfterHash
29 | IndentWidth: '2'
30 | IndentWrappedFunctionNames: 'false'
31 | KeepEmptyLinesAtTheStartOfBlocks: 'false'
32 | PointerAlignment: Right
33 | ReflowComments: 'true'
34 | SortIncludes: 'true'
35 | SortUsingDeclarations: 'true'
36 | SpaceAfterCStyleCast: 'true'
37 | SpaceAfterTemplateKeyword: 'false'
38 | SpaceBeforeAssignmentOperators: 'true'
39 | SpaceBeforeParens: Never
40 | SpaceInEmptyParentheses: 'false'
41 | SpacesInAngles: 'false'
42 | SpacesInCStyleCastParentheses: 'false'
43 | SpacesInContainerLiterals: 'false'
44 | SpacesInParentheses: 'false'
45 | SpacesInSquareBrackets: 'false'
46 | Standard: Auto
47 | UseTab: Never
48 | 
49 | ...
50 | 


--------------------------------------------------------------------------------
/external/fec/rs_speedtest.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | #include <time.h>
 5 | #include <sys/time.h>
 6 | #include <sys/resource.h>
 7 | #include "fec.h"
 8 | 
 9 | int main(){
10 |   unsigned char block[255];
11 |   int i;
12 |   void *rs;
13 |   struct rusage start,finish;
14 |   double extime;
15 |   int trials = 10000;
16 | 
17 |   for(i=0;i<223;i++)
18 |     block[i] = 0x01;
19 | 
20 |   rs = init_rs_char(8,0x187,112,11,32,0);
21 |   encode_rs_char(rs,block,&block[223]);
22 | 
23 |   getrusage(RUSAGE_SELF,&start);
24 |   for(i=0;i<trials;i++){
25 | #if 0
26 |     block[0] ^= 0xff; /* Introduce an error */
27 |     block[2] ^= 0xff; /* Introduce an error */
28 | #endif
29 |     decode_rs_char(rs,block,NULL,0);
30 |   }
31 |   getrusage(RUSAGE_SELF,&finish);
32 |   extime = finish.ru_utime.tv_sec - start.ru_utime.tv_sec + 1e-6*(finish.ru_utime.tv_usec - start.ru_utime.tv_usec);
33 |   
34 |   printf("Execution time for %d Reed-Solomon blocks using general decoder: %.2f sec\n",trials,extime);
35 |   printf("decoder speed: %g bits/s\n",trials*223*8/extime);
36 | 
37 | 
38 |   encode_rs_8(block,&block[223],0);
39 |   getrusage(RUSAGE_SELF,&start);
40 |   for(i=0;i<trials;i++){
41 | #if 0
42 |     block[0] ^= 0xff; /* Introduce an error */
43 |     block[2] ^= 0xff; /* Introduce an error */
44 | #endif
45 |     decode_rs_8(block,NULL,0,0);
46 |   }
47 |   getrusage(RUSAGE_SELF,&finish);
48 |   extime = finish.ru_utime.tv_sec - start.ru_utime.tv_sec + 1e-6*(finish.ru_utime.tv_usec - start.ru_utime.tv_usec);
49 |   printf("Execution time for %d Reed-Solomon blocks using CCSDS decoder: %.2f sec\n",trials,extime);
50 |   printf("decoder speed: %g bits/s\n",trials*223*8/extime);
51 | 
52 |   exit(0);
53 | }
54 | 
55 | 


--------------------------------------------------------------------------------
/external/fec/configure.in:
--------------------------------------------------------------------------------
 1 | dnl Process this file with autoconf to produce a configure script.
 2 | AC_INIT(viterbi27.c)
 3 | AC_CONFIG_HEADER(config.h)
 4 | SO_NAME=3
 5 | VERSION=3.0.0
 6 | AC_SUBST(SO_NAME)
 7 | AC_SUBST(VERSION)
 8 | 
 9 | dnl Checks for programs.
10 | AC_PROG_CC
11 | if test $GCC != "yes"
12 | then
13 | 	AC_MSG_ERROR([Need GNU C compiler])
14 | fi
15 | dnl Checks for libraries.
16 | AC_CHECK_LIB(c, malloc)
17 | 
18 | dnl Checks for header files.
19 | AC_CHECK_HEADERS(getopt.h stdio.h stdlib.h memory.h string.h)
20 | if test -z "$HAVE_stdio.h"
21 | then
22 | 	AC_MSG_ERROR([Need stdio.h!])
23 | fi
24 | if test -z "$HAVE_stdlib.h"
25 | then
26 | 	AC_MSG_ERROR([Need stdlib.h!])
27 | fi
28 | if test -z "$HAVE_stdlib.h"
29 | then
30 | 	AC_MSG_ERROR([Need memory.h!])
31 | fi
32 | if test -z "$HAVE_string.h"
33 | then
34 | 	AC_MSG_ERROR([Need string.h])
35 | fi
36 | 
37 | AC_CANONICAL_SYSTEM
38 | case $target_cpu in
39 | i386|i486|i586|i686)
40 | 	ARCH_OPTION="-march=$target_cpu"
41 | 	MLIBS="viterbi27_mmx.o mmxbfly27.o viterbi27_sse.o ssebfly27.o viterbi27_sse2.o sse2bfly27.o \
42 | 	viterbi29_mmx.o mmxbfly29.o viterbi29_sse.o ssebfly29.o viterbi29_sse2.o sse2bfly29.o \
43 | 	viterbi39_sse2.o viterbi39_sse.o viterbi39_mmx.o \
44 | 	viterbi615_mmx.o viterbi615_sse.o viterbi615_sse2.o \
45 | 	dotprod_mmx.o dotprod_mmx_assist.o \
46 | 	dotprod_sse2.o dotprod_sse2_assist.o \
47 | 	peakval_mmx.o peakval_mmx_assist.o \
48 | 	peakval_sse.o peakval_sse_assist.o \
49 | 	peakval_sse2.o peakval_sse2_assist.o \
50 | 	sumsq.o sumsq_port.o \
51 | 	sumsq_sse2.o sumsq_sse2_assist.o \
52 | 	sumsq_mmx.o sumsq_mmx_assist.o \
53 | 	cpu_features.o cpu_mode_x86.o"
54 | 	;;
55 | powerpc*)
56 | 	ARCH_OPTION="-fno-common -faltivec"
57 | 	MLIBS="viterbi27_av.o viterbi29_av.o viterbi39_av.o viterbi615_av.o \
58 | 	encode_rs_av.o \
59 | 	dotprod_av.o sumsq_av.o peakval_av.o cpu_mode_ppc.o"
60 | 	;;
61 | *)
62 | 	MLIBS=
63 | esac
64 | case $target_os in
65 | darwin*)
66 | 	SH_LIB=libfec.dylib
67 | 	REBIND=""
68 | 	;;
69 | *)
70 | 	SH_LIB=libfec.so
71 | 	REBIND=ldconfig
72 | 	;;
73 | esac
74 | AC_SUBST(SH_LIB)
75 | AC_SUBST(REBIND)
76 | AC_SUBST(MLIBS)
77 | AC_SUBST(ARCH_OPTION)
78 | 
79 | 
80 | dnl Checks for library functions.
81 | AC_CHECK_FUNCS(getopt_long memset memmove)
82 | 
83 | AC_OUTPUT(makefile)
84 | 


--------------------------------------------------------------------------------
/rsencoder.cpp:
--------------------------------------------------------------------------------
 1 | #include "rsencoder.hpp"
 2 | 
 3 | void RsEncoder::setInputFile(const fs::path &inputPath) {
 4 |   std::lock_guard<std::mutex> g(m_mutex);
 5 |   m_inputPath = inputPath;
 6 | }
 7 | 
 8 | void RsEncoder::setOutputFile(const fs::path &outputPath) {
 9 |   std::lock_guard<std::mutex> g(m_mutex);
10 |   m_outputPath = outputPath;
11 | }
12 | 
13 | void RsEncoder::start() {
14 |   this->m_done = false;
15 |   m_thread     = std::thread([this]() {
16 |     // Open both files
17 |     std::string inputPath, outputPath;
18 |     size_t      bytesConverted, fileSize;
19 | 
20 |     // Lock the mutex and execute code, that uses shared variables
21 |     {
22 |       std::lock_guard<std::mutex> g(m_mutex);
23 | 
24 |       // Remove the old file, if any
25 |       if(fs::exists(this->m_outputPath)) {
26 |         fs::remove(this->m_outputPath);
27 |       }
28 |       bytesConverted = 0, fileSize = fs::file_size(this->m_inputPath);
29 |       inputPath = this->m_inputPath, outputPath = this->m_outputPath;
30 |       if(!fs::exists(inputPath)) {
31 |         std::cout << "ERROR: file " << inputPath << " does not exist";
32 |       }
33 |     }
34 |     RsCodec<8, 32> codec;
35 |     std::ifstream  iFile(inputPath, std::ifstream::binary);
36 |     if(!iFile.is_open()) {
37 |       std::cout << "ERROR" << errno << ": Could not open iFile " << inputPath
38 |                 << std::endl;
39 |       this->m_done = true;
40 |       return;
41 |     }
42 |     std::ofstream oFile(this->m_outputPath, std::fstream::binary);
43 | 
44 |     std::array<unsigned char, codec.nn> block;
45 |     do {
46 |       // Read a chunk of the input file
47 |       iFile.read(reinterpret_cast<char *>(&block[0]), codec.kk);
48 | 
49 |       // Encode is with RS
50 |       codec.encode(block);
51 | 
52 |       // Write it to the output File
53 |       oFile.write(reinterpret_cast<char *>(&block[0]), codec.nn);
54 |       bytesConverted += codec.kk;
55 | 
56 |       // Update progress
57 |       {
58 |         std::lock_guard<std::mutex> g(m_mutex);
59 |         m_progress = (float) bytesConverted / (float) fileSize;
60 |       }
61 | 
62 |     } while(iFile.good());
63 | 
64 |     {
65 |       std::lock_guard<std::mutex> g(m_mutex);
66 |       m_done = true;
67 |     }
68 |   });
69 | }
70 | 
71 | float RsEncoder::getProgress() {
72 |   std::lock_guard<std::mutex> g(m_mutex);
73 |   return m_progress;
74 | }
75 | 
76 | bool RsEncoder::done() {
77 |   std::lock_guard<std::mutex> g(m_mutex);
78 |   return m_done;
79 | }
80 | 
81 | RsEncoder::~RsEncoder() {
82 |   if(m_thread.joinable())
83 |     m_thread.join();
84 | }
85 | 


--------------------------------------------------------------------------------
/external/fec/encode_rs.h:
--------------------------------------------------------------------------------
 1 | /* The guts of the Reed-Solomon encoder, meant to be #included
 2 |  * into a function body with the following typedefs, macros and variables supplied
 3 |  * according to the code parameters:
 4 | 
 5 |  * data_t - a typedef for the data symbol
 6 |  * data_t data[] - array of NN-NROOTS-PAD and type data_t to be encoded
 7 |  * data_t parity[] - an array of NROOTS and type data_t to be written with parity symbols
 8 |  * NROOTS - the number of roots in the RS code generator polynomial,
 9 |  *          which is the same as the number of parity symbols in a block.
10 |             Integer variable or literal.
11 | 	    * 
12 |  * NN - the total number of symbols in a RS block. Integer variable or literal.
13 |  * PAD - the number of pad symbols in a block. Integer variable or literal.
14 |  * ALPHA_TO - The address of an array of NN elements to convert Galois field
15 |  *            elements in index (log) form to polynomial form. Read only.
16 |  * INDEX_OF - The address of an array of NN elements to convert Galois field
17 |  *            elements in polynomial form to index (log) form. Read only.
18 |  * MODNN - a function to reduce its argument modulo NN. May be inline or a macro.
19 |  * GENPOLY - an array of NROOTS+1 elements containing the generator polynomial in index form
20 | 
21 |  * The memset() and memmove() functions are used. The appropriate header
22 |  * file declaring these functions (usually <string.h>) must be included by the calling
23 |  * program.
24 | 
25 |  * Copyright 2004, Phil Karn, KA9Q
26 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
27 |  */
28 | 
29 | 
30 | #undef A0
31 | #define A0 (NN) /* Special reserved value encoding zero in index form */
32 | 
33 | {
34 |   int i, j;
35 |   data_t feedback;
36 | 
37 |   memset(parity,0,NROOTS*sizeof(data_t));
38 | 
39 |   for(i=0;i<NN-NROOTS-PAD;i++){
40 |     feedback = INDEX_OF[data[i] ^ parity[0]];
41 |     if(feedback != A0){      /* feedback term is non-zero */
42 | #ifdef UNNORMALIZED
43 |       /* This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
44 |        * always be for the polynomials constructed by init_rs()
45 |        */
46 |       feedback = MODNN(NN - GENPOLY[NROOTS] + feedback);
47 | #endif
48 |       for(j=1;j<NROOTS;j++)
49 | 	parity[j] ^= ALPHA_TO[MODNN(feedback + GENPOLY[NROOTS-j])];
50 |     }
51 |     /* Shift */
52 |     memmove(&parity[0],&parity[1],sizeof(data_t)*(NROOTS-1));
53 |     if(feedback != A0)
54 |       parity[NROOTS-1] = ALPHA_TO[MODNN(feedback + GENPOLY[0])];
55 |     else
56 |       parity[NROOTS-1] = 0;
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/imagereader.cpp:
--------------------------------------------------------------------------------
 1 | #include "imagereader.hpp"
 2 | 
 3 | ImageReader::ImageReader() {}
 4 | void ImageReader::start() {
 5 |   try {
 6 |     if(std::filesystem::exists(cachePath))
 7 |       std::filesystem::remove_all(cachePath);
 8 |     std::filesystem::create_directory(cachePath);
 9 |   } catch(const std::exception &e) {
10 |     std::cout << e.what() << "\n";
11 |   }
12 | 
13 |   std::filesystem::path fullPath = cachePath / "img_%05d.png";
14 | 
15 |   std::string command = ffmpegName + " -y -i \"" + inputVideo.string()
16 |                         + "\" -vf \"fps=1\" -q:v 2 \"" + fullPath.string()
17 |                         + "\"";
18 |   CommandRunner runner;
19 |   runner.runCommand(command);
20 |   while(runner.readable()) {
21 |     runner.readAvail();
22 |   }
23 |   runner.close();
24 | 
25 |   outFile.open(outputPath, std::ios::binary | std::ios::out);
26 | 
27 |   std::vector<std::filesystem::path> paths;
28 |   for(const auto &p : std::filesystem::directory_iterator(cachePath)) {
29 |     if(p.path().extension() == ".png") {
30 |       paths.push_back(p.path());
31 |     }
32 |   }
33 | 
34 |   std::sort(paths.begin(), paths.end());
35 | 
36 |   for(const auto &p : paths) {
37 |     readImage(p);
38 |   }
39 | 
40 |   outFile.close();
41 | }
42 | 
43 | void ImageReader::readImage(const std::filesystem::path &path) {
44 |   int            w, h, n;
45 |   unsigned char *data = stbi_load(path.string().c_str(), &w, &h, &n, 1);
46 | 
47 |   auto getPixel = [&data, w](size_t x, size_t y) {
48 |     size_t        i = y * w + x;
49 |     unsigned char m = data[i];
50 |     return 127 < m;
51 |   };
52 |   auto readChunk = [this, &getPixel](size_t x, size_t y) {
53 |     unsigned char val = 0;
54 |     for(size_t i = 0; i < chunkSize; i++) {
55 |       // TODO: Sample any of the other 7 pixels
56 |       unsigned char pix =
57 |           getPixel(x * chunkSize + i, y * chunkSize + (chunkSize / 2));
58 |       val |= pix << i;
59 |     }
60 |     return val;
61 |   };
62 |   // sample every CHUNK pixel with a given offset
63 |   std::vector<unsigned char> imageData;
64 |   imageData.resize((w / chunkSize) * (h / chunkSize));
65 |   for(size_t i = 0; i < (w / chunkSize) * (h / chunkSize); i++) {
66 |     size_t x     = i % (w / chunkSize);
67 |     size_t y     = i / (w / chunkSize);
68 |     imageData[i] = readChunk(x, y);
69 |   }
70 | 
71 |   outFile.write(reinterpret_cast<char *>(&imageData[0]), imageData.size());
72 |   free(data);
73 | }
74 | 
75 | void ImageReader::setInputFile(const std::filesystem::path &path) {
76 |   inputVideo = path;
77 | }
78 | void ImageReader::setOutputFile(const std::filesystem::path &path) {
79 |   outputPath = path;
80 | }
81 | 


--------------------------------------------------------------------------------
/external/fec/fec.h:
--------------------------------------------------------------------------------
 1 | /* User include file for libfec
 2 |  * Copyright 2004, Phil Karn, KA9Q
 3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
 4 |  */
 5 | 
 6 | #ifndef _FEC_H_
 7 | #define _FEC_H_
 8 | 
 9 | /* General purpose RS codec, 8-bit symbols */
10 | void encode_rs_char(void *rs,unsigned char *data,unsigned char *parity);
11 | int decode_rs_char(void *rs,unsigned char *data,int *eras_pos,
12 | 		   int no_eras);
13 | void *init_rs_char(int symsize,int gfpoly,
14 | 		   int fcr,int prim,int nroots,
15 | 		   int pad);
16 | void free_rs_char(void *rs);
17 | 
18 | /* CCSDS standard (255,223) RS codec with conventional (*not* dual-basis)
19 |  * symbol representation
20 |  */
21 | void encode_rs_8(unsigned char *data,unsigned char *parity,int pad);
22 | int decode_rs_8(unsigned char *data,int *eras_pos,int no_eras,int pad);
23 | 
24 | /* CCSDS standard (255,223) RS codec with dual-basis symbol representation */
25 | void encode_rs_ccsds(unsigned char *data,unsigned char *parity,int pad);
26 | int decode_rs_ccsds(unsigned char *data,int *eras_pos,int no_eras,int pad);
27 | 
28 | /* Tables to map from conventional->dual (Taltab) and
29 |  * dual->conventional (Tal1tab) bases
30 |  */
31 | extern unsigned char Taltab[],Tal1tab[];
32 | 
33 | 
34 | /* CPU SIMD instruction set available */
35 | extern enum cpu_mode {UNKNOWN=0,PORT,MMX,SSE,SSE2,ALTIVEC} Cpu_mode;
36 | void find_cpu_mode(void); /* Call this once at startup to set Cpu_mode */
37 | 
38 | /* Determine parity of argument: 1 = odd, 0 = even */
39 | #ifdef __i386__
40 | static inline int parityb(unsigned char x){
41 |   __asm__ __volatile__ ("test %1,%1;setpo %0" : "=g"(x) : "r" (x));
42 |   return x;
43 | }
44 | #else
45 | void partab_init();
46 | 
47 | static inline int parityb(unsigned char x){
48 |   extern unsigned char Partab[256];
49 |   extern int P_init;
50 |   if(!P_init){
51 |     partab_init();
52 |   }
53 |   return Partab[x];
54 | }
55 | #endif
56 | 
57 | 
58 | static inline int parity(int x){
59 |   /* Fold down to one byte */
60 |   x ^= (x >> 16);
61 |   x ^= (x >> 8);
62 |   return parityb(x);
63 | }
64 | 
65 | /* Useful utilities for simulation */
66 | double normal_rand(double mean, double std_dev);
67 | unsigned char addnoise(int sym,double amp,double gain,double offset,int clip);
68 | 
69 | extern int Bitcnt[];
70 | 
71 | /* Dot product functions */
72 | void *initdp(signed short coeffs[],int len);
73 | void freedp(void *dp);
74 | long dotprod(void *dp,signed short a[]);
75 | 
76 | void *initdp_port(signed short coeffs[],int len);
77 | void freedp_port(void *dp);
78 | long dotprod_port(void *dp,signed short a[]);
79 | 
80 | 
81 | /* Sum of squares - accepts signed shorts, produces unsigned long long */
82 | unsigned long long sumsq(signed short *in,int cnt);
83 | unsigned long long sumsq_port(signed short *in,int cnt);
84 | 
85 | 
86 | 
87 | /* Low-level data structures and routines */
88 | 
89 | 
90 | #endif /* _FEC_H_ */
91 | 
92 | 
93 | 
94 | 


--------------------------------------------------------------------------------
/rsdecoder.cpp:
--------------------------------------------------------------------------------
 1 | #include "rsdecoder.hpp"
 2 | 
 3 | void RsDecoder::setInputFile(const fs::path &inputPath) {
 4 |   std::lock_guard<std::mutex> g(m_mutex);
 5 |   m_inputPath = inputPath;
 6 | }
 7 | 
 8 | void RsDecoder::setOutputFile(const fs::path &outputPath) {
 9 |   std::lock_guard<std::mutex> g(m_mutex);
10 |   m_outputPath = outputPath;
11 | }
12 | 
13 | void RsDecoder::start() {
14 |   this->m_done = false;
15 |   m_thread     = std::thread([this]() {
16 |     // Open both files
17 |     std::string inputPath, outputPath;
18 |     size_t      bytesConverted, fileSize;
19 | 
20 |     // Lock the mutex and execute code, that uses shared variables
21 |     {
22 |       std::lock_guard<std::mutex> g(m_mutex);
23 | 
24 |       // Remove the old file, if any
25 |       if(fs::exists(this->m_outputPath)) {
26 |         fs::remove(this->m_outputPath);
27 |       }
28 |       bytesConverted = 0, fileSize = fs::file_size(this->m_inputPath);
29 |       inputPath = this->m_inputPath, outputPath = this->m_outputPath;
30 |       if(!fs::exists(inputPath)) {
31 |         std::cout << "ERROR: file " << inputPath << " does not exist";
32 |       }
33 |       m_totalErrors = 0;
34 |     }
35 |     RsCodec<8, 32> codec;
36 |     std::ifstream  iFile(inputPath, std::ifstream::binary);
37 |     if(!iFile.is_open()) {
38 |       std::cout << "ERROR" << errno << ": Could not open iFile " << inputPath
39 |                 << std::endl;
40 |       this->m_done = true;
41 |       return;
42 |     }
43 |     std::ofstream oFile(this->m_outputPath, std::fstream::binary);
44 | 
45 |     std::array<unsigned char, codec.nn> block;
46 | 
47 |     do {
48 |       // Read a chunk of the input file
49 |       iFile.read(reinterpret_cast<char *>(&block[0]), codec.nn);
50 | 
51 |       // Encode is with RS
52 |       codec.decode(block);
53 | 
54 |       if(codec.getErrorStatistics().errors == -1) {
55 |         std::cout << "Could not decode block";
56 |         return;
57 |       }
58 | 
59 |       // Write it to the output File
60 |       oFile.write(reinterpret_cast<char *>(&block[0]), codec.kk);
61 |       bytesConverted += codec.nn;
62 | 
63 |       // Update progress
64 |       {
65 |         std::lock_guard<std::mutex> g(m_mutex);
66 |         m_progress = (float) bytesConverted / (float) fileSize;
67 |         m_totalErrors += codec.getErrorStatistics().errors;
68 |       }
69 | 
70 |     } while(iFile.good());
71 | 
72 |     {
73 |       std::lock_guard<std::mutex> g(m_mutex);
74 |       m_done = true;
75 |     }
76 |   });
77 | }
78 | 
79 | float RsDecoder::getProgress() {
80 |   std::lock_guard<std::mutex> g(m_mutex);
81 |   return m_progress;
82 | }
83 | 
84 | size_t RsDecoder::getTotalErrors() {
85 |   std::lock_guard<std::mutex> g(m_mutex);
86 |   return m_totalErrors;
87 | }
88 | 
89 | bool RsDecoder::done() {
90 |   std::lock_guard<std::mutex> g(m_mutex);
91 |   return m_done;
92 | }
93 | 
94 | RsDecoder::~RsDecoder() {
95 |   if(m_thread.joinable())
96 |     m_thread.join();
97 | }
98 | 


--------------------------------------------------------------------------------
/mainwindow.cpp:
--------------------------------------------------------------------------------
 1 | #include "mainwindow.hpp"
 2 | 
 3 | MainWindow::MainWindow(BaseObjectType *                  cobject,
 4 |                        const Glib::RefPtr<Gtk::Builder> &builder)
 5 |     : Gtk::Window(cobject) {
 6 |   builder->get_widget("mashRadio", mashRadio);
 7 |   builder->get_widget("recoverRadio", recoverRadio);
 8 |   builder->get_widget("fileLoadButton", openButton);
 9 |   builder->get_widget("setPathButton", setPathButton);
10 |   builder->get_widget("startButton", startButton);
11 |   builder->get_widget("savePathEntry", savePathEntry);
12 | 
13 |   startButton->signal_clicked().connect(
14 |       sigc::mem_fun(*this, &MainWindow::onStartClicked));
15 |   setPathButton->signal_clicked().connect(
16 |       sigc::mem_fun(*this, &MainWindow::onFileSetClicked));
17 | }
18 | 
19 | MainWindow::~MainWindow() {}
20 | 
21 | void MainWindow::onFileSetClicked() {
22 |   Gtk::FileChooserDialog dialog("Select a Save Path",
23 |                                 Gtk::FILE_CHOOSER_ACTION_SAVE);
24 |   dialog.set_transient_for(*this);
25 |   dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
26 |   dialog.add_button("Save", Gtk::RESPONSE_OK);
27 | 
28 |   int result = dialog.run();
29 | 
30 |   if(result == Gtk::RESPONSE_OK) {
31 |     savePathEntry->set_text(dialog.get_filename());
32 |   }
33 | }
34 | 
35 | void MainWindow::onStartClicked() {
36 |   std::string openFile = openButton->get_filename();
37 |   std::string saveFile = savePathEntry->get_text();
38 |   bool        mash     = mashRadio->get_active();
39 | 
40 |   auto mashFunc = [](std::string in, std::string out) {
41 | 
42 | 	
43 | 
44 |     //RS encode the file
45 |     RsEncoder encoder;
46 |     encoder.setInputFile(in);
47 |     encoder.setOutputFile("rsencoded.rs");
48 |     encoder.start();
49 |     while(!encoder.done()) {
50 |     	sleep(1);
51 | 	std::cout << encoder.getProgress() * 100.f << " % done" << std::endl;
52 |     }
53 | 
54 | 
55 |     ImageWriter writer;
56 |     writer.setOutputFile(out);
57 | 
58 |     std::ifstream file("rsencoded.rs", std::ifstream::binary);
59 |     writer.start();
60 |     char data[512];
61 |     do {
62 |       file.read(data, 512);
63 |       writer.writeData(data, file.gcount());
64 |     } while(!file.eof());
65 | 
66 |     writer.end();
67 |   };
68 |   auto recoverFunc = [](std::string in, std::string out) {
69 |     
70 | 
71 |     ImageReader reader;
72 |     reader.setInputFile(in);
73 |     reader.setOutputFile("rsencoded.rs");
74 |     reader.start();
75 | 
76 | 
77 |     RsDecoder decoder;
78 |     decoder.setInputFile("rsencoded.rs");
79 |     decoder.setOutputFile(out);
80 |     decoder.start();
81 |     while(!decoder.done()) {
82 |     	sleep(1);
83 | 	std::cout << decoder.getProgress() * 100.f << " % done" << std::endl;
84 |     }
85 |     std::cout << "Decoder done. " << decoder.getTotalErrors() << " Errors" << std::endl;
86 |   };
87 | 
88 |   if(mash)
89 |     mashFunc(openFile, saveFile);
90 |   else
91 |     recoverFunc(openFile, saveFile);
92 | 
93 |   Gtk::MessageDialog dialog("Conversion complete");
94 |   dialog.set_secondary_text("Press OK to close this window");
95 |   dialog.run();
96 | }
97 | 


--------------------------------------------------------------------------------
/external/fec/init_rs.h:
--------------------------------------------------------------------------------
  1 | /* Common code for intializing a Reed-Solomon control block (char or int symbols)
  2 |  * Copyright 2004 Phil Karn, KA9Q
  3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
  4 |  */
  5 | #undef NULL
  6 | #define NULL ((void *)0)
  7 | 
  8 | {
  9 |   int i, j, sr,root,iprim;
 10 | 
 11 |   rs = NULL;
 12 |   /* Check parameter ranges */
 13 |   if(symsize < 0 || symsize > 8*sizeof(data_t)){
 14 |     goto done;
 15 |   }
 16 | 
 17 |   if(fcr < 0 || fcr >= (1<<symsize))
 18 |     goto done;
 19 |   if(prim <= 0 || prim >= (1<<symsize))
 20 |     goto done;
 21 |   if(nroots < 0 || nroots >= (1<<symsize))
 22 |     goto done; /* Can't have more roots than symbol values! */
 23 |   if(pad < 0 || pad >= ((1<<symsize) -1 - nroots))
 24 |     goto done; /* Too much padding */
 25 | 
 26 |   rs = (struct rs *)calloc(1,sizeof(struct rs));
 27 |   if(rs == NULL)
 28 |     goto done;
 29 | 
 30 |   rs->mm = symsize;
 31 |   rs->nn = (1<<symsize)-1;
 32 |   rs->pad = pad;
 33 | 
 34 |   rs->alpha_to = (data_t *)malloc(sizeof(data_t)*(rs->nn+1));
 35 |   if(rs->alpha_to == NULL){
 36 |     free(rs);
 37 |     rs = NULL;
 38 |     goto done;
 39 |   }
 40 |   rs->index_of = (data_t *)malloc(sizeof(data_t)*(rs->nn+1));
 41 |   if(rs->index_of == NULL){
 42 |     free(rs->alpha_to);
 43 |     free(rs);
 44 |     rs = NULL;
 45 |     goto done;
 46 |   }
 47 | 
 48 |   /* Generate Galois field lookup tables */
 49 |   rs->index_of[0] = A0; /* log(zero) = -inf */
 50 |   rs->alpha_to[A0] = 0; /* alpha**-inf = 0 */
 51 |   sr = 1;
 52 |   for(i=0;i<rs->nn;i++){
 53 |     rs->index_of[sr] = i;
 54 |     rs->alpha_to[i] = sr;
 55 |     sr <<= 1;
 56 |     if(sr & (1<<symsize))
 57 |       sr ^= gfpoly;
 58 |     sr &= rs->nn;
 59 |   }
 60 |   if(sr != 1){
 61 |     /* field generator polynomial is not primitive! */
 62 |     free(rs->alpha_to);
 63 |     free(rs->index_of);
 64 |     free(rs);
 65 |     rs = NULL;
 66 |     goto done;
 67 |   }
 68 | 
 69 |   /* Form RS code generator polynomial from its roots */
 70 |   rs->genpoly = (data_t *)malloc(sizeof(data_t)*(nroots+1));
 71 |   if(rs->genpoly == NULL){
 72 |     free(rs->alpha_to);
 73 |     free(rs->index_of);
 74 |     free(rs);
 75 |     rs = NULL;
 76 |     goto done;
 77 |   }
 78 |   rs->fcr = fcr;
 79 |   rs->prim = prim;
 80 |   rs->nroots = nroots;
 81 | 
 82 |   /* Find prim-th root of 1, used in decoding */
 83 |   for(iprim=1;(iprim % prim) != 0;iprim += rs->nn)
 84 |     ;
 85 |   rs->iprim = iprim / prim;
 86 | 
 87 |   rs->genpoly[0] = 1;
 88 |   for (i = 0,root=fcr*prim; i < nroots; i++,root += prim) {
 89 |     rs->genpoly[i+1] = 1;
 90 | 
 91 |     /* Multiply rs->genpoly[] by  @**(root + x) */
 92 |     for (j = i; j > 0; j--){
 93 |       if (rs->genpoly[j] != 0)
 94 | 	rs->genpoly[j] = rs->genpoly[j-1] ^ rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[j]] + root)];
 95 |       else
 96 | 	rs->genpoly[j] = rs->genpoly[j-1];
 97 |     }
 98 |     /* rs->genpoly[0] can never be zero */
 99 |     rs->genpoly[0] = rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[0]] + root)];
100 |   }
101 |   /* convert rs->genpoly[] to index form for quicker encoding */
102 |   for (i = 0; i <= nroots; i++)
103 |     rs->genpoly[i] = rs->index_of[rs->genpoly[i]];
104 |  done:;
105 | 
106 | }
107 | 


--------------------------------------------------------------------------------
/imagewriter.cpp:
--------------------------------------------------------------------------------
  1 | #include "imagewriter.hpp"
  2 | void ImageWriter::start() {
  3 |   // TODO: Add multiple of 8 check
  4 |   bytesPerImage = width * height / (chunkSize * chunkSize);
  5 | 
  6 |   currentByte  = 0;
  7 |   currentImage = 0;
  8 |   try {
  9 |     if(std::filesystem::exists(wd))
 10 |       std::filesystem::remove_all(wd);
 11 |     std::filesystem::create_directory(wd);
 12 |   } catch(const std::exception &e) {
 13 |     std::cout << e.what() << "\n";
 14 |     exit(1);
 15 |   }
 16 | }
 17 | void ImageWriter::writeData(char *data, size_t size) {
 18 |   size_t dataRemaining = size;
 19 | 
 20 |   do {
 21 |     size_t bytesFreeInImage = bytesPerImage - currentImageData.size();
 22 | 
 23 |     if(bytesFreeInImage != 0) {
 24 |       size_t bytesToWrite = std::min(bytesFreeInImage, dataRemaining);
 25 |       currentImageData.insert(
 26 |           currentImageData.end(), data, data + bytesToWrite);
 27 |       data += bytesToWrite;
 28 |       dataRemaining -= bytesToWrite;
 29 | 
 30 |     } else {
 31 |       flushImage();
 32 |     }
 33 |   } while(dataRemaining != 0);
 34 | }
 35 | 
 36 | void ImageWriter::flushImage() {
 37 |   currentImageData.resize(bytesPerImage);
 38 | 
 39 |   // Create a vector that stores the final image
 40 |   std::vector<char> image;
 41 | 
 42 |   image.resize(width * height);
 43 | 
 44 |   // Lambda function to address a pixel
 45 | 
 46 |   auto setPixel = [&image, this](size_t x, size_t y, bool state) {
 47 |     size_t i = y * width + x;
 48 | 
 49 |     unsigned char c = 0;
 50 |     if(state)
 51 |       c = 255;
 52 | 
 53 |     image[i] = c;
 54 |   };
 55 | 
 56 |   auto setChunk = [this, &setPixel](size_t x, size_t y, unsigned char data) {
 57 |     for(size_t j = 0; j < chunkSize; j++) {
 58 |       for(size_t i = 0; i < 8; i++) {
 59 |         unsigned char val = (data >> i) & 0b00000001;
 60 |         setPixel((x * chunkSize) + i, (y * chunkSize) + j, val * 255);
 61 |       }
 62 |     }
 63 |   };
 64 |   size_t chunk          = 0;
 65 |   auto   writeNextChunk = [this, &setChunk, &chunk](char val) {
 66 |     size_t x = chunk % (width / chunkSize);
 67 |     size_t y = chunk / (width / chunkSize);
 68 |     setChunk(x, y, val);
 69 |     chunk++;
 70 |   };
 71 | 
 72 |   for(const char &byte : currentImageData) {
 73 |     writeNextChunk(byte);
 74 |   }
 75 |   char t[32];
 76 |   sprintf(t, "%05zu", currentImage++);
 77 |   std::string number = t;
 78 | 
 79 |   std::string           fileName = number + ".png";
 80 |   std::filesystem::path filePath = wd / fileName;
 81 |   stbi_write_png(filePath.string().c_str(), width, height, 1, &image[0], width);
 82 |   currentImageData.resize(0);
 83 | }
 84 | 
 85 | void ImageWriter::end() {
 86 |   // TODO: Mark data ending with something or have a header
 87 |   flushImage();
 88 |   std::filesystem::path fullWdPath = wd / "%05d.png";
 89 | 
 90 |   std::string command = ffmpegName + " -y -framerate 1 -i \""
 91 |                         + fullWdPath.string() + "\" -c:v libx264 \""
 92 |                         + fileOutputPath.string() + "\"";
 93 |   cmdRunner.runCommand(command);
 94 | 
 95 |   std::string log;
 96 | 
 97 |   do {
 98 |     std::string part = cmdRunner.readAvail();
 99 |     log += part;
100 | 
101 |   } while(cmdRunner.readable());
102 |   cmdRunner.close();
103 | }
104 | 
105 | void ImageWriter::setOutputFile(const std::string &path) {
106 |   fileOutputPath = path;
107 | }
108 | 


--------------------------------------------------------------------------------
/external/fec/exercise.c:
--------------------------------------------------------------------------------
  1 | /* Exercise an RS codec a specified number of times using random
  2 |  * data and error patterns
  3 |  *
  4 |  * Copyright 2002 Phil Karn, KA9Q
  5 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
  6 |  */
  7 | #define FLAG_ERASURE 1 /* Randomly flag 50% of errors as erasures */
  8 | 
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | 
 13 | #ifdef FIXED
 14 | #include "fixed.h"
 15 | #define EXERCISE exercise_8
 16 | #elif defined(CCSDS)
 17 | #include "fixed.h"
 18 | #include "ccsds.h"
 19 | #define EXERCISE exercise_ccsds
 20 | #elif defined(BIGSYM)
 21 | #include "int.h"
 22 | #define EXERCISE exercise_int
 23 | #else
 24 | #include "char.h"
 25 | #define EXERCISE exercise_char
 26 | #endif
 27 | 
 28 | #ifdef FIXED
 29 | #define PRINTPARM printf("(255,223):");
 30 | #elif defined(CCSDS)
 31 | #define PRINTPARM printf("CCSDS (255,223):");
 32 | #else
 33 | #define PRINTPARM printf("(%d,%d):",rs->nn,rs->nn-rs->nroots);
 34 | #endif
 35 | 
 36 | /* Exercise the RS codec passed as an argument */
 37 | int EXERCISE(
 38 | #if !defined(CCSDS) && !defined(FIXED)
 39 | void *p,
 40 | #endif
 41 | int trials){
 42 | #if !defined(CCSDS) && !defined(FIXED)
 43 |   struct rs *rs = (struct rs *)p;
 44 | #endif
 45 |   data_t block[NN],tblock[NN];
 46 |   int i;
 47 |   int errors;
 48 |   int errlocs[NN];
 49 |   int derrlocs[NROOTS];
 50 |   int derrors;
 51 |   int errval,errloc;
 52 |   int erasures;
 53 |   int decoder_errors = 0;
 54 | 
 55 |   while(trials-- != 0){
 56 |     /* Test up to the error correction capacity of the code */
 57 |     for(errors=0;errors <= NROOTS/2;errors++){
 58 | 
 59 |       /* Load block with random data and encode */
 60 |       for(i=0;i<NN-NROOTS;i++)
 61 | 	block[i] = random() & NN;
 62 |       
 63 | #if defined(CCSDS) || defined(FIXED)
 64 |       ENCODE_RS(&block[0],&block[NN-NROOTS],0);
 65 | #else
 66 |       ENCODE_RS(rs,&block[0],&block[NN-NROOTS]);
 67 | #endif
 68 | 
 69 |       /* Make temp copy, seed with errors */
 70 |       memcpy(tblock,block,sizeof(tblock));
 71 |       memset(errlocs,0,sizeof(errlocs));
 72 |       memset(derrlocs,0,sizeof(derrlocs));
 73 |       erasures=0;
 74 |       for(i=0;i<errors;i++){
 75 | 	do {
 76 | 	  errval = random() & NN;
 77 | 	} while(errval == 0); /* Error value must be nonzero */
 78 | 
 79 | 	do {
 80 | 	  errloc = random() % NN;
 81 | 	} while(errlocs[errloc] != 0); /* Must not choose the same location twice */
 82 | 
 83 | 	errlocs[errloc] = 1;
 84 | 
 85 | #if FLAG_ERASURE
 86 | 	if(random() & 1) /* 50-50 chance */
 87 | 	  derrlocs[erasures++] = errloc;
 88 | #endif
 89 | 	tblock[errloc] ^= errval;
 90 |       }
 91 | 
 92 |       /* Decode the errored block */
 93 | #if defined(CCSDS) || defined(FIXED)
 94 |       derrors = DECODE_RS(tblock,derrlocs,erasures,0);
 95 | #else
 96 |       derrors = DECODE_RS(rs,tblock,derrlocs,erasures);
 97 | #endif
 98 | 
 99 |       if(derrors != errors){
100 | 	PRINTPARM
101 | 	printf(" decoder says %d errors, true number is %d\n",derrors,errors);
102 | 	decoder_errors++;
103 |       }
104 |       for(i=0;i<derrors;i++){
105 | 	if(errlocs[derrlocs[i]] == 0){
106 | 	  PRINTPARM
107 | 	  printf(" decoder indicates error in location %d without error\n",derrlocs[i]);
108 | 	  decoder_errors++;
109 | 	}
110 |       }
111 |       if(memcmp(tblock,block,sizeof(tblock)) != 0){
112 | 	PRINTPARM
113 | 	printf(" uncorrected errors! output ^ input:");
114 | 	decoder_errors++;
115 | 	for(i=0;i<NN;i++)
116 | 	  printf(" %02x",tblock[i] ^ block[i]);
117 | 	printf("\n");
118 |       }
119 |     }
120 |   }
121 |   return decoder_errors;
122 | }
123 | 


--------------------------------------------------------------------------------
/external/fec/README:
--------------------------------------------------------------------------------
  1 | COPYRIGHT
  2 | 
  3 | This package is copyright 2006 by Phil Karn, KA9Q. It may be used
  4 | under the terms of the GNU Lesser General Public License (LGPL). See
  5 | the file "lesser.txt" in this package for license details.
  6 | 
  7 | INTRODUCTION
  8 | 
  9 | This package provides a set of functions that implement several
 10 | popular forward error correction (FEC) algorithms and several low-level routines
 11 | useful in modems implemented with digital signal processing (DSP).
 12 | 
 13 | The following routines are provided:
 14 | 
 15 | 1. Viterbi decoders for the following convolutional codes:
 16 | 
 17 | r=1/2 k=7 ("Voyager" code, now a widely used industry standard)
 18 | r=1/2 k=9 (Used on the IS-95 CDMA forward link)
 19 | r=1/6 k=15 ("Cassini" code, used by several NASA/JPL deep space missions)
 20 | 
 21 | 2. Reed-Solomon encoders and decoders for any user-specified code.
 22 | 
 23 | 3. Optimized encoder and decoder for the CCSDS-standard (255,223)
 24 | Reed-Solomon code, with and without the CCSDS-standard "dual basis"
 25 | symbol representation.
 26 | 
 27 | 4. Compute dot product between a 16-bit buffer and a set of 16-bit
 28 | coefficients. This is the basic DSP primitive for digital filtering
 29 | and correlation.
 30 | 
 31 | 4. Compute sum of squares of a buffer of 16-bit signed integers. This is
 32 | useful in DSP for finding the total energy in a signal.
 33 | 
 34 | 5. Find peak value in a buffer of 16-bit signed integers, useful for
 35 | scaling a signal to prevent overflow.
 36 | 
 37 | SIMD SUPPORT
 38 | 
 39 | This package automatically makes use of various SIMD (Single
 40 | Instruction stream, Multiple Data stream) instruction sets, when
 41 | available: MMX, SSE and SSE2 on the IA-32 (Intel) architecture, and
 42 | Altivec on the PowerPC G4 and G5 used by Power Macintoshes.
 43 | 
 44 | "Altivec" is a Motorola trademark; Apple calls it "Velocity Engine",
 45 | and IBM calls it "VMX". Altivec is roughly comparable to SSE2 on the
 46 | IA-32.
 47 | 
 48 | Many of the SIMD versions run more than an order of
 49 | magnitude faster than their portable C versions. The available SIMD
 50 | instruction sets, if any, are determined at run time and the proper
 51 | version of each routine is automatically selected. If no SIMD
 52 | instructions are available, the portable C version is invoked by
 53 | default. On targets other than IA-32 and PPC, only the portable C
 54 | version is built.
 55 | 
 56 | The SIMD-assisted versions generally produce the same results as the C
 57 | versions, with a few minor exceptions. The Viterbi decoders in C have
 58 | a very slightly greater Eb/No performance due to their use of 32-bit
 59 | path metrics. On the other hand, the SIMD versions use the
 60 | "saturating" arithmetic available in these instructions to avoid the
 61 | integer wraparounds that can occur in C when argument ranges are not
 62 | properly constrained. This applies primarily to the "dotprod" (dot
 63 | product) function.
 64 | 
 65 | The MMX (MultiMedia eXtensions) instruction set was introduced on
 66 | later Pentium CPUs; it is also implemented on the Pentium II and most
 67 | AMD CPUs starting with the K6. SSE (SIMD Streaming Extensions) was
 68 | introduced in the Pentium III; AMD calls it "3D Now! Professional".
 69 | Intel introduced SSE2 on the Pentium 4, and it has been picked up by
 70 | later AMD CPUs. SSE support implies MMX support, while SSE2 support
 71 | implies both SSE and MMX support.
 72 | 
 73 | The latest IA-32 SIMD instruction set, SSE3 (also known as "Prescott
 74 | New Instructions") was introduced in early 2004 with the latest
 75 | ("Prescott") revision of the Pentium 4. Relatively little was
 76 | introduced with SSE3, and this library currently makes no use of it.
 77 | 
 78 | See the various manual pages for details on how to use the library
 79 | routines.
 80 | 
 81 | Copyright 2006, Phil Karn, KA9Q
 82 | karn@ka9q.net
 83 | http://www.ka9q.net/
 84 | 
 85 | This software may be used under the terms of the GNU Lesser General
 86 | Public License (LGPL); see the file lesser.txt for details.
 87 | 
 88 | Revision history:
 89 | Version 1.0 released 29 May 2001
 90 | 
 91 | Version 2.0 released 3 Dec 2001:
 92 | Restructured to add support for shared libraries.
 93 | 
 94 | Version 2.0.1 released 8 Dec 2001:
 95 | Includes autoconf/configure script
 96 | 
 97 | Version 2.0.2 released 4 Feb 2002:
 98 | Add SIMD version override options
 99 | Test for lack of SSE2 mnemonic support in 'as'
100 | Build only selected version
101 | 
102 | Version 2.0.3 released 6 Feb 2002:
103 | Fix to parityb function in parity.h
104 | 
105 | feclib version 1.0 released November 2003
106 | Merged SIMD-Viterbi, RS and DSP libraries
107 | Changed SIMD Viterbi decoder to detect SSE2/SSE/MMX at runtime rather than build time
108 | 
109 | feclib version 2.0 (unreleased) Mar 2004
110 | General speedups and cleanups
111 | Switch from 4 to 8-bit input symbols on all Viterbi decoders
112 | Support for Altivec on PowerPC
113 | Support for k=15 r=1/6 Cassini/Mars Pathfinder/Mars Exploration Rover/STEREO code
114 | Changed license to GNU Lesser General Public License (LGPL)
115 | 
116 | feclib version 2.1 June 5 2006
117 | Added error checking, fixed alignment bug in SSE2 versions of Viterbi decoders causing segfaults
118 | 
119 | feclib version 2.1.1 June 6 2006
120 | Fix test/benchmark time measurement on Linux
121 | 


--------------------------------------------------------------------------------
/PygaGui.glade:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <!-- Generated with glade 3.22.1 -->
  3 | <interface>
  4 |   <requires lib="gtk+" version="3.20"/>
  5 |   <object class="GtkWindow" id="window">
  6 |     <property name="can_focus">False</property>
  7 |     <property name="title" translatable="yes">PygaMasher</property>
  8 |     <property name="default_width">300</property>
  9 |     <property name="default_height">120</property>
 10 |     <child>
 11 |       <placeholder/>
 12 |     </child>
 13 |     <child>
 14 |       <object class="GtkBox">
 15 |         <property name="visible">True</property>
 16 |         <property name="can_focus">False</property>
 17 |         <property name="margin_left">5</property>
 18 |         <property name="margin_right">5</property>
 19 |         <property name="margin_top">5</property>
 20 |         <property name="margin_bottom">5</property>
 21 |         <property name="orientation">vertical</property>
 22 |         <property name="spacing">5</property>
 23 |         <child>
 24 |           <object class="GtkGrid">
 25 |             <property name="visible">True</property>
 26 |             <property name="can_focus">False</property>
 27 |             <property name="row_spacing">5</property>
 28 |             <property name="column_spacing">5</property>
 29 |             <child>
 30 |               <object class="GtkLabel">
 31 |                 <property name="visible">True</property>
 32 |                 <property name="can_focus">False</property>
 33 |                 <property name="label" translatable="yes">Open File</property>
 34 |               </object>
 35 |               <packing>
 36 |                 <property name="left_attach">0</property>
 37 |                 <property name="top_attach">0</property>
 38 |               </packing>
 39 |             </child>
 40 |             <child>
 41 |               <object class="GtkLabel">
 42 |                 <property name="visible">True</property>
 43 |                 <property name="can_focus">False</property>
 44 |                 <property name="label" translatable="yes">Save File</property>
 45 |               </object>
 46 |               <packing>
 47 |                 <property name="left_attach">0</property>
 48 |                 <property name="top_attach">1</property>
 49 |               </packing>
 50 |             </child>
 51 |             <child>
 52 |               <object class="GtkFileChooserButton" id="fileLoadButton">
 53 |                 <property name="visible">True</property>
 54 |                 <property name="can_focus">False</property>
 55 |                 <property name="hexpand">True</property>
 56 |                 <property name="title" translatable="yes">File to Load</property>
 57 |               </object>
 58 |               <packing>
 59 |                 <property name="left_attach">2</property>
 60 |                 <property name="top_attach">0</property>
 61 |               </packing>
 62 |             </child>
 63 |             <child>
 64 |               <object class="GtkEntry" id="savePathEntry">
 65 |                 <property name="visible">True</property>
 66 |                 <property name="can_focus">True</property>
 67 |               </object>
 68 |               <packing>
 69 |                 <property name="left_attach">1</property>
 70 |                 <property name="top_attach">1</property>
 71 |               </packing>
 72 |             </child>
 73 |             <child>
 74 |               <object class="GtkButton" id="setPathButton">
 75 |                 <property name="label" translatable="yes">Set save path</property>
 76 |                 <property name="visible">True</property>
 77 |                 <property name="can_focus">True</property>
 78 |                 <property name="receives_default">True</property>
 79 |               </object>
 80 |               <packing>
 81 |                 <property name="left_attach">2</property>
 82 |                 <property name="top_attach">1</property>
 83 |               </packing>
 84 |             </child>
 85 |             <child>
 86 |               <placeholder/>
 87 |             </child>
 88 |           </object>
 89 |           <packing>
 90 |             <property name="expand">True</property>
 91 |             <property name="fill">True</property>
 92 |             <property name="position">0</property>
 93 |           </packing>
 94 |         </child>
 95 |         <child>
 96 |           <object class="GtkRadioButton" id="recoverRadio">
 97 |             <property name="label" translatable="yes">recover</property>
 98 |             <property name="visible">True</property>
 99 |             <property name="can_focus">True</property>
100 |             <property name="receives_default">False</property>
101 |             <property name="active">True</property>
102 |             <property name="draw_indicator">True</property>
103 |           </object>
104 |           <packing>
105 |             <property name="expand">False</property>
106 |             <property name="fill">True</property>
107 |             <property name="position">2</property>
108 |           </packing>
109 |         </child>
110 |         <child>
111 |           <object class="GtkRadioButton" id="mashRadio">
112 |             <property name="label" translatable="yes">mash</property>
113 |             <property name="visible">True</property>
114 |             <property name="can_focus">True</property>
115 |             <property name="receives_default">False</property>
116 |             <property name="draw_indicator">True</property>
117 |             <property name="group">recoverRadio</property>
118 |           </object>
119 |           <packing>
120 |             <property name="expand">False</property>
121 |             <property name="fill">True</property>
122 |             <property name="position">3</property>
123 |           </packing>
124 |         </child>
125 |         <child>
126 |           <object class="GtkButton" id="startButton">
127 |             <property name="label" translatable="yes">Start</property>
128 |             <property name="visible">True</property>
129 |             <property name="can_focus">True</property>
130 |             <property name="receives_default">True</property>
131 |           </object>
132 |           <packing>
133 |             <property name="expand">False</property>
134 |             <property name="fill">True</property>
135 |             <property name="position">4</property>
136 |           </packing>
137 |         </child>
138 |       </object>
139 |     </child>
140 |   </object>
141 | </interface>
142 | 


--------------------------------------------------------------------------------
/external/fec/rstest.cpp:
--------------------------------------------------------------------------------
  1 | /* Test the Reed-Solomon codecs
  2 |  * for various block sizes and with random data and random error patterns
  3 |  *
  4 |  * Copyright 2002 Phil Karn, KA9Q
  5 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
  6 |  */
  7 | 
  8 | #include <array>
  9 | #include <memory.h>
 10 | #include <stdio.h>
 11 | #include <stdlib.h>
 12 | #include <time.h>
 13 | extern "C" {
 14 | #include "fec.h"
 15 | };
 16 | 
 17 | template<size_t symsize, size_t nroots>
 18 | class RsCodec {
 19 | public:
 20 |   RsCodec(int genpoly = 0x187, int fcs = 112, int prim = 11) {
 21 |     rs = init_rs_char(symsize, genpoly, fcs, prim, nroots, 0);
 22 |   };
 23 |   ~RsCodec() { free_rs_char(rs); }
 24 | 
 25 |   static constexpr int nn = (1 << symsize) - 1, kk = nn - nroots;
 26 | 
 27 |   void encode(std::array<unsigned char, nn> &block) {
 28 |     encode_rs_char(rs, &block[0], &block[kk]);
 29 |   }
 30 |   void decode(std::array<unsigned char, nn> &block) {
 31 |     errorStatistics.errlocs.fill(0);
 32 |     errorStatistics.errors =
 33 |         decode_rs_char(rs, &block[0], &errorStatistics.errlocs[0], 0);
 34 |   }
 35 | 
 36 |   template<size_t nn>
 37 |   struct ErrorStatistics {
 38 |     std::array<int, nn> errlocs;
 39 |     int                 errors;
 40 |   };
 41 | 
 42 | private:
 43 |   ErrorStatistics<nn>           errorStatistics;
 44 |   void *                        rs;
 45 |   std::array<unsigned char, nn> block;
 46 | 
 47 | public:
 48 |   const ErrorStatistics<nn> &getErrorStatistics() { return errorStatistics; }
 49 | };
 50 | 
 51 | RsCodec<8, 32> block;
 52 | 
 53 | #include <iostream>
 54 | 
 55 | int main() {
 56 |   std::array<unsigned char, 255> data;
 57 |   data.fill(0);
 58 | 
 59 |   data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 13, 37};
 60 | 
 61 |   block.encode(data);
 62 | 
 63 |   data[0]   = 9;
 64 |   data[254] = 2;
 65 | 
 66 |   block.decode(data);
 67 | 
 68 |   for(const auto &elem : data)
 69 |     std::cout << std::to_string(elem) << std::endl;
 70 | 
 71 |   std::cout << "Errors " << block.getErrorStatistics().errors << std::endl;
 72 | }
 73 | 
 74 | //
 75 | // struct etab {
 76 | //   int symsize;
 77 | //   int genpoly;
 78 | //   int fcs;
 79 | //   int prim;
 80 | //   int nroots;
 81 | //   int ntrials;
 82 | // } Tab[] = {
 83 | //     {2, 0x7, 1, 1, 1, 10},
 84 | //     {3, 0xb, 1, 1, 2, 10},
 85 | //     {4, 0x13, 1, 1, 4, 10},
 86 | //     {5, 0x25, 1, 1, 6, 10},
 87 | //     {6, 0x43, 1, 1, 8, 10},
 88 | //     {7, 0x89, 1, 1, 10, 10},
 89 | //     {8, 0x11d, 1, 1, 32, 10},
 90 | //     {8, 0x187, 112, 11, 32, 10}, /* Duplicates CCSDS codec */
 91 | //     {9, 0x211, 1, 1, 32, 10},
 92 | //     {10, 0x409, 1, 1, 32, 10},
 93 | //     {11, 0x805, 1, 1, 32, 10},
 94 | //     {12, 0x1053, 1, 1, 32, 5},
 95 | //     {13, 0x201b, 1, 1, 32, 2},
 96 | //     {14, 0x4443, 1, 1, 32, 1},
 97 | //     {15, 0x8003, 1, 1, 32, 1},
 98 | //     {16, 0x1100b, 1, 1, 32, 1},
 99 | //     {0, 0, 0, 0, 0},
100 | // };
101 | //
102 | // int exercise_char(struct etab *e);
103 | //
104 | // int main() {
105 | //   int i;
106 | //
107 | //   srandom(time(NULL));
108 | //   for(i = 0; Tab[i].symsize != 0; i++) {
109 | //     int nn, kk;
110 | //
111 | //     nn = (1 << Tab[i].symsize) - 1;
112 | //     printf("Loop %d Testing (%d,%d) code...\n", i, nn, kk);
113 | //     if(Tab[i].symsize <= 8)
114 | //       exercise_char(&Tab[i]);
115 | //   }
116 | //   exit(0);
117 | // }
118 | //
119 | // int exercise_char(struct etab *e) {
120 | //   int           nn = (1 << e->symsize) - 1;
121 | //   unsigned char block[nn], tblock[nn];
122 | //   int           errlocs[nn], derrlocs[nn];
123 | //   int           i;
124 | //   int           errors;
125 | //   int           derrors, kk;
126 | //   int           errval, errloc;
127 | //   int           erasures;
128 | //   int           decoder_errors = 0;
129 | //   void *        rs;
130 | //
131 | //   if(e->symsize > 8)
132 | //     return -1;
133 | //
134 | //   /* Compute code parameters */
135 | //   kk = nn - e->nroots;
136 | //
137 | //   rs = init_rs_char(e->symsize, e->genpoly, e->fcs, e->prim, e->nroots, 0);
138 | //   if(rs == NULL) {
139 | //     printf("init_rs_char failed!\n");
140 | //     return -1;
141 | //   }
142 | //   /* Test up to the error correction capacity of the code */
143 | //   for(errors = 0; errors <= e->nroots / 2; errors++) {
144 | //     /* Load block with random data and encode */
145 | //     for(i = 0; i < kk; i++)
146 | //       block[i] = random() & nn;
147 | //     memcpy(tblock, block, sizeof(block));
148 | //     encode_rs_char(rs, block, &block[kk]);
149 | //
150 | //     /* Make temp copy, seed with errors */
151 | //     memcpy(tblock, block, sizeof(block));
152 | //     memset(errlocs, 0, sizeof(errlocs));
153 | //     memset(derrlocs, 0, sizeof(derrlocs));
154 | //     erasures = 0;
155 | //     for(i = 0; i < errors; i++) {
156 | //       do {
157 | //         errval = random() & nn;
158 | //       } while(errval == 0); /* Error value must be nonzero */
159 | //
160 | //       do {
161 | //         errloc = random() % nn;
162 | //       } while(errlocs[errloc]
163 | //               != 0); /* Must not choose the same location twice */
164 | //
165 | //       errlocs[errloc] = 1;
166 | //
167 | // #if FLAG_ERASURE
168 | //       if(random() & 1) /* 50-50 chance */
169 | //         derrlocs[erasures++] = errloc;
170 | // #endif
171 | //       tblock[errloc] ^= errval;
172 | //     }
173 | //
174 | //     /* Decode the errored block */
175 | //     derrors = decode_rs_char(rs, tblock, derrlocs, erasures);
176 | //
177 | //     if(derrors != errors) {
178 | //       printf("(%d,%d) decoder says %d errors, true number is %d\n",
179 | //              nn,
180 | //              kk,
181 | //              derrors,
182 | //              errors);
183 | //       decoder_errors++;
184 | //     }
185 | //     for(i = 0; i < derrors; i++) {
186 | //       if(errlocs[derrlocs[i]] == 0) {
187 | //         printf("(%d,%d) decoder indicates error in location %d without
188 | //         error\n",
189 | //                nn,
190 | //                kk,
191 | //                derrlocs[i]);
192 | //         decoder_errors++;
193 | //       }
194 | //     }
195 | //     if(memcmp(tblock, block, sizeof(tblock)) != 0) {
196 | //       printf("(%d,%d) decoder uncorrected errors! output ^ input:", nn, kk);
197 | //       decoder_errors++;
198 | //       for(i = 0; i < nn; i++)
199 | //         printf(" %02x", tblock[i] ^ block[i]);
200 | //       printf("\n");
201 | //     }
202 | //   }
203 | //
204 | //   free_rs_char(rs);
205 | //   return 0;
206 | // }
207 | 


--------------------------------------------------------------------------------
/external/fec/decode_rs.c:
--------------------------------------------------------------------------------
  1 | /* Reed-Solomon decoder
  2 |  * Copyright 2002 Phil Karn, KA9Q
  3 |  * May be used under the terms of the GNU Lesser General Public License (LGPL)
  4 |  */
  5 | 
  6 | #ifdef DEBUG
  7 | #include <stdio.h>
  8 | #endif
  9 | 
 10 | #include <string.h>
 11 | 
 12 | #define NULL ((void *)0)
 13 | #define	min(a,b)	((a) < (b) ? (a) : (b))
 14 | 
 15 | #ifdef FIXED
 16 | #include "fixed.h"
 17 | #elif defined(BIGSYM)
 18 | #include "int.h"
 19 | #else
 20 | #include "char.h"
 21 | #endif
 22 | 
 23 | int DECODE_RS(
 24 | #ifdef FIXED
 25 | data_t *data, int *eras_pos, int no_eras,int pad){
 26 | #else
 27 | void *p,data_t *data, int *eras_pos, int no_eras){
 28 |   struct rs *rs = (struct rs *)p;
 29 | #endif
 30 |   int deg_lambda, el, deg_omega;
 31 |   int i, j, r,k;
 32 |   data_t u,q,tmp,num1,num2,den,discr_r;
 33 |   data_t lambda[NROOTS+1], s[NROOTS];	/* Err+Eras Locator poly
 34 | 					 * and syndrome poly */
 35 |   data_t b[NROOTS+1], t[NROOTS+1], omega[NROOTS+1];
 36 |   data_t root[NROOTS], reg[NROOTS+1], loc[NROOTS];
 37 |   int syn_error, count;
 38 | 
 39 | #ifdef FIXED
 40 |   /* Check pad parameter for validity */
 41 |   if(pad < 0 || pad >= NN)
 42 |     return -1;
 43 | #endif
 44 | 
 45 |   /* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
 46 |   for(i=0;i<NROOTS;i++)
 47 |     s[i] = data[0];
 48 | 
 49 |   for(j=1;j<NN-PAD;j++){
 50 |     for(i=0;i<NROOTS;i++){
 51 |       if(s[i] == 0){
 52 | 	s[i] = data[j];
 53 |       } else {
 54 | 	s[i] = data[j] ^ ALPHA_TO[MODNN(INDEX_OF[s[i]] + (FCR+i)*PRIM)];
 55 |       }
 56 |     }
 57 |   }
 58 | 
 59 |   /* Convert syndromes to index form, checking for nonzero condition */
 60 |   syn_error = 0;
 61 |   for(i=0;i<NROOTS;i++){
 62 |     syn_error |= s[i];
 63 |     s[i] = INDEX_OF[s[i]];
 64 |   }
 65 | 
 66 |   if (!syn_error) {
 67 |     /* if syndrome is zero, data[] is a codeword and there are no
 68 |      * errors to correct. So return data[] unmodified
 69 |      */
 70 |     count = 0;
 71 |     goto finish;
 72 |   }
 73 |   memset(&lambda[1],0,NROOTS*sizeof(lambda[0]));
 74 |   lambda[0] = 1;
 75 | 
 76 |   if (no_eras > 0) {
 77 |     /* Init lambda to be the erasure locator polynomial */
 78 |     lambda[1] = ALPHA_TO[MODNN(PRIM*(NN-1-eras_pos[0]))];
 79 |     for (i = 1; i < no_eras; i++) {
 80 |       u = MODNN(PRIM*(NN-1-eras_pos[i]));
 81 |       for (j = i+1; j > 0; j--) {
 82 | 	tmp = INDEX_OF[lambda[j - 1]];
 83 | 	if(tmp != A0)
 84 | 	  lambda[j] ^= ALPHA_TO[MODNN(u + tmp)];
 85 |       }
 86 |     }
 87 | 
 88 | #if DEBUG >= 1
 89 |     /* Test code that verifies the erasure locator polynomial just constructed
 90 |        Needed only for decoder debugging. */
 91 |     
 92 |     /* find roots of the erasure location polynomial */
 93 |     for(i=1;i<=no_eras;i++)
 94 |       reg[i] = INDEX_OF[lambda[i]];
 95 | 
 96 |     count = 0;
 97 |     for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
 98 |       q = 1;
 99 |       for (j = 1; j <= no_eras; j++)
100 | 	if (reg[j] != A0) {
101 | 	  reg[j] = MODNN(reg[j] + j);
102 | 	  q ^= ALPHA_TO[reg[j]];
103 | 	}
104 |       if (q != 0)
105 | 	continue;
106 |       /* store root and error location number indices */
107 |       root[count] = i;
108 |       loc[count] = k;
109 |       count++;
110 |     }
111 |     if (count != no_eras) {
112 |       printf("count = %d no_eras = %d\n lambda(x) is WRONG\n",count,no_eras);
113 |       count = -1;
114 |       goto finish;
115 |     }
116 | #if DEBUG >= 2
117 |     printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n");
118 |     for (i = 0; i < count; i++)
119 |       printf("%d ", loc[i]);
120 |     printf("\n");
121 | #endif
122 | #endif
123 |   }
124 |   for(i=0;i<NROOTS+1;i++)
125 |     b[i] = INDEX_OF[lambda[i]];
126 |   
127 |   /*
128 |    * Begin Berlekamp-Massey algorithm to determine error+erasure
129 |    * locator polynomial
130 |    */
131 |   r = no_eras;
132 |   el = no_eras;
133 |   while (++r <= NROOTS) {	/* r is the step number */
134 |     /* Compute discrepancy at the r-th step in poly-form */
135 |     discr_r = 0;
136 |     for (i = 0; i < r; i++){
137 |       if ((lambda[i] != 0) && (s[r-i-1] != A0)) {
138 | 	discr_r ^= ALPHA_TO[MODNN(INDEX_OF[lambda[i]] + s[r-i-1])];
139 |       }
140 |     }
141 |     discr_r = INDEX_OF[discr_r];	/* Index form */
142 |     if (discr_r == A0) {
143 |       /* 2 lines below: B(x) <-- x*B(x) */
144 |       memmove(&b[1],b,NROOTS*sizeof(b[0]));
145 |       b[0] = A0;
146 |     } else {
147 |       /* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
148 |       t[0] = lambda[0];
149 |       for (i = 0 ; i < NROOTS; i++) {
150 | 	if(b[i] != A0)
151 | 	  t[i+1] = lambda[i+1] ^ ALPHA_TO[MODNN(discr_r + b[i])];
152 | 	else
153 | 	  t[i+1] = lambda[i+1];
154 |       }
155 |       if (2 * el <= r + no_eras - 1) {
156 | 	el = r + no_eras - el;
157 | 	/*
158 | 	 * 2 lines below: B(x) <-- inv(discr_r) *
159 | 	 * lambda(x)
160 | 	 */
161 | 	for (i = 0; i <= NROOTS; i++)
162 | 	  b[i] = (lambda[i] == 0) ? A0 : MODNN(INDEX_OF[lambda[i]] - discr_r + NN);
163 |       } else {
164 | 	/* 2 lines below: B(x) <-- x*B(x) */
165 | 	memmove(&b[1],b,NROOTS*sizeof(b[0]));
166 | 	b[0] = A0;
167 |       }
168 |       memcpy(lambda,t,(NROOTS+1)*sizeof(t[0]));
169 |     }
170 |   }
171 | 
172 |   /* Convert lambda to index form and compute deg(lambda(x)) */
173 |   deg_lambda = 0;
174 |   for(i=0;i<NROOTS+1;i++){
175 |     lambda[i] = INDEX_OF[lambda[i]];
176 |     if(lambda[i] != A0)
177 |       deg_lambda = i;
178 |   }
179 |   /* Find roots of the error+erasure locator polynomial by Chien search */
180 |   memcpy(&reg[1],&lambda[1],NROOTS*sizeof(reg[0]));
181 |   count = 0;		/* Number of roots of lambda(x) */
182 |   for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
183 |     q = 1; /* lambda[0] is always 0 */
184 |     for (j = deg_lambda; j > 0; j--){
185 |       if (reg[j] != A0) {
186 | 	reg[j] = MODNN(reg[j] + j);
187 | 	q ^= ALPHA_TO[reg[j]];
188 |       }
189 |     }
190 |     if (q != 0)
191 |       continue; /* Not a root */
192 |     /* store root (index-form) and error location number */
193 | #if DEBUG>=2
194 |     printf("count %d root %d loc %d\n",count,i,k);
195 | #endif
196 |     root[count] = i;
197 |     loc[count] = k;
198 |     /* If we've already found max possible roots,
199 |      * abort the search to save time
200 |      */
201 |     if(++count == deg_lambda)
202 |       break;
203 |   }
204 |   if (deg_lambda != count) {
205 |     /*
206 |      * deg(lambda) unequal to number of roots => uncorrectable
207 |      * error detected
208 |      */
209 |     count = -1;
210 |     goto finish;
211 |   }
212 |   /*
213 |    * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
214 |    * x**NROOTS). in index form. Also find deg(omega).
215 |    */
216 |   deg_omega = deg_lambda-1;
217 |   for (i = 0; i <= deg_omega;i++){
218 |     tmp = 0;
219 |     for(j=i;j >= 0; j--){
220 |       if ((s[i - j] != A0) && (lambda[j] != A0))
221 | 	tmp ^= ALPHA_TO[MODNN(s[i - j] + lambda[j])];
222 |     }
223 |     omega[i] = INDEX_OF[tmp];
224 |   }
225 | 
226 |   /*
227 |    * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
228 |    * inv(X(l))**(FCR-1) and den = lambda_pr(inv(X(l))) all in poly-form
229 |    */
230 |   for (j = count-1; j >=0; j--) {
231 |     num1 = 0;
232 |     for (i = deg_omega; i >= 0; i--) {
233 |       if (omega[i] != A0)
234 | 	num1  ^= ALPHA_TO[MODNN(omega[i] + i * root[j])];
235 |     }
236 |     num2 = ALPHA_TO[MODNN(root[j] * (FCR - 1) + NN)];
237 |     den = 0;
238 |     
239 |     /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
240 |     for (i = min(deg_lambda,NROOTS-1) & ~1; i >= 0; i -=2) {
241 |       if(lambda[i+1] != A0)
242 | 	den ^= ALPHA_TO[MODNN(lambda[i+1] + i * root[j])];
243 |     }
244 | #if DEBUG >= 1
245 |     if (den == 0) {
246 |       printf("\n ERROR: denominator = 0\n");
247 |       count = -1;
248 |       goto finish;
249 |     }
250 | #endif
251 |     /* Apply error to data */
252 |     if (num1 != 0 && loc[j] >= PAD) {
253 |       data[loc[j]-PAD] ^= ALPHA_TO[MODNN(INDEX_OF[num1] + INDEX_OF[num2] + NN - INDEX_OF[den])];
254 |     }
255 |   }
256 |  finish:
257 |   if(eras_pos != NULL){
258 |     for(i=0;i<count;i++)
259 |       eras_pos[i] = loc[i];
260 |   }
261 |   return count;
262 | }
263 | 


--------------------------------------------------------------------------------
/external/fec/decode_rs.h:
--------------------------------------------------------------------------------
  1 | /* The guts of the Reed-Solomon decoder, meant to be #included
  2 |  * into a function body with the following typedefs, macros and variables supplied
  3 |  * according to the code parameters:
  4 | 
  5 |  * data_t - a typedef for the data symbol
  6 |  * data_t data[] - array of NN data and parity symbols to be corrected in place
  7 |  * retval - an integer lvalue into which the decoder's return code is written
  8 |  * NROOTS - the number of roots in the RS code generator polynomial,
  9 |  *          which is the same as the number of parity symbols in a block.
 10 |             Integer variable or literal.
 11 |  * NN - the total number of symbols in a RS block. Integer variable or literal.
 12 |  * PAD - the number of pad symbols in a block. Integer variable or literal.
 13 |  * ALPHA_TO - The address of an array of NN elements to convert Galois field
 14 |  *            elements in index (log) form to polynomial form. Read only.
 15 |  * INDEX_OF - The address of an array of NN elements to convert Galois field
 16 |  *            elements in polynomial form to index (log) form. Read only.
 17 |  * MODNN - a function to reduce its argument modulo NN. May be inline or a macro.
 18 |  * FCR - An integer literal or variable specifying the first consecutive root of the
 19 |  *       Reed-Solomon generator polynomial. Integer variable or literal.
 20 |  * PRIM - The primitive root of the generator poly. Integer variable or literal.
 21 |  * DEBUG - If set to 1 or more, do various internal consistency checking. Leave this
 22 |  *         undefined for production code
 23 | 
 24 |  * The memset(), memmove(), and memcpy() functions are used. The appropriate header
 25 |  * file declaring these functions (usually <string.h>) must be included by the calling
 26 |  * program.
 27 |  */
 28 | 
 29 | 
 30 | #if !defined(NROOTS)
 31 | #error "NROOTS not defined"
 32 | #endif
 33 | 
 34 | #if !defined(NN)
 35 | #error "NN not defined"
 36 | #endif
 37 | 
 38 | #if !defined(PAD)
 39 | #error "PAD not defined"
 40 | #endif
 41 | 
 42 | #if !defined(ALPHA_TO)
 43 | #error "ALPHA_TO not defined"
 44 | #endif
 45 | 
 46 | #if !defined(INDEX_OF)
 47 | #error "INDEX_OF not defined"
 48 | #endif
 49 | 
 50 | #if !defined(MODNN)
 51 | #error "MODNN not defined"
 52 | #endif
 53 | 
 54 | #if !defined(FCR)
 55 | #error "FCR not defined"
 56 | #endif
 57 | 
 58 | #if !defined(PRIM)
 59 | #error "PRIM not defined"
 60 | #endif
 61 | 
 62 | #if !defined(NULL)
 63 | #define NULL ((void *)0)
 64 | #endif
 65 | 
 66 | #undef MIN
 67 | #define	MIN(a,b)	((a) < (b) ? (a) : (b))
 68 | #undef A0
 69 | #define A0 (NN)
 70 | 
 71 | {
 72 |   int deg_lambda, el, deg_omega;
 73 |   int i, j, r,k;
 74 |   data_t u,q,tmp,num1,num2,den,discr_r;
 75 |   data_t lambda[NROOTS+1], s[NROOTS];	/* Err+Eras Locator poly
 76 | 					 * and syndrome poly */
 77 |   data_t b[NROOTS+1], t[NROOTS+1], omega[NROOTS+1];
 78 |   data_t root[NROOTS], reg[NROOTS+1], loc[NROOTS];
 79 |   int syn_error, count;
 80 | 
 81 |   /* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
 82 |   for(i=0;i<NROOTS;i++)
 83 |     s[i] = data[0];
 84 | 
 85 |   for(j=1;j<NN-PAD;j++){
 86 |     for(i=0;i<NROOTS;i++){
 87 |       if(s[i] == 0){
 88 | 	s[i] = data[j];
 89 |       } else {
 90 | 	s[i] = data[j] ^ ALPHA_TO[MODNN(INDEX_OF[s[i]] + (FCR+i)*PRIM)];
 91 |       }
 92 |     }
 93 |   }
 94 | 
 95 |   /* Convert syndromes to index form, checking for nonzero condition */
 96 |   syn_error = 0;
 97 |   for(i=0;i<NROOTS;i++){
 98 |     syn_error |= s[i];
 99 |     s[i] = INDEX_OF[s[i]];
100 |   }
101 | 
102 |   if (!syn_error) {
103 |     /* if syndrome is zero, data[] is a codeword and there are no
104 |      * errors to correct. So return data[] unmodified
105 |      */
106 |     count = 0;
107 |     goto finish;
108 |   }
109 |   memset(&lambda[1],0,NROOTS*sizeof(lambda[0]));
110 |   lambda[0] = 1;
111 | 
112 |   if (no_eras > 0) {
113 |     /* Init lambda to be the erasure locator polynomial */
114 |     lambda[1] = ALPHA_TO[MODNN(PRIM*(NN-1-eras_pos[0]))];
115 |     for (i = 1; i < no_eras; i++) {
116 |       u = MODNN(PRIM*(NN-1-eras_pos[i]));
117 |       for (j = i+1; j > 0; j--) {
118 | 	tmp = INDEX_OF[lambda[j - 1]];
119 | 	if(tmp != A0)
120 | 	  lambda[j] ^= ALPHA_TO[MODNN(u + tmp)];
121 |       }
122 |     }
123 | 
124 | #if DEBUG >= 1
125 |     /* Test code that verifies the erasure locator polynomial just constructed
126 |        Needed only for decoder debugging. */
127 |     
128 |     /* find roots of the erasure location polynomial */
129 |     for(i=1;i<=no_eras;i++)
130 |       reg[i] = INDEX_OF[lambda[i]];
131 | 
132 |     count = 0;
133 |     for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
134 |       q = 1;
135 |       for (j = 1; j <= no_eras; j++)
136 | 	if (reg[j] != A0) {
137 | 	  reg[j] = MODNN(reg[j] + j);
138 | 	  q ^= ALPHA_TO[reg[j]];
139 | 	}
140 |       if (q != 0)
141 | 	continue;
142 |       /* store root and error location number indices */
143 |       root[count] = i;
144 |       loc[count] = k;
145 |       count++;
146 |     }
147 |     if (count != no_eras) {
148 |       printf("count = %d no_eras = %d\n lambda(x) is WRONG\n",count,no_eras);
149 |       count = -1;
150 |       goto finish;
151 |     }
152 | #if DEBUG >= 2
153 |     printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n");
154 |     for (i = 0; i < count; i++)
155 |       printf("%d ", loc[i]);
156 |     printf("\n");
157 | #endif
158 | #endif
159 |   }
160 |   for(i=0;i<NROOTS+1;i++)
161 |     b[i] = INDEX_OF[lambda[i]];
162 |   
163 |   /*
164 |    * Begin Berlekamp-Massey algorithm to determine error+erasure
165 |    * locator polynomial
166 |    */
167 |   r = no_eras;
168 |   el = no_eras;
169 |   while (++r <= NROOTS) {	/* r is the step number */
170 |     /* Compute discrepancy at the r-th step in poly-form */
171 |     discr_r = 0;
172 |     for (i = 0; i < r; i++){
173 |       if ((lambda[i] != 0) && (s[r-i-1] != A0)) {
174 | 	discr_r ^= ALPHA_TO[MODNN(INDEX_OF[lambda[i]] + s[r-i-1])];
175 |       }
176 |     }
177 |     discr_r = INDEX_OF[discr_r];	/* Index form */
178 |     if (discr_r == A0) {
179 |       /* 2 lines below: B(x) <-- x*B(x) */
180 |       memmove(&b[1],b,NROOTS*sizeof(b[0]));
181 |       b[0] = A0;
182 |     } else {
183 |       /* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
184 |       t[0] = lambda[0];
185 |       for (i = 0 ; i < NROOTS; i++) {
186 | 	if(b[i] != A0)
187 | 	  t[i+1] = lambda[i+1] ^ ALPHA_TO[MODNN(discr_r + b[i])];
188 | 	else
189 | 	  t[i+1] = lambda[i+1];
190 |       }
191 |       if (2 * el <= r + no_eras - 1) {
192 | 	el = r + no_eras - el;
193 | 	/*
194 | 	 * 2 lines below: B(x) <-- inv(discr_r) *
195 | 	 * lambda(x)
196 | 	 */
197 | 	for (i = 0; i <= NROOTS; i++)
198 | 	  b[i] = (lambda[i] == 0) ? A0 : MODNN(INDEX_OF[lambda[i]] - discr_r + NN);
199 |       } else {
200 | 	/* 2 lines below: B(x) <-- x*B(x) */
201 | 	memmove(&b[1],b,NROOTS*sizeof(b[0]));
202 | 	b[0] = A0;
203 |       }
204 |       memcpy(lambda,t,(NROOTS+1)*sizeof(t[0]));
205 |     }
206 |   }
207 | 
208 |   /* Convert lambda to index form and compute deg(lambda(x)) */
209 |   deg_lambda = 0;
210 |   for(i=0;i<NROOTS+1;i++){
211 |     lambda[i] = INDEX_OF[lambda[i]];
212 |     if(lambda[i] != A0)
213 |       deg_lambda = i;
214 |   }
215 |   /* Find roots of the error+erasure locator polynomial by Chien search */
216 |   memcpy(&reg[1],&lambda[1],NROOTS*sizeof(reg[0]));
217 |   count = 0;		/* Number of roots of lambda(x) */
218 |   for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
219 |     q = 1; /* lambda[0] is always 0 */
220 |     for (j = deg_lambda; j > 0; j--){
221 |       if (reg[j] != A0) {
222 | 	reg[j] = MODNN(reg[j] + j);
223 | 	q ^= ALPHA_TO[reg[j]];
224 |       }
225 |     }
226 |     if (q != 0)
227 |       continue; /* Not a root */
228 |     /* store root (index-form) and error location number */
229 | #if DEBUG>=2
230 |     printf("count %d root %d loc %d\n",count,i,k);
231 | #endif
232 |     root[count] = i;
233 |     loc[count] = k;
234 |     /* If we've already found max possible roots,
235 |      * abort the search to save time
236 |      */
237 |     if(++count == deg_lambda)
238 |       break;
239 |   }
240 |   if (deg_lambda != count) {
241 |     /*
242 |      * deg(lambda) unequal to number of roots => uncorrectable
243 |      * error detected
244 |      */
245 |     count = -1;
246 |     goto finish;
247 |   }
248 |   /*
249 |    * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
250 |    * x**NROOTS). in index form. Also find deg(omega).
251 |    */
252 |   deg_omega = deg_lambda-1;
253 |   for (i = 0; i <= deg_omega;i++){
254 |     tmp = 0;
255 |     for(j=i;j >= 0; j--){
256 |       if ((s[i - j] != A0) && (lambda[j] != A0))
257 | 	tmp ^= ALPHA_TO[MODNN(s[i - j] + lambda[j])];
258 |     }
259 |     omega[i] = INDEX_OF[tmp];
260 |   }
261 | 
262 |   /*
263 |    * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
264 |    * inv(X(l))**(FCR-1) and den = lambda_pr(inv(X(l))) all in poly-form
265 |    */
266 |   for (j = count-1; j >=0; j--) {
267 |     num1 = 0;
268 |     for (i = deg_omega; i >= 0; i--) {
269 |       if (omega[i] != A0)
270 | 	num1  ^= ALPHA_TO[MODNN(omega[i] + i * root[j])];
271 |     }
272 |     num2 = ALPHA_TO[MODNN(root[j] * (FCR - 1) + NN)];
273 |     den = 0;
274 |     
275 |     /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
276 |     for (i = MIN(deg_lambda,NROOTS-1) & ~1; i >= 0; i -=2) {
277 |       if(lambda[i+1] != A0)
278 | 	den ^= ALPHA_TO[MODNN(lambda[i+1] + i * root[j])];
279 |     }
280 | #if DEBUG >= 1
281 |     if (den == 0) {
282 |       printf("\n ERROR: denominator = 0\n");
283 |       count = -1;
284 |       goto finish;
285 |     }
286 | #endif
287 |     /* Apply error to data */
288 |     if (num1 != 0 && loc[j] >= PAD) {
289 |       data[loc[j]-PAD] ^= ALPHA_TO[MODNN(INDEX_OF[num1] + INDEX_OF[num2] + NN - INDEX_OF[den])];
290 |     }
291 |   }
292 |  finish:
293 |   if(eras_pos != NULL){
294 |     for(i=0;i<count;i++)
295 |       eras_pos[i] = loc[i];
296 |   }
297 |   retval = count;
298 | }
299 | 


--------------------------------------------------------------------------------
/external/fec/config.guess:
--------------------------------------------------------------------------------
   1 | #! /bin/sh
   2 | # Attempt to guess a canonical system name.
   3 | #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4 | #   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
   5 | #   Inc.
   6 | 
   7 | timestamp='2007-03-06'
   8 | 
   9 | # This file is free software; you can redistribute it and/or modify it
  10 | # under the terms of the GNU General Public License as published by
  11 | # the Free Software Foundation; either version 2 of the License, or
  12 | # (at your option) any later version.
  13 | #
  14 | # This program is distributed in the hope that it will be useful, but
  15 | # WITHOUT ANY WARRANTY; without even the implied warranty of
  16 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 | # General Public License for more details.
  18 | #
  19 | # You should have received a copy of the GNU General Public License
  20 | # along with this program; if not, write to the Free Software
  21 | # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22 | # 02110-1301, USA.
  23 | #
  24 | # As a special exception to the GNU General Public License, if you
  25 | # distribute this file as part of a program that contains a
  26 | # configuration script generated by Autoconf, you may include it under
  27 | # the same distribution terms that you use for the rest of that program.
  28 | 
  29 | 
  30 | # Originally written by Per Bothner <per@bothner.com>.
  31 | # Please send patches to <config-patches@gnu.org>.  Submit a context
  32 | # diff and a properly formatted ChangeLog entry.
  33 | #
  34 | # This script attempts to guess a canonical system name similar to
  35 | # config.sub.  If it succeeds, it prints the system name on stdout, and
  36 | # exits with 0.  Otherwise, it exits with 1.
  37 | #
  38 | # The plan is that this can be called by configure scripts if you
  39 | # don't specify an explicit build system type.
  40 | 
  41 | me=`echo "$0" | sed -e 's,.*/,,'`
  42 | 
  43 | usage="\
  44 | Usage: $0 [OPTION]
  45 | 
  46 | Output the configuration name of the system \`$me' is run on.
  47 | 
  48 | Operation modes:
  49 |   -h, --help         print this help, then exit
  50 |   -t, --time-stamp   print date of last modification, then exit
  51 |   -v, --version      print version number, then exit
  52 | 
  53 | Report bugs and patches to <config-patches@gnu.org>."
  54 | 
  55 | version="\
  56 | GNU config.guess ($timestamp)
  57 | 
  58 | Originally written by Per Bothner.
  59 | Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
  60 | Free Software Foundation, Inc.
  61 | 
  62 | This is free software; see the source for copying conditions.  There is NO
  63 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
  64 | 
  65 | help="
  66 | Try \`$me --help' for more information."
  67 | 
  68 | # Parse command line
  69 | while test $# -gt 0 ; do
  70 |   case $1 in
  71 |     --time-stamp | --time* | -t )
  72 |        echo "$timestamp" ; exit ;;
  73 |     --version | -v )
  74 |        echo "$version" ; exit ;;
  75 |     --help | --h* | -h )
  76 |        echo "$usage"; exit ;;
  77 |     -- )     # Stop option processing
  78 |        shift; break ;;
  79 |     - )	# Use stdin as input.
  80 |        break ;;
  81 |     -* )
  82 |        echo "$me: invalid option $1$help" >&2
  83 |        exit 1 ;;
  84 |     * )
  85 |        break ;;
  86 |   esac
  87 | done
  88 | 
  89 | if test $# != 0; then
  90 |   echo "$me: too many arguments$help" >&2
  91 |   exit 1
  92 | fi
  93 | 
  94 | trap 'exit 1' 1 2 15
  95 | 
  96 | # CC_FOR_BUILD -- compiler used by this script. Note that the use of a
  97 | # compiler to aid in system detection is discouraged as it requires
  98 | # temporary files to be created and, as you can see below, it is a
  99 | # headache to deal with in a portable fashion.
 100 | 
 101 | # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
 102 | # use `HOST_CC' if defined, but it is deprecated.
 103 | 
 104 | # Portable tmp directory creation inspired by the Autoconf team.
 105 | 
 106 | set_cc_for_build='
 107 | trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
 108 | trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
 109 | : ${TMPDIR=/tmp} ;
 110 |  { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
 111 |  { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
 112 |  { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
 113 |  { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
 114 | dummy=$tmp/dummy ;
 115 | tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
 116 | case $CC_FOR_BUILD,$HOST_CC,$CC in
 117 |  ,,)    echo "int x;" > $dummy.c ;
 118 | 	for c in cc gcc c89 c99 ; do
 119 | 	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
 120 | 	     CC_FOR_BUILD="$c"; break ;
 121 | 	  fi ;
 122 | 	done ;
 123 | 	if test x"$CC_FOR_BUILD" = x ; then
 124 | 	  CC_FOR_BUILD=no_compiler_found ;
 125 | 	fi
 126 | 	;;
 127 |  ,,*)   CC_FOR_BUILD=$CC ;;
 128 |  ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
 129 | esac ; set_cc_for_build= ;'
 130 | 
 131 | # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
 132 | # (ghazi@noc.rutgers.edu 1994-08-24)
 133 | if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
 134 | 	PATH=$PATH:/.attbin ; export PATH
 135 | fi
 136 | 
 137 | UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
 138 | UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
 139 | UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
 140 | UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 141 | 
 142 | # Note: order is significant - the case branches are not exclusive.
 143 | 
 144 | case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 145 |     *:NetBSD:*:*)
 146 | 	# NetBSD (nbsd) targets should (where applicable) match one or
 147 | 	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
 148 | 	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
 149 | 	# switched to ELF, *-*-netbsd* would select the old
 150 | 	# object file format.  This provides both forward
 151 | 	# compatibility and a consistent mechanism for selecting the
 152 | 	# object file format.
 153 | 	#
 154 | 	# Note: NetBSD doesn't particularly care about the vendor
 155 | 	# portion of the name.  We always set it to "unknown".
 156 | 	sysctl="sysctl -n hw.machine_arch"
 157 | 	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
 158 | 	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
 159 | 	case "${UNAME_MACHINE_ARCH}" in
 160 | 	    armeb) machine=armeb-unknown ;;
 161 | 	    arm*) machine=arm-unknown ;;
 162 | 	    sh3el) machine=shl-unknown ;;
 163 | 	    sh3eb) machine=sh-unknown ;;
 164 | 	    sh5el) machine=sh5le-unknown ;;
 165 | 	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
 166 | 	esac
 167 | 	# The Operating System including object format, if it has switched
 168 | 	# to ELF recently, or will in the future.
 169 | 	case "${UNAME_MACHINE_ARCH}" in
 170 | 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
 171 | 		eval $set_cc_for_build
 172 | 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 173 | 			| grep __ELF__ >/dev/null
 174 | 		then
 175 | 		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
 176 | 		    # Return netbsd for either.  FIX?
 177 | 		    os=netbsd
 178 | 		else
 179 | 		    os=netbsdelf
 180 | 		fi
 181 | 		;;
 182 | 	    *)
 183 | 	        os=netbsd
 184 | 		;;
 185 | 	esac
 186 | 	# The OS release
 187 | 	# Debian GNU/NetBSD machines have a different userland, and
 188 | 	# thus, need a distinct triplet. However, they do not need
 189 | 	# kernel version information, so it can be replaced with a
 190 | 	# suitable tag, in the style of linux-gnu.
 191 | 	case "${UNAME_VERSION}" in
 192 | 	    Debian*)
 193 | 		release='-gnu'
 194 | 		;;
 195 | 	    *)
 196 | 		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
 197 | 		;;
 198 | 	esac
 199 | 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
 200 | 	# contains redundant information, the shorter form:
 201 | 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
 202 | 	echo "${machine}-${os}${release}"
 203 | 	exit ;;
 204 |     *:OpenBSD:*:*)
 205 | 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
 206 | 	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
 207 | 	exit ;;
 208 |     *:ekkoBSD:*:*)
 209 | 	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
 210 | 	exit ;;
 211 |     *:SolidBSD:*:*)
 212 | 	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
 213 | 	exit ;;
 214 |     macppc:MirBSD:*:*)
 215 | 	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
 216 | 	exit ;;
 217 |     *:MirBSD:*:*)
 218 | 	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
 219 | 	exit ;;
 220 |     alpha:OSF1:*:*)
 221 | 	case $UNAME_RELEASE in
 222 | 	*4.0)
 223 | 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
 224 | 		;;
 225 | 	*5.*)
 226 | 	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
 227 | 		;;
 228 | 	esac
 229 | 	# According to Compaq, /usr/sbin/psrinfo has been available on
 230 | 	# OSF/1 and Tru64 systems produced since 1995.  I hope that
 231 | 	# covers most systems running today.  This code pipes the CPU
 232 | 	# types through head -n 1, so we only detect the type of CPU 0.
 233 | 	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
 234 | 	case "$ALPHA_CPU_TYPE" in
 235 | 	    "EV4 (21064)")
 236 | 		UNAME_MACHINE="alpha" ;;
 237 | 	    "EV4.5 (21064)")
 238 | 		UNAME_MACHINE="alpha" ;;
 239 | 	    "LCA4 (21066/21068)")
 240 | 		UNAME_MACHINE="alpha" ;;
 241 | 	    "EV5 (21164)")
 242 | 		UNAME_MACHINE="alphaev5" ;;
 243 | 	    "EV5.6 (21164A)")
 244 | 		UNAME_MACHINE="alphaev56" ;;
 245 | 	    "EV5.6 (21164PC)")
 246 | 		UNAME_MACHINE="alphapca56" ;;
 247 | 	    "EV5.7 (21164PC)")
 248 | 		UNAME_MACHINE="alphapca57" ;;
 249 | 	    "EV6 (21264)")
 250 | 		UNAME_MACHINE="alphaev6" ;;
 251 | 	    "EV6.7 (21264A)")
 252 | 		UNAME_MACHINE="alphaev67" ;;
 253 | 	    "EV6.8CB (21264C)")
 254 | 		UNAME_MACHINE="alphaev68" ;;
 255 | 	    "EV6.8AL (21264B)")
 256 | 		UNAME_MACHINE="alphaev68" ;;
 257 | 	    "EV6.8CX (21264D)")
 258 | 		UNAME_MACHINE="alphaev68" ;;
 259 | 	    "EV6.9A (21264/EV69A)")
 260 | 		UNAME_MACHINE="alphaev69" ;;
 261 | 	    "EV7 (21364)")
 262 | 		UNAME_MACHINE="alphaev7" ;;
 263 | 	    "EV7.9 (21364A)")
 264 | 		UNAME_MACHINE="alphaev79" ;;
 265 | 	esac
 266 | 	# A Pn.n version is a patched version.
 267 | 	# A Vn.n version is a released version.
 268 | 	# A Tn.n version is a released field test version.
 269 | 	# A Xn.n version is an unreleased experimental baselevel.
 270 | 	# 1.2 uses "1.2" for uname -r.
 271 | 	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
 272 | 	exit ;;
 273 |     Alpha\ *:Windows_NT*:*)
 274 | 	# How do we know it's Interix rather than the generic POSIX subsystem?
 275 | 	# Should we change UNAME_MACHINE based on the output of uname instead
 276 | 	# of the specific Alpha model?
 277 | 	echo alpha-pc-interix
 278 | 	exit ;;
 279 |     21064:Windows_NT:50:3)
 280 | 	echo alpha-dec-winnt3.5
 281 | 	exit ;;
 282 |     Amiga*:UNIX_System_V:4.0:*)
 283 | 	echo m68k-unknown-sysv4
 284 | 	exit ;;
 285 |     *:[Aa]miga[Oo][Ss]:*:*)
 286 | 	echo ${UNAME_MACHINE}-unknown-amigaos
 287 | 	exit ;;
 288 |     *:[Mm]orph[Oo][Ss]:*:*)
 289 | 	echo ${UNAME_MACHINE}-unknown-morphos
 290 | 	exit ;;
 291 |     *:OS/390:*:*)
 292 | 	echo i370-ibm-openedition
 293 | 	exit ;;
 294 |     *:z/VM:*:*)
 295 | 	echo s390-ibm-zvmoe
 296 | 	exit ;;
 297 |     *:OS400:*:*)
 298 |         echo powerpc-ibm-os400
 299 | 	exit ;;
 300 |     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
 301 | 	echo arm-acorn-riscix${UNAME_RELEASE}
 302 | 	exit ;;
 303 |     arm:riscos:*:*|arm:RISCOS:*:*)
 304 | 	echo arm-unknown-riscos
 305 | 	exit ;;
 306 |     SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
 307 | 	echo hppa1.1-hitachi-hiuxmpp
 308 | 	exit ;;
 309 |     Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
 310 | 	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
 311 | 	if test "`(/bin/universe) 2>/dev/null`" = att ; then
 312 | 		echo pyramid-pyramid-sysv3
 313 | 	else
 314 | 		echo pyramid-pyramid-bsd
 315 | 	fi
 316 | 	exit ;;
 317 |     NILE*:*:*:dcosx)
 318 | 	echo pyramid-pyramid-svr4
 319 | 	exit ;;
 320 |     DRS?6000:unix:4.0:6*)
 321 | 	echo sparc-icl-nx6
 322 | 	exit ;;
 323 |     DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
 324 | 	case `/usr/bin/uname -p` in
 325 | 	    sparc) echo sparc-icl-nx7; exit ;;
 326 | 	esac ;;
 327 |     sun4H:SunOS:5.*:*)
 328 | 	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 329 | 	exit ;;
 330 |     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
 331 | 	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 332 | 	exit ;;
 333 |     i86pc:SunOS:5.*:*)
 334 | 	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 335 | 	exit ;;
 336 |     sun4*:SunOS:6*:*)
 337 | 	# According to config.sub, this is the proper way to canonicalize
 338 | 	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
 339 | 	# it's likely to be more like Solaris than SunOS4.
 340 | 	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 341 | 	exit ;;
 342 |     sun4*:SunOS:*:*)
 343 | 	case "`/usr/bin/arch -k`" in
 344 | 	    Series*|S4*)
 345 | 		UNAME_RELEASE=`uname -v`
 346 | 		;;
 347 | 	esac
 348 | 	# Japanese Language versions have a version number like `4.1.3-JL'.
 349 | 	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
 350 | 	exit ;;
 351 |     sun3*:SunOS:*:*)
 352 | 	echo m68k-sun-sunos${UNAME_RELEASE}
 353 | 	exit ;;
 354 |     sun*:*:4.2BSD:*)
 355 | 	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
 356 | 	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
 357 | 	case "`/bin/arch`" in
 358 | 	    sun3)
 359 | 		echo m68k-sun-sunos${UNAME_RELEASE}
 360 | 		;;
 361 | 	    sun4)
 362 | 		echo sparc-sun-sunos${UNAME_RELEASE}
 363 | 		;;
 364 | 	esac
 365 | 	exit ;;
 366 |     aushp:SunOS:*:*)
 367 | 	echo sparc-auspex-sunos${UNAME_RELEASE}
 368 | 	exit ;;
 369 |     # The situation for MiNT is a little confusing.  The machine name
 370 |     # can be virtually everything (everything which is not
 371 |     # "atarist" or "atariste" at least should have a processor
 372 |     # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
 373 |     # to the lowercase version "mint" (or "freemint").  Finally
 374 |     # the system name "TOS" denotes a system which is actually not
 375 |     # MiNT.  But MiNT is downward compatible to TOS, so this should
 376 |     # be no problem.
 377 |     atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
 378 |         echo m68k-atari-mint${UNAME_RELEASE}
 379 | 	exit ;;
 380 |     atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
 381 | 	echo m68k-atari-mint${UNAME_RELEASE}
 382 |         exit ;;
 383 |     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
 384 |         echo m68k-atari-mint${UNAME_RELEASE}
 385 | 	exit ;;
 386 |     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
 387 |         echo m68k-milan-mint${UNAME_RELEASE}
 388 |         exit ;;
 389 |     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
 390 |         echo m68k-hades-mint${UNAME_RELEASE}
 391 |         exit ;;
 392 |     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
 393 |         echo m68k-unknown-mint${UNAME_RELEASE}
 394 |         exit ;;
 395 |     m68k:machten:*:*)
 396 | 	echo m68k-apple-machten${UNAME_RELEASE}
 397 | 	exit ;;
 398 |     powerpc:machten:*:*)
 399 | 	echo powerpc-apple-machten${UNAME_RELEASE}
 400 | 	exit ;;
 401 |     RISC*:Mach:*:*)
 402 | 	echo mips-dec-mach_bsd4.3
 403 | 	exit ;;
 404 |     RISC*:ULTRIX:*:*)
 405 | 	echo mips-dec-ultrix${UNAME_RELEASE}
 406 | 	exit ;;
 407 |     VAX*:ULTRIX*:*:*)
 408 | 	echo vax-dec-ultrix${UNAME_RELEASE}
 409 | 	exit ;;
 410 |     2020:CLIX:*:* | 2430:CLIX:*:*)
 411 | 	echo clipper-intergraph-clix${UNAME_RELEASE}
 412 | 	exit ;;
 413 |     mips:*:*:UMIPS | mips:*:*:RISCos)
 414 | 	eval $set_cc_for_build
 415 | 	sed 's/^	//' << EOF >$dummy.c
 416 | #ifdef __cplusplus
 417 | #include <stdio.h>  /* for printf() prototype */
 418 | 	int main (int argc, char *argv[]) {
 419 | #else
 420 | 	int main (argc, argv) int argc; char *argv[]; {
 421 | #endif
 422 | 	#if defined (host_mips) && defined (MIPSEB)
 423 | 	#if defined (SYSTYPE_SYSV)
 424 | 	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
 425 | 	#endif
 426 | 	#if defined (SYSTYPE_SVR4)
 427 | 	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
 428 | 	#endif
 429 | 	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
 430 | 	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
 431 | 	#endif
 432 | 	#endif
 433 | 	  exit (-1);
 434 | 	}
 435 | EOF
 436 | 	$CC_FOR_BUILD -o $dummy $dummy.c &&
 437 | 	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
 438 | 	  SYSTEM_NAME=`$dummy $dummyarg` &&
 439 | 	    { echo "$SYSTEM_NAME"; exit; }
 440 | 	echo mips-mips-riscos${UNAME_RELEASE}
 441 | 	exit ;;
 442 |     Motorola:PowerMAX_OS:*:*)
 443 | 	echo powerpc-motorola-powermax
 444 | 	exit ;;
 445 |     Motorola:*:4.3:PL8-*)
 446 | 	echo powerpc-harris-powermax
 447 | 	exit ;;
 448 |     Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
 449 | 	echo powerpc-harris-powermax
 450 | 	exit ;;
 451 |     Night_Hawk:Power_UNIX:*:*)
 452 | 	echo powerpc-harris-powerunix
 453 | 	exit ;;
 454 |     m88k:CX/UX:7*:*)
 455 | 	echo m88k-harris-cxux7
 456 | 	exit ;;
 457 |     m88k:*:4*:R4*)
 458 | 	echo m88k-motorola-sysv4
 459 | 	exit ;;
 460 |     m88k:*:3*:R3*)
 461 | 	echo m88k-motorola-sysv3
 462 | 	exit ;;
 463 |     AViiON:dgux:*:*)
 464 |         # DG/UX returns AViiON for all architectures
 465 |         UNAME_PROCESSOR=`/usr/bin/uname -p`
 466 | 	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
 467 | 	then
 468 | 	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
 469 | 	       [ ${TARGET_BINARY_INTERFACE}x = x ]
 470 | 	    then
 471 | 		echo m88k-dg-dgux${UNAME_RELEASE}
 472 | 	    else
 473 | 		echo m88k-dg-dguxbcs${UNAME_RELEASE}
 474 | 	    fi
 475 | 	else
 476 | 	    echo i586-dg-dgux${UNAME_RELEASE}
 477 | 	fi
 478 |  	exit ;;
 479 |     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
 480 | 	echo m88k-dolphin-sysv3
 481 | 	exit ;;
 482 |     M88*:*:R3*:*)
 483 | 	# Delta 88k system running SVR3
 484 | 	echo m88k-motorola-sysv3
 485 | 	exit ;;
 486 |     XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
 487 | 	echo m88k-tektronix-sysv3
 488 | 	exit ;;
 489 |     Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
 490 | 	echo m68k-tektronix-bsd
 491 | 	exit ;;
 492 |     *:IRIX*:*:*)
 493 | 	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
 494 | 	exit ;;
 495 |     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
 496 | 	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
 497 | 	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
 498 |     i*86:AIX:*:*)
 499 | 	echo i386-ibm-aix
 500 | 	exit ;;
 501 |     ia64:AIX:*:*)
 502 | 	if [ -x /usr/bin/oslevel ] ; then
 503 | 		IBM_REV=`/usr/bin/oslevel`
 504 | 	else
 505 | 		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
 506 | 	fi
 507 | 	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
 508 | 	exit ;;
 509 |     *:AIX:2:3)
 510 | 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
 511 | 		eval $set_cc_for_build
 512 | 		sed 's/^		//' << EOF >$dummy.c
 513 | 		#include <sys/systemcfg.h>
 514 | 
 515 | 		main()
 516 | 			{
 517 | 			if (!__power_pc())
 518 | 				exit(1);
 519 | 			puts("powerpc-ibm-aix3.2.5");
 520 | 			exit(0);
 521 | 			}
 522 | EOF
 523 | 		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
 524 | 		then
 525 | 			echo "$SYSTEM_NAME"
 526 | 		else
 527 | 			echo rs6000-ibm-aix3.2.5
 528 | 		fi
 529 | 	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
 530 | 		echo rs6000-ibm-aix3.2.4
 531 | 	else
 532 | 		echo rs6000-ibm-aix3.2
 533 | 	fi
 534 | 	exit ;;
 535 |     *:AIX:*:[45])
 536 | 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
 537 | 	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
 538 | 		IBM_ARCH=rs6000
 539 | 	else
 540 | 		IBM_ARCH=powerpc
 541 | 	fi
 542 | 	if [ -x /usr/bin/oslevel ] ; then
 543 | 		IBM_REV=`/usr/bin/oslevel`
 544 | 	else
 545 | 		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
 546 | 	fi
 547 | 	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
 548 | 	exit ;;
 549 |     *:AIX:*:*)
 550 | 	echo rs6000-ibm-aix
 551 | 	exit ;;
 552 |     ibmrt:4.4BSD:*|romp-ibm:BSD:*)
 553 | 	echo romp-ibm-bsd4.4
 554 | 	exit ;;
 555 |     ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
 556 | 	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
 557 | 	exit ;;                             # report: romp-ibm BSD 4.3
 558 |     *:BOSX:*:*)
 559 | 	echo rs6000-bull-bosx
 560 | 	exit ;;
 561 |     DPX/2?00:B.O.S.:*:*)
 562 | 	echo m68k-bull-sysv3
 563 | 	exit ;;
 564 |     9000/[34]??:4.3bsd:1.*:*)
 565 | 	echo m68k-hp-bsd
 566 | 	exit ;;
 567 |     hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
 568 | 	echo m68k-hp-bsd4.4
 569 | 	exit ;;
 570 |     9000/[34678]??:HP-UX:*:*)
 571 | 	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
 572 | 	case "${UNAME_MACHINE}" in
 573 | 	    9000/31? )            HP_ARCH=m68000 ;;
 574 | 	    9000/[34]?? )         HP_ARCH=m68k ;;
 575 | 	    9000/[678][0-9][0-9])
 576 | 		if [ -x /usr/bin/getconf ]; then
 577 | 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
 578 |                     sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
 579 |                     case "${sc_cpu_version}" in
 580 |                       523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
 581 |                       528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
 582 |                       532)                      # CPU_PA_RISC2_0
 583 |                         case "${sc_kernel_bits}" in
 584 |                           32) HP_ARCH="hppa2.0n" ;;
 585 |                           64) HP_ARCH="hppa2.0w" ;;
 586 | 			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
 587 |                         esac ;;
 588 |                     esac
 589 | 		fi
 590 | 		if [ "${HP_ARCH}" = "" ]; then
 591 | 		    eval $set_cc_for_build
 592 | 		    sed 's/^              //' << EOF >$dummy.c
 593 | 
 594 |               #define _HPUX_SOURCE
 595 |               #include <stdlib.h>
 596 |               #include <unistd.h>
 597 | 
 598 |               int main ()
 599 |               {
 600 |               #if defined(_SC_KERNEL_BITS)
 601 |                   long bits = sysconf(_SC_KERNEL_BITS);
 602 |               #endif
 603 |                   long cpu  = sysconf (_SC_CPU_VERSION);
 604 | 
 605 |                   switch (cpu)
 606 |               	{
 607 |               	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
 608 |               	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
 609 |               	case CPU_PA_RISC2_0:
 610 |               #if defined(_SC_KERNEL_BITS)
 611 |               	    switch (bits)
 612 |               		{
 613 |               		case 64: puts ("hppa2.0w"); break;
 614 |               		case 32: puts ("hppa2.0n"); break;
 615 |               		default: puts ("hppa2.0"); break;
 616 |               		} break;
 617 |               #else  /* !defined(_SC_KERNEL_BITS) */
 618 |               	    puts ("hppa2.0"); break;
 619 |               #endif
 620 |               	default: puts ("hppa1.0"); break;
 621 |               	}
 622 |                   exit (0);
 623 |               }
 624 | EOF
 625 | 		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
 626 | 		    test -z "$HP_ARCH" && HP_ARCH=hppa
 627 | 		fi ;;
 628 | 	esac
 629 | 	if [ ${HP_ARCH} = "hppa2.0w" ]
 630 | 	then
 631 | 	    eval $set_cc_for_build
 632 | 
 633 | 	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
 634 | 	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
 635 | 	    # generating 64-bit code.  GNU and HP use different nomenclature:
 636 | 	    #
 637 | 	    # $ CC_FOR_BUILD=cc ./config.guess
 638 | 	    # => hppa2.0w-hp-hpux11.23
 639 | 	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
 640 | 	    # => hppa64-hp-hpux11.23
 641 | 
 642 | 	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
 643 | 		grep __LP64__ >/dev/null
 644 | 	    then
 645 | 		HP_ARCH="hppa2.0w"
 646 | 	    else
 647 | 		HP_ARCH="hppa64"
 648 | 	    fi
 649 | 	fi
 650 | 	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
 651 | 	exit ;;
 652 |     ia64:HP-UX:*:*)
 653 | 	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
 654 | 	echo ia64-hp-hpux${HPUX_REV}
 655 | 	exit ;;
 656 |     3050*:HI-UX:*:*)
 657 | 	eval $set_cc_for_build
 658 | 	sed 's/^	//' << EOF >$dummy.c
 659 | 	#include <unistd.h>
 660 | 	int
 661 | 	main ()
 662 | 	{
 663 | 	  long cpu = sysconf (_SC_CPU_VERSION);
 664 | 	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
 665 | 	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
 666 | 	     results, however.  */
 667 | 	  if (CPU_IS_PA_RISC (cpu))
 668 | 	    {
 669 | 	      switch (cpu)
 670 | 		{
 671 | 		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
 672 | 		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
 673 | 		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
 674 | 		  default: puts ("hppa-hitachi-hiuxwe2"); break;
 675 | 		}
 676 | 	    }
 677 | 	  else if (CPU_IS_HP_MC68K (cpu))
 678 | 	    puts ("m68k-hitachi-hiuxwe2");
 679 | 	  else puts ("unknown-hitachi-hiuxwe2");
 680 | 	  exit (0);
 681 | 	}
 682 | EOF
 683 | 	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
 684 | 		{ echo "$SYSTEM_NAME"; exit; }
 685 | 	echo unknown-hitachi-hiuxwe2
 686 | 	exit ;;
 687 |     9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
 688 | 	echo hppa1.1-hp-bsd
 689 | 	exit ;;
 690 |     9000/8??:4.3bsd:*:*)
 691 | 	echo hppa1.0-hp-bsd
 692 | 	exit ;;
 693 |     *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
 694 | 	echo hppa1.0-hp-mpeix
 695 | 	exit ;;
 696 |     hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
 697 | 	echo hppa1.1-hp-osf
 698 | 	exit ;;
 699 |     hp8??:OSF1:*:*)
 700 | 	echo hppa1.0-hp-osf
 701 | 	exit ;;
 702 |     i*86:OSF1:*:*)
 703 | 	if [ -x /usr/sbin/sysversion ] ; then
 704 | 	    echo ${UNAME_MACHINE}-unknown-osf1mk
 705 | 	else
 706 | 	    echo ${UNAME_MACHINE}-unknown-osf1
 707 | 	fi
 708 | 	exit ;;
 709 |     parisc*:Lites*:*:*)
 710 | 	echo hppa1.1-hp-lites
 711 | 	exit ;;
 712 |     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
 713 | 	echo c1-convex-bsd
 714 |         exit ;;
 715 |     C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
 716 | 	if getsysinfo -f scalar_acc
 717 | 	then echo c32-convex-bsd
 718 | 	else echo c2-convex-bsd
 719 | 	fi
 720 |         exit ;;
 721 |     C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
 722 | 	echo c34-convex-bsd
 723 |         exit ;;
 724 |     C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
 725 | 	echo c38-convex-bsd
 726 |         exit ;;
 727 |     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
 728 | 	echo c4-convex-bsd
 729 |         exit ;;
 730 |     CRAY*Y-MP:*:*:*)
 731 | 	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 732 | 	exit ;;
 733 |     CRAY*[A-Z]90:*:*:*)
 734 | 	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
 735 | 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
 736 | 	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
 737 | 	      -e 's/\.[^.]*$/.X/'
 738 | 	exit ;;
 739 |     CRAY*TS:*:*:*)
 740 | 	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 741 | 	exit ;;
 742 |     CRAY*T3E:*:*:*)
 743 | 	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 744 | 	exit ;;
 745 |     CRAY*SV1:*:*:*)
 746 | 	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 747 | 	exit ;;
 748 |     *:UNICOS/mp:*:*)
 749 | 	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 750 | 	exit ;;
 751 |     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
 752 | 	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
 753 |         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
 754 |         FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
 755 |         echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
 756 |         exit ;;
 757 |     5000:UNIX_System_V:4.*:*)
 758 |         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
 759 |         FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
 760 |         echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
 761 | 	exit ;;
 762 |     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
 763 | 	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
 764 | 	exit ;;
 765 |     sparc*:BSD/OS:*:*)
 766 | 	echo sparc-unknown-bsdi${UNAME_RELEASE}
 767 | 	exit ;;
 768 |     *:BSD/OS:*:*)
 769 | 	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
 770 | 	exit ;;
 771 |     *:FreeBSD:*:*)
 772 | 	case ${UNAME_MACHINE} in
 773 | 	    pc98)
 774 | 		echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
 775 | 	    amd64)
 776 | 		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
 777 | 	    *)
 778 | 		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
 779 | 	esac
 780 | 	exit ;;
 781 |     i*:CYGWIN*:*)
 782 | 	echo ${UNAME_MACHINE}-pc-cygwin
 783 | 	exit ;;
 784 |     *:MINGW*:*)
 785 | 	echo ${UNAME_MACHINE}-pc-mingw32
 786 | 	exit ;;
 787 |     i*:windows32*:*)
 788 |     	# uname -m includes "-pc" on this system.
 789 |     	echo ${UNAME_MACHINE}-mingw32
 790 | 	exit ;;
 791 |     i*:PW*:*)
 792 | 	echo ${UNAME_MACHINE}-pc-pw32
 793 | 	exit ;;
 794 |     *:Interix*:[3456]*)
 795 |     	case ${UNAME_MACHINE} in
 796 | 	    x86) 
 797 | 		echo i586-pc-interix${UNAME_RELEASE}
 798 | 		exit ;;
 799 | 	    EM64T | authenticamd)
 800 | 		echo x86_64-unknown-interix${UNAME_RELEASE}
 801 | 		exit ;;
 802 | 	esac ;;
 803 |     [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
 804 | 	echo i${UNAME_MACHINE}-pc-mks
 805 | 	exit ;;
 806 |     i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
 807 | 	# How do we know it's Interix rather than the generic POSIX subsystem?
 808 | 	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
 809 | 	# UNAME_MACHINE based on the output of uname instead of i386?
 810 | 	echo i586-pc-interix
 811 | 	exit ;;
 812 |     i*:UWIN*:*)
 813 | 	echo ${UNAME_MACHINE}-pc-uwin
 814 | 	exit ;;
 815 |     amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
 816 | 	echo x86_64-unknown-cygwin
 817 | 	exit ;;
 818 |     p*:CYGWIN*:*)
 819 | 	echo powerpcle-unknown-cygwin
 820 | 	exit ;;
 821 |     prep*:SunOS:5.*:*)
 822 | 	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 823 | 	exit ;;
 824 |     *:GNU:*:*)
 825 | 	# the GNU system
 826 | 	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
 827 | 	exit ;;
 828 |     *:GNU/*:*:*)
 829 | 	# other systems with GNU libc and userland
 830 | 	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
 831 | 	exit ;;
 832 |     i*86:Minix:*:*)
 833 | 	echo ${UNAME_MACHINE}-pc-minix
 834 | 	exit ;;
 835 |     arm*:Linux:*:*)
 836 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 837 | 	exit ;;
 838 |     avr32*:Linux:*:*)
 839 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 840 | 	exit ;;
 841 |     cris:Linux:*:*)
 842 | 	echo cris-axis-linux-gnu
 843 | 	exit ;;
 844 |     crisv32:Linux:*:*)
 845 | 	echo crisv32-axis-linux-gnu
 846 | 	exit ;;
 847 |     frv:Linux:*:*)
 848 |     	echo frv-unknown-linux-gnu
 849 | 	exit ;;
 850 |     ia64:Linux:*:*)
 851 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 852 | 	exit ;;
 853 |     m32r*:Linux:*:*)
 854 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 855 | 	exit ;;
 856 |     m68*:Linux:*:*)
 857 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 858 | 	exit ;;
 859 |     mips:Linux:*:*)
 860 | 	eval $set_cc_for_build
 861 | 	sed 's/^	//' << EOF >$dummy.c
 862 | 	#undef CPU
 863 | 	#undef mips
 864 | 	#undef mipsel
 865 | 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
 866 | 	CPU=mipsel
 867 | 	#else
 868 | 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
 869 | 	CPU=mips
 870 | 	#else
 871 | 	CPU=
 872 | 	#endif
 873 | 	#endif
 874 | EOF
 875 | 	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
 876 | 	    /^CPU/{
 877 | 		s: ::g
 878 | 		p
 879 | 	    }'`"
 880 | 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
 881 | 	;;
 882 |     mips64:Linux:*:*)
 883 | 	eval $set_cc_for_build
 884 | 	sed 's/^	//' << EOF >$dummy.c
 885 | 	#undef CPU
 886 | 	#undef mips64
 887 | 	#undef mips64el
 888 | 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
 889 | 	CPU=mips64el
 890 | 	#else
 891 | 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
 892 | 	CPU=mips64
 893 | 	#else
 894 | 	CPU=
 895 | 	#endif
 896 | 	#endif
 897 | EOF
 898 | 	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
 899 | 	    /^CPU/{
 900 | 		s: ::g
 901 | 		p
 902 | 	    }'`"
 903 | 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
 904 | 	;;
 905 |     or32:Linux:*:*)
 906 | 	echo or32-unknown-linux-gnu
 907 | 	exit ;;
 908 |     ppc:Linux:*:*)
 909 | 	echo powerpc-unknown-linux-gnu
 910 | 	exit ;;
 911 |     ppc64:Linux:*:*)
 912 | 	echo powerpc64-unknown-linux-gnu
 913 | 	exit ;;
 914 |     alpha:Linux:*:*)
 915 | 	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
 916 | 	  EV5)   UNAME_MACHINE=alphaev5 ;;
 917 | 	  EV56)  UNAME_MACHINE=alphaev56 ;;
 918 | 	  PCA56) UNAME_MACHINE=alphapca56 ;;
 919 | 	  PCA57) UNAME_MACHINE=alphapca56 ;;
 920 | 	  EV6)   UNAME_MACHINE=alphaev6 ;;
 921 | 	  EV67)  UNAME_MACHINE=alphaev67 ;;
 922 | 	  EV68*) UNAME_MACHINE=alphaev68 ;;
 923 |         esac
 924 | 	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
 925 | 	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
 926 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
 927 | 	exit ;;
 928 |     parisc:Linux:*:* | hppa:Linux:*:*)
 929 | 	# Look for CPU level
 930 | 	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
 931 | 	  PA7*) echo hppa1.1-unknown-linux-gnu ;;
 932 | 	  PA8*) echo hppa2.0-unknown-linux-gnu ;;
 933 | 	  *)    echo hppa-unknown-linux-gnu ;;
 934 | 	esac
 935 | 	exit ;;
 936 |     parisc64:Linux:*:* | hppa64:Linux:*:*)
 937 | 	echo hppa64-unknown-linux-gnu
 938 | 	exit ;;
 939 |     s390:Linux:*:* | s390x:Linux:*:*)
 940 | 	echo ${UNAME_MACHINE}-ibm-linux
 941 | 	exit ;;
 942 |     sh64*:Linux:*:*)
 943 |     	echo ${UNAME_MACHINE}-unknown-linux-gnu
 944 | 	exit ;;
 945 |     sh*:Linux:*:*)
 946 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 947 | 	exit ;;
 948 |     sparc:Linux:*:* | sparc64:Linux:*:*)
 949 | 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 950 | 	exit ;;
 951 |     vax:Linux:*:*)
 952 | 	echo ${UNAME_MACHINE}-dec-linux-gnu
 953 | 	exit ;;
 954 |     x86_64:Linux:*:*)
 955 | 	echo x86_64-unknown-linux-gnu
 956 | 	exit ;;
 957 |     xtensa:Linux:*:*)
 958 |     	echo xtensa-unknown-linux-gnu
 959 | 	exit ;;
 960 |     i*86:Linux:*:*)
 961 | 	# The BFD linker knows what the default object file format is, so
 962 | 	# first see if it will tell us. cd to the root directory to prevent
 963 | 	# problems with other programs or directories called `ld' in the path.
 964 | 	# Set LC_ALL=C to ensure ld outputs messages in English.
 965 | 	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
 966 | 			 | sed -ne '/supported targets:/!d
 967 | 				    s/[ 	][ 	]*/ /g
 968 | 				    s/.*supported targets: *//
 969 | 				    s/ .*//
 970 | 				    p'`
 971 |         case "$ld_supported_targets" in
 972 | 	  elf32-i386)
 973 | 		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
 974 | 		;;
 975 | 	  a.out-i386-linux)
 976 | 		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
 977 | 		exit ;;
 978 | 	  coff-i386)
 979 | 		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
 980 | 		exit ;;
 981 | 	  "")
 982 | 		# Either a pre-BFD a.out linker (linux-gnuoldld) or
 983 | 		# one that does not give us useful --help.
 984 | 		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
 985 | 		exit ;;
 986 | 	esac
 987 | 	# Determine whether the default compiler is a.out or elf
 988 | 	eval $set_cc_for_build
 989 | 	sed 's/^	//' << EOF >$dummy.c
 990 | 	#include <features.h>
 991 | 	#ifdef __ELF__
 992 | 	# ifdef __GLIBC__
 993 | 	#  if __GLIBC__ >= 2
 994 | 	LIBC=gnu
 995 | 	#  else
 996 | 	LIBC=gnulibc1
 997 | 	#  endif
 998 | 	# else
 999 | 	LIBC=gnulibc1
1000 | 	# endif
1001 | 	#else
1002 | 	#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
1003 | 	LIBC=gnu
1004 | 	#else
1005 | 	LIBC=gnuaout
1006 | 	#endif
1007 | 	#endif
1008 | 	#ifdef __dietlibc__
1009 | 	LIBC=dietlibc
1010 | 	#endif
1011 | EOF
1012 | 	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
1013 | 	    /^LIBC/{
1014 | 		s: ::g
1015 | 		p
1016 | 	    }'`"
1017 | 	test x"${LIBC}" != x && {
1018 | 		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
1019 | 		exit
1020 | 	}
1021 | 	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
1022 | 	;;
1023 |     i*86:DYNIX/ptx:4*:*)
1024 | 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
1025 | 	# earlier versions are messed up and put the nodename in both
1026 | 	# sysname and nodename.
1027 | 	echo i386-sequent-sysv4
1028 | 	exit ;;
1029 |     i*86:UNIX_SV:4.2MP:2.*)
1030 |         # Unixware is an offshoot of SVR4, but it has its own version
1031 |         # number series starting with 2...
1032 |         # I am not positive that other SVR4 systems won't match this,
1033 | 	# I just have to hope.  -- rms.
1034 |         # Use sysv4.2uw... so that sysv4* matches it.
1035 | 	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
1036 | 	exit ;;
1037 |     i*86:OS/2:*:*)
1038 | 	# If we were able to find `uname', then EMX Unix compatibility
1039 | 	# is probably installed.
1040 | 	echo ${UNAME_MACHINE}-pc-os2-emx
1041 | 	exit ;;
1042 |     i*86:XTS-300:*:STOP)
1043 | 	echo ${UNAME_MACHINE}-unknown-stop
1044 | 	exit ;;
1045 |     i*86:atheos:*:*)
1046 | 	echo ${UNAME_MACHINE}-unknown-atheos
1047 | 	exit ;;
1048 |     i*86:syllable:*:*)
1049 | 	echo ${UNAME_MACHINE}-pc-syllable
1050 | 	exit ;;
1051 |     i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
1052 | 	echo i386-unknown-lynxos${UNAME_RELEASE}
1053 | 	exit ;;
1054 |     i*86:*DOS:*:*)
1055 | 	echo ${UNAME_MACHINE}-pc-msdosdjgpp
1056 | 	exit ;;
1057 |     i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
1058 | 	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
1059 | 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
1060 | 		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
1061 | 	else
1062 | 		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
1063 | 	fi
1064 | 	exit ;;
1065 |     i*86:*:5:[678]*)
1066 |     	# UnixWare 7.x, OpenUNIX and OpenServer 6.
1067 | 	case `/bin/uname -X | grep "^Machine"` in
1068 | 	    *486*)	     UNAME_MACHINE=i486 ;;
1069 | 	    *Pentium)	     UNAME_MACHINE=i586 ;;
1070 | 	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
1071 | 	esac
1072 | 	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
1073 | 	exit ;;
1074 |     i*86:*:3.2:*)
1075 | 	if test -f /usr/options/cb.name; then
1076 | 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
1077 | 		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
1078 | 	elif /bin/uname -X 2>/dev/null >/dev/null ; then
1079 | 		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
1080 | 		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
1081 | 		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
1082 | 			&& UNAME_MACHINE=i586
1083 | 		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
1084 | 			&& UNAME_MACHINE=i686
1085 | 		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
1086 | 			&& UNAME_MACHINE=i686
1087 | 		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
1088 | 	else
1089 | 		echo ${UNAME_MACHINE}-pc-sysv32
1090 | 	fi
1091 | 	exit ;;
1092 |     pc:*:*:*)
1093 | 	# Left here for compatibility:
1094 |         # uname -m prints for DJGPP always 'pc', but it prints nothing about
1095 |         # the processor, so we play safe by assuming i386.
1096 | 	echo i386-pc-msdosdjgpp
1097 |         exit ;;
1098 |     Intel:Mach:3*:*)
1099 | 	echo i386-pc-mach3
1100 | 	exit ;;
1101 |     paragon:*:*:*)
1102 | 	echo i860-intel-osf1
1103 | 	exit ;;
1104 |     i860:*:4.*:*) # i860-SVR4
1105 | 	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
1106 | 	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
1107 | 	else # Add other i860-SVR4 vendors below as they are discovered.
1108 | 	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
1109 | 	fi
1110 | 	exit ;;
1111 |     mini*:CTIX:SYS*5:*)
1112 | 	# "miniframe"
1113 | 	echo m68010-convergent-sysv
1114 | 	exit ;;
1115 |     mc68k:UNIX:SYSTEM5:3.51m)
1116 | 	echo m68k-convergent-sysv
1117 | 	exit ;;
1118 |     M680?0:D-NIX:5.3:*)
1119 | 	echo m68k-diab-dnix
1120 | 	exit ;;
1121 |     M68*:*:R3V[5678]*:*)
1122 | 	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
1123 |     3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
1124 | 	OS_REL=''
1125 | 	test -r /etc/.relid \
1126 | 	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
1127 | 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
1128 | 	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
1129 | 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
1130 | 	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
1131 |     3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
1132 |         /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
1133 |           && { echo i486-ncr-sysv4; exit; } ;;
1134 |     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
1135 | 	echo m68k-unknown-lynxos${UNAME_RELEASE}
1136 | 	exit ;;
1137 |     mc68030:UNIX_System_V:4.*:*)
1138 | 	echo m68k-atari-sysv4
1139 | 	exit ;;
1140 |     TSUNAMI:LynxOS:2.*:*)
1141 | 	echo sparc-unknown-lynxos${UNAME_RELEASE}
1142 | 	exit ;;
1143 |     rs6000:LynxOS:2.*:*)
1144 | 	echo rs6000-unknown-lynxos${UNAME_RELEASE}
1145 | 	exit ;;
1146 |     PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
1147 | 	echo powerpc-unknown-lynxos${UNAME_RELEASE}
1148 | 	exit ;;
1149 |     SM[BE]S:UNIX_SV:*:*)
1150 | 	echo mips-dde-sysv${UNAME_RELEASE}
1151 | 	exit ;;
1152 |     RM*:ReliantUNIX-*:*:*)
1153 | 	echo mips-sni-sysv4
1154 | 	exit ;;
1155 |     RM*:SINIX-*:*:*)
1156 | 	echo mips-sni-sysv4
1157 | 	exit ;;
1158 |     *:SINIX-*:*:*)
1159 | 	if uname -p 2>/dev/null >/dev/null ; then
1160 | 		UNAME_MACHINE=`(uname -p) 2>/dev/null`
1161 | 		echo ${UNAME_MACHINE}-sni-sysv4
1162 | 	else
1163 | 		echo ns32k-sni-sysv
1164 | 	fi
1165 | 	exit ;;
1166 |     PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
1167 |                       # says <Richard.M.Bartel@ccMail.Census.GOV>
1168 |         echo i586-unisys-sysv4
1169 |         exit ;;
1170 |     *:UNIX_System_V:4*:FTX*)
1171 | 	# From Gerald Hewes <hewes@openmarket.com>.
1172 | 	# How about differentiating between stratus architectures? -djm
1173 | 	echo hppa1.1-stratus-sysv4
1174 | 	exit ;;
1175 |     *:*:*:FTX*)
1176 | 	# From seanf@swdc.stratus.com.
1177 | 	echo i860-stratus-sysv4
1178 | 	exit ;;
1179 |     i*86:VOS:*:*)
1180 | 	# From Paul.Green@stratus.com.
1181 | 	echo ${UNAME_MACHINE}-stratus-vos
1182 | 	exit ;;
1183 |     *:VOS:*:*)
1184 | 	# From Paul.Green@stratus.com.
1185 | 	echo hppa1.1-stratus-vos
1186 | 	exit ;;
1187 |     mc68*:A/UX:*:*)
1188 | 	echo m68k-apple-aux${UNAME_RELEASE}
1189 | 	exit ;;
1190 |     news*:NEWS-OS:6*:*)
1191 | 	echo mips-sony-newsos6
1192 | 	exit ;;
1193 |     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
1194 | 	if [ -d /usr/nec ]; then
1195 | 	        echo mips-nec-sysv${UNAME_RELEASE}
1196 | 	else
1197 | 	        echo mips-unknown-sysv${UNAME_RELEASE}
1198 | 	fi
1199 |         exit ;;
1200 |     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
1201 | 	echo powerpc-be-beos
1202 | 	exit ;;
1203 |     BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
1204 | 	echo powerpc-apple-beos
1205 | 	exit ;;
1206 |     BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
1207 | 	echo i586-pc-beos
1208 | 	exit ;;
1209 |     SX-4:SUPER-UX:*:*)
1210 | 	echo sx4-nec-superux${UNAME_RELEASE}
1211 | 	exit ;;
1212 |     SX-5:SUPER-UX:*:*)
1213 | 	echo sx5-nec-superux${UNAME_RELEASE}
1214 | 	exit ;;
1215 |     SX-6:SUPER-UX:*:*)
1216 | 	echo sx6-nec-superux${UNAME_RELEASE}
1217 | 	exit ;;
1218 |     SX-7:SUPER-UX:*:*)
1219 | 	echo sx7-nec-superux${UNAME_RELEASE}
1220 | 	exit ;;
1221 |     SX-8:SUPER-UX:*:*)
1222 | 	echo sx8-nec-superux${UNAME_RELEASE}
1223 | 	exit ;;
1224 |     SX-8R:SUPER-UX:*:*)
1225 | 	echo sx8r-nec-superux${UNAME_RELEASE}
1226 | 	exit ;;
1227 |     Power*:Rhapsody:*:*)
1228 | 	echo powerpc-apple-rhapsody${UNAME_RELEASE}
1229 | 	exit ;;
1230 |     *:Rhapsody:*:*)
1231 | 	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
1232 | 	exit ;;
1233 |     *:Darwin:*:*)
1234 | 	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
1235 | 	case $UNAME_PROCESSOR in
1236 | 	    unknown) UNAME_PROCESSOR=powerpc ;;
1237 | 	esac
1238 | 	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
1239 | 	exit ;;
1240 |     *:procnto*:*:* | *:QNX:[0123456789]*:*)
1241 | 	UNAME_PROCESSOR=`uname -p`
1242 | 	if test "$UNAME_PROCESSOR" = "x86"; then
1243 | 		UNAME_PROCESSOR=i386
1244 | 		UNAME_MACHINE=pc
1245 | 	fi
1246 | 	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
1247 | 	exit ;;
1248 |     *:QNX:*:4*)
1249 | 	echo i386-pc-qnx
1250 | 	exit ;;
1251 |     NSE-?:NONSTOP_KERNEL:*:*)
1252 | 	echo nse-tandem-nsk${UNAME_RELEASE}
1253 | 	exit ;;
1254 |     NSR-?:NONSTOP_KERNEL:*:*)
1255 | 	echo nsr-tandem-nsk${UNAME_RELEASE}
1256 | 	exit ;;
1257 |     *:NonStop-UX:*:*)
1258 | 	echo mips-compaq-nonstopux
1259 | 	exit ;;
1260 |     BS2000:POSIX*:*:*)
1261 | 	echo bs2000-siemens-sysv
1262 | 	exit ;;
1263 |     DS/*:UNIX_System_V:*:*)
1264 | 	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
1265 | 	exit ;;
1266 |     *:Plan9:*:*)
1267 | 	# "uname -m" is not consistent, so use $cputype instead. 386
1268 | 	# is converted to i386 for consistency with other x86
1269 | 	# operating systems.
1270 | 	if test "$cputype" = "386"; then
1271 | 	    UNAME_MACHINE=i386
1272 | 	else
1273 | 	    UNAME_MACHINE="$cputype"
1274 | 	fi
1275 | 	echo ${UNAME_MACHINE}-unknown-plan9
1276 | 	exit ;;
1277 |     *:TOPS-10:*:*)
1278 | 	echo pdp10-unknown-tops10
1279 | 	exit ;;
1280 |     *:TENEX:*:*)
1281 | 	echo pdp10-unknown-tenex
1282 | 	exit ;;
1283 |     KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
1284 | 	echo pdp10-dec-tops20
1285 | 	exit ;;
1286 |     XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
1287 | 	echo pdp10-xkl-tops20
1288 | 	exit ;;
1289 |     *:TOPS-20:*:*)
1290 | 	echo pdp10-unknown-tops20
1291 | 	exit ;;
1292 |     *:ITS:*:*)
1293 | 	echo pdp10-unknown-its
1294 | 	exit ;;
1295 |     SEI:*:*:SEIUX)
1296 |         echo mips-sei-seiux${UNAME_RELEASE}
1297 | 	exit ;;
1298 |     *:DragonFly:*:*)
1299 | 	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
1300 | 	exit ;;
1301 |     *:*VMS:*:*)
1302 |     	UNAME_MACHINE=`(uname -p) 2>/dev/null`
1303 | 	case "${UNAME_MACHINE}" in
1304 | 	    A*) echo alpha-dec-vms ; exit ;;
1305 | 	    I*) echo ia64-dec-vms ; exit ;;
1306 | 	    V*) echo vax-dec-vms ; exit ;;
1307 | 	esac ;;
1308 |     *:XENIX:*:SysV)
1309 | 	echo i386-pc-xenix
1310 | 	exit ;;
1311 |     i*86:skyos:*:*)
1312 | 	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
1313 | 	exit ;;
1314 |     i*86:rdos:*:*)
1315 | 	echo ${UNAME_MACHINE}-pc-rdos
1316 | 	exit ;;
1317 | esac
1318 | 
1319 | #echo '(No uname command or uname output not recognized.)' 1>&2
1320 | #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
1321 | 
1322 | eval $set_cc_for_build
1323 | cat >$dummy.c <<EOF
1324 | #ifdef _SEQUENT_
1325 | # include <sys/types.h>
1326 | # include <sys/utsname.h>
1327 | #endif
1328 | main ()
1329 | {
1330 | #if defined (sony)
1331 | #if defined (MIPSEB)
1332 |   /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
1333 |      I don't know....  */
1334 |   printf ("mips-sony-bsd\n"); exit (0);
1335 | #else
1336 | #include <sys/param.h>
1337 |   printf ("m68k-sony-newsos%s\n",
1338 | #ifdef NEWSOS4
1339 |           "4"
1340 | #else
1341 | 	  ""
1342 | #endif
1343 |          ); exit (0);
1344 | #endif
1345 | #endif
1346 | 
1347 | #if defined (__arm) && defined (__acorn) && defined (__unix)
1348 |   printf ("arm-acorn-riscix\n"); exit (0);
1349 | #endif
1350 | 
1351 | #if defined (hp300) && !defined (hpux)
1352 |   printf ("m68k-hp-bsd\n"); exit (0);
1353 | #endif
1354 | 
1355 | #if defined (NeXT)
1356 | #if !defined (__ARCHITECTURE__)
1357 | #define __ARCHITECTURE__ "m68k"
1358 | #endif
1359 |   int version;
1360 |   version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
1361 |   if (version < 4)
1362 |     printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
1363 |   else
1364 |     printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
1365 |   exit (0);
1366 | #endif
1367 | 
1368 | #if defined (MULTIMAX) || defined (n16)
1369 | #if defined (UMAXV)
1370 |   printf ("ns32k-encore-sysv\n"); exit (0);
1371 | #else
1372 | #if defined (CMU)
1373 |   printf ("ns32k-encore-mach\n"); exit (0);
1374 | #else
1375 |   printf ("ns32k-encore-bsd\n"); exit (0);
1376 | #endif
1377 | #endif
1378 | #endif
1379 | 
1380 | #if defined (__386BSD__)
1381 |   printf ("i386-pc-bsd\n"); exit (0);
1382 | #endif
1383 | 
1384 | #if defined (sequent)
1385 | #if defined (i386)
1386 |   printf ("i386-sequent-dynix\n"); exit (0);
1387 | #endif
1388 | #if defined (ns32000)
1389 |   printf ("ns32k-sequent-dynix\n"); exit (0);
1390 | #endif
1391 | #endif
1392 | 
1393 | #if defined (_SEQUENT_)
1394 |     struct utsname un;
1395 | 
1396 |     uname(&un);
1397 | 
1398 |     if (strncmp(un.version, "V2", 2) == 0) {
1399 | 	printf ("i386-sequent-ptx2\n"); exit (0);
1400 |     }
1401 |     if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
1402 | 	printf ("i386-sequent-ptx1\n"); exit (0);
1403 |     }
1404 |     printf ("i386-sequent-ptx\n"); exit (0);
1405 | 
1406 | #endif
1407 | 
1408 | #if defined (vax)
1409 | # if !defined (ultrix)
1410 | #  include <sys/param.h>
1411 | #  if defined (BSD)
1412 | #   if BSD == 43
1413 |       printf ("vax-dec-bsd4.3\n"); exit (0);
1414 | #   else
1415 | #    if BSD == 199006
1416 |       printf ("vax-dec-bsd4.3reno\n"); exit (0);
1417 | #    else
1418 |       printf ("vax-dec-bsd\n"); exit (0);
1419 | #    endif
1420 | #   endif
1421 | #  else
1422 |     printf ("vax-dec-bsd\n"); exit (0);
1423 | #  endif
1424 | # else
1425 |     printf ("vax-dec-ultrix\n"); exit (0);
1426 | # endif
1427 | #endif
1428 | 
1429 | #if defined (alliant) && defined (i860)
1430 |   printf ("i860-alliant-bsd\n"); exit (0);
1431 | #endif
1432 | 
1433 |   exit (1);
1434 | }
1435 | EOF
1436 | 
1437 | $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
1438 | 	{ echo "$SYSTEM_NAME"; exit; }
1439 | 
1440 | # Apollos put the system type in the environment.
1441 | 
1442 | test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
1443 | 
1444 | # Convex versions that predate uname can use getsysinfo(1)
1445 | 
1446 | if [ -x /usr/convex/getsysinfo ]
1447 | then
1448 |     case `getsysinfo -f cpu_type` in
1449 |     c1*)
1450 | 	echo c1-convex-bsd
1451 | 	exit ;;
1452 |     c2*)
1453 | 	if getsysinfo -f scalar_acc
1454 | 	then echo c32-convex-bsd
1455 | 	else echo c2-convex-bsd
1456 | 	fi
1457 | 	exit ;;
1458 |     c34*)
1459 | 	echo c34-convex-bsd
1460 | 	exit ;;
1461 |     c38*)
1462 | 	echo c38-convex-bsd
1463 | 	exit ;;
1464 |     c4*)
1465 | 	echo c4-convex-bsd
1466 | 	exit ;;
1467 |     esac
1468 | fi
1469 | 
1470 | cat >&2 <<EOF
1471 | $0: unable to guess system type
1472 | 
1473 | This script, last modified $timestamp, has failed to recognize
1474 | the operating system you are using. It is advised that you
1475 | download the most up to date version of the config scripts from
1476 | 
1477 |   http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
1478 | and
1479 |   http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
1480 | 
1481 | If the version you run ($0) is already up to date, please
1482 | send the following data and any information you think might be
1483 | pertinent to <config-patches@gnu.org> in order to provide the needed
1484 | information to handle your system.
1485 | 
1486 | config.guess timestamp = $timestamp
1487 | 
1488 | uname -m = `(uname -m) 2>/dev/null || echo unknown`
1489 | uname -r = `(uname -r) 2>/dev/null || echo unknown`
1490 | uname -s = `(uname -s) 2>/dev/null || echo unknown`
1491 | uname -v = `(uname -v) 2>/dev/null || echo unknown`
1492 | 
1493 | /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
1494 | /bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
1495 | 
1496 | hostinfo               = `(hostinfo) 2>/dev/null`
1497 | /bin/universe          = `(/bin/universe) 2>/dev/null`
1498 | /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
1499 | /bin/arch              = `(/bin/arch) 2>/dev/null`
1500 | /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
1501 | /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
1502 | 
1503 | UNAME_MACHINE = ${UNAME_MACHINE}
1504 | UNAME_RELEASE = ${UNAME_RELEASE}
1505 | UNAME_SYSTEM  = ${UNAME_SYSTEM}
1506 | UNAME_VERSION = ${UNAME_VERSION}
1507 | EOF
1508 | 
1509 | exit 1
1510 | 
1511 | # Local variables:
1512 | # eval: (add-hook 'write-file-hooks 'time-stamp)
1513 | # time-stamp-start: "timestamp='"
1514 | # time-stamp-format: "%:y-%02m-%02d"
1515 | # time-stamp-end: "'"
1516 | # End:
1517 | 


--------------------------------------------------------------------------------