#include "hb.h"
#include "hbffmpeg.h"
#include "mpeg2dec/mpeg2.h"
-#include "deccc608sub.h"
/* Cadence tracking */
#ifndef PIC_FLAG_REPEAT_FIRST_FIELD
#define TB_PROG 128
#define TBT_PROG 256
+#define NTAGS 8
+
/**********************************************************************
* hb_libmpeg2_t
*********************************************************************/
int height;
int rate;
double aspect_ratio;
+ enum PixelFormat pixfmt;
int got_iframe; /* set when we get our first iframe */
int look_for_iframe; /* need an iframe to add chap break */
int look_for_break; /* need gop start to add chap break */
+ int cur_tag; /* index of current tag */
uint32_t nframes; /* number of frames we've decoded */
int64_t last_pts;
+ int64_t first_pts;
int cadence[12];
int flag;
- struct s_write cc608; /* Closed Captions */
- hb_subtitle_t * subtitle;
+ hb_list_t * list_subtitle;
+ hb_buffer_t * last_cc1_buf;
+ struct {
+ int64_t start; // start time of this frame
+ hb_buffer_t * cc_buf; // captions for this frame
+ } tags[NTAGS];
} hb_libmpeg2_t;
/**********************************************************************
m->libmpeg2 = mpeg2_init();
m->info = mpeg2_info( m->libmpeg2 );
m->last_pts = -1;
+ m->first_pts = -1;
+
+ int i;
+ for ( i = 0; i < NTAGS; ++i )
+ {
+ m->tags[i].start = -1;
+ }
- /* Closed Captions init, whether needed or not */
- general_608_init( &m->cc608 );
- m->cc608.data608 = calloc(1, sizeof(struct eia608));
return m;
}
-static void hb_mpeg2_cc( hb_libmpeg2_t * m, uint8_t *cc_block )
+// send cc_buf to the CC decoder(s)
+static void cc_send_to_decoder( hb_libmpeg2_t *m, hb_buffer_t *cc_buf )
{
- uint8_t cc_valid = (*cc_block & 4) >>2;
- uint8_t cc_type = *cc_block & 3;
-
- if( !m->job )
+ hb_subtitle_t *subtitle;
+
+ // if there's more than one decoder for the captions send a copy
+ // of the buffer to all but the last. Then send the buffer to
+ // the last one (usually there's just one decoder so the 'while' is skipped).
+ int i = 0, n = hb_list_count( m->list_subtitle );
+ while ( --n > 0 )
{
- /*
- * Ignore CC decoding during scanning.
- */
- return;
+ // make a copy of the buf then forward it to the decoder
+ hb_buffer_t *cpy = hb_buffer_init( cc_buf->size );
+ hb_buffer_copy_settings( cpy, cc_buf );
+ memcpy( cpy->data, cc_buf->data, cc_buf->size );
+
+ subtitle = hb_list_item( m->list_subtitle, i++ );
+ hb_fifo_push( subtitle->fifo_in, cpy );
}
+ subtitle = hb_list_item( m->list_subtitle, i );
+ hb_fifo_push( subtitle->fifo_in, cc_buf );
+}
+
+static void hb_mpeg2_cc( hb_libmpeg2_t *m, const uint8_t *cc_block )
+{
+ uint8_t cc_hdr = *cc_block;
+
+ if ( ( cc_hdr & 0x4 ) == 0 )
+ // not valid - ignore
+ return;
- if (cc_valid || cc_type==3)
+ switch (cc_hdr & 3)
{
- switch (cc_type)
- {
case 0:
// CC1 stream
- process608( cc_block+1, 2, &m->cc608 );
+ if ( ( cc_block[1] & 0x7f ) == 0 && ( cc_block[2] & 0x7f ) == 0 )
+ // just padding - ignore
+ return;
+
+ if ( m->last_cc1_buf )
+ {
+ // new data from the same time as last call - add to buffer
+ int len = m->last_cc1_buf->size;
+ hb_buffer_realloc( m->last_cc1_buf, len + 2 );
+ memcpy( m->last_cc1_buf->data + len, cc_block+1, 2 );
+ m->last_cc1_buf->size = len + 2;
+ return;
+ }
+
+ // allocate a new buffer and copy the caption data into it.
+ // (we don't send it yet because we don't know what timestamp to use).
+ hb_buffer_t *cc_buf = hb_buffer_init( 2 );
+ if( !cc_buf )
+ return;
+
+ memcpy( cc_buf->data, cc_block+1, 2 );
+ m->last_cc1_buf = cc_buf;
break;
+#ifdef notyet
case 1:
// CC2 stream
//process608( cc_block+1, 2, &m->cc608 );
// DTVCC packet data
// Fall through
case 3: //EIA-708
- {
- uint8_t temp[4];
- temp[0]=cc_valid;
- temp[1]=cc_type;
- temp[2]=cc_block[1];
- temp[3]=cc_block[2];
- //do_708 ((const unsigned char *) temp, 4);
- }
- break;
+ {
+ uint8_t temp[4];
+ temp[0]=cc_valid;
+ temp[1]=cc_type;
+ temp[2]=cc_block[1];
+ temp[3]=cc_block[2];
+ do_708 ((const unsigned char *) temp, 4);
+ }
+ break;
+#endif
default:
break;
- }
}
+}
+
+static inline int have_captions( const uint8_t *user_data, uint32_t len )
+{
+ return len >= 6 &&
+ ( ( user_data[0] == 0x43 && user_data[1] == 0x43 ) ||
+ ( user_data[0] == 0x47 && user_data[1] == 0x41 &&
+ user_data[2] == 0x39 && user_data[3] == 0x34 &&
+ user_data[4] == 3 && (user_data[5] & 0x40) ) );
+}
+
+static void do_one_dvd_cc( hb_libmpeg2_t *m, const uint8_t *header, int field1 )
+{
+ uint8_t data[3];
+
+ data[0] = ( header[0] == 0xff && 0 == field1 )? 0x04 : 0x05;
+ data[1] = header[1];
+ data[2] = header[2];
+ hb_mpeg2_cc( m, data );
+
+ data[0] = ( header[3] == 0xff && 1 == field1 )? 0x04 : 0x05;
+ data[1] = header[4];
+ data[2] = header[5];
+ hb_mpeg2_cc( m, data );
+}
+
+// extract all the captions in the current frame and send them downstream
+// to the decoder.
+//
+// (this routine should only be called if there are captions in the current
+// frame. I.e., only if a call to 'have_captions' returns true.)
+static void extract_mpeg2_captions( hb_libmpeg2_t *m )
+{
+ const uint8_t *user_data = m->info->user_data;
+ int dvd_captions = user_data[0] == 0x43;
+ int capcount, field1packet = 0;
+ const uint8_t *header = &user_data[4];
+ if ( !dvd_captions )
+ {
+ // ATSC encapsulated captions - header starts one byte later
+ // and has an extra unused byte following it.
+ capcount = header[1] & 0x1f;
+ header += 3;
+ }
else
{
- hb_log("Ignoring invalid CC block");
+ // DVD captions
+ if ( ( header[0] & 0x80 ) == 0x00 )
+ field1packet=1; /* expect Field 1 second */
+ capcount=(header[0] & 0x1e) / 2;
+ header++;
+ }
+
+ int i;
+ for( i=0; i<capcount; i++ )
+ {
+ if ( !dvd_captions )
+ {
+ hb_mpeg2_cc( m, header );
+ header += 3;
+ }
+ else
+ {
+ do_one_dvd_cc( m, header, field1packet );
+ header += 6;
+ }
+ }
+ if ( dvd_captions )
+ {
+ // Deal with extra closed captions some DVDs have.
+ while( header[0]==0xfe || header[0]==0xff )
+ {
+ do_one_dvd_cc( m, header, field1packet );
+ header += 6;
+ }
+ }
+}
+
+static void next_tag( hb_libmpeg2_t *m, hb_buffer_t *buf_es )
+{
+ m->cur_tag = ( m->cur_tag + 1 ) & (NTAGS-1);
+ if ( m->tags[m->cur_tag].start >= 0 || m->tags[m->cur_tag].cc_buf )
+ {
+ if ( m->tags[m->cur_tag].start < 0 ||
+ ( m->got_iframe && m->tags[m->cur_tag].start >= m->first_pts ) )
+ hb_log("mpeg2 tag botch: pts %"PRId64", tag pts %"PRId64" buf 0x%p",
+ buf_es->start, m->tags[m->cur_tag].start, m->tags[m->cur_tag].cc_buf);
+ if ( m->tags[m->cur_tag].cc_buf )
+ hb_buffer_close( &m->tags[m->cur_tag].cc_buf );
}
+ m->tags[m->cur_tag].start = buf_es->start;
+ mpeg2_tag_picture( m->libmpeg2, m->cur_tag, 0 );
}
static hb_buffer_t *hb_copy_frame( hb_job_t *job, int width, int height,
+ enum PixelFormat pixfmt,
uint8_t* y, uint8_t *u, uint8_t *v )
{
int dst_w = width, dst_h = height;
}
int dst_wh = dst_w * dst_h;
hb_buffer_t *buf = hb_video_buffer_init( dst_w, dst_h );
+ buf->start = -1;
- if ( dst_w != width || dst_h != height )
+ if ( dst_w != width || dst_h != height || pixfmt == PIX_FMT_YUV422P )
{
// we're encoding and the frame dimensions don't match the title dimensions -
// rescale & matte Y, U, V into our output buf.
AVPicture in, out;
- avpicture_alloc(&in, PIX_FMT_YUV420P, width, height );
+ avpicture_alloc(&in, pixfmt, width, height );
avpicture_alloc(&out, PIX_FMT_YUV420P, dst_w, dst_h );
int src_wh = width * height;
- memcpy( in.data[0], y, src_wh );
- memcpy( in.data[1], u, src_wh >> 2 );
- memcpy( in.data[2], v, src_wh >> 2 );
- struct SwsContext *context = sws_getContext( width, height, PIX_FMT_YUV420P,
+ if ( pixfmt == PIX_FMT_YUV422P )
+ {
+ memcpy( in.data[0], y, src_wh );
+ memcpy( in.data[1], u, src_wh >> 1 );
+ memcpy( in.data[2], v, src_wh >> 1 );
+ }
+ else
+ {
+ memcpy( in.data[0], y, src_wh );
+ memcpy( in.data[1], u, src_wh >> 2 );
+ memcpy( in.data[2], v, src_wh >> 2 );
+ }
+ struct SwsContext *context = hb_sws_get_context( width, height, pixfmt,
dst_w, dst_h, PIX_FMT_YUV420P,
- SWS_LANCZOS|SWS_ACCURATE_RND,
- NULL, NULL, NULL );
+ SWS_LANCZOS|SWS_ACCURATE_RND);
sws_scale( context, in.data, in.linesize, 0, height, out.data, out.linesize );
sws_freeContext( context );
static int hb_libmpeg2_decode( hb_libmpeg2_t * m, hb_buffer_t * buf_es,
hb_list_t * list_raw )
{
- mpeg2_state_t state;
- hb_buffer_t * buf;
+ mpeg2_state_t state;
+ hb_buffer_t * buf;
if ( buf_es->size )
{
/* Feed libmpeg2 */
- if( buf_es->start > -1 )
+ if( buf_es->start >= 0 )
{
- mpeg2_tag_picture( m->libmpeg2, buf_es->start >> 32,
- buf_es->start & 0xFFFFFFFF );
+ next_tag( m, buf_es );
}
- mpeg2_buffer( m->libmpeg2, buf_es->data,
- buf_es->data + buf_es->size );
+ mpeg2_buffer( m->libmpeg2, buf_es->data, buf_es->data + buf_es->size );
}
for( ;; )
/* Require some more data */
break;
}
- else if( state == STATE_SEQUENCE )
+
+ // if the user requested captions, process
+ // any captions found in the current frame.
+ if ( m->list_subtitle && m->last_pts >= 0 &&
+ have_captions( m->info->user_data, m->info->user_data_len ) )
+ {
+ extract_mpeg2_captions( m );
+ // if we don't have a tag for the captions, make one
+ if ( m->last_cc1_buf && m->tags[m->cur_tag].cc_buf != m->last_cc1_buf )
+ {
+ if (m->tags[m->cur_tag].cc_buf)
+ {
+ hb_log("mpeg2 tag botch2: pts %"PRId64", tag pts %"PRId64" buf 0x%p",
+ buf_es->start, m->tags[m->cur_tag].start, m->tags[m->cur_tag].cc_buf);
+ hb_buffer_close( &m->tags[m->cur_tag].cc_buf );
+ }
+ // see if we already made a tag for the timestamp. If so we
+ // can just use it, otherwise make a new tag.
+ if (m->tags[m->cur_tag].start < 0)
+ {
+ next_tag( m, buf_es );
+ }
+ m->tags[m->cur_tag].cc_buf = m->last_cc1_buf;
+ }
+ }
+ if( state == STATE_SEQUENCE )
{
if( !( m->width && m->height && m->rate ) )
{
m->aspect_ratio = ar_numer / ar_denom;
}
}
+ if ( m->info->sequence->width >> 1 == m->info->sequence->chroma_width &&
+ m->info->sequence->height >> 1 == m->info->sequence->chroma_height )
+ {
+ m->pixfmt = PIX_FMT_YUV420P;
+ }
+ else
+ {
+ m->pixfmt = PIX_FMT_YUV422P;
+ }
}
else if( state == STATE_GOP && m->look_for_break)
{
else if( ( state == STATE_SLICE || state == STATE_END ) &&
m->info->display_fbuf )
{
- if( ( m->info->display_picture->flags &
+ m->last_cc1_buf = NULL;
+
+ if( !m->got_iframe && ( m->info->display_picture->flags &
PIC_MASK_CODING_TYPE ) == PIC_FLAG_CODING_TYPE_I )
{
// we got an iframe so we can start decoding video now
{
buf = hb_copy_frame( m->job, m->info->sequence->width,
m->info->sequence->height,
+ m->pixfmt,
m->info->display_fbuf->buf[0],
m->info->display_fbuf->buf[1],
m->info->display_fbuf->buf[2] );
buf->sequence = buf_es->sequence;
+ hb_buffer_t *cc_buf = NULL;
if( m->info->display_picture->flags & PIC_FLAG_TAGS )
{
- buf->start =
- ( (uint64_t) m->info->display_picture->tag << 32 ) |
- ( (uint64_t) m->info->display_picture->tag2 );
+ int t = m->info->display_picture->tag;
+ buf->start = m->tags[t].start;
+ cc_buf = m->tags[t].cc_buf;
+ m->tags[t].start = -1;
+ m->tags[t].cc_buf = NULL;
}
- else if( m->last_pts > -1 )
+ if( buf->start < 0 && m->last_pts >= 0 )
{
/* For some reason nb_fields is sometimes 1 while it
should be 2 */
MAX( 2, m->info->display_picture->nb_fields ) *
m->info->sequence->frame_period / 600;
}
- else
+ if ( buf->start >= 0 )
{
- buf->start = -1;
+ m->last_pts = buf->start;
+ }
+
+ // if we were accumulating captions we now know the timestamp
+ // so ship them to the decoder.
+ if ( cc_buf )
+ {
+ cc_buf->start = m->last_pts;
+ cc_send_to_decoder( m, cc_buf );
}
- m->last_pts = buf->start;
if( m->look_for_iframe && ( m->info->display_picture->flags &
PIC_MASK_CODING_TYPE ) == PIC_FLAG_CODING_TYPE_I )
buf->new_chap - 1 );
chap_name = c->title;
}
- hb_log( "mpeg2: \"%s\" (%d) at frame %u time %lld",
+ hb_log( "mpeg2: \"%s\" (%d) at frame %u time %"PRId64,
chap_name, buf->new_chap, m->nframes, buf->start );
- } else if ( m->nframes == 0 && m->job &&
- hb_list_item( m->job->title->list_chapter,
- m->job->chapter_start - 1 ) )
+ }
+ else if ( m->nframes == 0 )
{
- hb_chapter_t * c = hb_list_item( m->job->title->list_chapter,
- m->job->chapter_start - 1 );
- hb_log( "mpeg2: \"%s\" (%d) at frame %u time %lld", c->title,
- m->job->chapter_start, m->nframes, buf->start );
+ // this is the first frame returned by the decoder
+ m->first_pts = buf->start;
+ if ( m->job && hb_list_item( m->job->title->list_chapter,
+ m->job->chapter_start - 1 ) )
+ {
+ hb_chapter_t * c = hb_list_item( m->job->title->list_chapter,
+ m->job->chapter_start - 1 );
+ hb_log( "mpeg2: \"%s\" (%d) at frame %u time %"PRId64,
+ c->title, m->job->chapter_start, m->nframes, buf->start );
+ }
}
++m->nframes;
m->flag = m->info->display_picture->flags;
/* Uncomment this block to see frame-by-frame picture flags, as the video encodes.
- hb_log("***** MPEG 2 Picture Info for PTS %lld *****", buf->start);
+ hb_log("***** MPEG 2 Picture Info for PTS %"PRId64" *****", buf->start);
if( m->flag & TOP_FIRST )
hb_log("MPEG2 Flag: Top field first");
if( m->flag & PROGRESSIVE )
}
/*
- * Look for Closed Captions if scanning (!job) or if closed captions have been requested.
+ * Add closed captions to the title if we are scanning (no job).
+ *
+ * Just because we don't add this doesn't mean that there aren't any when
+ * we scan, just that noone said anything. So you should be able to add
+ * closed captions some other way (See decmpeg2Init() for alternative
+ * approach of assuming that there are always CC, which is probably
+ * safer - however I want to leave the autodetect in here for now to
+ * see how it goes).
*/
- if( ( !m->job || m->subtitle) &&
- ( m->info->user_data_len != 0 &&
- m->info->user_data[0] == 0x43 &&
- m->info->user_data[1] == 0x43 ) )
+ if( !m->job && m->title &&
+ have_captions( m->info->user_data, m->info->user_data_len ) )
{
- int i, j;
- const uint8_t *header = &m->info->user_data[4];
- uint8_t pattern=header[0] & 0x80;
- int field1packet = 0; /* expect Field 1 first */
- if (pattern==0x00)
- field1packet=1; /* expect Field 1 second */
- int capcount=(header[0] & 0x1e) / 2;
- header++;
+ hb_subtitle_t *subtitle;
+ int i = 0;
- m->cc608.last_pts = m->last_pts;
-
- /*
- * Add closed captions to the title if we are scanning (no job).
- *
- * Just because we don't add this doesn't mean that there aren't any when
- * we scan, just that noone said anything. So you should be able to add
- * closed captions some other way (See decmpeg2Init() for alternative
- * approach of assuming that there are always CC, which is probably
- * safer - however I want to leave the autodetect in here for now to
- * see how it goes).
- */
- if( !m->job && m->title )
+ while ( ( subtitle = hb_list_item( m->title->list_subtitle, i++ ) ) )
{
- hb_subtitle_t * subtitle;
- int found = 0;
- int i;
-
- for( i = 0; i < hb_list_count( m->title->list_subtitle ); i++ )
+ /*
+ * Let's call them 608 subs for now even if they aren't,
+ * since they are the only types we grok.
+ */
+ if( subtitle->source == CC608SUB )
{
- subtitle = hb_list_item( m->title->list_subtitle, i);
- if( subtitle && subtitle->source == CCSUB )
- {
- found = 1;
- break;
- }
- }
-
- if( !found )
- {
- subtitle = calloc( sizeof( hb_subtitle_t ), 1 );
- subtitle->track = 0;
- subtitle->id = 0x0;
- snprintf( subtitle->lang, sizeof( subtitle->lang ), "Closed Captions");
- snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "und");
- subtitle->format = TEXTSUB;
- subtitle->source = CCSUB;
- subtitle->dest = PASSTHRUSUB;
- subtitle->type = 5;
-
- hb_list_add( m->title->list_subtitle, subtitle );
+ break;
}
}
-
- for( i=0; i<capcount; i++ )
+
+ if( ! subtitle )
{
- for( j=0; j<2; j++ )
+ subtitle = calloc( sizeof( hb_subtitle_t ), 1 );
+ subtitle->track = 0;
+ subtitle->id = 0;
+ subtitle->format = TEXTSUB;
+ subtitle->source = CC608SUB;
+ subtitle->config.dest = PASSTHRUSUB;
+ subtitle->type = 5;
+ snprintf( subtitle->lang, sizeof( subtitle->lang ), "Closed Captions");
+ /*
+ * The language of the subtitles will be the same as the first audio
+ * track, i.e. the same as the video.
+ */
+ hb_audio_t *audio = hb_list_item( m->title->list_audio, 0 );
+ if( audio )
{
- uint8_t data[3];
- data[0] = header[0];
- data[1] = header[1];
- data[2] = header[2];
- header += 3;
- /* Field 1 and 2 data can be in either order,
- with marker bytes of \xff and \xfe
- Since markers can be repeated, use pattern as well */
- if( data[0] == 0xff && j == field1packet )
- {
- data[0] = 0x04; // Field 1
- }
- else
- {
- data[0] = 0x05; // Field 2
- }
- hb_mpeg2_cc( m, data );
+ snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ),
+ audio->config.lang.iso639_2);
+ } else {
+ snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "und");
}
+ hb_list_add( m->title->list_subtitle, subtitle );
}
- // Deal with extra closed captions some DVD have.
- while( header[0]==0xfe || header[0]==0xff )
- {
- for( j=0; j<2; j++ )
- {
- uint8_t data[3];
- data[0] = header[0];
- data[1] = header[1];
- data[2] = header[2];
- header += 3;
- /* Field 1 and 2 data can be in either order,
- with marker bytes of \xff and \xfe
- Since markers can be repeated, use pattern as well */
- if( data[0] == 0xff && j == field1packet )
- {
- data[0] = 0x04; // Field 1
- }
- else
- {
- data[0] = 0x05; // Field 2
- }
- hb_mpeg2_cc( m, data );
- }
- }
}
}
return 1;
mpeg2_close( m->libmpeg2 );
- free( m->cc608.data608 );
- general_608_close( &m->cc608 );
+ int i;
+ for ( i = 0; i < NTAGS; ++i )
+ {
+ if ( m->tags[i].cc_buf )
+ {
+ if ( m->tags[i].cc_buf == m->last_cc1_buf )
+ m->last_cc1_buf = NULL;
+ hb_buffer_close( &m->tags[i].cc_buf );
+ }
+ }
+ if ( m->last_cc1_buf )
+ {
+ hb_buffer_close( &m->last_cc1_buf );
+ }
free( m );
*_m = NULL;
}
/*
- * If not scanning, then are we supposed to extract Closed Captions?
+ * If not scanning, then are we supposed to extract Closed Captions
+ * and send them to the decoder?
*/
- if( job )
+ if( job && hb_list_count( job->list_subtitle ) > 0 )
{
- hb_subtitle_t * subtitle;
- int i;
+ hb_subtitle_t *subtitle;
+ int i = 0;
for( i = 0; i < hb_list_count( job->list_subtitle ); i++ )
+ while ( ( subtitle = hb_list_item( job->list_subtitle, i++ ) ) != NULL )
{
- subtitle = hb_list_item( job->list_subtitle, i);
- if( subtitle && subtitle->source == CCSUB )
- {
- pv->libmpeg2->subtitle = subtitle;
- pv->libmpeg2->cc608.subtitle = subtitle;
- break;
- }
- }
-
- }
-
- /*
- * During a scan add a Closed Caption subtitle track to the title,
- * since we may have CC. Don't bother actually trying to detect CC
- * since we'd have to go through too much of the source.
- *
- if( !job && w->title )
- {
- hb_subtitle_t * subtitle;
- int found = 0;
- int i;
-
- for( i = 0; i < hb_list_count( w->title->list_subtitle ); i++ )
- {
- subtitle = hb_list_item( w->title->list_subtitle, i);
- if( subtitle && subtitle->source == CCSUB )
+ if( subtitle->source == CC608SUB )
{
- found = 1;
- break;
+ if ( ! pv->libmpeg2->list_subtitle )
+ {
+ pv->libmpeg2->list_subtitle = hb_list_init();
+ }
+ hb_list_add(pv->libmpeg2->list_subtitle, subtitle);
}
}
-
- if( !found )
- {
- subtitle = calloc( sizeof( hb_subtitle_t ), 1 );
- subtitle->track = 0;
- subtitle->id = 0x0;
- snprintf( subtitle->lang, sizeof( subtitle->lang ), "Closed Captions");
- snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "und");
- subtitle->format = TEXTSUB;
- subtitle->source = CCSUB;
- subtitle->dest = PASSTHRUSUB;
- subtitle->type = 5;
-
- hb_list_add( w->title->list_subtitle, subtitle );
- }
}
- */
return 0;
}
pv->libmpeg2->title = w->title;
}
- // The reader found a chapter break, consume it completely, and remove it from the
- // stream. We need to shift it.
+ // The reader found a chapter break. Remove it from the input
+ // stream. If we're reading (as opposed to scanning) start looking
+ // for the next GOP start since that's where the chapter begins.
if( (*buf_in)->new_chap )
{
- pv->libmpeg2->look_for_break = (*buf_in)->new_chap;
+ if ( pv->libmpeg2->job )
+ {
+ pv->libmpeg2->look_for_break = (*buf_in)->new_chap;
+ }
(*buf_in)->new_chap = 0;
}
hb_list_add( pv->list, *buf_in );
*buf_in = NULL;
status = HB_WORK_DONE;
+
+ /*
+ * Purge any pending caption buffer then let the Closed Captions decoder
+ * know that it is the end of the data.
+ */
+ if ( pv->libmpeg2->list_subtitle )
+ {
+ if ( pv->libmpeg2->last_cc1_buf )
+ {
+ cc_send_to_decoder( pv->libmpeg2, pv->libmpeg2->last_cc1_buf );
+ if ( pv->libmpeg2->tags[pv->libmpeg2->cur_tag].cc_buf ==
+ pv->libmpeg2->last_cc1_buf )
+ {
+ pv->libmpeg2->tags[pv->libmpeg2->cur_tag].cc_buf = NULL;
+ }
+ pv->libmpeg2->last_cc1_buf = NULL;
+ }
+ cc_send_to_decoder( pv->libmpeg2, hb_buffer_init( 0 ) );
+ }
}
*buf_out = NULL;
hb_log( "mpeg2 done: %d frames", pv->libmpeg2->nframes );
}
hb_list_close( &pv->list );
+ if ( pv->libmpeg2->list_subtitle )
+ {
+ hb_list_close( &pv->libmpeg2->list_subtitle );
+ }
hb_libmpeg2_close( &pv->libmpeg2 );
free( pv );
}
OSDN Git Service
