mg_video.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2008 Ocean Blue Software Ltd
 *
 * 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 <string.h>
#include "dvb_video.h"
#include "mg_video.h"
#include "mg_api.h"
#include "mg_osd.h"

#include "mh5profile.h"
#include "mh5debug.h"

#include "glue_main.h"

#ifdef INCLUDE_ICS
#include "dvb_ics.h"
#endif


typedef struct _S_Region
{
   S32BIT left;
   S32BIT top;
   S32BIT right;
   S32BIT bottom;
} S_Region;


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

/* Initial values are unlikely to be used in a real application */
static MHEG5Bool mg_subtitle_on = MHEG5TRUE;
static MHEG5Bool mg_full_screen = MHEG5TRUE;
static S_RECTANGLE mg_video_scaling = { -1000, -1000, 1000, 1000 };
#ifdef INCLUDE_FREESAT
static S_RECTANGLE mg_image_scaling = { -1000, -1000, 1000, 1000 };
#endif

static void Mheg5ToScalingCoordinates( S_RECTANGLE *rect )
{
   S32BIT tmp;
   /* Translate according to MHEG5 HD rules */
   DBGTRACE(TGRAPHICS, " RatioX (%d/%d)", mg_ctxt.vid_x.mlt, mg_ctxt.vid_x.div);
   tmp = rect->left + rect->width;
   rect->left = (rect->left * mg_ctxt.vid_x.mlt) / mg_ctxt.vid_x.div;
   tmp = (tmp * mg_ctxt.vid_x.mlt) / mg_ctxt.vid_x.div;
   rect->width = tmp - rect->left;
   DBGTRACE(TGRAPHICS, " RatioY (%d/%d)", mg_ctxt.vid_y.mlt, mg_ctxt.vid_y.div);
   tmp = rect->top + rect->height;
   rect->top = (rect->top * mg_ctxt.vid_y.mlt) / mg_ctxt.vid_y.div;
   tmp = (tmp * mg_ctxt.vid_y.mlt) / mg_ctxt.vid_y.div;
   rect->height = tmp - rect->top;
   DBGTRACE(TGRAPHICS,"%ux%u", rect->width, rect->height);
}


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

void MG_SetSubtitleMode(MHEG5Bool subtitleOn)
{
   if (mg_subtitle_on != subtitleOn)
   {
      mg_subtitle_on = subtitleOn;
      if (subtitleOn && mg_full_screen)
      {
         DVB_MhegSubtitleSetVisibility(MHEG5_DVB_SUBTITLE_SHOW);
      }
      else
      {
         DVB_MhegSubtitleSetVisibility(MHEG5_DVB_SUBTITLE_HIDE);
      }
   }
}

