mh5bitmap.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "mh5application.h"     /* Application class header file. */
#include "mh5bitmap.h"          /* Bitmap class header file. */
#include "mh5object.h"          /* For actions. */
#include "mh5variable.h"        /* For actions. */
#include "mh5display.h"         /* For actions. */
#include "mh5memory.h"          /* For constructor/destructor. */
#include "mh5debug.h"           /* Debug header file. */
#include "mh5misc.h"
#include "mh5profile.h"
#include "mg_api.h"

#ifdef MH5PRINTOUT              /* Check if MHEG5 printout is required. */
#include <string.h>             /* String mani[ulation functions. */
#endif

/*---constant definitions for this file--------------------------------------*/


/*---local typedef structs for this file-------------------------------------*/

/*---local (static) variable declarations for this file----------------------*/

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/


#ifdef MH5PRINTOUT

void MHEG5bitmapPrint(MHEG5Bitmap *bitmap, char *out)
{
   /* Inherited class */
   MHEG5visiblePrint(&bitmap->visible, out);

   /* Exchanged attributes */
   if (bitmap->tiling)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":Tiling TRUE");
      MHEG5newLine(out);
   }

   if (bitmap->originalTransparency != 0)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, ":originalTransparency ");
      MHEG5intPrint(bitmap->originalTransparency, out);
      MHEG5newLine(out);
   }
}

#endif

void MHEG5bitmapInit(MHEG5Bitmap *bitmap)
{
   assert(bitmap);

   MHEG5visibleInit(&bitmap->visible);
}

void MHEG5bitmapFree(MHEG5Bitmap *bitmap)
{
   assert(bitmap);

   MHEG5visibleFree(&bitmap->visible);
}

MHEG5Bitmap* MHEG5bitmapClone(MHEG5Bitmap *source)
{
   MHEG5Bitmap *destination;

   assert(source);
   destination = (MHEG5Bitmap *)MHEG5getMem( sizeof(MHEG5Bitmap));
   if (destination != NULL)
   {
      memset( destination, 0, sizeof(MHEG5Bitmap));
      destination->visible.ingredient.root.clazz = MHEG5BITMAP;

      MHEG5visibleClone(&destination->visible, &source->visible);
      destination->tiling = source->tiling;
      destination->originalTransparency = source->originalTransparency;
   }
   return destination;
}

void MHEG5bitmapPrepare(MHEG5Bitmap *bitmap)
{
   assert(bitmap);
   bitmap->transparency = bitmap->originalTransparency;
   bitmap->xOffset = 0;
   bitmap->yOffset = 0;
   bitmap->scaleSet = MHEG5FALSE;

   MHEG5visiblePrepare(&bitmap->visible);
}

void MHEG5bitmapActivate(MHEG5Bitmap *bitmap)
{
   assert(bitmap);

   if (!bitmap->visible.ingredient.root.runningStatus)
   {
      if (!bitmap->visible.ingredient.root.availabilityStatus)
      {
         MHEG5bitmapPrepare( bitmap );
      }
      if (bitmap->visible.ingredient.contentHook == MHEG5CHOOK_UNDEFINED)
      {
         MHEG5Application *cp = MHEG5getCurrentApplication();
         if (cp)
         {
            bitmap->visible.ingredient.contentHook = cp->bitmapContentHook;
         }
      }
      /* Check whether this is an I-frame */
      if (bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_NORMAL_IFRAME ||
          bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_H264_IFRAME
          #ifdef INCLUDE_FREESAT
          || bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_IMAGE_PLANE_IFRAME
          #endif
          )
      {
         /* Check that we have something to show */
         if ((bitmap->visible.ingredient.data != NULL) &&
             (bitmap->visible.ingredient.dataLen > 0))
         {
            /* Start displaying I-Frame */
            MHEG5displayIFrameStart( bitmap );
         }
      }

      MHEG5visibleActivate(&bitmap->visible);
   }
}

