1 /* $Id: scan.c,v 1.52 2005/11/25 15:05:25 titer Exp $
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. */
9 #include "a52dec/a52.h"
12 #define HB_MAX_PREVIEWS 30 // 30 previews = every 5 minutes of a 2.5 hour video
21 hb_list_t * list_title;
31 uint64_t min_title_duration;
35 static void ScanFunc( void * );
36 static int DecodePreviews( hb_scan_t *, hb_title_t * title );
37 static void LookForAudio( hb_title_t * title, hb_buffer_t * b );
38 static int AllAudioOK( hb_title_t * title );
40 static const char *aspect_to_string( double aspect )
42 switch ( (int)(aspect * 9.) )
44 case 9 * 4 / 3: return "4:3";
45 case 9 * 16 / 9: return "16:9";
47 static char arstr[32];
48 sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", aspect );
52 hb_thread_t * hb_scan_init( hb_handle_t * handle, volatile int * die,
53 const char * path, int title_index,
54 hb_list_t * list_title, int preview_count,
55 int store_previews, uint64_t min_duration )
57 hb_scan_t * data = calloc( sizeof( hb_scan_t ), 1 );
61 data->path = strdup( path );
62 data->title_index = title_index;
63 data->list_title = list_title;
65 data->preview_count = preview_count;
66 data->store_previews = store_previews;
67 data->min_title_duration = min_duration;
69 return hb_thread_init( "scan", ScanFunc, data, HB_NORMAL_PRIORITY );
72 static void ScanFunc( void * _data )
74 hb_scan_t * data = (hb_scan_t *) _data;
83 /* Try to open the path as a DVD. If it fails, try as a file */
84 if( ( data->bd = hb_bd_init( data->path ) ) )
86 hb_log( "scan: BD has %d title(s)",
87 hb_bd_title_count( data->bd ) );
88 if( data->title_index )
90 /* Scan this title only */
91 hb_list_add( data->list_title, hb_bd_title_scan( data->bd,
92 data->title_index, 0 ) );
97 for( i = 0; i < hb_bd_title_count( data->bd ); i++ )
99 hb_list_add( data->list_title, hb_bd_title_scan( data->bd,
100 i + 1, data->min_title_duration ) );
102 feature = hb_bd_main_feature( data->bd, data->list_title );
105 else if( ( data->dvd = hb_dvd_init( data->path ) ) )
107 hb_log( "scan: DVD has %d title(s)",
108 hb_dvd_title_count( data->dvd ) );
109 if( data->title_index )
111 /* Scan this title only */
112 hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
113 data->title_index, 0 ) );
117 /* Scan all titles */
118 for( i = 0; i < hb_dvd_title_count( data->dvd ); i++ )
120 hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
121 i + 1, data->min_title_duration ) );
123 feature = hb_dvd_main_feature( data->dvd, data->list_title );
126 else if ( ( data->batch = hb_batch_init( data->path ) ) )
128 if( data->title_index )
130 /* Scan this title only */
131 title = hb_batch_title_scan( data->batch, data->title_index );
134 hb_list_add( data->list_title, title );
139 /* Scan all titles */
140 for( i = 0; i < hb_batch_title_count( data->batch ); i++ )
144 title = hb_batch_title_scan( data->batch, i + 1 );
147 hb_list_add( data->list_title, title );
152 else if ( (data->stream = hb_stream_open( data->path, 0 ) ) != NULL )
154 hb_list_add( data->list_title, hb_stream_title_scan( data->stream ) );
158 hb_log( "scan: unrecognized file type" );
162 for( i = 0; i < hb_list_count( data->list_title ); )
172 title = hb_list_item( data->list_title, i );
174 #define p state.param.scanning
176 state.state = HB_STATE_SCANNING;
177 p.title_cur = title->index;
178 p.title_count = data->dvd ? hb_dvd_title_count( data->dvd ) :
179 data->bd ? hb_bd_title_count( data->bd ) :
180 hb_list_count(data->list_title);
181 hb_set_state( data->h, &state );
184 /* Decode previews */
185 /* this will also detect more AC3 / DTS information */
186 if( !DecodePreviews( data, title ) )
188 /* TODO: free things */
189 hb_list_rem( data->list_title, title );
193 /* Make sure we found audio rates and bitrates */
194 for( j = 0; j < hb_list_count( title->list_audio ); )
196 audio = hb_list_item( title->list_audio, j );
197 if( !audio->config.in.bitrate )
199 hb_log( "scan: removing audio 0x%x because no bitrate found",
201 hb_list_rem( title->list_audio, audio );
205 if ( audio->priv.scan_cache )
207 hb_fifo_flush( audio->priv.scan_cache );
208 hb_fifo_close( &audio->priv.scan_cache );
213 if ( data->dvd || data->bd )
215 // The subtitle width and height needs to be set to the
216 // title widht and height for DVDs. title width and
217 // height don't get set until we decode previews, so
218 // we can't set subtitle width/height till we get here.
219 for( j = 0; j < hb_list_count( title->list_subtitle ); j++ )
221 hb_subtitle_t *subtitle = hb_list_item( title->list_subtitle, j );
222 if ( subtitle->source == VOBSUB )
224 subtitle->width = title->width;
225 subtitle->height = title->height;
232 /* Init jobs templates */
233 for( i = 0; i < hb_list_count( data->list_title ); i++ )
237 title = hb_list_item( data->list_title, i );
238 job = calloc( sizeof( hb_job_t ), 1 );
242 job->feature = feature;
244 /* Set defaults settings */
245 job->chapter_start = 1;
246 job->chapter_end = hb_list_count( title->list_chapter );
248 /* Autocrop by default. Gnark gnark */
249 memcpy( job->crop, title->crop, 4 * sizeof( int ) );
251 /* Preserve a source's pixel aspect, if it's available. */
252 if( title->pixel_aspect_width && title->pixel_aspect_height )
254 job->anamorphic.par_width = title->pixel_aspect_width;
255 job->anamorphic.par_height = title->pixel_aspect_height;
258 if( title->aspect != 0 && title->aspect != 1. &&
259 !job->anamorphic.par_width && !job->anamorphic.par_height)
261 hb_reduce( &job->anamorphic.par_width, &job->anamorphic.par_height,
262 (int)(title->aspect * title->height + 0.5), title->width );
265 job->width = title->width - job->crop[2] - job->crop[3];
266 hb_fix_aspect( job, HB_KEEP_WIDTH );
267 if( job->height > title->height - job->crop[0] - job->crop[1] )
269 job->height = title->height - job->crop[0] - job->crop[1];
270 hb_fix_aspect( job, HB_KEEP_HEIGHT );
273 hb_log( "scan: title (%d) job->width:%d, job->height:%d",
274 i, job->width, job->height );
278 job->vcodec = HB_VCODEC_FFMPEG;
279 job->vquality = -1.0;
280 job->vbitrate = 1000;
282 job->vrate = title->rate;
283 job->vrate_base = title->rate_base;
285 job->list_audio = hb_list_init();
286 job->list_subtitle = hb_list_init();
288 job->mux = HB_MUX_MP4;
295 hb_bd_close( &data->bd );
299 hb_dvd_close( &data->dvd );
303 hb_stream_close(&data->stream);
307 hb_batch_close( &data->batch );
314 // -----------------------------------------------
315 // stuff related to cropping
319 static inline int absdiff( int x, int y )
321 return x < y ? y - x : x - y;
324 static inline int clampBlack( int x )
326 // luma 'black' is 16 and anything less should be clamped at 16
327 return x < 16 ? 16 : x;
330 static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
332 luma += title->width * row;
334 // compute the average luma value of the row
336 for ( i = 0; i < title->width; ++i )
338 avg += clampBlack( luma[i] );
344 // since we're trying to detect smooth borders, only take the row if
345 // all pixels are within +-16 of the average (this range is fairly coarse
346 // but there's a lot of quantization noise for luma values near black
347 // so anything less will fail to crop because of the noise).
348 for ( i = 0; i < title->width; ++i )
350 if ( absdiff( avg, clampBlack( luma[i] ) ) > 16 )
356 static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int bottom,
359 int stride = title->width;
360 int height = title->height - top - bottom;
361 luma += stride * top + col;
363 // compute the average value of the column
364 int i = height, avg = 0, row = 0;
365 for ( ; --i >= 0; row += stride )
367 avg += clampBlack( luma[row] );
373 // since we're trying to detect smooth borders, only take the column if
374 // all pixels are within +-16 of the average.
376 for ( ; --i >= 0; row += stride )
378 if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 )
387 int t[HB_MAX_PREVIEWS];
388 int b[HB_MAX_PREVIEWS];
389 int l[HB_MAX_PREVIEWS];
390 int r[HB_MAX_PREVIEWS];
393 static void record_crop( crop_record_t *crops, int t, int b, int l, int r )
395 crops->t[crops->n] = t;
396 crops->b[crops->n] = b;
397 crops->l[crops->n] = l;
398 crops->r[crops->n] = r;
402 static int compare_int( const void *a, const void *b )
404 return *(const int *)a - *(const int *)b;
407 static void sort_crops( crop_record_t *crops )
409 qsort( crops->t, crops->n, sizeof(crops->t[0]), compare_int );
410 qsort( crops->b, crops->n, sizeof(crops->t[0]), compare_int );
411 qsort( crops->l, crops->n, sizeof(crops->t[0]), compare_int );
412 qsort( crops->r, crops->n, sizeof(crops->t[0]), compare_int );
415 // -----------------------------------------------
416 // stuff related to title width/height/aspect info
419 int count; /* number of times we've seen this info entry */
420 hb_work_info_t info; /* copy of info entry */
423 static void remember_info( info_list_t *info_list, hb_work_info_t *info )
425 for ( ; info_list->count; ++info_list )
427 if ( memcmp( &info_list->info, info, sizeof(*info) ) == 0 )
429 // we found a match - bump its count
434 // no match found - add new entry to list (info_list points to
435 // the first free slot). NB - we assume that info_list was allocated
436 // so that it's big enough even if there are no dups. I.e., 10 slots
437 // allocated if there are 10 previews.
438 info_list->count = 1;
439 info_list->info = *info;
442 static void most_common_info( info_list_t *info_list, hb_work_info_t *info )
445 for ( i = 1; info_list[i].count; ++i )
447 if ( info_list[i].count > info_list[biggest].count )
450 *info = info_list[biggest].info;
454 /***********************************************************************
456 ***********************************************************************
457 * Decode 10 pictures for the given title.
458 * It assumes that data->reader and data->vts have successfully been
459 * DVDOpen()ed and ifoOpen()ed.
460 **********************************************************************/
461 static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
463 int i, npreviews = 0;
464 hb_buffer_t * buf_ps, * buf_es;
466 int progressive_count = 0;
467 int interlaced_preview_count = 0;
468 info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) );
469 crop_record_t *crops = calloc( 1, sizeof(*crops) );
471 buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
472 list_es = hb_list_init();
474 hb_log( "scan: decoding previews for title %d", title->index );
478 hb_bd_start( data->bd, title );
479 hb_log( "scan: title angle(s) %d", title->angle_count );
483 hb_dvd_start( data->dvd, title, 1 );
484 title->angle_count = hb_dvd_angle_count( data->dvd );
485 hb_log( "scan: title angle(s) %d", title->angle_count );
487 else if (data->batch)
489 data->stream = hb_stream_open( title->path, title );
492 for( i = 0; i < data->preview_count; i++ )
504 if( !hb_bd_seek( data->bd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) )
511 if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) )
516 else if (data->stream)
518 /* we start reading streams at zero rather than 1/11 because
519 * short streams may have only one sequence header in the entire
520 * file and we need it to decode any previews. */
521 if (!hb_stream_seek(data->stream, (float) i / ( data->preview_count + 1.0 ) ) )
527 hb_deep_log( 2, "scan: preview %d", i + 1 );
529 int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
530 #if defined(USE_FF_MPEG2)
531 if (vcodec == WORK_DECMPEG2)
533 vcodec = WORK_DECAVCODECV;
534 title->video_codec_param = CODEC_ID_MPEG2VIDEO;
537 hb_work_object_t *vid_decoder = hb_get_work( vcodec );
538 vid_decoder->codec_param = title->video_codec_param;
539 vid_decoder->title = title;
540 vid_decoder->init( vid_decoder, NULL );
541 hb_buffer_t * vid_buf = NULL;
544 if ( title->flags & HBTF_NO_IDR )
546 // title doesn't have IDR frames so we decode but drop one second's
547 // worth of frames to allow the decoder to converge.
548 if ( ! title->rate_base )
554 vidskip = (double)title->rate / (double)title->rate_base + 0.5;
556 // If it's a BD, we can relax this a bit. Since seeks will
557 // at least get us to a recovery point.
562 for( j = 0; j < 10240 ; j++ )
566 if( !hb_bd_read( data->bd, buf_ps ) )
572 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
578 if( !hb_dvd_read( data->dvd, buf_ps ) )
584 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
588 else if (data->stream)
590 if ( !hb_stream_read(data->stream,buf_ps) )
596 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
600 (hb_demux[title->demuxer])(buf_ps, list_es, 0 );
602 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
604 hb_list_rem( list_es, buf_es );
605 if( buf_es->id == title->video_id && vid_buf == NULL )
607 vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
608 if ( vid_buf && vidskip && --vidskip > 0 )
610 // we're dropping frames to get the video decoder in sync
611 // when the video stream doesn't contain IDR frames
612 while (vid_buf && --vidskip >= 0)
614 hb_buffer_t * next = vid_buf->next;
615 vid_buf->next = NULL;
616 hb_buffer_close( &vid_buf );
621 else if( ! AllAudioOK( title ) )
623 LookForAudio( title, buf_es );
627 hb_buffer_close( &buf_es );
630 if( vid_buf && AllAudioOK( title ) )
636 hb_log( "scan: could not get a decoded picture" );
640 /* Get size and rate infos */
642 hb_work_info_t vid_info;
643 if( !vid_decoder->info( vid_decoder, &vid_info ) )
646 * Could not fill vid_info, don't continue and try to use vid_info
651 hb_buffer_close( &vid_buf );
653 vid_decoder->close( vid_decoder );
657 vid_decoder->close( vid_decoder );
660 remember_info( info_list, &vid_info );
662 title->video_codec_name = strdup( vid_info.name );
663 title->width = vid_info.width;
664 title->height = vid_info.height;
665 title->rate = vid_info.rate;
666 title->rate_base = vid_info.rate_base;
667 title->video_bitrate = vid_info.bitrate;
669 if( title->rate_base == 1126125 )
671 /* Frame FPS is 23.976 (meaning it's progressive), so
672 start keeping track of how many are reporting at
673 that speed. When enough show up that way, we want
674 to make that the overall title FPS.
678 if( progressive_count < 6 )
680 /* Not enough frames are reporting as progressive,
681 which means we should be conservative and use
682 29.97 as the title's FPS for now.
684 title->rate_base = 900900;
688 /* A majority of the scan frames are progressive. Make that
689 the title's FPS, and announce it once to the log.
691 if( progressive_count == 6 )
693 hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976");
695 title->rate_base = 1126125;
698 else if( title->rate_base == 900900 && progressive_count >= 6 )
701 * We've already deduced that the frame rate is 23.976, so set it
704 title->rate_base = 1126125;
707 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
709 hb_list_rem( list_es, buf_es );
710 hb_buffer_close( &buf_es );
713 /* Check preview for interlacing artifacts */
714 if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
716 hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1);
717 interlaced_preview_count++;
720 if( data->store_previews )
722 hb_get_tempory_filename( data->h, filename, "%d_%d_%d",
723 hb_get_instance_id(data->h), title->index, i );
725 file_preview = fopen( filename, "wb" );
728 fwrite( vid_buf->data, title->width * title->height * 3 / 2,
730 fclose( file_preview );
734 hb_log( "scan: fopen failed (%s)", filename );
738 /* Detect black borders */
740 #define Y vid_buf->data
741 int top, bottom, left, right;
742 int h4 = title->height / 4, w4 = title->width / 4;
744 // When widescreen content is matted to 16:9 or 4:3 there's sometimes
745 // a thin border on the outer edge of the matte. On TV content it can be
746 // "line 21" VBI data that's normally hidden in the overscan. For HD
747 // content it can just be a diagnostic added in post production so that
748 // the frame borders are visible. We try to ignore these borders so
749 // we can crop the matte. The border width depends on the resolution
750 // (12 pixels on 1080i looks visually the same as 4 pixels on 480i)
751 // so we allow the border to be up to 1% of the frame height.
752 const int border = title->height / 100;
754 for ( top = border; top < h4; ++top )
756 if ( ! row_all_dark( title, Y, top ) )
761 // we never made it past the border region - see if the rows we
762 // didn't check are dark or if we shouldn't crop at all.
763 for ( top = 0; top < border; ++top )
765 if ( ! row_all_dark( title, Y, top ) )
773 for ( bottom = border; bottom < h4; ++bottom )
775 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
778 if ( bottom <= border )
780 for ( bottom = 0; bottom < border; ++bottom )
782 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
785 if ( bottom >= border )
790 for ( left = 0; left < w4; ++left )
792 if ( ! column_all_dark( title, Y, top, bottom, left ) )
795 for ( right = 0; right < w4; ++right )
797 if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) )
801 // only record the result if all the crops are less than a quarter of
802 // the frame otherwise we can get fooled by frames with a lot of black
803 // like titles, credits & fade-thru-black transitions.
804 if ( top < h4 && bottom < h4 && left < w4 && right < w4 )
806 record_crop( crops, top, bottom, left, right );
811 /* Make sure we found audio rates and bitrates */
812 for( j = 0; j < hb_list_count( title->list_audio ); j++ )
814 hb_audio_t * audio = hb_list_item( title->list_audio, j );
815 if ( audio->priv.scan_cache )
817 hb_fifo_flush( audio->priv.scan_cache );
822 hb_buffer_close( &vid_buf );
826 if ( data->batch && data->stream )
828 hb_stream_close( &data->stream );
833 // use the most common frame info for our final title dimensions
834 hb_work_info_t vid_info;
835 most_common_info( info_list, &vid_info );
837 title->width = vid_info.width;
838 title->height = vid_info.height;
839 title->pixel_aspect_width = vid_info.pixel_aspect_width;
840 title->pixel_aspect_height = vid_info.pixel_aspect_height;
842 // compute the aspect ratio based on the storage dimensions and the
843 // pixel aspect ratio (if supplied) or just storage dimensions if no PAR.
844 title->aspect = (double)title->width / (double)title->height;
845 if( title->pixel_aspect_width && title->pixel_aspect_height )
847 title->aspect *= (double)title->pixel_aspect_width /
848 (double)title->pixel_aspect_height;
850 // For unknown reasons some French PAL DVDs put the original
851 // content's aspect ratio into the mpeg PAR even though it's
852 // the wrong PAR for the DVD. Apparently they rely on the fact
853 // that DVD players ignore the content PAR and just use the
854 // aspect ratio from the DVD metadata. So, if the aspect computed
855 // from the PAR is different from the container's aspect we use
856 // the container's aspect & recompute the PAR from it.
857 if( title->container_aspect && (int)(title->aspect * 9) != (int)(title->container_aspect * 9) )
859 hb_log("scan: content PAR gives wrong aspect %.2f; "
860 "using container aspect %.2f", title->aspect,
861 title->container_aspect );
862 title->aspect = title->container_aspect;
863 hb_reduce( &title->pixel_aspect_width, &title->pixel_aspect_height,
864 (int)(title->aspect * title->height + 0.5), title->width );
868 // don't try to crop unless we got at least 3 previews
872 // The next line selects median cropping - at least
873 // 50% of the frames will have their borders removed.
874 // Other possible choices are loose cropping (i = 0) where
875 // no non-black pixels will be cropped from any frame and a
876 // tight cropping (i = crops->n - (crops->n >> 2)) where at
877 // least 75% of the frames will have their borders removed.
879 title->crop[0] = EVEN( crops->t[i] );
880 title->crop[1] = EVEN( crops->b[i] );
881 title->crop[2] = EVEN( crops->l[i] );
882 title->crop[3] = EVEN( crops->r[i] );
886 hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, "
887 "aspect %s, PAR %d:%d",
888 npreviews, title->width, title->height, (float) title->rate /
889 (float) title->rate_base,
890 title->crop[0], title->crop[1], title->crop[2], title->crop[3],
891 aspect_to_string( title->aspect ), title->pixel_aspect_width,
892 title->pixel_aspect_height );
894 if( interlaced_preview_count >= ( npreviews / 2 ) )
896 hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.",
897 interlaced_preview_count, npreviews);
898 title->detected_interlacing = 1;
902 title->detected_interlacing = 0;
906 hb_buffer_close( &buf_ps );
907 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
909 hb_list_rem( list_es, buf_es );
910 hb_buffer_close( &buf_es );
912 hb_list_close( &list_es );
914 hb_bd_stop( data->bd );
916 hb_dvd_stop( data->dvd );
922 * This routine is called for every frame from a non-video elementary stream.
923 * These are a mix of audio & subtitle streams, some of which we want & some
924 * we're ignoring. This routine checks the frame against all our audio streams
925 * to see if it's one we want and haven't identified yet. If yes, it passes the
926 * frame to a codec-specific id routine which is responsible for filling in
927 * the sample rate, bit rate, channels & other audio parameters.
929 * Since a sample rate is essential for further audio processing, any audio
930 * stream which isn't successfully id'd by is deleted at the end of the scan.
931 * This is necessary to avoid ambiguities where things that might be audio
932 * aren't (e.g., some European DVD Teletext streams use the same IDs as US ATSC
935 static void LookForAudio( hb_title_t * title, hb_buffer_t * b )
939 hb_audio_t * audio = NULL;
940 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
942 audio = hb_list_item( title->list_audio, i );
943 /* check if this elementary stream is one we want */
944 if ( audio->id == b->id )
953 if( !audio || audio->config.in.bitrate != 0 )
955 /* not found or already done */
956 hb_buffer_close( &b );
960 if ( audio->priv.scan_cache == NULL )
961 audio->priv.scan_cache = hb_fifo_init( 16, 16 );
963 if ( hb_fifo_size_bytes( audio->priv.scan_cache ) >= 4096 )
966 tmp = hb_fifo_get( audio->priv.scan_cache );
967 hb_buffer_close( &tmp );
969 hb_fifo_push( audio->priv.scan_cache, b );
971 hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
973 if ( w == NULL || w->bsinfo == NULL )
975 hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
976 audio->config.in.codec, audio->id );
982 w->codec_param = audio->config.in.codec_param;
983 b = hb_fifo_see( audio->priv.scan_cache );
984 int ret = w->bsinfo( w, b, &info );
987 hb_log( "no info on audio type %d/0x%x for id 0x%x",
988 audio->config.in.codec, audio->config.in.codec_param,
994 /* didn't find any info */
997 hb_fifo_flush( audio->priv.scan_cache );
998 hb_fifo_close( &audio->priv.scan_cache );
1000 audio->config.in.samplerate = info.rate;
1001 audio->config.in.bitrate = info.bitrate;
1002 audio->config.in.channel_layout = info.channel_layout;
1003 audio->config.in.version = info.version;
1004 audio->config.in.mode = info.mode;
1005 audio->config.flags.ac3 = info.flags;
1007 // update the audio description string based on the info we found
1008 if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
1010 strcat( audio->config.lang.description, " (Dolby Surround)" );
1014 int layout = audio->config.in.channel_layout;
1015 char *desc = audio->config.lang.description +
1016 strlen( audio->config.lang.description );
1017 sprintf( desc, " (%d.%d ch)",
1018 HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
1019 HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
1020 HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
1023 hb_log( "scan: audio 0x%x: %s, rate=%dHz, bitrate=%d %s", audio->id,
1024 info.name, audio->config.in.samplerate, audio->config.in.bitrate,
1025 audio->config.lang.description );
1030 // We get here if there's no hope of finding info on an audio bitstream,
1031 // either because we don't have a decoder (or a decoder with a bitstream
1032 // info proc) or because the decoder's info proc said that the stream
1033 // wasn't something it could handle. Delete the item from the title's
1034 // audio list so we won't keep reading packets while trying to get its
1040 hb_fifo_flush( audio->priv.scan_cache );
1041 hb_fifo_close( &audio->priv.scan_cache );
1042 hb_list_rem( title->list_audio, audio );
1047 * This routine checks to see if we've ID'd all the audio streams associated
1048 * with a title. It returns 0 if there are more to ID & 1 if all are done.
1050 static int AllAudioOK( hb_title_t * title )
1055 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
1057 audio = hb_list_item( title->list_audio, i );
1058 if( audio->config.in.bitrate == 0 )