From: van Date: Sat, 10 Jan 2009 04:47:48 +0000 (+0000) Subject: Get previews from H.264 content even if it's missing IDR frames (e.g., NZ TV & some... X-Git-Url: http://git.osdn.jp/view?a=commitdiff_plain;h=8f82160f8029a84a12d8219b35497727a27c9564;p=handbrake-jp%2Fhandbrake-jp-git.git Get previews from H.264 content even if it's missing IDR frames (e.g., NZ TV & some blu-rays): - Grab stream characteristics (IDRs or not, PCRs or not, RAPs or not) while we're reading to compute the duration rather than trying to guess with no information later. - Only wait for an IDR after a seek if we know the stream has IDRs. Even then, wait for at most 255 frames. - If the stream doesn't have IDRs tell scan (via a new flag in the title struct) so that it can read but discard a second's worth of frames to get the decoder in sync withe stream. - While we're trying to sync the decoder, ffmpeg will spit out dozens of useless error messages so suppress them. git-svn-id: svn://localhost/HandBrake/trunk@2071 b64f7644-9d1e-0410-96f1-a4d463321fa5 --- diff --git a/libhb/common.h b/libhb/common.h index 5da21214..e0376914 100644 --- a/libhb/common.h +++ b/libhb/common.h @@ -497,6 +497,10 @@ struct hb_title_s /* Job template for this title */ hb_job_t * job; + + uint32_t flags; + // set if video stream doesn't have IDR frames +#define HBTF_NO_IDR (1 << 0) }; diff --git a/libhb/decavcodec.c b/libhb/decavcodec.c index 28709916..5dd22244 100644 --- a/libhb/decavcodec.c +++ b/libhb/decavcodec.c @@ -550,13 +550,22 @@ static void flushDelayQueue( hb_work_private_t *pv ) static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size ) { - int got_picture; + int got_picture, oldlevel = 0; AVFrame frame; + if ( global_verbosity_level <= 1 ) + { + oldlevel = av_log_get_level(); + av_log_set_level( AV_LOG_QUIET ); + } if ( avcodec_decode_video( pv->context, &frame, &got_picture, data, size ) < 0 ) { ++pv->decode_errors; } + if ( global_verbosity_level <= 1 ) + { + av_log_set_level( oldlevel ); + } if( got_picture ) { // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES diff --git a/libhb/scan.c b/libhb/scan.c index 6459c1d5..6cdaceb6 100644 --- a/libhb/scan.c +++ b/libhb/scan.c @@ -439,6 +439,21 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) vid_decoder->codec_param = title->video_codec_param; vid_decoder->init( vid_decoder, NULL ); hb_buffer_t * vid_buf = NULL; + int vidskip = 0; + + if ( title->flags & HBTF_NO_IDR ) + { + // title doesn't have IDR frames so we decode but drop one second's + // worth of frames to allow the decoder to converge. + if ( ! title->rate_base ) + { + vidskip = 30; + } + else + { + vidskip = (double)title->rate / (double)title->rate_base + 0.5; + } + } for( j = 0; j < 10240 ; j++ ) { @@ -446,6 +461,10 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) { if( !hb_dvd_read( data->dvd, buf_ps ) ) { + if ( vid_buf ) + { + break; + } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } @@ -470,6 +489,13 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) if( buf_es->id == title->video_id && vid_buf == NULL ) { vid_decoder->work( vid_decoder, &buf_es, &vid_buf ); + if ( vid_buf && vidskip && --vidskip > 0 ) + { + // we're dropping frames to get the video decoder in sync + // when the video stream doesn't contain IDR frames + hb_buffer_close( &vid_buf ); + vid_buf = NULL; + } } else if( ! AllAudioOK( title ) ) { diff --git a/libhb/stream.c b/libhb/stream.c index 479ee538..7d1236da 100755 --- a/libhb/stream.c +++ b/libhb/stream.c @@ -102,10 +102,8 @@ struct hb_stream_s int last_error_count; /* # errors at last error message */ int packetsize; /* Transport Stream packet size */ - int8_t need_keyframe; // non-zero if want to start at a keyframe - int8_t ts_no_RAP; // non-zero if there are no random access points - - int8_t ts_found_pcr; // non-zero if we've found at least one input pcr + uint8_t need_keyframe; // non-zero if want to start at a keyframe + uint8_t ts_found_pcr; // non-zero if we've found at least one input pcr int ts_pcr_out; // sequence number of most recent output pcr int ts_pcr_in; // sequence number of most recent input pcr int64_t ts_pcr; // most recent input pcr @@ -130,6 +128,11 @@ struct hb_stream_s */ uint8_t ts_number_video_pids; uint8_t ts_number_audio_pids; + uint8_t ts_flags; // stream characteristics: +#define TS_HAS_PCR (1 << 0) // at least one PCR seen +#define TS_HAS_RAP (1 << 1) // Random Access Point bit seen +#define TS_HAS_RSEI (1 << 2) // "Restart point" SEI seen + uint8_t ts_IDRs; // # IDRs found during duration scan int16_t ts_video_pids[kMaxNumberVideoPIDS]; int16_t ts_audio_pids[kMaxNumberAudioPIDS]; @@ -704,6 +707,17 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) aTitle->video_codec = st2codec[stream->ts_stream_type[0]].codec; aTitle->video_codec_param = st2codec[stream->ts_stream_type[0]].codec_param; aTitle->demuxer = HB_MPEG2_TS_DEMUXER; + + if ( ( stream->ts_flags & TS_HAS_PCR ) == 0 ) + { + hb_log( "transport stream missing PCRs - using video DTS instead" ); + } + + if ( stream->ts_IDRs < 1 ) + { + hb_log( "transport stream doesn't seem to have video IDR frames" ); + aTitle->flags |= HBTF_NO_IDR; + } } else { @@ -772,42 +786,87 @@ static void skip_to_next_pack( hb_stream_t *src_stream ) } } -/* - * scan the next MB of 'stream' to try to find a random access point - */ -static void hb_ts_stream_find_RAP( hb_stream_t *stream ) +static int isIframe( hb_stream_t *stream, const uint8_t *buf, int adapt_len ) { - off_t starting_point = ftello(stream->file_handle); - int npack = 300000; // max packets to read + // For mpeg2: look for a gop start or i-frame picture start + // for h.264: look for idr nal type or a slice header for an i-frame + // for vc1: look for a Sequence header + int i; + uint32_t strid = 0; - while (--npack >= 0) + + if ( stream->ts_stream_type[0] <= 2 ) { - off_t cur = ftello(stream->file_handle); - const uint8_t *buf = next_packet( stream ); - if ( buf == NULL ) - { - break; - } - switch (buf[3] & 0x30) + // This section of the code handles MPEG-1 and MPEG-2 video streams + for (i = 13 + adapt_len; i < 188; i++) { - case 0x00: // illegal - continue; - - case 0x20: // fill packet - case 0x30: // adaptation - if ( buf[5] & 0x40 ) + strid = (strid << 8) | buf[i]; + if ( ( strid >> 8 ) == 1 ) + { + // we found a start code + uint8_t id = strid; + switch ( id ) { - // found a random access point - fseeko( stream->file_handle, cur, SEEK_SET ); - return; + case 0xB8: // group_start_code (GOP header) + case 0xB3: // sequence_header code + return 1; + + case 0x00: // picture_start_code + // picture_header, let's see if it's an I-frame + if (i<185) + { + // check if picture_coding_type == 1 + if ((buf[i+2] & (0x7 << 3)) == (1 << 3)) + { + // found an I-frame picture + return 1; + } + } + break; } - continue; + } + } + // didn't find an I-frame + return 0; + } + if ( stream->ts_stream_type[0] == 0x1b ) + { + // we have an h.264 stream + for (i = 13 + adapt_len; i < 188; i++) + { + strid = (strid << 8) | buf[i]; + if ( ( strid >> 8 ) == 1 ) + { + // we found a start code - remove the ref_idc from the nal type + uint8_t nal_type = strid & 0x1f; + if ( nal_type == 0x05 ) + // h.264 IDR picture start + return 1; + } + } + // didn't find an I-frame + return 0; + } + if ( stream->ts_stream_type[0] == 0xea ) + { + // we have an vc1 stream + for (i = 13 + adapt_len; i < 188; i++) + { + strid = (strid << 8) | buf[i]; + if ( strid == 0x10f ) + { + // the ffmpeg vc1 decoder requires a seq hdr code in the first + // frame. + return 1; + } } + // didn't find an I-frame + return 0; } - /* didn't find it */ - fseeko( stream->file_handle, starting_point, SEEK_SET ); - stream->ts_no_RAP = 1; + // we don't understand the stream type so just say "yes" otherwise + // we'll discard all the video. + return 1; } /* @@ -827,12 +886,28 @@ static const uint8_t *hb_ts_stream_getPEStype(hb_stream_t *stream, uint32_t pid) return 0; } + // while we're reading the stream, check if it has valid PCRs + // and/or random access points. + uint32_t pack_pid = ( (buf[1] & 0x1f) << 8 ) | buf[2]; + if ( pack_pid == stream->pmt_info.PCR_PID ) + { + if ( ( buf[5] & 0x10 ) && + ( ( ( buf[3] & 0x30 ) == 0x20 ) || + ( ( buf[3] & 0x30 ) == 0x30 && buf[4] > 6 ) ) ) + { + stream->ts_flags |= TS_HAS_PCR; + } + } + if ( buf[5] & 0x40 ) + { + stream->ts_flags |= TS_HAS_RAP; + } + /* * The PES header is only in TS packets with 'start' set so we check * that first then check for the right PID. */ - if ((buf[1] & 0x40) == 0 || (buf[1] & 0x1f) != (pid >> 8) || - buf[2] != (pid & 0xff)) + if ((buf[1] & 0x40) == 0 || pack_pid != pid ) { // not a start packet or not the pid we want continue; @@ -934,7 +1009,7 @@ struct pts_pos { uint64_t pts; /* PTS from video stream */ }; -#define NDURSAMPLES 64 +#define NDURSAMPLES 128 // get one (position, timestamp) sampple from a transport or program // stream. @@ -963,6 +1038,14 @@ static struct pts_pos hb_sample_pts(hb_stream_t *stream, uint64_t fpos) ( ( (uint64_t)buf[11] >> 1 ) << 15 ) | ( (uint64_t)buf[12] << 7 ) | ( (uint64_t)buf[13] >> 1 ); + + if ( isIframe( stream, buf, -4 ) ) + { + if ( stream->ts_IDRs < 255 ) + { + ++stream->ts_IDRs; + } + } } else { @@ -1221,12 +1304,11 @@ int hb_stream_seek( hb_stream_t * stream, float f ) hb_ts_stream_reset(stream); if ( f > 0 ) { - if ( !stream->ts_no_RAP ) + if ( stream->ts_IDRs ) { - // we're not at the beginning - try to find a random access point - hb_ts_stream_find_RAP( stream ); + // the stream has IDRs so look for one. + stream->need_keyframe = 1; } - stream->need_keyframe = 1; } else { @@ -2080,108 +2162,6 @@ static void generate_output_data(hb_stream_t *stream, int curstream) stream->ts_buf[curstream]->size = 0; } -static int isIframe( hb_stream_t *stream, const uint8_t *buf, int adapt_len ) -{ - // For mpeg2: look for a gop start or i-frame picture start - // for h.264: look for idr nal type or a slice header for an i-frame - // for vc1: ??? - int i; - uint32_t strid = 0; - - - if ( stream->ts_stream_type[0] <= 2 ) - { - // This section of the code handles MPEG-1 and MPEG-2 video streams - for (i = 13 + adapt_len; i < 188; i++) - { - strid = (strid << 8) | buf[i]; - if ( ( strid >> 8 ) == 1 ) - { - // we found a start code - uint8_t id = strid; - switch ( id ) - { - case 0xB8: // group_start_code (GOP header) - case 0xB3: // sequence_header code - return 1; - - case 0x00: // picture_start_code - // picture_header, let's see if it's an I-frame - if (i<185) - { - // check if picture_coding_type == 1 - if ((buf[i+2] & (0x7 << 3)) == (1 << 3)) - { - // found an I-frame picture - return 1; - } - } - break; - } - } - } - // didn't find an I-frame - return 0; - } - if ( stream->ts_stream_type[0] == 0x1b ) - { - // we have an h.264 stream - for (i = 13 + adapt_len; i < 188; i++) - { - strid = (strid << 8) | buf[i]; - if ( ( strid >> 8 ) == 1 ) - { - // we found a start code - remove the ref_idc from the nal type - uint8_t nal_type = strid & 0x1f; - if ( nal_type == 0x05 ) - // h.264 IDR picture start - return 1; - - if ( stream->packetsize == 192 ) - { - // m2ts files have idr frames so keep looking for one - continue; - } - - // h.264 in ts files (ATSC or DVB video) often seem to be - // missing IDR frames so look for at least an I - if ( nal_type == 0x01 ) - { - // h.264 slice: has to be start MB 0 & type I (2, 4, 7 or 9) - uint8_t id = buf[i+1]; - if ( ( id >> 4 ) == 0x0b || ( id >> 2 ) == 0x25 || - id == 0x88 || id == 0x8a ) - { - return 1; - } - } - } - } - // didn't find an I-frame - return 0; - } - if ( stream->ts_stream_type[0] == 0xea ) - { - // we have an vc1 stream - for (i = 13 + adapt_len; i < 188; i++) - { - strid = (strid << 8) | buf[i]; - if ( strid == 0x10f ) - { - // the ffmpeg vc1 decoder requires a seq hdr code in the first - // frame. - return 1; - } - } - // didn't find an I-frame - return 0; - } - - // we don't understand the stream type so just say "yes" otherwise - // we'll discard all the video. - return 1; -} - static void hb_ts_stream_append_pkt(hb_stream_t *stream, int idx, const uint8_t *buf, int len) { if (stream->ts_pos[idx] + len > stream->ts_buf[idx]->alloc) @@ -2279,11 +2259,16 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) } } - // If we don't have a pcr yet, the right thing to do here would - // be a 'continue' so we don't process anything until we have a - // clock reference. Unfortunately the HD Home Run appears to null - // out the pcr field of some streams so we keep going & substitute - // the video stream dts for the pcr when there's no pcr. + // If we don't have a PCR yet but the stream has PCRs just loop + // so we don't process anything until we have a clock reference. + // Unfortunately the HD Home Run appears to null out the PCR so if + // we didn't detect a PCR during scan keep going and we'll use + // the video stream DTS for the PCR. + + if ( !stream->ts_found_pcr && ( stream->ts_flags & TS_HAS_PCR ) ) + { + continue; + } // Get continuity // Continuity only increments for adaption values of 0x3 or 0x01 @@ -2325,10 +2310,14 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) { // we're looking for the first video frame because we're // doing random access during 'scan' - if (curstream != 0 || !isIframe( stream, buf, adapt_len ) ) + if ( curstream != 0 || !isIframe( stream, buf, adapt_len ) ) { // not the video stream or didn't find an I frame - continue; + // but we'll only wait 255 video frames for an I frame. + if ( curstream != 0 || ++stream->need_keyframe ) + { + continue; + } } stream->need_keyframe = 0; }