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     double        next_pts;
  18     int64_t       last_buf_pts;
  19     int           flags_in;
  20     int           flags_out;
  21     int           rate;
  22     int           bitrate;
  23     int           frame_length;
  24     float         level;
  25
  26     int           error;
  27     int           sync;
  28     int           size;
  29
  30     /* max frame size of the 16 bits version is 16384 */
  31     /* max frame size of the 14 bits version is 18726 */
  32     uint8_t       frame[18726];
  33
  34     hb_list_t   * list;
  35
  36         int           out_discrete_channels;
  37
  38 };
  39
  40 static int  decdcaInit( hb_work_object_t *, hb_job_t * );
  41 static int  decdcaWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
  42 static void decdcaClose( hb_work_object_t * );
  43 static int  decdcaBSInfo( hb_work_object_t *, const hb_buffer_t *,
  44                           hb_work_info_t * );
  45
  46 hb_work_object_t hb_decdca =
  47 {
  48     WORK_DECDCA,
  49     "DCA decoder",
  50     decdcaInit,
  51     decdcaWork,
  52     decdcaClose,
  53     0,
  54     decdcaBSInfo
  55 };
  56
  57 /***********************************************************************
  58  * Local prototypes
  59  **********************************************************************/
  60 static hb_buffer_t * Decode( hb_work_object_t * w );
  61
  62 /***********************************************************************
  63  * hb_work_decdca_init
  64  ***********************************************************************
  65  * Allocate the work object, initialize libdca
  66  **********************************************************************/
  67 static int decdcaInit( hb_work_object_t * w, hb_job_t * job )
  68 {
  69     hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
  70     hb_audio_t * audio = w->audio;
  71     w->private_data = pv;
  72
  73     pv->job   = job;
  74
  75     pv->list      = hb_list_init();
  76     pv->state     = dca_init( 0 );
  77
  78         /* Decide what format we want out of libdca
  79         work.c has already done some of this deduction for us in do_job() */
  80
  81         pv->flags_out = HB_AMIXDOWN_GET_DCA_FORMAT(audio->config.out.mixdown);
  82
  83         /* pass the number of channels used into the private work data */
  84         /* will only be actually used if we're not doing AC3 passthru */
  85     pv->out_discrete_channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
  86
  87     pv->level     = 32768.0;
  88
  89     return 0;
  90 }
  91
  92 /***********************************************************************
  93  * Close
  94  ***********************************************************************
  95  * Free memory
  96  **********************************************************************/
  97 static void decdcaClose( hb_work_object_t * w )
  98 {
  99     hb_work_private_t * pv = w->private_data;
 100     dca_free( pv->state );
 101     hb_list_empty( &pv->list );
 102     free( pv );
 103     w->private_data = NULL;
 104 }
 105
 106 /***********************************************************************
 107  * Work
 108  ***********************************************************************
 109  * Add the given buffer to the data we already have, and decode as much
 110  * as we can
 111  **********************************************************************/
 112 static int decdcaWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
 113                 hb_buffer_t ** buf_out )
 114 {
 115     hb_work_private_t * pv = w->private_data;
 116     hb_buffer_t * buf;
 117
 118     if ( (*buf_in)->size <= 0 )
 119     {
 120         /* EOF on input stream - send it downstream & say that we're done */
 121         *buf_out = *buf_in;
 122         *buf_in = NULL;
 123         return HB_WORK_DONE;
 124     }
 125
 126     if ( (*buf_in)->start < -1 && pv->next_pts == 0 )
 127     {
 128         // discard buffers that start before video time 0
 129         *buf_out = NULL;
 130         return HB_WORK_OK;
 131     }
 132
 133     hb_list_add( pv->list, *buf_in );
 134     *buf_in = NULL;
 135
 136     /* If we got more than a frame, chain raw buffers */
 137     *buf_out = buf = Decode( w );
 138     while( buf )
 139     {
 140         buf->next = Decode( w );
 141         buf       = buf->next;
 142     }
 143
 144     return HB_WORK_OK;
 145 }
 146
 147 /***********************************************************************
 148  * Decode
 149  ***********************************************************************
 150  *
 151  **********************************************************************/
 152 static hb_buffer_t * Decode( hb_work_object_t * w )
 153 {
 154     hb_work_private_t * pv = w->private_data;
 155     hb_buffer_t * buf;
 156     hb_audio_t  * audio = w->audio;
 157     int           i, j, k;
 158     int64_t       pts, pos;
 159     uint64_t      upts, upos;
 160     int           num_blocks;
 161
 162     /* Get a frame header if don't have one yet */
 163     if( !pv->sync )
 164     {
 165         while( hb_list_bytes( pv->list ) >= 14 )
 166         {
 167             /* We have 14 bytes, check if this is a correct header */
 168             hb_list_seebytes( pv->list, pv->frame, 14 );
 169             pv->size = dca_syncinfo( pv->state, pv->frame, &pv->flags_in, &pv->rate,
 170                                     &pv->bitrate, &pv->frame_length );
 171             if( pv->size )
 172             {
 173                 /* It is. W00t. */
 174                 if( pv->error )
 175                 {
 176                     hb_log( "dca_syncinfo ok" );
 177                 }
 178                 pv->error = 0;
 179                 pv->sync  = 1;
 180                 break;
 181             }
 182
 183             /* It is not */
 184             if( !pv->error )
 185             {
 186                 hb_log( "dca_syncinfo failed" );
 187                 pv->error = 1;
 188             }
 189
 190             /* Try one byte later */
 191             hb_list_getbytes( pv->list, pv->frame, 1, NULL, NULL );
 192         }
 193     }
 194
 195     if( !pv->sync || hb_list_bytes( pv->list ) < pv->size )
 196     {
 197         /* Need more data */
 198         return NULL;
 199     }
 200
 201     /* Get the whole frame */
 202     hb_list_getbytes( pv->list, pv->frame, pv->size, &upts, &upos );
 203     pts = (int64_t)upts;
 204     pos = (int64_t)upos;
 205
 206     if ( pts != pv->last_buf_pts )
 207     {
 208         pv->last_buf_pts = pts;
 209     }
 210     else
 211     {
 212         // spec says that the PTS is the start time of the first frame
 213         // that starts in the PES frame so we only use the PTS once then
 214         // get the following frames' PTS from the frame length.
 215         pts = -1;
 216     }
 217
 218     // mkv files typically use a 1ms timebase which results in a lot of
 219     // truncation error in their timestamps. Also, TSMuxer or something
 220     // in the m2ts-to-mkv toolchain seems to take a very casual attitude
 221     // about time - timestamps seem to randomly offset by ~40ms for a few
 222     // seconds then recover. So, if the pts we got is within 50ms of the
 223     // pts computed from the data stream, use the data stream pts.
 224     if ( pts == -1 || ( pv->next_pts && fabs( pts - pv->next_pts ) < 50.*90. ) )
 225     {
 226         pts = pv->next_pts;
 227     }
 228
 229     double frame_dur = (double)(pv->frame_length & ~0xFF) / (double)pv->rate * 90000.;
 230
 231     /* DCA passthrough: don't decode the DCA frame */
 232     if( audio->config.out.codec == HB_ACODEC_DCA )
 233     {
 234         buf = hb_buffer_init( pv->size );
 235         memcpy( buf->data, pv->frame, pv->size );
 236         buf->start = pts;
 237         pv->next_pts = pts + frame_dur;
 238         buf->stop  = pv->next_pts;
 239         pv->sync = 0;
 240         return buf;
 241     }
 242
 243     /* Feed libdca */
 244     dca_frame( pv->state, pv->frame, &pv->flags_out, &pv->level, 0 );
 245
 246     /* find out how many blocks are in this frame */
 247     num_blocks = dca_blocks_num( pv->state );
 248
 249     /* num_blocks blocks per frame, 256 samples per block, channelsused channels */
 250     int nsamp = num_blocks * 256;
 251     buf = hb_buffer_init( nsamp * pv->out_discrete_channels * sizeof( float ) );
 252
 253     buf->start = pts;
 254     pv->next_pts = pts + (double)nsamp / (double)pv->rate * 90000.;
 255     buf->stop  = pv->next_pts;
 256
 257     for( i = 0; i < num_blocks; i++ )
 258     {
 259         dca_sample_t * samples_in;
 260         float    * samples_out;
 261
 262         dca_block( pv->state );
 263         samples_in  = dca_samples( pv->state );
 264         samples_out = ((float *) buf->data) + 256 * pv->out_discrete_channels * i;
 265
 266         /* Interleave */
 267         for( j = 0; j < 256; j++ )
 268         {
 269                         for ( k = 0; k < pv->out_discrete_channels; k++ )
 270                         {
 271                                 samples_out[(pv->out_discrete_channels*j)+k]   = samples_in[(256*k)+j] * 16384;
 272                         }
 273         }
 274
 275     }
 276
 277     pv->sync = 0;
 278     return buf;
 279 }
 280
 281
 282 static int decdcaBSInfo( hb_work_object_t *w, const hb_buffer_t *b,
 283                          hb_work_info_t *info )
 284 {
 285     int i, flags, rate, bitrate, frame_length;
 286     dca_state_t * state = dca_init( 0 );
 287
 288     memset( info, 0, sizeof(*info) );
 289
 290     /* since DCA frames don't line up with MPEG ES frames scan the
 291      * entire frame for an DCA sync pattern.  */
 292     for ( i = 0; i < b->size - 7; ++i )
 293     {
 294         if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate,
 295                           &frame_length ) )
 296         {
 297             break;
 298         }
 299     }
 300     if ( i >= b->size - 7 )
 301     {
 302         /* didn't find DCA sync */
 303         return 0;
 304     }
 305
 306     info->name = "DCA";
 307     info->rate = rate;
 308     info->rate_base = 1;
 309     info->bitrate = bitrate;
 310     info->flags = flags;
 311
 312     if ( ( flags & DCA_CHANNEL_MASK) == DCA_DOLBY )
 313     {
 314         info->flags |= AUDIO_F_DOLBY;
 315     }
 316
 317     switch( flags & DCA_CHANNEL_MASK )
 318     {
 319         /* mono sources */
 320         case DCA_MONO:
 321             info->channel_layout = HB_INPUT_CH_LAYOUT_MONO;
 322             break;
 323         /* stereo input */
 324         case DCA_CHANNEL:
 325         case DCA_STEREO:
 326         case DCA_STEREO_SUMDIFF:
 327         case DCA_STEREO_TOTAL:
 328             info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
 329             break;
 330         /* 3F/2R input */
 331         case DCA_3F2R:
 332             info->channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
 333             break;
 334         /* 3F/1R input */
 335         case DCA_3F1R:
 336             info->channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
 337             break;
 338         /* other inputs */
 339         case DCA_3F:
 340             info->channel_layout = HB_INPUT_CH_LAYOUT_3F;
 341             break;
 342         case DCA_2F1R:
 343             info->channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
 344             break;
 345         case DCA_2F2R:
 346             info->channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
 347             break;
 348         case DCA_4F2R:
 349             info->channel_layout = HB_INPUT_CH_LAYOUT_4F2R;
 350             break;
 351         /* unknown */
 352         default:
 353             info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
 354     }
 355
 356     if (flags & DCA_LFE)
 357     {
 358         info->channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
 359     }
 360
 361     return 1;
 362 }