Index: libhb/decmpeg2.c =================================================================== --- libhb/decmpeg2.c (revision 1368) +++ libhb/decmpeg2.c (working copy) @@ -100,28 +100,18 @@ m->width = m->info->sequence->width; m->height = m->info->sequence->height; m->rate = m->info->sequence->frame_period; - } - if ( m->aspect_ratio <= 0 ) - { - // We can parse out the aspect ratio from the Sequence Start Header data in buf_es->data - - // Make sure we have the correct data in the buffer - if ((buf_es->data[0] == 0x00) && (buf_es->data[1] == 0x00) && (buf_es->data[2] == 0x01) && (buf_es->data[3] == 0xb3)) - { - unsigned char ar_fr = buf_es->data[7]; // Top 4 bits == aspect ratio flag - bottom 4 bits == rate flags - switch ((ar_fr & 0xf0) >> 4) + if ( m->aspect_ratio <= 0 && m->height && + m->info->sequence->pixel_height ) { - case 2: - m->aspect_ratio = HB_ASPECT_BASE * 4 / 3; // 4:3 - break; - case 3: - m->aspect_ratio = HB_ASPECT_BASE * 16 / 9; // 16:9 - break; - default: - hb_log("hb_libmpeg2_decode - STATE_SEQUENCE unexpected aspect ratio/frame rate 0x%x\n", ar_fr); - break; + /* mpeg2_parse doesn't store the aspect ratio. Instead + * it keeps the pixel width & height that would cause + * the storage width & height to come out in the correct + * aspect ratio. Convert these back to aspect ratio. + */ + m->aspect_ratio = ( m->width * m->info->sequence->pixel_width * + HB_ASPECT_BASE ) / m->height / + m->info->sequence->pixel_height; } - } } } else if( state == STATE_GOP && m->look_for_break == 2) Index: libhb/stream.c =================================================================== --- libhb/stream.c (revision 1368) +++ libhb/stream.c (working copy) @@ -904,98 +904,13 @@ audio->id); return; } - if (audio->id < 0xd0) - { - /* XXX fake mpeg audio sample rate & bps */ - stream->a52_info[i].flags = A52_STEREO; - stream->a52_info[i].rate = 48000 /*Hz*/; - stream->a52_info[i].bitrate = 384000 /*Bps*/; - } - lang = lang_for_code(stream->a52_info[i].lang_code); - if (!audio->config.in.samplerate) - audio->config.in.samplerate = stream->a52_info[i].rate; - if (!audio->config.in.bitrate) - audio->config.in.bitrate = stream->a52_info[i].bitrate; - if (!audio->priv.config.a52.ac3flags) - audio->priv.config.a52.ac3flags = audio->config.flags.ac3 = stream->a52_info[i].flags; - } else { // XXX should try to get language code from the AC3 bitstream lang = lang_for_code(0x0000); } - - if (!audio->config.in.channel_layout) - { - switch( audio->config.flags.ac3 & A52_CHANNEL_MASK ) - { - /* mono sources */ - case A52_MONO: - case A52_CHANNEL1: - case A52_CHANNEL2: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO; - break; - /* stereo input */ - case A52_CHANNEL: - case A52_STEREO: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - break; - /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */ - case A52_DOLBY: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_DOLBY; - break; - /* 3F/2R input */ - case A52_3F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R; - break; - /* 3F/1R input */ - case A52_3F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R; - break; - /* other inputs */ - case A52_3F: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F; - break; - case A52_2F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R; - break; - case A52_2F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R; - break; - /* unknown */ - default: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - } - - /* add in our own LFE flag if the source has LFE */ - if (audio->config.flags.ac3 & A52_LFE) - { - audio->config.in.channel_layout = audio->config.in.channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE; - } - } - - snprintf( audio->config.lang.description, sizeof( audio->config.lang.description ), "%s (%s)", strlen(lang->native_name) ? lang->native_name : lang->eng_name, - audio->config.in.codec == HB_ACODEC_AC3 ? "AC3" : ( audio->config.in.codec == HB_ACODEC_MPGA ? "MPEG" : ( audio->config.in.codec == HB_ACODEC_DCA ? "DTS" : "LPCM" ) ) ); - snprintf( audio->config.lang.simple, sizeof( audio->config.lang.simple ), "%s", strlen(lang->native_name) ? lang->native_name : lang->eng_name ); - snprintf( audio->config.lang.iso639_2, sizeof( audio->config.lang.iso639_2 ), "%s", lang->iso639_2); - - if ( (audio->config.flags.ac3 & A52_CHANNEL_MASK) == A52_DOLBY ) { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (Dolby Surround)" ); - } else { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (%d.%d ch)", - HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->config.in.channel_layout) + - HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->config.in.channel_layout), - HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->config.in.channel_layout)); - } - - hb_log( "stream: audio %x: lang %s, rate %d, bitrate %d, " - "flags = 0x%x", audio->id, audio->config.lang.description, audio->config.in.samplerate, - audio->config.in.bitrate, audio->config.flags.ac3 ); - } /*********************************************************************** Index: libhb/declpcm.c =================================================================== --- libhb/declpcm.c (revision 1368) +++ libhb/declpcm.c (working copy) @@ -6,6 +6,27 @@ #include "hb.h" +struct hb_work_private_s +{ + hb_job_t *job; + uint32_t size; /* frame size in bytes */ + uint32_t count; /* frame size in samples */ + uint32_t pos; /* buffer offset for next input data */ + + int64_t next_pts; /* pts for next output frame */ + int64_t sequence; + + /* the following is frame info for the frame we're currently accumulating */ + uint64_t duration; /* frame duratin (in 90KHz ticks) */ + uint32_t offset; /* where in buf frame starts */ + uint32_t samplerate; /* sample rate in bits/sec */ + uint8_t nchannels; + uint8_t sample_size; /* bits per sample */ + + uint8_t frame[HB_DVD_READ_BUFFER_SIZE*2]; +}; + +static hb_buffer_t * Decode( hb_work_object_t * w ); int declpcmInit( hb_work_object_t *, hb_job_t * ); int declpcmWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** ); void declpcmClose( hb_work_object_t * ); @@ -19,72 +40,196 @@ declpcmClose }; +static const int hdr2samplerate[] = { 48000, 96000, 44100, 32000 }; +static const int hdr2samplesize[] = { 16, 20, 24, 16 }; + +static void lpcmInfo( hb_work_object_t *w, hb_buffer_t *in ) +{ + hb_work_private_t * pv = w->private_data; + + /* + * LPCM packets have a 7 byte header (the substream id is stripped off + * before we get here so it's numbered -1 below):: + * byte -1 Substream id + * byte 0 Number of frames that begin in this packet + * (last frame may finish in next packet) + * byte 1,2 offset to first frame that begins in this packet (not including hdr) + * byte 3: + * bits 0-4 continuity counter (increments modulo 20) + * bit 5 reserved + * bit 6 audio mute on/off + * bit 7 audio emphasis on/off + * byte 4: + * bits 0-2 #channels - 1 (e.g., stereo = 1) + * bit 3 reserved + * bits 4-5 sample rate (0=48K,1=96K,2=44.1K,3=32K) + * bits 6-7 bits per sample (0=16 bit, 1=20 bit, 2=24 bit) + * byte 5 Dynamic range control (0x80 = off) + * + * The audio is viewed as "frames" of 150 90KHz ticks each (80 samples @ 48KHz). + * The frames are laid down continuously without regard to MPEG packet + * boundaries. E.g., for 48KHz stereo, the first packet will contain 6 + * frames plus the start of the 7th, the second packet will contain the + * end of the 7th, 8-13 & the start of 14, etc. The frame structure is + * important because the PTS on the packet gives the time of the first + * frame that starts in the packet *NOT* the time of the first sample + * in the packet. Also samples get split across packet boundaries + * so we can't assume that we can consume all the data in one packet + * on every call to the work routine. + */ + pv->offset = ( ( in->data[1] << 8 ) | in->data[2] ) + 2; + if ( pv->offset >= HB_DVD_READ_BUFFER_SIZE ) + { + hb_log( "declpcm: illegal frame offset %d", pv->offset ); + pv->offset = 2; /*XXX*/ + } + pv->samplerate = hdr2samplerate[ ( in->data[4] >> 4 ) & 0x3 ]; + pv->nchannels = ( in->data[4] & 7 ) + 1; + pv->sample_size = hdr2samplesize[in->data[4] >> 6]; + + /* + * PCM frames have a constant duration (150 90KHz ticks). + * We need to convert that to the amount of data expected. It's the + * duration divided by the sample rate (to get #samples) times the number + * of channels times the bits per sample divided by 8 to get bytes. + * (we have to compute in bits because 20 bit samples are not an integral + * number of bytes). We do all the multiplies first then the divides to + * avoid truncation errors. + */ + pv->duration = in->data[0] * 150; + pv->count = ( pv->duration * pv->nchannels * pv->samplerate ) / 90000; + pv->size = ( pv->count * pv->sample_size ) / 8; + + pv->next_pts = in->start; +} + int declpcmInit( hb_work_object_t * w, hb_job_t * job ) { + hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) ); + w->private_data = pv; + pv->job = job; return 0; } +/* + * Convert DVD encapsulated LPCM to floating point PCM audio buffers. + * The amount of audio in a PCM frame is always <= the amount that will fit + * in a DVD block (2048 bytes) but the standard doesn't require that the audio + * frames line up with the DVD frames. Since audio frame boundaries are unrelated + * to DVD PES boundaries, this routine has to reconstruct then extract the audio + * frames. Because of the arbitrary alignment, it can output zero, one or two buf's. + */ int declpcmWork( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t ** buf_out ) { - hb_buffer_t * in = *buf_in, * out; - int samplerate = 0; - int count; - uint8_t * samples_u8; - float * samples_fl32; - int i; - uint64_t duration; + hb_work_private_t * pv = w->private_data; + hb_buffer_t *in; + hb_buffer_t *buf = NULL; - *buf_out = NULL; - - if( in->data[5] != 0x80 ) + /* need an input buffer to do anything */ + if( ! buf_in || ! ( in = *buf_in ) ) { - hb_log( "no LPCM frame sync (%02x)", in->data[5] ); + *buf_out = buf; return HB_WORK_OK; } - switch( ( in->data[4] >> 4 ) & 0x3 ) + pv->sequence = in->sequence; + + /* if we have a frame to finish, add enough data from this buf to finish it */ + if ( pv->size ) { - case 0: - samplerate = 48000; - break; - case 1: - samplerate = 96000;//32000; /* FIXME vlc says it is 96000 */ - break; - case 2: - samplerate = 44100; - break; - case 3: - samplerate = 32000; - break; + memcpy( pv->frame + pv->pos, in->data + 6, pv->size - pv->pos ); + buf = Decode( w ); } + *buf_out = buf; - count = ( in->size - 6 ) / 2; - out = hb_buffer_init( count * sizeof( float ) ); - duration = count * 90000 / samplerate / 2; - out->start = in->start; - out->stop = out->start + duration; + /* save the (rest of) data from this buf in our frame buffer */ + lpcmInfo( w, in ); + int off = pv->offset; + int amt = in->size - off; + pv->pos = amt; + memcpy( pv->frame, in->data + off, amt ); + if ( amt >= pv->size ) + { + if ( buf ) + { + buf->next = Decode( w ); + } + else + { + *buf_out = Decode( w ); + } + pv->size = 0; + } + return HB_WORK_OK; +} - samples_u8 = in->data + 6; - samples_fl32 = (float *) out->data; +static hb_buffer_t *Decode( hb_work_object_t *w ) +{ + hb_work_private_t *pv = w->private_data; + hb_buffer_t *out = hb_buffer_init( pv->count * sizeof( float ) ); + + out->start = pv->next_pts; + pv->next_pts += pv->duration; + out->stop = pv->next_pts; - /* Big endian int16 -> float conversion */ - for( i = 0; i < count; i++ ) + uint8_t *frm = pv->frame; + float *odat = (float *)out->data; + int count = pv->count; + + switch( pv->sample_size ) { -#ifdef WORDS_BIGENDIAN - samples_fl32[0] = *( (int16_t *) samples_u8 ); -#else - samples_fl32[0] = (int16_t) ( ( samples_u8[0] << 8 ) | samples_u8[1] ); -#endif - samples_u8 += 2; - samples_fl32 += 1; + case 16: // 2 byte, big endian, signed (the right shift sign extends) + while ( --count >= 0 ) + { + *odat++ = ( (int)( frm[0] << 24 ) >> 16 ) | frm[1]; + frm += 2; + } + break; + case 20: + // 20 bit big endian signed (5 bytes for 2 samples = 2.5 bytes/sample + // so we do two samples per iteration). + count /= 2; + while ( --count >= 0 ) + { + *odat++ = (float)( ( (int)( frm[0] << 24 ) >> 12 ) | + ( frm[1] << 4 ) | ( frm[2] >> 4 ) ) / 16.; + *odat++ = (float)( ( (int)( frm[2] << 28 ) >> 16 ) | + ( frm[3] << 8 ) | frm[4] ) / 16.; + frm += 5; + } + break; + case 24: + // This format is bizarre. It's 24 bit samples but some confused + // individual apparently thought they would be easier to interpret + // as 16 bits if they were scrambled in the following way: + // Things are stored in 4 sample (12 byte) chunks. Each chunk has + // 4 samples containing the two top bytes of the actual samples in + // 16 bit big-endian order followed by the four least significant bytes + // of each sample. + count /= 4; // the loop has to work in 4 sample chunks + while ( --count >= 0 ) + { + *odat++ = (float)( ( (int)( frm[0] << 24 ) >> 8 ) | + ( frm[1] << 8 ) | frm[8] ) / 256.; + *odat++ = (float)( ( (int)( frm[2] << 24 ) >> 8 ) | + ( frm[3] << 8 ) | frm[9] ) / 256.; + *odat++ = (float)( ( (int)( frm[4] << 24 ) >> 8 ) | + ( frm[5] << 8 ) | frm[10] ) / 256.; + *odat++ = (float)( ( (int)( frm[6] << 24 ) >> 8 ) | + ( frm[7] << 8 ) | frm[11] ) / 256.; + frm += 12; + } + break; } - - *buf_out = out; - - return HB_WORK_OK; + return out; } void declpcmClose( hb_work_object_t * w ) { + if ( w->private_data ) + { + free( w->private_data ); + w->private_data = 0; + } } Index: libhb/scan.c =================================================================== --- libhb/scan.c (revision 1368) +++ libhb/scan.c (working copy) @@ -23,8 +23,8 @@ static void ScanFunc( void * ); static int DecodePreviews( hb_scan_t *, hb_title_t * title ); -static void LookForAC3AndDCA( hb_title_t * title, hb_buffer_t * b ); -static int AllAC3AndDCAOK( hb_title_t * title ); +static void LookForAudio( hb_title_t * title, hb_buffer_t * b ); +static int AllAudioOK( hb_title_t * title ); hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path, int title_index, hb_list_t * list_title ) @@ -134,39 +134,23 @@ if (data->stream) { - // Stream based processing uses PID's to handle the different audio options for a given title + // Stream based processing uses PID's to handle the different + // audio options for a given title for( j = 0; j < hb_list_count( title->list_audio ); j++ ) { audio = hb_list_item( title->list_audio, j ); hb_stream_update_audio(data->stream, audio); } } - else if (data->dvd) - { - /* Make sure we found AC3 rates and bitrates */ - for( j = 0; j < hb_list_count( title->list_audio ); ) - { - audio = hb_list_item( title->list_audio, j ); - if( audio->config.in.codec == HB_ACODEC_AC3 && - !audio->config.in.bitrate ) - { - hb_list_rem( title->list_audio, audio ); - free( audio ); - continue; - } - j++; - } - } - /* Make sure we found AC3 / DCA rates and bitrates */ + /* Make sure we found audio rates and bitrates */ for( j = 0; j < hb_list_count( title->list_audio ); ) { audio = hb_list_item( title->list_audio, j ); - if( ( audio->config.in.codec == HB_ACODEC_AC3 || audio->config.in.codec == HB_ACODEC_DCA ) && - !audio->config.in.bitrate ) + if( !audio->config.in.bitrate ) { - hb_log( "scan: removing audio with codec of 0x%x because of no bitrate", - audio->config.in.codec ); + hb_log( "scan: removing audio 0x%x because no bitrate found", + audio->id ); hb_list_rem( title->list_audio, audio ); free( audio ); continue; @@ -174,7 +158,7 @@ j++; } - /* Do we still have audio */ + /* If we don't have any audio streams left, remove the title */ if( !hb_list_count( title->list_audio ) ) { hb_list_rem( data->list_title, title ); @@ -182,18 +166,6 @@ continue; } - /* set a default input channel layout of stereo for LPCM or MPEG2 audio */ - /* AC3 and DCA will already have had their layout set via DecodePreviews above, */ - /* which calls LookForAC3AndDCA */ - for( j = 0; j < hb_list_count( title->list_audio ); j++ ) - { - audio = hb_list_item( title->list_audio, j ); - if( audio->config.in.codec == HB_ACODEC_LPCM || audio->config.in.codec == HB_ACODEC_MPGA ) - { - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - } - } - i++; } @@ -227,7 +199,6 @@ } job->width = title->width - job->crop[2] - job->crop[3]; -// job->height = title->height - job->crop[0] - job->crop[1]; hb_fix_aspect( job, HB_KEEP_WIDTH ); if( job->height > title->height - job->crop[0] - job->crop[1] ) { @@ -235,8 +206,8 @@ hb_fix_aspect( job, HB_KEEP_HEIGHT ); } - hb_log( "scan: title (%d) job->width:%d, job->height:%d", - i,job->width, job->height ); + hb_log( "scan: title (%d) job->width:%d, job->height:%d", + i, job->width, job->height ); job->keep_ratio = 1; @@ -311,7 +282,10 @@ } else if (data->stream) { - if (!hb_stream_seek(data->stream, (float) ( i + 1 ) / 11.0 ) ) + /* we start reading streams at zero rather than 1/11 because + * short streams may have only one sequence header in the entire + * file and we need it to decode any previews. */ + if (!hb_stream_seek(data->stream, (float) i / 11.0 ) ) { goto error; } @@ -354,22 +328,20 @@ ++ar4_count : ++ar16_count ; } } - else if( !i ) + else if( ! AllAudioOK( title ) ) { - LookForAC3AndDCA( title, buf_es ); + LookForAudio( title, buf_es ); } hb_buffer_close( &buf_es ); - if( hb_list_count( list_raw ) && - ( i || AllAC3AndDCAOK( title ) ) ) + if( hb_list_count( list_raw ) && AllAudioOK( title ) ) { /* We got a picture */ break; } } - if( hb_list_count( list_raw ) && - ( i || AllAC3AndDCAOK( title ) ) ) + if( hb_list_count( list_raw ) && AllAudioOK( title ) ) { break; } @@ -378,7 +350,7 @@ if( !hb_list_count( list_raw ) ) { hb_log( "scan: could not get a decoded picture" ); - goto error; + continue; } /* Get size and rate infos */ @@ -564,23 +536,231 @@ return npreviews; } -static void LookForAC3AndDCA( hb_title_t * title, hb_buffer_t * b ) +static void update_audio_description( const char *codec, hb_audio_t *audio, + int is_dolby ) { - int i; + hb_log( "scan: %s, rate=%dHz, bitrate=%d", codec, audio->config.in.samplerate, + audio->config.in.bitrate ); + + /* XXX */ + if ( is_dolby ) + { + strcat( audio->config.lang.description, " (Dolby Surround)" ); + return; + } + + char *desc = audio->config.lang.description + + strlen( audio->config.lang.description ); + sprintf( desc, " (%d.%d ch)", + HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->config.in.channel_layout) + + HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->config.in.channel_layout), + HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->config.in.channel_layout)); +} + +static int hb_setup_a52_audio( hb_audio_t *audio, uint8_t *b ) +{ + int rate, bitrate, flags; + + if( a52_syncinfo( b, &flags, &rate, &bitrate ) == 0 ) + { + return 0; + } + + audio->config.in.samplerate = rate; + audio->config.in.bitrate = bitrate; + + switch( flags & A52_CHANNEL_MASK ) + { + /* mono sources */ + case A52_MONO: + case A52_CHANNEL1: + case A52_CHANNEL2: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO; + break; + /* stereo input */ + case A52_CHANNEL: + case A52_STEREO: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + break; + /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */ + case A52_DOLBY: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_DOLBY; + break; + /* 3F/2R input */ + case A52_3F2R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R; + break; + /* 3F/1R input */ + case A52_3F1R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R; + break; + /* other inputs */ + case A52_3F: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F; + break; + case A52_2F1R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R; + break; + case A52_2F2R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R; + break; + /* unknown */ + default: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + } + + if (flags & A52_LFE) + { + audio->config.in.channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE; + } + + /* store the AC3 flags for future reference + * This enables us to find out if we had a stereo or Dolby source later on + * Store the ac3 flags in the public ac3flags property too, so we can access + * it from the GUI + */ + audio->config.flags.ac3 = audio->priv.config.a52.ac3flags = flags; + update_audio_description( "AC3", audio, (flags & A52_CHANNEL_MASK) == A52_DOLBY ); + return 1; +} + +static int hb_setup_dca_audio( hb_audio_t *audio, uint8_t *b ) +{ int flags; int rate; int bitrate; int frame_length; - dca_state_t * state; + dca_state_t * state = dca_init( 0 ); - /* Figure out if this is a AC3 or DCA buffer for a known track */ + hb_log( "scan: checking for DCA syncinfo" ); + + if( !dca_syncinfo( state, b, &flags, &rate, &bitrate, &frame_length ) ) + { + return 0; + } + audio->config.in.samplerate = rate; + audio->config.in.bitrate = bitrate; + switch( flags & DCA_CHANNEL_MASK ) + { + /* mono sources */ + case DCA_MONO: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO; + break; + /* stereo input */ + case DCA_CHANNEL: + case DCA_STEREO: + case DCA_STEREO_SUMDIFF: + case DCA_STEREO_TOTAL: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + break; + /* 3F/2R input */ + case DCA_3F2R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R; + break; + /* 3F/1R input */ + case DCA_3F1R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R; + break; + /* other inputs */ + case DCA_3F: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F; + break; + case DCA_2F1R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R; + break; + case DCA_2F2R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R; + break; + case DCA_4F2R: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_4F2R; + break; + /* unknown */ + default: + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + } + + if (flags & DCA_LFE) + { + audio->config.in.channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE; + } + + /* store the DCA flags for future reference + * This enables us to find out if we had a stereo or Dolby source later on + * store the dca flags in the public dcaflags property too, so we can access + * it from the GUI + */ + audio->config.flags.dca = audio->priv.config.dca.dcaflags = flags; + update_audio_description( "DCA", audio, (flags & DCA_CHANNEL_MASK) == DCA_DOLBY ); + return 1; +} + +static int hb_setup_pcm_audio( hb_audio_t *audio, uint8_t *b ) +{ + // LPCM doesn't have a sync pattern like AC3 or DCA but every + // LPCM elementary stream packet starts with a 7 byte header + // giving the characteristics of the stream. + // See libhb/declpcm.c for a description of the LPCM header. + + static const int hdr2samplerate[] = { 48000, 96000, 44100, 32000 }; + static const int hdr2samplesize[] = { 16, 20, 24, 16 }; + static const int hdr2layout[] = { + HB_INPUT_CH_LAYOUT_MONO, HB_INPUT_CH_LAYOUT_STEREO, + HB_INPUT_CH_LAYOUT_2F1R, HB_INPUT_CH_LAYOUT_2F2R, + HB_INPUT_CH_LAYOUT_3F2R, HB_INPUT_CH_LAYOUT_4F2R, + HB_INPUT_CH_LAYOUT_STEREO, HB_INPUT_CH_LAYOUT_STEREO, + }; + + int nchannels = ( b[4] & 7 ) + 1; + int sample_size = hdr2samplesize[b[4] >> 6]; + + int rate = hdr2samplerate[ ( b[4] >> 4 ) & 0x3 ]; + int bitrate = rate * sample_size * nchannels; + + audio->config.in.samplerate = rate; + audio->config.in.bitrate = bitrate; + audio->config.in.channel_layout = hdr2layout[nchannels - 1]; + update_audio_description( "LPCM", audio, 0 ); + return 1; +} + +static int hb_setup_mpg_audio( hb_audio_t *audio, uint8_t *b ) +{ + /* XXX + * This is a placeholder to get the audio sample rate set. + * It should be replaced by something that extracts the correct info from + * the mpeg audio bitstream. + */ + audio->config.in.samplerate = 48000; + audio->config.in.bitrate = 384000; + audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + update_audio_description( "MPGA", audio, 0 ); + return 1; +} + +/* + * This routine is called for every frame from a non-video elementary stream. + * These are a mix of audio & subtitle streams, some of which we want & some + * we're ignoring. This routine checks the frame against all our audio streams + * to see if it's one we want and haven't identified yet. If yes, it passes the + * frame to a codec-specific id routine which is responsible for filling in + * the sample rate, bit rate, channels & other audio parameters. + * + * Since a sample rate is essential for further audio processing, any audio + * stream which isn't successfully id'd by is deleted at the end of the scan. + * This is necessary to avoid ambiguities where things that might be audio + * aren't (e.g., some European DVD Teletext streams use the same IDs as US ATSC + * AC-3 audio). + */ +static void LookForAudio( hb_title_t * title, hb_buffer_t * b ) +{ + int i; + hb_audio_t * audio = NULL; for( i = 0; i < hb_list_count( title->list_audio ); i++ ) { audio = hb_list_item( title->list_audio, i ); - /* check if we have an AC3 or DCA which we recognise */ - if( ( audio->config.in.codec == HB_ACODEC_AC3 || audio->config.in.codec == HB_ACODEC_DCA ) && - audio->id == b->id ) + /* check if this elementary stream is one we want */ + if ( audio->id == b->id ) { break; } @@ -589,181 +769,64 @@ audio = NULL; } } - if( !audio ) + if( !audio || audio->config.in.bitrate != 0 ) { + /* not found or already done */ return; } - if( audio->config.in.bitrate ) + switch ( audio->config.in.codec ) { - /* Already done for this track */ - return; - } - - for( i = 0; i < b->size - 7; i++ ) - { - - if ( audio->config.in.codec == HB_ACODEC_AC3 ) - { - - /* check for a52 */ - if( a52_syncinfo( &b->data[i], &flags, &rate, &bitrate ) ) + case HB_ACODEC_AC3: + /* since AC3 frames don't line up with MPEG ES frames, scan the + * entire frame for an AC3 sync pattern. */ + for ( i = 0; i < b->size - 7; ++i ) { - hb_log( "scan: AC3, rate=%dHz, bitrate=%d", rate, bitrate ); - audio->config.in.samplerate = rate; - audio->config.in.bitrate = bitrate; - switch( flags & A52_CHANNEL_MASK ) + if ( hb_setup_a52_audio( audio, &b->data[i] ) ) { - /* mono sources */ - case A52_MONO: - case A52_CHANNEL1: - case A52_CHANNEL2: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO; - break; - /* stereo input */ - case A52_CHANNEL: - case A52_STEREO: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - break; - /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */ - case A52_DOLBY: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_DOLBY; - break; - /* 3F/2R input */ - case A52_3F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R; - break; - /* 3F/1R input */ - case A52_3F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R; - break; - /* other inputs */ - case A52_3F: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F; - break; - case A52_2F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R; - break; - case A52_2F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R; - break; - /* unknown */ - default: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; + return; } + } + break; - /* add in our own LFE flag if the source has LFE */ - if (flags & A52_LFE) + case HB_ACODEC_DCA: + /* since DCA frames don't line up with MPEG ES frames, scan the + * entire frame for an DCA sync pattern. */ + for ( i = 0; i < b->size - 7; ++i ) + { + if ( hb_setup_dca_audio( audio, &b->data[i] ) ) { - audio->config.in.channel_layout = audio->config.in.channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE; + return; } + } + break; - /* store the AC3 flags for future reference - * This enables us to find out if we had a stereo or Dolby source later on - * Store the ac3 flags in the public ac3flags property too, so we can access it from the GUI - */ - audio->config.flags.ac3 = audio->priv.config.a52.ac3flags = flags; - - /* XXX */ - if ( (flags & A52_CHANNEL_MASK) == A52_DOLBY ) { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (Dolby Surround)" ); - } else { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (%d.%d ch)", - HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->config.in.channel_layout) + - HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->config.in.channel_layout), - HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->config.in.channel_layout)); - } - - break; - + case HB_ACODEC_LPCM: + if ( hb_setup_pcm_audio( audio, b->data ) ) + { + return; } + break; - } - else if ( audio->config.in.codec == HB_ACODEC_DCA ) - { - - hb_log( "scan: checking for DCA syncinfo" ); - - /* check for dca */ - state = dca_init( 0 ); - if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate, &frame_length ) ) + case HB_ACODEC_MPGA: + if ( hb_setup_mpg_audio( audio, b->data ) ) { - hb_log( "scan: DCA, rate=%dHz, bitrate=%d", rate, bitrate ); - audio->config.in.samplerate = rate; - audio->config.in.bitrate = bitrate; - switch( flags & DCA_CHANNEL_MASK ) - { - /* mono sources */ - case DCA_MONO: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO; - break; - /* stereo input */ - case DCA_CHANNEL: - case DCA_STEREO: - case DCA_STEREO_SUMDIFF: - case DCA_STEREO_TOTAL: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - break; - /* 3F/2R input */ - case DCA_3F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R; - break; - /* 3F/1R input */ - case DCA_3F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R; - break; - /* other inputs */ - case DCA_3F: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F; - break; - case DCA_2F1R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R; - break; - case DCA_2F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R; - break; - case DCA_4F2R: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_4F2R; - break; - /* unknown */ - default: - audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO; - } + return; + } + break; - /* add in our own LFE flag if the source has LFE */ - if (flags & DCA_LFE) - { - audio->config.in.channel_layout = audio->config.in.channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE; - } - - /* store the DCA flags for future reference - * This enables us to find out if we had a stereo or Dolby source later on - * store the dca flags in the public dcaflags property too, so we can access it from the GUI - */ - audio->config.flags.dca = audio->priv.config.dca.dcaflags = flags; - - /* XXX */ - if ( (flags & DCA_CHANNEL_MASK) == DCA_DOLBY ) { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (Dolby Surround)" ); - } else { - sprintf( audio->config.lang.description + strlen( audio->config.lang.description ), - " (%d.%d ch)", - HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->config.in.channel_layout) + - HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->config.in.channel_layout), - HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->config.in.channel_layout)); - } - - break; - } - } + default: + hb_log( "Internal error in scan: unhandled audio type %d for 0x%x", + audio->config.in.codec, audio->id ); + return; } - } -static int AllAC3AndDCAOK( hb_title_t * title ) +/* + * This routine checks to see if we've ID'd all the audio streams associated + * with a title. It returns 0 if there are more to ID & 1 if all are done. + */ +static int AllAudioOK( hb_title_t * title ) { int i; hb_audio_t * audio; @@ -771,12 +834,10 @@ for( i = 0; i < hb_list_count( title->list_audio ); i++ ) { audio = hb_list_item( title->list_audio, i ); - if( ( audio->config.in.codec == HB_ACODEC_AC3 || audio->config.in.codec == HB_ACODEC_DCA ) && - !audio->config.in.bitrate ) + if( audio->config.in.bitrate == 0 ) { return 0; } } - return 1; }