* File name: MFunc.cpp 
 * Location: See Matrox Example Launcher in the MIL Control Center
 * Synopsis:  This example shows the use of the MIL Function Developer Tool Kit and how 
 *            MIL and custom code can be mixed to create a custom MIL function that 
 *            accesses the data pointer of a MIL buffer directly in order to process it.
 *            The example creates a Master MIL function that registers all the parameters 
 *            to MIL and calls the Slave function. The Slave function retrieves all the 
 *            parameters, gets the pointers to the MIL image buffers, uses them to access 
 *            the data directly and adds a constant.
 *            Note: The images must be 8-bit unsigned and have a valid Host pointer.
 * Copyright (C) Matrox Electronic Systems Ltd., 1992-2020.
 * All Rights Reserved
#include <mil.h>

/* MIL function specifications. */
#define FUNCTION_NB_PARAM                 4

/* Target image file name. */
#define IMAGE_FILE M_IMAGE_PATH MIL_TEXT("BoltsNutsWashers.mim")

/* Master and Slave MIL functions declarations. */
MIL_INT AddConstant(MIL_ID SrcImageId, MIL_ID DstImageId, MIL_INT ConstantToAdd);
void MFTYPE SlaveAddConstant(MIL_ID Func);

/* Master MIL Function definition. */
/* ------------------------------- */

MIL_INT AddConstant(MIL_ID SrcImageId, MIL_ID DstImageId, MIL_INT ConstantToAdd)
   MIL_ID   Func;
   MIL_INT  SlaveReturnValue = 0;

   /* Allocate a MIL function context that will be used to call a target 
      Slave function locally on the Host to do the processing.
              SlaveAddConstant, M_NULL, M_NULL, 

   /* Register the parameters. */
   MfuncParamMilId( Func, 1, SrcImageId, M_IMAGE, M_IN);
   MfuncParamMilId( Func, 2, DstImageId, M_IMAGE, M_OUT);
   MfuncParamMilInt(Func, 3, ConstantToAdd);
   MfuncParamDataPointer(Func, 4, &SlaveReturnValue, sizeof(MIL_INT), M_OUT);

   /* Call the target Slave function. */

   /* Free the MIL function context. */
   /* Return the value recieved from the Slave function. */
   return SlaveReturnValue;

/* MIL Slave function definition. */
/* ------------------------------ */

