test-rand-ontology.cpp

Go to the documentation of this file.

/*
  TestRandOntoloy  -  implementation of a test framework processing dummy data frames

   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

* *****************************************************************/

#include "steam/engine/test-rand-ontology.hpp"
#include "lib/hash-combine.hpp"
#include "lib/iter-zip.hpp"

#include <cmath>

using std::lround;
using lib::zip;


namespace steam {
namespace engine{
namespace test  {
//  namespace err = lumiera::error;
  
  namespace { // hidden local support facilities....
    
  } // (End) hidden impl details
  
  
  const string DUMMY_FUN_ID{"dummyFun(TestFrame)"};

  /* ========= Dummy implementation of Media processing ========= */

  void
  generateFrame (TestFrame* buff, size_t frameNr, uint flavour)
  {
    REQUIRE (buff);
    new(buff) TestFrame{uint(frameNr), flavour};
  }
  
  void
  generateMultichan (TestFrame* buffArry, uint chanCnt, size_t frameNr, uint flavour)
  {
    REQUIRE (buffArry);
    for (uint i=0; i<chanCnt; ++i)
      new(buffArry+i) TestFrame{uint(frameNr), flavour+i};
  }
  
  void
  duplicateMultichan (TestFrame* outArry, TestFrame* inArry, uint chanCnt)
  {
    REQUIRE (inArry);
    REQUIRE (outArry);
    for (uint i=0; i<chanCnt; ++i)
      new(outArry+i) TestFrame{inArry[i]};
  }
  
  void
  manipulateMultichan (TestFrame* buffArry, uint chanCnt, uint64_t param)
  {
    REQUIRE (buffArry);
    const uint SIZ = buffArry->data64().size();
    for (uint i=0; i<SIZ; ++i)
      {
        uint64_t feed{param};
        for (uint c=0; c<chanCnt; ++c)
          {
            auto& data = buffArry[c].data64()[i];
            lib::hash::combine(feed, data);
            data = feed;
          }
      }
    for (uint c=0; c<chanCnt; ++c)
      buffArry[c].markChecksum();
  }
  
  void
  manipulateFrame (TestFrame* out, TestFrame const* in, uint64_t param)
  {
    REQUIRE (in);
    REQUIRE (out);
    auto calculate = [](uint64_t chain, uint64_t val){ lib::hash::combine(chain,val); return chain; };
    for (auto& [res,src] : zip (out->data64(), in->data64()))
        res = calculate(param, src);
    out->markChecksum();
  }
  
  void
  combineFrames (TestFrame* out, TestFrame const* srcA, TestFrame const* srcB, double mix)
  {
    REQUIRE (srcA);
    REQUIRE (srcB);
    REQUIRE (out);
    for (auto& [res,inA,inB] : zip (out->data()
                                   ,srcA->data()
                                   ,srcB->data()))
        res = lround((1-mix)*inA + mix*inB);
    out->markChecksum();
  }
  
  
  
  /* =========== Test-Rand-Ontology ================ */
  
  lib::Depend<TestRandOntology> testRand;
  
  
  
}}} // namespace steam::engine::test