mg_bmp.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
 *******************************************************************************/
#undef DEBUG_FUNCTION

/*---includes for this file--------------------------------------------------*/
/* compiler library header files */
#include <stdlib.h>
#include <string.h>  /* memset */
#include <stdio.h>

/* OBS header files */
#include "mg_api.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "osd_utils.h"
#include "mg_osd.h"
#include "decoder.h"
#include "mh5bitmap.h" /* Bitmap class header file. */

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


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


/*---static function definitions---------------------------------------------*/

static void DrawBmpOnSurface( S_IMAGE *s_bmp, S_SURFACE *d_surf, int tiling,
   int left, int top, int width, int height )
{
   U32BIT d_width, d_height;

   d_width = s_bmp->width;
   d_height = s_bmp->height;

   if (s_bmp->y_resolution == 5315)
   {
      /* PNG ready for 1920x1080 screen. */
      if (mg_ctxt.out_osd_height != 1080)
      {
         /* 720 -> 1920 is multiply by 8/3 */

         /*width is already scaled for 1920x1080
            need to scale down to actual resolution
            w' = w / 1920 * actual

            other order:
            w' = w * actual / 1920

            but we don't have the actual resolution. It's stored as 16/9 for 1280x720 (for example)
            we also don't have 1920, but 8/3

            so

            w' = w * (actual/720) / (1920/720)
            w' = w * (actual * 720) / (1920 * 720)

            but this may overflow (actually would never overflow)

            w' = w * (screen_x/norm_x) / (8/3)
            w' = w * (screen_x/norm_x) * (3/8)
            w' = (w * screen_x * 3) / (norm_x * 8)

            We then round it by
            w' = ( w * screen_x * 3 + (norm_x * 8)/2 ) / (norm_x * 8)

          */

         d_width *= mg_ctxt.osd_x.mlt * 3;
         d_width += (mg_ctxt.osd_x.div << 2);
         d_width /= (mg_ctxt.osd_x.div << 3);
         /* 576 -> 1080 is multiply by 15/8 */
         d_height *= mg_ctxt.osd_y.mlt << 3;
         d_height += (mg_ctxt.osd_y.div * 15) >> 1;
         d_height /= (mg_ctxt.osd_y.div * 15);
      }
   }
   else if (s_bmp->y_resolution == 3543)
   {
      /* PNG ready for 1280x720 screen */
      if (mg_ctxt.out_osd_height != 720)
      {
         /* 720 -> 1280 is multiply by 16/9 */
         d_width *= mg_ctxt.osd_x.mlt * 9;
         d_width += (mg_ctxt.osd_x.div << 3);
         d_width /= (mg_ctxt.osd_x.div << 4);
         /* 576 -> 720 is multiply by 5/4 */
         d_height *= mg_ctxt.osd_y.mlt << 3;
         d_height += (mg_ctxt.osd_y.div * 5);
         d_height /= (mg_ctxt.osd_y.div * 10);
      }
   }
   else
   {
      if (mg_ctxt.out_osd_height != 576)
      {

         /* The PNG is ready for 720x576, needs to be scaled up to actual resolution

            w' = w * actual_x / 720
            h' = h * actual_y / 576

            Not allowed to do this directly, due to intelligent rendering
            Instead, we have to calculate for left and right separately
          */
         d_width = HD_X_SCALEUP(left + d_width) - HD_X_SCALEUP(left);
         d_height = HD_Y_SCALEUP(top + d_height) - HD_Y_SCALEUP(top);
      }
   }

   d_surf->opaque = s_bmp->opaque;
   if (!tiling)
   {
      d_surf->width = d_width;
      d_surf->height = d_height;
      d_surf->buff_pitch = d_width * BytesPerPixel(mg_ctxt.colour_format);
      d_surf->hw_handle = DEC_OSDCreateBmpSurf( d_width, d_height, d_width, d_height,
            s_bmp, &d_surf->buff_pitch );
   }
   else
   {
      d_surf->width = (((left + width) * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div) -
         ((left * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div);
      if (d_surf->width < d_width)
         d_surf->width = d_width;
      d_surf->height = (((top + height) * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div) -
         ((top * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div);
      if (d_surf->height < d_height)
         d_surf->height = d_height;
      d_surf->opaque = s_bmp->opaque;
      d_surf->buff_pitch = d_surf->width * BytesPerPixel(mg_ctxt.colour_format);
      d_surf->hw_handle = DEC_OSDCreateBmpSurf( d_surf->width, d_surf->height, d_width, d_height,
            s_bmp, &d_surf->buff_pitch );
   }
}

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

void MG_DrawPng( void *data, int len, MHEG5Visible *visible )
{
   S_IMAGE *bmp;
   S_SURFACE *b_srf;

   assert( visible->graphic_data == NULL );

   if (data && len && visible->boxSize[0] != 0 && visible->boxSize[1] != 0)
   {
      bmp = DEC_DecodePng( data, len );
      if (bmp)
      {
         TRACE(TGRAPHICS, ("decode bmp: w=%d h=%d", bmp->width, bmp->height))
         b_srf = OSD_MemAlloc( sizeof(S_SURFACE));
         if (b_srf != NULL)
         {
            IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
            {
            #ifdef OSD_8_BIT
               U32BIT sz = bmp->width * bmp->height;
               /* Not HD so no scaling up */
               assert( mg_ctxt.osd_y.mlt == mg_ctxt.osd_y.div );
               b_srf->col_buff = OSD_MemAlloc( sz );
               if (b_srf->col_buff == NULL)
               {
                  OSD_MemFree( b_srf );
                  b_srf = NULL;
               }
               else
               {
                  b_srf->width = bmp->width;
                  b_srf->height = bmp->height;
                  b_srf->opaque = bmp->opaque;
                  b_srf->srf_type = SRF_TYPE_PNG;
                  b_srf->buff_pitch = bmp->width;
                  b_srf->hw_handle = NULL; /*assign to something sensible*/
                  memcpy( b_srf->col_buff, bmp->col_buff, sz );
                  TRACE(TGRAPHICS, ("copied bmp"))
                  /*TRACE_BUFF(TGRAPHICS,b_srf->col_buff,bmp->width)*/
               }
            #endif /*OSD_8_BIT*/
            }
            ELSE
            {
            #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
               DrawBmpOnSurface( bmp, b_srf, ((MHEG5Bitmap *) visible)->tiling,
                  visible->position[0], visible->position[1], visible->boxSize[0], visible->boxSize[1] );
               if (b_srf->hw_handle == NULL)
               {
                  OSD_MemFree( b_srf );
                  b_srf = NULL;
               }
               #ifdef SRF_MEM_DGB
               else
               {
                  OSD_DbgAddSurf( b_srf );
               }
               #endif
            #endif
            }
         }
         DEC_FreePng( bmp );
      }
      else
      {
         if (data != NULL && len > 0)
         {
            TRACE(TERROR, ("DEC_DecodePng returned NULL"))
         }
         b_srf = 0;
      }
      visible->graphic_data = b_srf;
   }
}

void MG_DrawJpg( void *data, int len, MHEG5Visible *visible )
{
   S_SURFACE *b_srf = 0;
   S_IMAGE *bmp;

   if (data && len && visible->boxSize[0] != 0 && visible->boxSize[1] != 0)
   {
      bmp = DEC_DecodeJpg( data, len );
      if (bmp)
      {
         b_srf = OSD_MemAlloc( sizeof(S_SURFACE));
         if (b_srf != NULL)
         {
            IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
            {
            #ifdef OSD_8_BIT
               U32BIT sz = bmp->width * bmp->height;
               /* Not HD so no scaling up */
               assert( mg_ctxt.osd_y.mlt == mg_ctxt.osd_y.div );
               b_srf->col_buff = OSD_MemAlloc( sz );
               if (b_srf->col_buff == NULL)
               {
                  OSD_MemFree( b_srf );
                  b_srf = NULL;
               }
               else
               {
                  b_srf->width = bmp->width;
                  b_srf->height = bmp->height;
                  b_srf->opaque = bmp->opaque;
                  b_srf->srf_type = SRF_TYPE_JPG;
                  b_srf->buff_pitch = bmp->width;
                  b_srf->hw_handle = NULL; /*assign to something sensible*/
                  memcpy( b_srf->col_buff, bmp->col_buff, sz );
               }
            #endif /*OSD_8_BIT*/
            }
            ELSE
            {
            #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
               DrawBmpOnSurface( bmp, b_srf, ((MHEG5Bitmap *) visible)->tiling,
                  visible->position[0], visible->position[1], visible->boxSize[0], visible->boxSize[1] );
               if (b_srf->hw_handle == NULL)
               {
                  OSD_MemFree( b_srf );
                  b_srf = NULL;
               }
               #ifdef SRF_MEM_DGB
               else
               {
                  OSD_DbgAddSurf( b_srf );
               }
               #endif
            #endif
            }
         }
         DEC_FreeJpg( bmp );
      }
   }
   visible->graphic_data = b_srf;
}

void MG_OSDdisplayBitmap( MHEG5Visible *visible, S_REGION *overlap )
{
   S_SURFACE *surf;
   int left, top, right, bottom;
   U32BIT dummy;

   assert( visible->graphic_data != NULL );

   surf = (S_SURFACE *)visible->graphic_data;

   if (surf->width == 1 && surf->height == 1 && ((MHEG5Bitmap *) visible)->tiling)
   {
      /* Special case for a tiling 1 pixel bitmap - it's the same as a plain rectangle */
      OSDColor box_col;

      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
      #ifdef OSD_8_BIT
         box_col = mg_palette[*((U8BIT *)surf->col_buff)];
      #endif
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
      #ifdef OSD_16_BIT
         left = *((OSDColor *)STB_OSDMhegLockBuffer( surf->hw_handle, &dummy ));
         box_col = (left & 0xf000) << 16 |
            (left & 0x0f00) << 12 |
            (left & 0x00f0) << 8 |
            (left & 0x000f) << 4;
         STB_OSDMhegUnlockBuffer( surf->hw_handle );
      #endif
      }

      ELSE
      {
      #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         box_col = *((OSDColor *)STB_OSDMhegLockBuffer( surf->hw_handle, &dummy ));
         STB_OSDMhegUnlockBuffer( surf->hw_handle );
      #endif
      }

      MG_OSDdisplayRectangle( overlap, visible->position[0], visible->position[1],
         visible->boxSize[0], visible->boxSize[1], 0, 0, box_col );
   }
   else if (surf->width != 0 && surf->height != 0)
   {
      left = (visible->position[0] * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;
      top = (visible->position[1] * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;

      TRACE(TGRAPHICS, ("id=%ld left=%d top=%d", visible->ingredient.root.id, left, top))

      MG_DisplayImage( surf, overlap, left, top );

      if (((MHEG5Bitmap *) visible)->tiling)
      {
         right = visible->position[0] + visible->boxSize[0];
         right = (right * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;
         bottom = visible->position[1] + visible->boxSize[1];
         bottom = (bottom * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;

         TRACE(TGRAPHICS, (" width=%d height=%d", surf->width, surf->height))
         left += surf->width;

         do
         {
            while (left < right)
            {
               MG_DisplayImage( surf, overlap, left, top );
               left += surf->width;
            }
            left = (visible->rect.left * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;
            top += surf->height;
         }
         while (top < bottom);
      }
   }
}