void MFTYPE SlaveAddConstant(MIL_ID Func)
  MIL_ID    SrcImageId, DstImageId;
  MIL_INT   ConstantToAdd, TempValue;
  unsigned  char *SrcImageDataPtr, *DstImageDataPtr;
  MIL_INT   SrcImageSizeX, SrcImageSizeY, SrcImageType, SrcImagePitchByte;
  MIL_INT   DstImageSizeX, DstImageSizeY, DstImageType, DstImagePitchByte;
  MIL_INT   x, y;
  MIL_INT  *SlaveReturnValuePtr;

  /* Read the parameters. */
  MfuncParamValue(Func, 1, &SrcImageId);
  MfuncParamValue(Func, 2, &DstImageId);
  MfuncParamValue(Func, 3, &ConstantToAdd); 
  MfuncParamValue(Func, 4, &SlaveReturnValuePtr); 

  /* Lock buffers for direct access. */
  MbufControl(SrcImageId, M_LOCK, M_DEFAULT);
  MbufControl(DstImageId, M_LOCK, M_DEFAULT);

  /* Read image information. */
  MbufInquire(SrcImageId, M_HOST_ADDRESS, &SrcImageDataPtr);
  MbufInquire(SrcImageId, M_SIZE_X,       &SrcImageSizeX);
  MbufInquire(SrcImageId, M_SIZE_Y,       &SrcImageSizeY);
  MbufInquire(SrcImageId, M_TYPE,         &SrcImageType);
  MbufInquire(SrcImageId, M_PITCH_BYTE,   &SrcImagePitchByte);
  MbufInquire(DstImageId, M_HOST_ADDRESS, &DstImageDataPtr);
  MbufInquire(DstImageId, M_SIZE_X,       &DstImageSizeX);
  MbufInquire(DstImageId, M_SIZE_Y,       &DstImageSizeY);
  MbufInquire(DstImageId, M_TYPE,         &DstImageType);
  MbufInquire(DstImageId, M_PITCH_BYTE,   &DstImagePitchByte);

  /* Reduce the destination area to process if necessary. */
  if (SrcImageSizeX < DstImageSizeX)   DstImageSizeX = SrcImageSizeX;
  if (SrcImageSizeY < DstImageSizeY)   DstImageSizeY = SrcImageSizeY;

  /* If images have the proper type and a valid host pointer,
     execute the operation using custom C code.
  if ((SrcImageType == DstImageType) && (SrcImageType == FUNCTION_SUPPORTED_IMAGE_TYPE) &&
      (SrcImageDataPtr != M_NULL) && (DstImageDataPtr != M_NULL)
     /* Add the constant to the image. */
     for (y= 0; y < DstImageSizeY; y++)
        for (x= 0; x < DstImageSizeX; x++) 
           /* Calculate the value to write. */
           TempValue = (MIL_INT)SrcImageDataPtr[x] + (MIL_INT)ConstantToAdd;

           /* Write the value if no overflow, else saturate. */
           if (TempValue <= 0xff)
              DstImageDataPtr[x] = (unsigned char)TempValue;
              DstImageDataPtr[x] = 0xff;

         /* Move pointer to the next line taking into account the image's pitch. */
         SrcImageDataPtr += SrcImagePitchByte;
         DstImageDataPtr += DstImagePitchByte;
     /* Return a null error code to the Master function. */
     *SlaveReturnValuePtr = M_NULL;
     /* Buffer cannot be processed. Report an error. */ 
                      MIL_TEXT("Invalid parameter."),
                      MIL_TEXT("Image type not supported or invalid target system."),
                      MIL_TEXT("Image must be 8-bit and have a valid host address."),

     /* Return an error code to the Master function. */

  /* Unlock buffers. */
  MbufControl(SrcImageId, M_UNLOCK, M_DEFAULT);
  MbufControl(DstImageId, M_UNLOCK, M_DEFAULT);

  /* Signal to MIL that the destination buffer was modified. */
  MbufControl(DstImageId, M_MODIFIED, M_DEFAULT); 

/* Main to test the custom function. */
/* --------------------------------- */

int MosMain(void)
   MIL_ID  MilApplication,  /* Application identifier.       */
           MilSystem,       /* System identifier.            */ 
           MilDisplay,      /* Display identifier.           */
           MilImage;        /* Image buffer identifier.      */
   MIL_INT ReturnValue;     /* Return value of the function. */

   /* Allocate default application, system, display and image. */
   MappAllocDefault(M_DEFAULT, &MilApplication, &MilSystem, &MilDisplay, M_NULL, M_NULL);

   /* Load source image into a Host memory image buffer. */
               MbufDiskInquire(IMAGE_FILE, M_SIZE_X, M_NULL), 
               MbufDiskInquire(IMAGE_FILE, M_SIZE_Y, M_NULL), 
   MbufLoad(IMAGE_FILE, MilImage);
   /* Display the image. */
   MdispSelect(MilDisplay, MilImage);
   /* Pause. */
   MosPrintf(MIL_TEXT("This example creates a custom MIL function that processes\n"));
   MosPrintf(MIL_TEXT("an image using its data pointer directly.\n\n"));
   MosPrintf(MIL_TEXT("Target image was loaded.\n"));
   MosPrintf(MIL_TEXT("Press a key to continue.\n\n"));

   /* Run the custom function only if the target system's memory is local and accessible. */
   if (MsysInquire(MilSystem, M_LOCATION, M_NULL) == M_LOCAL)
      /* Process the image directly with the custom MIL function. */
      ReturnValue = AddConstant(MilImage, MilImage, 0x40);
      /* Print a conclusion message. */
      if (ReturnValue == M_NULL)
         MosPrintf(MIL_TEXT("The white level of the image was augmented.\n"));
         MosPrintf(MIL_TEXT("An error was returned by the Slave function.\n"));
      /* Print that the example don't run remotely. */
      MosPrintf(MIL_TEXT("This example doesn't run with Distributed MIL.\n"));
   /* Wait for a key to terminate. */
   MosPrintf(MIL_TEXT("Press a key to terminate.\n\n"));

   /* Free all allocations. */
   MappFreeDefault(MilApplication, MilSystem, MilDisplay, M_NULL, M_NULL);

   return 0;