git.sesse.net Git - vlc/blob - modules/codec/lpcm.c

   1 /*****************************************************************************
   2  * lpcm.c: lpcm decoder/packetizer module
   3  *****************************************************************************
   4  * Copyright (C) 1999-2008 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Henri Fallon <henri@videolan.org>
   9  *          Christophe Massiot <massiot@via.ecp.fr>
  10  *          Gildas Bazin <gbazin@videolan.org>
  11  *          Lauren Aimar <fenrir _AT_ videolan _DOT_ org >
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Preamble
  30  *****************************************************************************/
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <vlc_common.h>
  36 #include <vlc_plugin.h>
  37 #include <vlc_codec.h>
  38 #include <vlc_aout.h>
  39 #include <assert.h>
  40
  41 /*****************************************************************************
  42  * Module descriptor
  43  *****************************************************************************/
  44 static int  OpenDecoder   ( vlc_object_t * );
  45 static int  OpenPacketizer( vlc_object_t * );
  46 static void CloseCommon   ( vlc_object_t * );
  47
  48 vlc_module_begin ()
  49
  50     set_category( CAT_INPUT )
  51     set_subcategory( SUBCAT_INPUT_ACODEC )
  52     set_description( N_("Linear PCM audio decoder") )
  53     set_capability( "decoder", 100 )
  54     set_callbacks( OpenDecoder, CloseCommon )
  55
  56     add_submodule ()
  57     set_description( N_("Linear PCM audio packetizer") )
  58     set_capability( "packetizer", 100 )
  59     set_callbacks( OpenPacketizer, CloseCommon )
  60
  61 vlc_module_end ()
  62
  63
  64 /*****************************************************************************
  65  * decoder_sys_t : lpcm decoder descriptor
  66  *****************************************************************************/
  67 struct decoder_sys_t
  68 {
  69     /* Module mode */
  70     bool b_packetizer;
  71
  72     /*
  73      * Output properties
  74      */
  75     audio_date_t end_date;
  76
  77     /* */
  78     unsigned i_header_size;
  79     bool b_dvd;
  80 };
  81
  82 /*
  83  * LPCM DVD header :
  84  * - frame number (8 bits)
  85  * - unknown (16 bits) == 0x0003 ?
  86  * - unknown (4 bits)
  87  * - current frame (4 bits)
  88  * - unknown (2 bits)
  89  * - frequency (2 bits) 0 == 48 kHz, 1 == 32 kHz, 2 == ?, 3 == ?
  90  * - unknown (1 bit)
  91  * - number of channels - 1 (3 bits) 1 == 2 channels
  92  * - start code (8 bits) == 0x80
  93  *
  94  * LPCM BD header :
  95  * - unkown (16 bits)
  96  * - number of channels (4 bits)
  97  * - frequency (4 bits)
  98  * - bits per sample (2 bits)
  99  * - unknown (6 bits)
 100  */
 101
 102 #define LPCM_DVD_HEADER_LEN (6)
 103 #define LPCM_BD_HEADER_LEN (4)
 104
 105 /*****************************************************************************
 106  * Local prototypes
 107  *****************************************************************************/
 108 static void *DecodeFrame  ( decoder_t *, block_t ** );
 109 static int DvdHeader( unsigned *pi_rate,
 110                       unsigned *pi_channels, unsigned *pi_original_channels,
 111                       unsigned *pi_bits,
 112                       const uint8_t *p_header );
 113 static void DvdExtract( aout_buffer_t *, block_t *, unsigned i_bits );
 114
 115 static int BdHeader( unsigned *pi_rate,
 116                      unsigned *pi_channels, unsigned *pi_original_channels,
 117                      unsigned *pi_bits,
 118                      const uint8_t *p_header );
 119 static void BdExtract( aout_buffer_t *, block_t * );
 120
 121
 122 /*****************************************************************************
 123  * OpenCommon:
 124  *****************************************************************************/
 125 static int OpenCommon( vlc_object_t *p_this, bool b_packetizer )
 126 {
 127     decoder_t *p_dec = (decoder_t*)p_this;
 128     decoder_sys_t *p_sys;
 129     bool b_dvd;
 130
 131     switch( p_dec->fmt_in.i_codec )
 132     {
 133     /* DVD LPCM */
 134     case VLC_CODEC_DVD_LPCM:
 135         b_dvd = true;
 136         break;
 137     /* BD LPCM */
 138     case VLC_CODEC_BD_LPCM:
 139         b_dvd = false;
 140         break;
 141     default:
 142         return VLC_EGENERIC;
 143     }
 144
 145     /* Allocate the memory needed to store the decoder's structure */
 146     if( ( p_dec->p_sys = p_sys = malloc(sizeof(decoder_sys_t)) ) == NULL )
 147         return VLC_ENOMEM;
 148
 149     /* Misc init */
 150     p_sys->b_packetizer = b_packetizer;
 151     aout_DateSet( &p_sys->end_date, 0 );
 152     p_sys->i_header_size = b_dvd ? LPCM_DVD_HEADER_LEN : LPCM_BD_HEADER_LEN;
 153     p_sys->b_dvd = b_dvd;
 154
 155     /* Set output properties */
 156     p_dec->fmt_out.i_cat = AUDIO_ES;
 157
 158     if( b_packetizer )
 159     {
 160         p_dec->fmt_out.i_codec = b_dvd ? VLC_CODEC_DVD_LPCM : VLC_CODEC_BD_LPCM;
 161     }
 162     else
 163     {
 164         switch( p_dec->fmt_out.audio.i_bitspersample )
 165         {
 166         case 24:
 167         case 20:
 168             p_dec->fmt_out.i_codec = VLC_CODEC_S24B;
 169             p_dec->fmt_out.audio.i_bitspersample = 24;
 170             break;
 171         default:
 172             p_dec->fmt_out.i_codec = VLC_CODEC_S16B;
 173             p_dec->fmt_out.audio.i_bitspersample = 16;
 174             break;
 175         }
 176     }
 177
 178     /* Set callback */
 179     p_dec->pf_decode_audio = (aout_buffer_t *(*)(decoder_t *, block_t **))
 180         DecodeFrame;
 181     p_dec->pf_packetize    = (block_t *(*)(decoder_t *, block_t **))
 182         DecodeFrame;
 183
 184     return VLC_SUCCESS;
 185 }
 186 static int OpenDecoder( vlc_object_t *p_this )
 187 {
 188     return OpenCommon( p_this, false );
 189 }
 190 static int OpenPacketizer( vlc_object_t *p_this )
 191 {
 192     return OpenCommon( p_this, true );
 193 }
 194
 195 /*****************************************************************************
 196  * DecodeFrame: decodes an lpcm frame.
 197  ****************************************************************************
 198  * Beware, this function must be fed with complete frames (PES packet).
 199  *****************************************************************************/
 200 static void *DecodeFrame( decoder_t *p_dec, block_t **pp_block )
 201 {
 202     decoder_sys_t *p_sys = p_dec->p_sys;
 203     block_t       *p_block;
 204     unsigned int  i_rate = 0, i_original_channels = 0, i_channels = 0, i_bits = 0;
 205     int           i_frame_length;
 206
 207     if( !pp_block || !*pp_block ) return NULL;
 208
 209     p_block = *pp_block;
 210     *pp_block = NULL; /* So the packet doesn't get re-sent */
 211
 212     /* Date management */
 213     if( p_block->i_pts > 0 &&
 214         p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
 215     {
 216         aout_DateSet( &p_sys->end_date, p_block->i_pts );
 217     }
 218
 219     if( !aout_DateGet( &p_sys->end_date ) )
 220     {
 221         /* We've just started the stream, wait for the first PTS. */
 222         block_Release( p_block );
 223         return NULL;
 224     }
 225
 226     if( p_block->i_buffer <= p_sys->i_header_size )
 227     {
 228         msg_Err(p_dec, "frame is too short");
 229         block_Release( p_block );
 230         return NULL;
 231     }
 232
 233     int i_ret;
 234     if( p_sys->b_dvd )
 235         i_ret = DvdHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
 236                            p_block->p_buffer );
 237     else
 238         i_ret = BdHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
 239                           p_block->p_buffer );
 240
 241     if( i_ret )
 242     {
 243         msg_Warn( p_dec, "no frame sync" );
 244         block_Release( p_block );
 245         return NULL;
 246     }
 247
 248     /* Set output properties */
 249     if( p_dec->fmt_out.audio.i_rate != i_rate )
 250     {
 251         aout_DateInit( &p_sys->end_date, i_rate );
 252         aout_DateSet( &p_sys->end_date, p_block->i_pts );
 253     }
 254     p_dec->fmt_out.audio.i_rate = i_rate;
 255     p_dec->fmt_out.audio.i_channels = i_channels;
 256     p_dec->fmt_out.audio.i_original_channels = i_original_channels;
 257     p_dec->fmt_out.audio.i_physical_channels = i_original_channels & AOUT_CHAN_PHYSMASK;
 258
 259     i_frame_length = (p_block->i_buffer - p_sys->i_header_size) / i_channels * 8 / i_bits;
 260
 261     if( p_sys->b_packetizer )
 262     {
 263         p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
 264         p_block->i_length =
 265             aout_DateIncrement( &p_sys->end_date, i_frame_length ) -
 266             p_block->i_pts;
 267
 268         /* Just pass on the incoming frame */
 269         return p_block;
 270     }
 271     else
 272     {
 273         /* */
 274         if( i_bits == 16 )
 275         {
 276             p_dec->fmt_out.i_codec = VLC_CODEC_S16B;
 277             p_dec->fmt_out.audio.i_bitspersample = 16;
 278         }
 279         else
 280         {
 281             p_dec->fmt_out.i_codec = VLC_CODEC_S24B;
 282             p_dec->fmt_out.audio.i_bitspersample = 24;
 283         }
 284
 285         /* */
 286         aout_buffer_t *p_aout_buffer;
 287         p_aout_buffer = decoder_NewAudioBuffer( p_dec, i_frame_length );
 288         if( !p_aout_buffer )
 289             return NULL;
 290
 291         p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
 292         p_aout_buffer->end_date =
 293             aout_DateIncrement( &p_sys->end_date, i_frame_length );
 294
 295         p_block->p_buffer += p_sys->i_header_size;
 296         p_block->i_buffer -= p_sys->i_header_size;
 297
 298         if( p_sys->b_dvd )
 299             DvdExtract( p_aout_buffer, p_block, i_bits );
 300         else
 301             BdExtract( p_aout_buffer, p_block );
 302
 303         block_Release( p_block );
 304         return p_aout_buffer;
 305     }
 306 }
 307
 308 /*****************************************************************************
 309  * CloseCommon : lpcm decoder destruction
 310  *****************************************************************************/
 311 static void CloseCommon( vlc_object_t *p_this )
 312 {
 313     decoder_t *p_dec = (decoder_t*)p_this;
 314     free( p_dec->p_sys );
 315 }
 316
 317 /*****************************************************************************
 318  *
 319  *****************************************************************************/
 320 static int DvdHeader( unsigned *pi_rate,
 321                       unsigned *pi_channels, unsigned *pi_original_channels,
 322                       unsigned *pi_bits,
 323                       const uint8_t *p_header )
 324 {
 325     const uint8_t i_header = p_header[4];
 326
 327     switch( (i_header >> 4) & 0x3 )
 328     {
 329     case 0:
 330         *pi_rate = 48000;
 331         break;
 332     case 1:
 333         *pi_rate = 96000;
 334         break;
 335     case 2:
 336         *pi_rate = 44100;
 337         break;
 338     case 3:
 339         *pi_rate = 32000;
 340         break;
 341     }
 342
 343     *pi_channels = (i_header & 0x7) + 1;
 344     switch( *pi_channels - 1 )
 345     {
 346     case 0:
 347         *pi_original_channels = AOUT_CHAN_CENTER;
 348         break;
 349     case 1:
 350         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 351         break;
 352     case 2:
 353         /* This is unsure. */
 354         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_LFE;
 355         break;
 356     case 3:
 357         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 358                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 359         break;
 360     case 4:
 361         /* This is unsure. */
 362         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 363                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 364                                | AOUT_CHAN_LFE;
 365         break;
 366     case 5:
 367         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 368                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 369                                | AOUT_CHAN_CENTER | AOUT_CHAN_LFE;
 370         break;
 371     case 6:
 372         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 373                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 374                                | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
 375                                | AOUT_CHAN_MIDDLERIGHT;
 376         break;
 377     case 7:
 378         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 379                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 380                                | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
 381                                | AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_LFE;
 382         break;
 383     }
 384
 385     switch( (i_header >> 6) & 0x3 )
 386     {
 387     case 2:
 388         *pi_bits = 24;
 389         break;
 390     case 1:
 391         *pi_bits = 20;
 392         break;
 393     case 0:
 394     default:
 395         *pi_bits = 16;
 396         break;
 397     }
 398
 399     /* Check frame sync and drop it. */
 400     if( p_header[5] != 0x80 )
 401         return -1;
 402     return 0;
 403 }
 404 static int BdHeader( unsigned *pi_rate,
 405                      unsigned *pi_channels, unsigned *pi_original_channels,
 406                      unsigned *pi_bits,
 407                      const uint8_t *p_header )
 408 {
 409     const uint32_t h = GetDWBE( p_header );
 410     switch( ( h & 0xf000) >> 12 )
 411     {
 412     case 1:
 413         *pi_channels = 1;
 414         *pi_original_channels = AOUT_CHAN_CENTER;
 415         break;
 416     case 3:
 417         *pi_channels = 2;
 418         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 419         break;
 420     case 4:
 421         *pi_channels = 3;
 422         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER;
 423         break;
 424     case 5:
 425         *pi_channels = 3;
 426         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARCENTER;
 427         break;
 428     case 6:
 429         *pi_channels = 4;
 430         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 431                                 AOUT_CHAN_REARCENTER;
 432         break;
 433     case 7:
 434         *pi_channels = 4;
 435         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
 436                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 437         break;
 438     case 8:
 439         *pi_channels = 5;
 440         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 441                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 442         break;
 443     case 9:
 444         *pi_channels = 6;
 445         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 446                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 447                                 AOUT_CHAN_LFE;
 448         break;
 449     case 10:
 450         *pi_channels = 7;
 451         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 452                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 453                                 AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT;
 454         break;
 455     case 11:
 456         *pi_channels = 8;
 457         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 458                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 459                                 AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT |
 460                                 AOUT_CHAN_LFE;
 461         break;
 462
 463     default:
 464         return -1;
 465     }
 466     switch( (h >> 6) & 0x03 )
 467     {
 468     case 1:
 469         *pi_bits = 16;
 470         break;
 471     case 2: /* 20 bits but samples are stored on 24 bits */
 472     case 3: /* 24 bits */
 473         *pi_bits = 24;
 474         break;
 475     default:
 476         return -1;
 477     }
 478     switch( (h >> 8) & 0x0f )
 479     {
 480     case 1:
 481         *pi_rate = 48000;
 482         break;
 483     case 4:
 484         *pi_rate = 96000;
 485         break;
 486     case 5:
 487         *pi_rate = 192000;
 488         break;
 489     default:
 490         return -1;
 491     }
 492     return 0;
 493 }
 494
 495 static void DvdExtract( aout_buffer_t *p_aout_buffer, block_t *p_block,
 496                         unsigned i_bits )
 497 {
 498     uint8_t *p_out = p_aout_buffer->p_buffer;
 499
 500     /* 20/24 bits LPCM use special packing */
 501     if( i_bits == 24 )
 502     {
 503         while( p_block->i_buffer / 12 )
 504         {
 505             /* Sample 1 */
 506             p_out[0] = p_block->p_buffer[0];
 507             p_out[1] = p_block->p_buffer[1];
 508             p_out[2] = p_block->p_buffer[8];
 509             /* Sample 2 */
 510             p_out[3] = p_block->p_buffer[2];
 511             p_out[4] = p_block->p_buffer[3];
 512             p_out[5] = p_block->p_buffer[9];
 513             /* Sample 3 */
 514             p_out[6] = p_block->p_buffer[4];
 515             p_out[7] = p_block->p_buffer[5];
 516             p_out[8] = p_block->p_buffer[10];
 517             /* Sample 4 */
 518             p_out[9] = p_block->p_buffer[6];
 519             p_out[10] = p_block->p_buffer[7];
 520             p_out[11] = p_block->p_buffer[11];
 521
 522             p_block->i_buffer -= 12;
 523             p_block->p_buffer += 12;
 524             p_out += 12;
 525         }
 526     }
 527     else if( i_bits == 20 )
 528     {
 529         while( p_block->i_buffer / 10 )
 530         {
 531             /* Sample 1 */
 532             p_out[0] = p_block->p_buffer[0];
 533             p_out[1] = p_block->p_buffer[1];
 534             p_out[2] = p_block->p_buffer[8] & 0xF0;
 535             /* Sample 2 */
 536             p_out[3] = p_block->p_buffer[2];
 537             p_out[4] = p_block->p_buffer[3];
 538             p_out[5] = p_block->p_buffer[8] << 4;
 539             /* Sample 3 */
 540             p_out[6] = p_block->p_buffer[4];
 541             p_out[7] = p_block->p_buffer[5];
 542             p_out[8] = p_block->p_buffer[9] & 0xF0;
 543             /* Sample 4 */
 544             p_out[9] = p_block->p_buffer[6];
 545             p_out[10] = p_block->p_buffer[7];
 546             p_out[11] = p_block->p_buffer[9] << 4;
 547
 548             p_block->i_buffer -= 10;
 549             p_block->p_buffer += 10;
 550             p_out += 12;
 551         }
 552     }
 553     else
 554     {
 555         assert( i_bits == 16 );
 556         memcpy( p_out, p_block->p_buffer, p_block->i_buffer );
 557     }
 558 }
 559 static void BdExtract( aout_buffer_t *p_aout_buffer, block_t *p_block )
 560 {
 561     memcpy( p_aout_buffer->p_buffer, p_block->p_buffer, p_block->i_buffer );
 562 }
 563
 564