src/misc/es_format.c

   1 /*****************************************************************************
   2  * es_format.c : es_format_t helpers.
   3  *****************************************************************************
   4  * Copyright (C) 2008 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Laurent Aimar <fenrir@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_es.h>
  34 #include <vlc_aout.h>
  35
  36
  37 /*****************************************************************************
  38  * BinaryLog: computes the base 2 log of a binary value
  39  *****************************************************************************
  40  * This functions is used by MaskToShift, to get a bit index from a binary
  41  * value.
  42  *****************************************************************************/
  43 static int BinaryLog( uint32_t i )
  44 {
  45     int i_log = 0;
  46
  47     if( i == 0 ) return -31337;
  48
  49     if( i & 0xffff0000 ) i_log += 16;
  50     if( i & 0xff00ff00 ) i_log += 8;
  51     if( i & 0xf0f0f0f0 ) i_log += 4;
  52     if( i & 0xcccccccc ) i_log += 2;
  53     if( i & 0xaaaaaaaa ) i_log += 1;
  54
  55     return i_log;
  56 }
  57
  58 /**
  59  * It transforms a color mask into right and left shifts
  60  * FIXME copied from video_output.c
  61  */
  62 static void MaskToShift( int *pi_left, int *pi_right, uint32_t i_mask )
  63 {
  64     uint32_t i_low, i_high;            /* lower and higher bits of the mask */
  65
  66     if( !i_mask )
  67     {
  68         *pi_left = *pi_right = 0;
  69         return;
  70     }
  71
  72     /* Get bits */
  73     i_low = i_high = i_mask;
  74
  75     i_low &= - (int32_t)i_low;          /* lower bit of the mask */
  76     i_high += i_low;                    /* higher bit of the mask */
  77
  78     /* Transform bits into an index. Also deal with i_high overflow, which
  79      * is faster than changing the BinaryLog code to handle 64 bit integers. */
  80     i_low =  BinaryLog (i_low);
  81     i_high = i_high ? BinaryLog (i_high) : 32;
  82
  83     /* Update pointers and return */
  84     *pi_left =   i_low;
  85     *pi_right = (8 - i_high + i_low);
  86 }
  87
  88 /* */
  89 void video_format_FixRgb( video_format_t *p_fmt )
  90 {
  91     /* FIXME find right default mask */
  92     if( !p_fmt->i_rmask || !p_fmt->i_gmask || !p_fmt->i_bmask )
  93     {
  94         switch( p_fmt->i_chroma )
  95         {
  96         case VLC_CODEC_RGB15:
  97             p_fmt->i_rmask = 0x7c00;
  98             p_fmt->i_gmask = 0x03e0;
  99             p_fmt->i_bmask = 0x001f;
 100             break;
 101
 102         case VLC_CODEC_RGB16:
 103             p_fmt->i_rmask = 0xf800;
 104             p_fmt->i_gmask = 0x07e0;
 105             p_fmt->i_bmask = 0x001f;
 106             break;
 107
 108         case VLC_CODEC_RGB24:
 109             p_fmt->i_rmask = 0xff0000;
 110             p_fmt->i_gmask = 0x00ff00;
 111             p_fmt->i_bmask = 0x0000ff;
 112             break;
 113         case VLC_CODEC_RGB32:
 114             p_fmt->i_rmask = 0x00ff0000;
 115             p_fmt->i_gmask = 0x0000ff00;
 116             p_fmt->i_bmask = 0x000000ff;
 117             break;
 118
 119         default:
 120             return;
 121         }
 122     }
 123
 124     MaskToShift( &p_fmt->i_lrshift, &p_fmt->i_rrshift,
 125                  p_fmt->i_rmask );
 126     MaskToShift( &p_fmt->i_lgshift, &p_fmt->i_rgshift,
 127                  p_fmt->i_gmask );
 128     MaskToShift( &p_fmt->i_lbshift, &p_fmt->i_rbshift,
 129                  p_fmt->i_bmask );
 130 }
 131
 132 void video_format_Setup( video_format_t *p_fmt, vlc_fourcc_t i_chroma,
 133                          int i_width, int i_height,
 134                          int i_sar_num, int i_sar_den )
 135 {
 136     p_fmt->i_chroma         = vlc_fourcc_GetCodec( VIDEO_ES, i_chroma );
 137     p_fmt->i_width          =
 138     p_fmt->i_visible_width  = i_width;
 139     p_fmt->i_height         =
 140     p_fmt->i_visible_height = i_height;
 141     p_fmt->i_x_offset       =
 142     p_fmt->i_y_offset       = 0;
 143     vlc_ureduce( &p_fmt->i_sar_num, &p_fmt->i_sar_den,
 144                  i_sar_num, i_sar_den, 0 );
 145
 146     switch( p_fmt->i_chroma )
 147     {
 148     case VLC_CODEC_YUVA:
 149         p_fmt->i_bits_per_pixel = 32;
 150         break;
 151     case VLC_CODEC_I444:
 152     case VLC_CODEC_J444:
 153         p_fmt->i_bits_per_pixel = 24;
 154         break;
 155     case VLC_CODEC_I422:
 156     case VLC_CODEC_YUYV:
 157     case VLC_CODEC_YVYU:
 158     case VLC_CODEC_UYVY:
 159     case VLC_CODEC_VYUY:
 160     case VLC_CODEC_J422:
 161         p_fmt->i_bits_per_pixel = 16;
 162         break;
 163     case VLC_CODEC_I440:
 164     case VLC_CODEC_J440:
 165         p_fmt->i_bits_per_pixel = 16;
 166         break;
 167     case VLC_CODEC_I411:
 168     case VLC_CODEC_YV12:
 169     case VLC_CODEC_I420:
 170     case VLC_CODEC_J420:
 171         p_fmt->i_bits_per_pixel = 12;
 172         break;
 173     case VLC_CODEC_YV9:
 174     case VLC_CODEC_I410:
 175         p_fmt->i_bits_per_pixel = 9;
 176         break;
 177     case VLC_CODEC_Y211:
 178         p_fmt->i_bits_per_pixel = 8;
 179         break;
 180     case VLC_CODEC_YUVP:
 181         p_fmt->i_bits_per_pixel = 8;
 182         break;
 183
 184     case VLC_CODEC_RGB32:
 185     case VLC_CODEC_RGBA:
 186         p_fmt->i_bits_per_pixel = 32;
 187         break;
 188     case VLC_CODEC_RGB24:
 189         p_fmt->i_bits_per_pixel = 24;
 190         break;
 191     case VLC_CODEC_RGB15:
 192     case VLC_CODEC_RGB16:
 193         p_fmt->i_bits_per_pixel = 16;
 194         break;
 195     case VLC_CODEC_RGB8:
 196         p_fmt->i_bits_per_pixel = 8;
 197         break;
 198
 199     case VLC_CODEC_GREY:
 200     case VLC_CODEC_RGBP:
 201         p_fmt->i_bits_per_pixel = 8;
 202         break;
 203
 204     default:
 205         p_fmt->i_bits_per_pixel = 0;
 206         break;
 207     }
 208 }
 209 bool video_format_IsSimilar( const video_format_t *p_fmt1, const video_format_t *p_fmt2 )
 210 {
 211     video_format_t v1 = *p_fmt1;
 212     video_format_t v2 = *p_fmt2;
 213
 214     if( v1.i_chroma != v2.i_chroma )
 215         return false;
 216
 217     if( v1.i_width != v2.i_width || v1.i_height != v2.i_height ||
 218         v1.i_visible_width != v2.i_visible_width ||
 219         v1.i_visible_height != v2.i_visible_height ||
 220         v1.i_x_offset != v2.i_x_offset || v1.i_y_offset != v2.i_y_offset )
 221         return false;
 222     if( v1.i_sar_num * v2.i_sar_den != v2.i_sar_num * v1.i_sar_den )
 223         return false;
 224
 225     if( v1.i_chroma == VLC_CODEC_RGB15 ||
 226         v1.i_chroma == VLC_CODEC_RGB16 ||
 227         v1.i_chroma == VLC_CODEC_RGB24 ||
 228         v1.i_chroma == VLC_CODEC_RGB32 )
 229     {
 230         video_format_FixRgb( &v1 );
 231         video_format_FixRgb( &v2 );
 232
 233         if( v1.i_rmask != v2.i_rmask ||
 234             v1.i_gmask != v2.i_gmask ||
 235             v1.i_bmask != v2.i_bmask )
 236             return false;
 237     }
 238     return true;
 239 }
 240 void video_format_Print( vlc_object_t *p_this,
 241                          const char *psz_text, const video_format_t *fmt )
 242 {
 243     msg_Dbg( p_this,
 244              "%s sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, sar %i:%i, msk r0x%x g0x%x b0x%x",
 245              psz_text,
 246              fmt->i_width, fmt->i_height, fmt->i_x_offset, fmt->i_y_offset,
 247              fmt->i_visible_width, fmt->i_visible_height,
 248              (char*)&fmt->i_chroma,
 249              fmt->i_sar_num, fmt->i_sar_den,
 250              fmt->i_rmask, fmt->i_gmask, fmt->i_bmask );
 251 }
 252
 253 void es_format_Init( es_format_t *fmt,
 254                      int i_cat, vlc_fourcc_t i_codec )
 255 {
 256     fmt->i_cat                  = i_cat;
 257     fmt->i_codec                = i_codec;
 258     fmt->i_original_fourcc      = 0;
 259     fmt->i_profile              = -1;
 260     fmt->i_level                = -1;
 261     fmt->i_id                   = -1;
 262     fmt->i_group                = 0;
 263     fmt->i_priority             = 0;
 264     fmt->psz_language           = NULL;
 265     fmt->psz_description        = NULL;
 266
 267     fmt->i_extra_languages      = 0;
 268     fmt->p_extra_languages      = NULL;
 269
 270     memset( &fmt->audio, 0, sizeof(audio_format_t) );
 271     memset( &fmt->audio_replay_gain, 0, sizeof(audio_replay_gain_t) );
 272     memset( &fmt->video, 0, sizeof(video_format_t) );
 273     memset( &fmt->subs, 0, sizeof(subs_format_t) );
 274
 275     fmt->b_packetized           = true;
 276     fmt->i_bitrate              = 0;
 277     fmt->i_extra                = 0;
 278     fmt->p_extra                = NULL;
 279 }
 280
 281 void es_format_InitFromVideo( es_format_t *p_es, const video_format_t *p_fmt )
 282 {
 283     es_format_Init( p_es, VIDEO_ES, p_fmt->i_chroma );
 284     video_format_Copy( &p_es->video, p_fmt );
 285 }
 286
 287 int es_format_Copy( es_format_t *dst, const es_format_t *src )
 288 {
 289     int i;
 290     memcpy( dst, src, sizeof( es_format_t ) );
 291     dst->psz_language = src->psz_language ? strdup( src->psz_language ) : NULL;
 292     dst->psz_description = src->psz_description ? strdup( src->psz_description ) : NULL;
 293     if( src->i_extra > 0 && dst->p_extra )
 294     {
 295         dst->i_extra = src->i_extra;
 296         dst->p_extra = malloc( src->i_extra );
 297         if(dst->p_extra)
 298             memcpy( dst->p_extra, src->p_extra, src->i_extra );
 299         else
 300             dst->i_extra = 0;
 301     }
 302     else
 303     {
 304         dst->i_extra = 0;
 305         dst->p_extra = NULL;
 306     }
 307
 308     dst->subs.psz_encoding = dst->subs.psz_encoding ? strdup( src->subs.psz_encoding ) : NULL;
 309
 310     if( src->video.p_palette )
 311     {
 312         dst->video.p_palette =
 313             (video_palette_t*)malloc( sizeof( video_palette_t ) );
 314         if(dst->video.p_palette)
 315         {
 316             memcpy( dst->video.p_palette, src->video.p_palette,
 317                 sizeof( video_palette_t ) );
 318         }
 319     }
 320
 321     if( dst->i_extra_languages && src->p_extra_languages)
 322     {
 323         dst->i_extra_languages = src->i_extra_languages;
 324         dst->p_extra_languages = (extra_languages_t*)
 325             malloc(dst->i_extra_languages * sizeof(*dst->p_extra_languages ));
 326         if( dst->p_extra_languages )
 327         {
 328             for( i = 0; i < dst->i_extra_languages; i++ ) {
 329                 if( src->p_extra_languages[i].psz_language )
 330                     dst->p_extra_languages[i].psz_language = strdup( src->p_extra_languages[i].psz_language );
 331                 else
 332                     dst->p_extra_languages[i].psz_language = NULL;
 333                 if( src->p_extra_languages[i].psz_description )
 334                     dst->p_extra_languages[i].psz_description = strdup( src->p_extra_languages[i].psz_description );
 335                 else
 336                     dst->p_extra_languages[i].psz_description = NULL;
 337             }
 338         }
 339         else
 340             dst->i_extra_languages = 0;
 341     }
 342     else
 343         dst->i_extra_languages = 0;
 344     return VLC_SUCCESS;
 345 }
 346
 347 void es_format_Clean( es_format_t *fmt )
 348 {
 349     free( fmt->psz_language );
 350     free( fmt->psz_description );
 351
 352     if( fmt->i_extra > 0 ) free( fmt->p_extra );
 353
 354     free( fmt->video.p_palette );
 355     free( fmt->subs.psz_encoding );
 356
 357     if( fmt->i_extra_languages > 0 && fmt->p_extra_languages )
 358     {
 359         int i;
 360         for( i = 0; i < fmt->i_extra_languages; i++ )
 361         {
 362             free( fmt->p_extra_languages[i].psz_language );
 363             free( fmt->p_extra_languages[i].psz_description );
 364         }
 365         free( fmt->p_extra_languages );
 366     }
 367
 368     /* es_format_Clean can be called multiple times */
 369     memset( fmt, 0, sizeof(*fmt) );
 370 }
 371
 372 bool es_format_IsSimilar( const es_format_t *p_fmt1, const es_format_t *p_fmt2 )
 373 {
 374     if( p_fmt1->i_cat != p_fmt2->i_cat ||
 375         vlc_fourcc_GetCodec( p_fmt1->i_cat, p_fmt1->i_codec ) !=
 376         vlc_fourcc_GetCodec( p_fmt2->i_cat, p_fmt2->i_codec ) )
 377         return false;
 378
 379     switch( p_fmt1->i_cat )
 380     {
 381     case AUDIO_ES:
 382     {
 383         audio_format_t a1 = p_fmt1->audio;
 384         audio_format_t a2 = p_fmt2->audio;
 385
 386         if( a1.i_format && a2.i_format && a1.i_format != a2.i_format )
 387             return false;
 388         if( a1.i_rate != a2.i_rate ||
 389             a1.i_physical_channels != a2.i_physical_channels ||
 390             a1.i_original_channels != a2.i_original_channels )
 391             return false;
 392         return true;
 393     }
 394
 395     case VIDEO_ES:
 396     {
 397         video_format_t v1 = p_fmt1->video;
 398         video_format_t v2 = p_fmt2->video;
 399         if( !v1.i_chroma )
 400             v1.i_chroma = vlc_fourcc_GetCodec( p_fmt1->i_cat, p_fmt1->i_codec );
 401         if( !v2.i_chroma )
 402             v2.i_chroma = vlc_fourcc_GetCodec( p_fmt1->i_cat, p_fmt2->i_codec );
 403         return video_format_IsSimilar( &p_fmt1->video, &p_fmt2->video );
 404     }
 405
 406     case SPU_ES:
 407     default:
 408         return true;
 409     }
 410 }
 411