void MG_SetVideoPosition( MHEG5Video *video, MHEG5Int contentHook )
{
   S_Region rgn;
   S32BIT xOffset, yOffset;
   S_RECTANGLE new_video_scaling;
   MHEG5Bool fullscreen = MHEG5FALSE;

   if (video && video->visible.ingredient.root.runningStatus)
   {
      rgn.left = video->visible.position[0];
      rgn.top = video->visible.position[1];
      rgn.right = video->visible.position[0] + video->visible.boxSize[0];
      rgn.bottom = video->visible.position[1] + video->visible.boxSize[1];

      xOffset = video->visible.position[0] + video->xOffset;
      yOffset = video->visible.position[1] + video->yOffset;
      new_video_scaling.left = xOffset;
      new_video_scaling.top = yOffset;
      TRACE(TGRAPHICS | TSTRM | TSTATE, ("rgn=(%d,%d,%d,%d) offset=(%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom, xOffset, yOffset))

      /*clip to SD coordinate screen*/
      if (rgn.left < 0)
         rgn.left = 0;
      else if (rgn.left > mg_ctxt.input_width)
         rgn.left = mg_ctxt.input_width;

      if (rgn.top < 0)
         rgn.top = 0;
      else if (rgn.top > mg_ctxt.input_height)
         rgn.top = mg_ctxt.input_height;

      if (rgn.right > mg_ctxt.input_width)
         rgn.right = mg_ctxt.input_width;
      else if (rgn.right < 0)
         rgn.right = 0;

      if (rgn.bottom > mg_ctxt.input_height)
         rgn.bottom = mg_ctxt.input_height;
      else if (rgn.bottom < 0)
         rgn.bottom = 0;
      TRACE(TGRAPHICS | TSTRM | TSTATE, ("rgn=(%d,%d,%d,%d) offset=(%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom, xOffset, yOffset))

      /* Check for sensible width/height */
      if (rgn.right < rgn.left) rgn.right = rgn.left;
      if (rgn.bottom < rgn.top) rgn.bottom = rgn.top;

      /* Check whether offset clips output */
      if (video->scaleSet)
      {
         if (xOffset + video->xScale < rgn.right)
         {
            rgn.right = video->xScale + xOffset;
         }
         if (yOffset + video->yScale < rgn.bottom)
         {
            rgn.bottom = video->yScale + yOffset;
         }
      }
      else
      {
         if (xOffset + mg_ctxt.input_width < rgn.right)
         {
            rgn.right = mg_ctxt.input_width + xOffset;
         }
         if (yOffset + mg_ctxt.input_height < rgn.bottom)
         {
            rgn.bottom = mg_ctxt.input_height + yOffset;
         }
      }
      if (rgn.left < xOffset)
      {
         rgn.left = xOffset;
         xOffset = 0;
      }
      else
      {
         xOffset = rgn.left - xOffset;
      }
      if (rgn.top < yOffset)
      {
         rgn.top = yOffset;
         yOffset = 0;
      }
      else
      {
         yOffset = rgn.top - yOffset;
      }
      TRACE(TGRAPHICS | TSTRM | TSTATE, ("rgn=(%d,%d,%d,%d) offset=(%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom, xOffset, yOffset));

      if (!video->scaleSet)
      {
         TRACE(TGRAPHICS | TSTRM | TSTATE, ("No SCALE rgn=(%d,%d,%d,%d) offset=(%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom, xOffset, yOffset))
         new_video_scaling.width = (U16BIT)SD_WIDTH;
         new_video_scaling.height = (U16BIT)SD_HEIGHT;
         if (new_video_scaling.left == 0 && new_video_scaling.top == 0)
         {
            fullscreen = MHEG5TRUE;
         }
      }
      else
      {
         TRACE(TGRAPHICS | TSTRM | TSTATE, ("SCALE(%d,%d) rgn=(%d,%d,%d,%d) offset=(%d,%d)", (int)video->xScale, (int)video->yScale,
                                    rgn.left, rgn.top, rgn.right, rgn.bottom, xOffset, yOffset))
         new_video_scaling.width = (U16BIT)video->xScale;
         new_video_scaling.height = (U16BIT)video->yScale;
         if (new_video_scaling.left == 0 && new_video_scaling.top == 0 &&
            new_video_scaling.width == SD_WIDTH && new_video_scaling.height == SD_HEIGHT)
         {
            fullscreen = MHEG5TRUE;
         }
      }
   }
   else
   {
      TRACE(TGRAPHICS | TSTRM | TSTATE, ("default video position"))
      new_video_scaling.top = 0;
      new_video_scaling.left = 0;
      new_video_scaling.width = SD_WIDTH;
      new_video_scaling.height = SD_HEIGHT;
      fullscreen = MHEG5TRUE;
   }
  #ifdef INCLUDE_FREESAT
   if (contentHook == CHOOK_BITMAP_IMAGE_PLANE_IFRAME)
   {
      if (new_video_scaling.height != mg_image_scaling.height ||
          new_video_scaling.width != mg_image_scaling.width ||
          new_video_scaling.left != mg_image_scaling.left ||
          new_video_scaling.top != mg_image_scaling.top
          )
      {
         mg_image_scaling = new_video_scaling;
         if (fullscreen)
         {
            DVB_MhegSetImageScaling( NULL );
         }
         else
         {
            /* only after assigning values to global can we translate to final
             * coordinates. Otherwise VideoToGraphics will be wrong */
            Mheg5ToScalingCoordinates( &new_video_scaling );
            DVB_MhegSetImageScaling( &new_video_scaling );
         }
      }
   }
   else
  #endif
   if (new_video_scaling.height != mg_video_scaling.height ||
       new_video_scaling.width != mg_video_scaling.width ||
       new_video_scaling.left != mg_video_scaling.left ||
       new_video_scaling.top != mg_video_scaling.top
       )
   {
      mg_video_scaling = new_video_scaling;
      if (fullscreen)
      {
         DVB_MhegSetVideoScaling( NULL );
      }
      else
      {
         /* only after assigning values to global can we translate to final
          * coordinates. Otherwise VideoToGraphics will be wrong */
         Mheg5ToScalingCoordinates( &new_video_scaling );
         DVB_MhegSetVideoScaling( &new_video_scaling );
      }
   }
   if (mg_full_screen != fullscreen)
   {
      mg_full_screen = fullscreen;
      if (fullscreen && mg_subtitle_on)
      {
         DVB_MhegSubtitleSetVisibility(MHEG5_DVB_SUBTITLE_SHOW);
      }
      else
      {
         DVB_MhegSubtitleSetVisibility(MHEG5_DVB_SUBTITLE_HIDE);
      }
   }
}

void MG_DisplayVideoToGraphics( MHEG5Int videoXval, MHEG5Int videoYval,
   MHEG5Int *graphicsXVal, MHEG5Int *graphicsYVal )
{
   E_FORMAT_CONVERSION formatConversion;
   BOOLEAN scaled;
   S32BIT width = (S32BIT)mg_video_scaling.width;
   S32BIT height = (S32BIT)mg_video_scaling.height;
#ifdef INCLUDE_USER_DEFINED_VTG
   S32BIT xVal, yVal;
#endif  /* INCLUDE_USER_DEFINED_VTG */

   scaled = TRUE;
   formatConversion = DVB_MhegGetDecoderFormatConversion();
   switch (formatConversion)
   {
      case FORMAT_CONVERSION_UNKNOWN:
      case FORMAT_CONVERSION_IGNORE:
         *graphicsXVal = width * videoXval;
         *graphicsYVal = height * videoYval;
         break;
      case FORMAT_CONVERSION_PANSCAN:
         *graphicsXVal = width * (8 * videoXval - SD_WIDTH) / 6;
         *graphicsYVal = height * videoYval;
         break;
      case FORMAT_CONVERSION_LETTERBOX:
         *graphicsXVal = width * videoXval;
         *graphicsYVal = height * (6 * videoYval + SD_HEIGHT) / 8;
         break;
      case FORMAT_CONVERSION_LETTERBOX_14_9:
         *graphicsXVal = width * (16 * videoXval - SD_WIDTH) / 14;
         *graphicsYVal = height * (12 * videoYval + SD_HEIGHT) / 14;
         break;
      case FORMAT_CONVERSION_PILLAR_BOX:
         *graphicsXVal = width * (6 * videoXval + SD_WIDTH) / 8;
         *graphicsYVal = height * videoYval;
         break;
      case FORMAT_CONVERSION_ZOOM_4_3:
         *graphicsXVal = width * videoXval;
         *graphicsYVal = height * (8 * videoYval - SD_HEIGHT) / 6;
         break;
      case FORMAT_CONVERSION_CENTRE_4_3:
         *graphicsXVal = width * (8 * videoXval - SD_WIDTH) / 6;
         *graphicsYVal = height * (8 * videoYval - SD_HEIGHT) / 6;
         break;
      case FORMAT_CONVERSION_ZOOM_14_9:
         *graphicsXVal = width * (14 * videoXval + SD_WIDTH) / 16;
         *graphicsYVal = height * (14 * videoYval - SD_HEIGHT) / 12;
         break;
      case FORMAT_CONVERSION_PANSCAN_14_9:
         *graphicsXVal = width * (14 * videoXval - SD_WIDTH) / 12;
         *graphicsYVal = height * (14 * videoYval - SD_HEIGHT) / 12;
         break;
      case FORMAT_CONVERSION_CENTRE_14_9:
         *graphicsXVal = width * (16 * videoXval - SD_WIDTH) / 14;
         *graphicsYVal = height * (16 * videoYval - SD_HEIGHT) / 14;
         break;
#ifdef INCLUDE_USER_DEFINED_VTG
      case FORMAT_CONVERSION_USER_DEFINED:
         tmMHEG5VideoToGraphics(videoXval, videoYval, &xVal, &yVal);
         *graphicsXVal = ((xVal * mg_ctxt.vid_x.div + mg_ctxt.vid_x.mlt / 2) /
                          mg_ctxt.vid_x.mlt);
         *graphicsYVal = ((yVal * mg_ctxt.vid_y.div + mg_ctxt.vid_y.mlt / 2) /
                          mg_ctxt.vid_y.mlt);
         scaled = FALSE;
         break;
#endif  /* INCLUDE_USER_DEFINED_VTG */
      default:
         *graphicsXVal = width * videoXval;
         *graphicsYVal = height * videoYval;
   }

   if (scaled)
   {
      *graphicsXVal = ((*graphicsXVal + SD_WIDTH / 2) / SD_WIDTH +
                       mg_video_scaling.left);
      *graphicsYVal = ((*graphicsYVal + SD_HEIGHT / 2) / SD_HEIGHT +
                       mg_video_scaling.top);
   }
}

void MG_VideoPositionReset(void)
{
   memset(&mg_video_scaling, 0, sizeof(S_RECTANGLE));
   /* do not set mg_full_screen to either MHEG5TRUE or MHEG5FALSE,
    * so that MG_SetVideoPosition() will be forced to call DVB_MhegSubtitleSetVisibility() */
   mg_full_screen = TRUE;
}