void MHEG5bitmapDeactivate(MHEG5Bitmap *bitmap)
{
   assert(bitmap);

   if (bitmap->visible.ingredient.root.runningStatus)
   {
      switch (bitmap->visible.ingredient.contentHook)
      {
         case CHOOK_BITMAP_PNG:
         case CHOOK_BITMAP_JPG:
            if (bitmap->visible.graphic_data != NULL)
            {
               MG_FreeData( bitmap->visible.graphic_data );
               bitmap->visible.graphic_data = NULL;
            }
            break;

         case CHOOK_BITMAP_H264_IFRAME:
         case CHOOK_BITMAP_NORMAL_IFRAME:
            /* If this is an I-frame bitmap, reset the scaling of the video decoder */
            MHEG5displayIFrameStop();
            break;

         #ifdef INCLUDE_FREESAT
         case CHOOK_BITMAP_IMAGE_PLANE_IFRAME:
            MHEG5displayImagePlaneStop();
            break;
         #endif

         default:;
      }
      MHEG5visibleDeactivate(&bitmap->visible);
   }
}

void MHEG5bitmapDestruct(MHEG5Bitmap *bitmap)
{
   assert(bitmap);
   MHEG5visibleDestruct(&bitmap->visible);
   if (bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_NORMAL_IFRAME ||
       bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_H264_IFRAME
     #ifdef INCLUDE_FREESAT
       || bitmap->visible.ingredient.contentHook == CHOOK_BITMAP_IMAGE_PLANE_IFRAME
     #endif
       )
   {
      MHEG5displayIframeDestroy( bitmap );
   }
}

/* Bitmap Actions. */

MHEG5ErrorCode MHEG5scaleBitmap(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam;
   MHEG5Int x = 0, y = 0;

   assert(target);

   if (target->clazz != MHEG5BITMAP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   thirdParam = MHEG5resolveGenericInteger(params, &x);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   MHEG5resolveGenericInteger(thirdParam, &y);

   if ((x > 0) && (y > 0))
   {
      ((MHEG5Bitmap *)target)->scaleSet = MHEG5TRUE;
      ((MHEG5Bitmap *)target)->xscale = x;
      ((MHEG5Bitmap *)target)->yscale = y;

      if (target->runningStatus)
      {
         if (((MHEG5Ingredient *)target)->contentHook == CHOOK_BITMAP_NORMAL_IFRAME ||
             ((MHEG5Ingredient *)target)->contentHook == CHOOK_BITMAP_H264_IFRAME
             )
         {
            MHEG5displayVideoPositionUpdate();
         }
      }
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setTransparency(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int tr = -1;

   if (target->clazz != MHEG5BITMAP)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(params, &tr);

   if ((tr >= 0) && (tr <= 100))
   {
      ((MHEG5Bitmap *) target)->transparency = tr;
      MHEG5displayRedraw((MHEG5Visible *) target);
   }
   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5setBitmapDecodeOffset(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Bitmap *bitmap = 0;
   MHEG5Int xOffset = 0, yOffset = 0;

   assert(target);

   if (target->clazz != MHEG5BITMAP)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &xOffset);

   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveGenericInteger(thirdParam, &yOffset);

   bitmap = (MHEG5Bitmap *)target;
   bitmap->xOffset = xOffset;
   bitmap->yOffset = yOffset;
   if (bitmap->visible.ingredient.root.runningStatus)
   {
      MHEG5displayVideoPositionUpdate();
   }

   return MHEG5ERR_NOERROR;
}

MHEG5ErrorCode MHEG5getBitmapDecodeOffset(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0;
   MHEG5Root *xOffset, *yOffset;
   MHEG5Bitmap *bitmap;

   assert(target);

   if (target->clazz != MHEG5BITMAP)
   {
      return MHEG5ERR_WRONGTARGET;
   }
   bitmap = (MHEG5Bitmap *)target;

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveORef(params, &xOffset);

   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   MHEG5resolveORef(thirdParam, &yOffset);

   if (!xOffset || !yOffset)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (xOffset->clazz != MHEG5INTEGERVARIABLE ||
       yOffset->clazz != MHEG5INTEGERVARIABLE)
   {
      return MHEG5ERR_WRONGPARAM;
   }
   if (!xOffset->runningStatus || !yOffset->runningStatus)
   {
      return MHEG5ERR_PARAMNOTACTIVE;
   }

   ((MHEG5IntegerVariable *) xOffset)->value = bitmap->xOffset;
   ((MHEG5IntegerVariable *) yOffset)->value = bitmap->yOffset;

   return MHEG5ERR_NOERROR;
}