libhb/decdca.c

   1 /* $Id: decdca.c,v 1.14 2005/03/03 17:21:57 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8 #include "dca.h"
   9
  10 struct hb_work_private_s
  11 {
  12     hb_job_t    * job;
  13
  14     /* libdca handle */
  15     dca_state_t * state;
  16
  17     int           flags_in;
  18     int           flags_out;
  19     int           rate;
  20     int           bitrate;
  21     int           frame_length;
  22     float         level;
  23
  24     int           error;
  25     int           sync;
  26     int           size;
  27
  28     /* max frame size of the 16 bits version is 16384 */
  29     /* max frame size of the 14 bits version is 18726 */
  30     uint8_t       frame[18726];
  31
  32     hb_list_t   * list;
  33
  34         int           out_discrete_channels;
  35
  36 };
  37
  38 static int  decdcaInit( hb_work_object_t *, hb_job_t * );
  39 static int  decdcaWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
  40 static void decdcaClose( hb_work_object_t * );
  41 static int  decdcaBSInfo( hb_work_object_t *, const hb_buffer_t *,
  42                           hb_work_info_t * );
  43
  44 hb_work_object_t hb_decdca =
  45 {
  46     WORK_DECDCA,
  47     "DCA decoder",
  48     decdcaInit,
  49     decdcaWork,
  50     decdcaClose,
  51     0,
  52     decdcaBSInfo
  53 };
  54
  55 /***********************************************************************
  56  * Local prototypes
  57  **********************************************************************/
  58 static hb_buffer_t * Decode( hb_work_object_t * w );
  59
  60 /***********************************************************************
  61  * hb_work_decdca_init
  62  ***********************************************************************
  63  * Allocate the work object, initialize libdca
  64  **********************************************************************/
  65 static int decdcaInit( hb_work_object_t * w, hb_job_t * job )
  66 {
  67     hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
  68     hb_audio_t * audio = w->audio;
  69     w->private_data = pv;
  70
  71     pv->job   = job;
  72
  73     pv->list      = hb_list_init();
  74     pv->state     = dca_init( 0 );
  75
  76         /* Decide what format we want out of libdca
  77         work.c has already done some of this deduction for us in do_job() */
  78
  79         pv->flags_out = HB_AMIXDOWN_GET_DCA_FORMAT(audio->config.out.mixdown);
  80
  81         /* pass the number of channels used into the private work data */
  82         /* will only be actually used if we're not doing AC3 passthru */
  83     pv->out_discrete_channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
  84
  85     pv->level     = 32768.0;
  86
  87     return 0;
  88 }
  89
  90 /***********************************************************************
  91  * Close
  92  ***********************************************************************
  93  * Free memory
  94  **********************************************************************/
  95 static void decdcaClose( hb_work_object_t * w )
  96 {
  97     hb_work_private_t * pv = w->private_data;
  98     dca_free( pv->state );
  99     hb_list_empty( &pv->list );
 100     free( pv );
 101     w->private_data = NULL;
 102 }
 103
 104 /***********************************************************************
 105  * Work
 106  ***********************************************************************
 107  * Add the given buffer to the data we already have, and decode as much
 108  * as we can
 109  **********************************************************************/
 110 static int decdcaWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
 111                 hb_buffer_t ** buf_out )
 112 {
 113     hb_work_private_t * pv = w->private_data;
 114     hb_buffer_t * buf;
 115
 116     if ( (*buf_in)->size <= 0 )
 117     {
 118         /* EOF on input stream - send it downstream & say that we're done */
 119         *buf_out = *buf_in;
 120         *buf_in = NULL;
 121         return HB_WORK_DONE;
 122     }
 123
 124     hb_list_add( pv->list, *buf_in );
 125     *buf_in = NULL;
 126
 127     /* If we got more than a frame, chain raw buffers */
 128     *buf_out = buf = Decode( w );
 129     while( buf )
 130     {
 131         buf->next = Decode( w );
 132         buf       = buf->next;
 133     }
 134
 135     return HB_WORK_OK;
 136 }
 137
 138 /***********************************************************************
 139  * Decode
 140  ***********************************************************************
 141  *
 142  **********************************************************************/
 143 static hb_buffer_t * Decode( hb_work_object_t * w )
 144 {
 145     hb_work_private_t * pv = w->private_data;
 146     hb_buffer_t * buf;
 147     int           i, j, k;
 148     uint64_t      pts, pos;
 149     int           num_blocks;
 150
 151     /* Get a frame header if don't have one yet */
 152     if( !pv->sync )
 153     {
 154         while( hb_list_bytes( pv->list ) >= 14 )
 155         {
 156             /* We have 14 bytes, check if this is a correct header */
 157             hb_list_seebytes( pv->list, pv->frame, 14 );
 158             pv->size = dca_syncinfo( pv->state, pv->frame, &pv->flags_in, &pv->rate,
 159                                     &pv->bitrate, &pv->frame_length );
 160             if( pv->size )
 161             {
 162                 /* It is. W00t. */
 163                 if( pv->error )
 164                 {
 165                     hb_log( "dca_syncinfo ok" );
 166                 }
 167                 pv->error = 0;
 168                 pv->sync  = 1;
 169                 break;
 170             }
 171
 172             /* It is not */
 173             if( !pv->error )
 174             {
 175                 hb_log( "dca_syncinfo failed" );
 176                 pv->error = 1;
 177             }
 178
 179             /* Try one byte later */
 180             hb_list_getbytes( pv->list, pv->frame, 1, NULL, NULL );
 181         }
 182     }
 183
 184     if( !pv->sync ||
 185         hb_list_bytes( pv->list ) < pv->size )
 186     {
 187         /* Need more data */
 188         return NULL;
 189     }
 190
 191     /* Get the whole frame */
 192     hb_list_getbytes( pv->list, pv->frame, pv->size, &pts, &pos );
 193
 194     /* Feed libdca */
 195     dca_frame( pv->state, pv->frame, &pv->flags_out, &pv->level, 0 );
 196
 197     /* find out how many blocks are in this frame */
 198     num_blocks = dca_blocks_num( pv->state );
 199
 200     /* num_blocks blocks per frame, 256 samples per block, channelsused channels */
 201     buf        = hb_buffer_init( num_blocks * 256 * pv->out_discrete_channels * sizeof( float ) );
 202     buf->start = pts + ( pos / pv->size ) * num_blocks * 256 * 90000 / pv->rate;
 203     buf->stop  = buf->start + num_blocks * 256 * 90000 / pv->rate;
 204
 205     for( i = 0; i < num_blocks; i++ )
 206     {
 207         dca_sample_t * samples_in;
 208         float    * samples_out;
 209
 210         dca_block( pv->state );
 211         samples_in  = dca_samples( pv->state );
 212         samples_out = ((float *) buf->data) + 256 * pv->out_discrete_channels * i;
 213
 214         /* Interleave */
 215         for( j = 0; j < 256; j++ )
 216         {
 217                         for ( k = 0; k < pv->out_discrete_channels; k++ )
 218                         {
 219                                 samples_out[(pv->out_discrete_channels*j)+k]   = samples_in[(256*k)+j] * 16384;
 220                         }
 221         }
 222
 223     }
 224
 225     pv->sync = 0;
 226     return buf;
 227 }
 228
 229
 230 static int decdcaBSInfo( hb_work_object_t *w, const hb_buffer_t *b,
 231                          hb_work_info_t *info )
 232 {
 233     int i, flags, rate, bitrate, frame_length;
 234     dca_state_t * state = dca_init( 0 );
 235
 236     memset( info, 0, sizeof(*info) );
 237
 238     /* since DCA frames don't line up with MPEG ES frames scan the
 239      * entire frame for an DCA sync pattern.  */
 240     for ( i = 0; i < b->size - 7; ++i )
 241     {
 242         if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate,
 243                           &frame_length ) )
 244         {
 245             break;
 246         }
 247     }
 248     if ( i >= b->size - 7 )
 249     {
 250         /* didn't find DCA sync */
 251         return 0;
 252     }
 253
 254     info->name = "DCA";
 255     info->rate = rate;
 256     info->rate_base = 1;
 257     info->bitrate = bitrate;
 258     info->flags = flags;
 259
 260     if ( ( flags & DCA_CHANNEL_MASK) == DCA_DOLBY )
 261     {
 262         info->flags |= AUDIO_F_DOLBY;
 263     }
 264
 265     switch( flags & DCA_CHANNEL_MASK )
 266     {
 267         /* mono sources */
 268         case DCA_MONO:
 269             info->channel_layout = HB_INPUT_CH_LAYOUT_MONO;
 270             break;
 271         /* stereo input */
 272         case DCA_CHANNEL:
 273         case DCA_STEREO:
 274         case DCA_STEREO_SUMDIFF:
 275         case DCA_STEREO_TOTAL:
 276             info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
 277             break;
 278         /* 3F/2R input */
 279         case DCA_3F2R:
 280             info->channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
 281             break;
 282         /* 3F/1R input */
 283         case DCA_3F1R:
 284             info->channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
 285             break;
 286         /* other inputs */
 287         case DCA_3F:
 288             info->channel_layout = HB_INPUT_CH_LAYOUT_3F;
 289             break;
 290         case DCA_2F1R:
 291             info->channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
 292             break;
 293         case DCA_2F2R:
 294             info->channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
 295             break;
 296         case DCA_4F2R:
 297             info->channel_layout = HB_INPUT_CH_LAYOUT_4F2R;
 298             break;
 299         /* unknown */
 300         default:
 301             info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
 302     }
 303
 304     if (flags & DCA_LFE)
 305     {
 306         info->channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
 307     }
 308
 309     return 1;
 310 }