diff options
| -rw-r--r-- | libhb/avfilter.c | 87 | ||||
| -rw-r--r-- | libhb/decavcodec.c | 710 | ||||
| -rw-r--r-- | libhb/hb.c | 185 | ||||
| -rw-r--r-- | libhb/hbffmpeg.c | 276 | ||||
| -rw-r--r-- | libhb/hbffmpeg.h | 4 | ||||
| -rw-r--r-- | libhb/internal.h | 1 | ||||
| -rw-r--r-- | libhb/stream.c | 2 |
7 files changed, 740 insertions, 525 deletions
diff --git a/libhb/avfilter.c b/libhb/avfilter.c index c37950815..9729a2c9c 100644 --- a/libhb/avfilter.c +++ b/libhb/avfilter.c @@ -401,62 +401,6 @@ static void fill_frame(hb_filter_private_t * pv, frame->top_field_first = !!(buf->s.flags & PIC_FLAG_TOP_FIELD_FIRST); } -static hb_buffer_t* avframe_to_buffer(hb_filter_private_t * pv, AVFrame *frame) -{ - hb_buffer_t * buf; - - buf = hb_frame_buffer_init(frame->format, frame->width, frame->height); - if (buf == NULL) - { - return NULL; - } - - int pp; - for (pp = 0; pp < 3; pp++) - { - int yy; - int width = buf->plane[pp].width; - int stride = buf->plane[pp].stride; - int height = buf->plane[pp].height; - int linesize = frame->linesize[pp]; - uint8_t * dst = buf->plane[pp].data; - uint8_t * src = frame->data[pp]; - - for (yy = 0; yy < height; yy++) - { - memcpy(dst, src, width); - dst += stride; - src += linesize; - } - } - buf->s.start = av_rescale_q(frame->pts, pv->out_time_base, - (AVRational){1, 90000}); - buf->s.duration = frame->reordered_opaque; - - if (frame->top_field_first) - { - buf->s.flags |= PIC_FLAG_TOP_FIELD_FIRST; - } - if (!frame->interlaced_frame) - { - buf->s.flags |= PIC_FLAG_PROGRESSIVE_FRAME; - } - else - { - buf->s.combed = HB_COMB_HEAVY; - } - if (frame->repeat_pict == 1) - { - buf->s.flags |= PIC_FLAG_REPEAT_FIRST_FIELD; - } - if (frame->repeat_pict == 2) - { - buf->s.flags |= PIC_FLAG_REPEAT_FRAME; - } - - return buf; -} - static hb_buffer_t* filterFrame( hb_filter_private_t * pv, hb_buffer_t * in ) { int result; @@ -473,7 +417,8 @@ static hb_buffer_t* filterFrame( hb_filter_private_t * pv, hb_buffer_t * in ) result = av_buffersink_get_frame(pv->output, pv->frame); while (result >= 0) { - hb_buffer_t * buf = avframe_to_buffer(pv, pv->frame); + hb_buffer_t * buf = hb_avframe_to_video_buffer(pv->frame, + pv->out_time_base); hb_buffer_list_append(&pv->list, buf); av_frame_unref(pv->frame); @@ -795,3 +740,31 @@ void hb_avfilter_combine( hb_list_t * list ) } } +char * hb_append_filter_string(char * graph_str, char * filter_str) +{ + char * tmp; + int size = 1, len = 0; + + if (graph_str != NULL) + { + len = strlen(graph_str); + size += len + 1; + } + if (filter_str != NULL) + { + size += strlen(filter_str); + } + tmp = realloc(graph_str, size); + if (tmp == NULL) + { + return graph_str; + } + graph_str = tmp; + if (len > 0) + { + graph_str[len++] = ','; + } + strcpy(&graph_str[len], filter_str); + return graph_str; +} + diff --git a/libhb/decavcodec.c b/libhb/decavcodec.c index d308a49d5..8e32064a6 100644 --- a/libhb/decavcodec.c +++ b/libhb/decavcodec.c @@ -40,6 +40,9 @@ #include "hb.h" #include "hbffmpeg.h" +#include "libavfilter/avfilter.h" +#include "libavfilter/buffersrc.h" +#include "libavfilter/buffersink.h" #include "lang.h" #include "audio_resample.h" @@ -93,6 +96,18 @@ struct reordered_data_s #define REORDERED_HASH_SZ (2 << 7) #define REORDERED_HASH_MASK (REORDERED_HASH_SZ - 1) +struct video_filters_s +{ + AVFilterGraph * graph; + AVFilterContext * last; + AVFilterContext * input; + AVFilterContext * output; + + int width; + int height; + int pix_fmt; +}; + struct hb_work_private_s { hb_job_t * job; @@ -119,11 +134,7 @@ struct hb_work_private_s int64_t sequence; int last_scr_sequence; int last_chapter; - struct SwsContext * sws_context; // if we have to rescale or convert color space - - int sws_width; - int sws_height; - int sws_pix_fmt; + struct video_filters_s video_filters; hb_audio_t * audio; hb_audio_resample_t * resample; @@ -322,6 +333,25 @@ static int decavcodecaInit( hb_work_object_t * w, hb_job_t * job ) *********************************************************************** * **********************************************************************/ +static void close_video_filters(hb_work_private_t *pv) +{ + if (pv->video_filters.input != NULL) + { + avfilter_free(pv->video_filters.input); + pv->video_filters.input = NULL; + } + if (pv->video_filters.output != NULL) + { + avfilter_free(pv->video_filters.output); + pv->video_filters.output = NULL; + } + if (pv->video_filters.graph != NULL) + { + avfilter_graph_free(&pv->video_filters.graph); + } + pv->video_filters.last = NULL; +} + static void closePrivData( hb_work_private_t ** ppv ) { hb_work_private_t * pv = *ppv; @@ -336,10 +366,7 @@ static void closePrivData( hb_work_private_t ** ppv ) pv->context->codec->name, pv->nframes, pv->decode_errors); } av_frame_free(&pv->frame); - if ( pv->sws_context ) - { - sws_freeContext( pv->sws_context ); - } + close_video_filters(pv); if ( pv->parser ) { av_parser_close(pv->parser); @@ -835,22 +862,64 @@ reordered_hash_add(hb_work_private_t * pv, reordered_data_t * reordered) * General purpose video decoder using libavcodec */ -static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride, - int h ) +// send cc_buf to the CC decoder(s) +static void cc_send_to_decoder(hb_work_private_t *pv, hb_buffer_t *buf) { - if ( dstride == sstride ) + if (buf == NULL) + return; + + // if there's more than one decoder for the captions send a copy + // of the buffer to all. + hb_subtitle_t *subtitle; + int ii = 0, n = hb_list_count(pv->list_subtitle); + while (--n > 0) { - memcpy( dst, src, dstride * h ); - return dst + dstride * h; + // make a copy of the buf then forward it to the decoder + hb_buffer_t *cpy = hb_buffer_dup(buf); + + subtitle = hb_list_item(pv->list_subtitle, ii++); + hb_fifo_push(subtitle->fifo_in, cpy); } - int lbytes = dstride <= sstride? dstride : sstride; - while ( --h >= 0 ) + subtitle = hb_list_item(pv->list_subtitle, ii); + hb_fifo_push( subtitle->fifo_in, buf ); +} + +static hb_buffer_t * cc_fill_buffer(hb_work_private_t *pv, uint8_t *cc, int size) +{ + int cc_count[4] = {0,}; + int ii; + hb_buffer_t *buf = NULL; + + for (ii = 0; ii < size; ii += 3) + { + if ((cc[ii] & 0x04) == 0) // not valid + continue; + if ((cc[ii+1] & 0x7f) == 0 && (cc[ii+2] & 0x7f) == 0) // stuffing + continue; + int type = cc[ii] & 0x03; + cc_count[type]++; + } + + // Only handles CC1 for now. + if (cc_count[0] > 0) { - memcpy( dst, src, lbytes ); - src += sstride; - dst += dstride; + buf = hb_buffer_init(cc_count[0] * 2); + int jj = 0; + for (ii = 0; ii < size; ii += 3) + { + if ((cc[ii] & 0x04) == 0) // not valid + continue; + if ((cc[ii+1] & 0x7f) == 0 && (cc[ii+2] & 0x7f) == 0) // stuffing + continue; + int type = cc[ii] & 0x03; + if (type == 0) + { + buf->data[jj++] = cc[ii+1]; + buf->data[jj++] = cc[ii+2]; + } + } } - return dst; + return buf; } // copy one video frame into an HB buf. If the frame isn't in our color space @@ -858,25 +927,26 @@ static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride // Otherwise just copy the bits. static hb_buffer_t *copy_frame( hb_work_private_t *pv ) { - AVCodecContext *context = pv->context; - int w, h; - if ( ! pv->job ) + reordered_data_t * reordered = NULL; + hb_buffer_t * out; + +#ifdef USE_QSV + // no need to copy the frame data when decoding with QSV to opaque memory + if (pv->qsv.decode && + pv->qsv.config.io_pattern == MFX_IOPATTERN_OUT_OPAQUE_MEMORY) { - // HandBrake's video pipeline uses yuv420 color. This means all - // dimensions must be even. So we must adjust the dimensions - // of incoming video if not even. - w = context->width & ~1; - h = context->height & ~1; + out = hb_frame_buffer_init(pv->frame->format, pv->frame->width, pv->frame->height); + hb_avframe_set_video_buffer_flags(out, pv->frame, (AVRational){1,1}); + + out->qsv_details.qsv_atom = pv->frame->data[2]; + out->qsv_details.ctx = pv->job->qsv.ctx; } else +#endif { - w = pv->job->title->geometry.width; - h = pv->job->title->geometry.height; + out = hb_avframe_to_video_buffer(pv->frame, (AVRational){1,1}); } - reordered_data_t * reordered = NULL; - hb_buffer_t * out = hb_video_buffer_init( w, h ); - if (pv->frame->pts != AV_NOPTS_VALUE) { reordered = reordered_hash_rem(pv, pv->frame->pts); @@ -895,6 +965,27 @@ static hb_buffer_t *copy_frame( hb_work_private_t *pv ) out->s.scr_sequence = pv->last_scr_sequence; out->s.start = AV_NOPTS_VALUE; } + + double frame_dur = pv->duration; + if (pv->frame->repeat_pict) + { + frame_dur += pv->frame->repeat_pict * pv->field_duration; + } + if (out->s.start == AV_NOPTS_VALUE) + { + out->s.start = pv->next_pts; + } + else + { + pv->next_pts = out->s.start; + } + if (pv->next_pts != (int64_t)AV_NOPTS_VALUE) + { + pv->next_pts += frame_dur; + out->s.stop = pv->next_pts; + } + out->s.duration = frame_dur; + if (out->s.new_chap > 0 && out->s.new_chap == pv->new_chap) { pv->new_chap = 0; @@ -910,148 +1001,318 @@ static hb_buffer_t *copy_frame( hb_work_private_t *pv ) pv->new_chap = 0; } + // Check for CC data + AVFrameSideData *sd; + sd = av_frame_get_side_data(pv->frame, AV_FRAME_DATA_A53_CC); + if (sd != NULL) + { + if (!pv->job && pv->title && sd->size > 0) + { + hb_subtitle_t *subtitle; + int i = 0; + + while ((subtitle = hb_list_item(pv->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) + { + break; + } + } + if (subtitle == NULL) + { + iso639_lang_t * lang; + hb_audio_t * audio; + + subtitle = calloc(sizeof( hb_subtitle_t ), 1); + subtitle->track = hb_list_count(pv->title->list_subtitle); + subtitle->id = 0; + subtitle->format = TEXTSUB; + subtitle->source = CC608SUB; + subtitle->config.dest = PASSTHRUSUB; + subtitle->codec = WORK_DECCC608; + subtitle->attributes = HB_SUBTITLE_ATTR_CC; + + /* + * The language of the subtitles will be the same as the + * first audio track, i.e. the same as the video. + */ + audio = hb_list_item(pv->title->list_audio, 0); + if (audio != NULL) + { + lang = lang_for_code2( audio->config.lang.iso639_2 ); + } else { + lang = lang_for_code2( "und" ); + } + snprintf(subtitle->lang, sizeof(subtitle->lang), + "%s, Closed Caption [%s]", + strlen(lang->native_name) ? lang->native_name : + lang->eng_name, + hb_subsource_name(subtitle->source)); + snprintf(subtitle->iso639_2, sizeof(subtitle->iso639_2), + "%s", lang->iso639_2); + + hb_list_add(pv->title->list_subtitle, subtitle); + } + } + if (pv->list_subtitle != NULL && sd->size > 0) + { + hb_buffer_t *cc_buf; + cc_buf = cc_fill_buffer(pv, sd->data, sd->size); + if (cc_buf != NULL) + { + cc_buf->s.start = out->s.start; + cc_buf->s.scr_sequence = out->s.scr_sequence; + } + cc_send_to_decoder(pv, cc_buf); + } + } + + return out; +} + +static AVFilterContext * append_filter(hb_work_private_t * pv, + const char * name, const char * args) +{ + AVFilterContext * filter; + int result; + + result = avfilter_graph_create_filter(&filter, avfilter_get_by_name(name), + name, args, NULL, + pv->video_filters.graph); + if (result < 0) + { + return NULL; + } + if (pv->video_filters.last != NULL) + { + result = avfilter_link(pv->video_filters.last, 0, filter, 0); + if (result < 0) + { + avfilter_free(filter); + return NULL; + } + } + pv->video_filters.last = filter; + + return filter; +} + +int reinit_video_filters(hb_work_private_t * pv) +{ + char * sws_flags; + int result; + AVFilterContext * avfilter; + char * graph_str = NULL, * filter_str; + AVFilterInOut * in = NULL, * out = NULL; + int orig_width; + int orig_height; + #ifdef USE_QSV - // no need to copy the frame data when decoding with QSV to opaque memory if (pv->qsv.decode && pv->qsv.config.io_pattern == MFX_IOPATTERN_OUT_OPAQUE_MEMORY) { - out->qsv_details.qsv_atom = pv->frame->data[2]; - out->qsv_details.ctx = pv->job->qsv.ctx; - return out; + // Can't use software filters when decoding with QSV opaque memory + return; } #endif + if (!pv->job) + { + // HandBrake's video pipeline uses yuv420 color. This means all + // dimensions must be even. So we must adjust the dimensions + // of incoming video if not even. + orig_width = pv->context->width & ~1; + orig_height = pv->context->height & ~1; + } + else + { + if (pv->title->rotation == HB_ROTATION_90 || + pv->title->rotation == HB_ROTATION_270) + { + orig_width = pv->job->title->geometry.height; + orig_height = pv->job->title->geometry.width; + } + else + { + orig_width = pv->job->title->geometry.width; + orig_height = pv->job->title->geometry.height; + } + } - uint8_t *dst = out->data; + if (AV_PIX_FMT_YUV420P == pv->frame->format && + orig_width == pv->frame->width && + orig_height == pv->frame->height && + HB_ROTATION_0 == pv->title->rotation) + { + // No filtering required. + close_video_filters(pv); + return 0; + } - if (context->pix_fmt != AV_PIX_FMT_YUV420P || w != context->width || - h != context->height) + if (pv->video_filters.graph != NULL && + pv->video_filters.width == pv->frame->width && + pv->video_filters.height == pv->frame->height && + pv->video_filters.pix_fmt == pv->frame->format) { - // have to convert to our internal color space and/or rescale - uint8_t * data[4]; - int stride[4]; - hb_picture_fill(data, stride, out); + // Current filter settings are good + return 0; + } - if (pv->sws_context == NULL || - pv->sws_width != context->width || - pv->sws_height != context->height || - pv->sws_pix_fmt != context->pix_fmt) - { - if (pv->sws_context != NULL) - sws_freeContext(pv->sws_context); + pv->video_filters.width = pv->frame->width; + pv->video_filters.height = pv->frame->height; + pv->video_filters.pix_fmt = pv->frame->format; - hb_geometry_t geometry = {context->width, context->height}; - int color_matrix = get_color_matrix(context->colorspace, geometry); + // New filter required, create filter graph + close_video_filters(pv); + pv->video_filters.graph = avfilter_graph_alloc(); + if (pv->video_filters.graph == NULL) + { + hb_log("reinit_video_filters: avfilter_graph_alloc failed"); + goto fail; + } + sws_flags = hb_strdup_printf("flags=%d", SWS_LANCZOS|SWS_ACCURATE_RND); + // avfilter_graph_free uses av_free to release scale_sws_opts. Due + // to the hacky implementation of av_free/av_malloc on windows, + // you must av_malloc anything that is av_free'd. + pv->video_filters.graph->scale_sws_opts = av_malloc(strlen(sws_flags) + 1); + strcpy(pv->video_filters.graph->scale_sws_opts, sws_flags); + free(sws_flags); - pv->sws_context = hb_sws_get_context(context->width, - context->height, - context->pix_fmt, - w, h, AV_PIX_FMT_YUV420P, - SWS_LANCZOS|SWS_ACCURATE_RND, - hb_ff_get_colorspace(color_matrix)); - pv->sws_width = context->width; - pv->sws_height = context->height; - pv->sws_pix_fmt = context->pix_fmt; - } - sws_scale(pv->sws_context, - (const uint8_t* const *)pv->frame->data, - pv->frame->linesize, 0, context->height, data, stride); + int clock_min, clock_max, clock; + hb_rational_t vrate; + + hb_video_framerate_get_limits(&clock_min, &clock_max, &clock); + vrate.num = clock; + vrate.den = pv->duration * (clock / 90000.); + + if (AV_PIX_FMT_YUV420P != pv->frame->format || + orig_width != pv->frame->width || + orig_height != pv->frame->height) + { + + filter_str = hb_strdup_printf( + "scale='w=%d:h=%d:flags=lanczos+accurate_rnd'," + "format='pix_fmts=yuv420p'", + orig_width, orig_height); + graph_str = hb_append_filter_string(graph_str, filter_str); + free(filter_str); } - else + if (pv->title->rotation != HB_ROTATION_0) { - w = out->plane[0].stride; - h = out->plane[0].height; - dst = out->plane[0].data; - copy_plane( dst, pv->frame->data[0], w, pv->frame->linesize[0], h ); - w = out->plane[1].stride; - h = out->plane[1].height; - dst = out->plane[1].data; - copy_plane( dst, pv->frame->data[1], w, pv->frame->linesize[1], h ); - w = out->plane[2].stride; - h = out->plane[2].height; - dst = out->plane[2].data; - copy_plane( dst, pv->frame->data[2], w, pv->frame->linesize[2], h ); + switch (pv->title->rotation) + { + case HB_ROTATION_90: + filter_str = "transpose='dir=cclock'"; + break; + case HB_ROTATION_180: + filter_str = "hflip,vflip"; + break; + case HB_ROTATION_270: + filter_str = "transpose='dir=clock'"; + break; + default: + hb_log("reinit_video_filters: Unknown rotation, failed"); + goto fail; + } + graph_str = hb_append_filter_string(graph_str, filter_str); } - return out; -} - -// send cc_buf to the CC decoder(s) -static void cc_send_to_decoder(hb_work_private_t *pv, hb_buffer_t *buf) -{ - if (buf == NULL) - return; + // Build filter input + filter_str = hb_strdup_printf( + "width=%d:height=%d:pix_fmt=%d:sar=%d/%d:" + "time_base=%d/%d:frame_rate=%d/%d", + pv->frame->width, pv->frame->height, + pv->frame->format, + pv->frame->sample_aspect_ratio.num, + pv->frame->sample_aspect_ratio.den, + 1, 1, vrate.num, vrate.den); - // if there's more than one decoder for the captions send a copy - // of the buffer to all. - hb_subtitle_t *subtitle; - int ii = 0, n = hb_list_count(pv->list_subtitle); - while (--n > 0) + avfilter = append_filter(pv, "buffer", filter_str); + free(filter_str); + if (avfilter == NULL) { - // make a copy of the buf then forward it to the decoder - hb_buffer_t *cpy = hb_buffer_dup(buf); + hb_error("reinit_video_filters: failed to create buffer source filter"); + goto fail; + } + pv->video_filters.input = avfilter; - subtitle = hb_list_item(pv->list_subtitle, ii++); - hb_fifo_push(subtitle->fifo_in, cpy); + // Build the filter graph + result = avfilter_graph_parse2(pv->video_filters.graph, + graph_str, &in, &out); + if (result < 0 || in == NULL || out == NULL) + { + hb_error("reinit_video_filters: avfilter_graph_parse2 failed (%s)", + graph_str); + goto fail; } - subtitle = hb_list_item(pv->list_subtitle, ii); - hb_fifo_push( subtitle->fifo_in, buf ); -} -static hb_buffer_t * cc_fill_buffer(hb_work_private_t *pv, uint8_t *cc, int size) -{ - int cc_count[4] = {0,}; - int ii; - hb_buffer_t *buf = NULL; + // Link input to filter graph + result = avfilter_link(pv->video_filters.last, 0, in->filter_ctx, 0); + if (result < 0) + { + goto fail; + } + pv->video_filters.last = out->filter_ctx; - for (ii = 0; ii < size; ii += 3) + // Build filter output and append to filter graph + avfilter = append_filter(pv, "buffersink", NULL); + if (avfilter == NULL) { - if ((cc[ii] & 0x04) == 0) // not valid - continue; - if ((cc[ii+1] & 0x7f) == 0 && (cc[ii+2] & 0x7f) == 0) // stuffing - continue; - int type = cc[ii] & 0x03; - cc_count[type]++; + hb_error("reinit_video_filters: failed to create buffer output filter"); + goto fail; } + pv->video_filters.output = avfilter; - // Only handles CC1 for now. - if (cc_count[0] > 0) + result = avfilter_graph_config(pv->video_filters.graph, NULL); + if (result < 0) { - buf = hb_buffer_init(cc_count[0] * 2); - int jj = 0; - for (ii = 0; ii < size; ii += 3) - { - if ((cc[ii] & 0x04) == 0) // not valid - continue; - if ((cc[ii+1] & 0x7f) == 0 && (cc[ii+2] & 0x7f) == 0) // stuffing - continue; - int type = cc[ii] & 0x03; - if (type == 0) - { - buf->data[jj++] = cc[ii+1]; - buf->data[jj++] = cc[ii+2]; - } - } + hb_error("reinit_video_filters: failed to configure filter graph"); + goto fail; } - return buf; + + free(graph_str); + avfilter_inout_free(&in); + avfilter_inout_free(&out); + return 0; + +fail: + free(graph_str); + avfilter_inout_free(&in); + avfilter_inout_free(&out); + close_video_filters(pv); + + return 1; } -static int get_frame_type(int type) +static void filter_video(hb_work_private_t *pv) { - switch (type) + reinit_video_filters(pv); + if (pv->video_filters.graph != NULL) { - case AV_PICTURE_TYPE_B: - return HB_FRAME_B; + int result; - case AV_PICTURE_TYPE_S: - case AV_PICTURE_TYPE_P: - case AV_PICTURE_TYPE_SP: - return HB_FRAME_P; + av_buffersrc_add_frame(pv->video_filters.input, pv->frame); + result = av_buffersink_get_frame(pv->video_filters.output, pv->frame); + while (result >= 0) + { + hb_buffer_t * buf = copy_frame(pv); + hb_buffer_list_append(&pv->list, buf); + av_frame_unref(pv->frame); + ++pv->nframes; - case AV_PICTURE_TYPE_BI: - case AV_PICTURE_TYPE_SI: - case AV_PICTURE_TYPE_I: - default: - return HB_FRAME_I; + result = av_buffersink_get_frame(pv->video_filters.output, + pv->frame); + } + } + else + { + hb_buffer_t * buf = copy_frame(pv); + hb_buffer_list_append(&pv->list, buf); + av_frame_unref(pv->frame); + ++pv->nframes; } } @@ -1147,141 +1408,9 @@ static int decodeFrame( hb_work_object_t *w, packet_info_t * packet_info ) } got_picture = 1; - uint16_t flags = 0; - - // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES - // packet had a pts we handed it to av_parser_parse (if the packet had - // no pts we set it to AV_NOPTS_VALUE, but before the parse we can't - // distinguish between the start of a video frame with no pts & an - // intermediate packet of some frame which never has a pts). we hope - // that when parse returns the frame to us the pts we originally - // handed it will be in parser->pts. we put this pts into avp.pts so - // that when avcodec_receive_frame finally gets around to allocating an - // AVFrame to hold the decoded frame, avcodec_default_get_buffer can - // stuff that pts into the it. if all of these relays worked at this - // point frame.pts should hold the frame's pts from the original data - // stream or AV_NOPTS_VALUE if it didn't have one. in the latter case - // we generate the next pts in sequence for it. - // recompute the frame/field duration, because sometimes it changes compute_frame_duration( pv ); - - double frame_dur = pv->duration; - if ( pv->frame->repeat_pict ) - { - frame_dur += pv->frame->repeat_pict * pv->field_duration; - } - hb_buffer_t * out = copy_frame( pv ); - if (out->s.start == AV_NOPTS_VALUE) - { - out->s.start = pv->next_pts; - } - else - { - pv->next_pts = out->s.start; - } - if (pv->next_pts != (int64_t)AV_NOPTS_VALUE) - { - pv->next_pts += frame_dur; - out->s.stop = pv->next_pts; - } - - if ( pv->frame->top_field_first ) - { - flags |= PIC_FLAG_TOP_FIELD_FIRST; - } - if ( !pv->frame->interlaced_frame ) - { - flags |= PIC_FLAG_PROGRESSIVE_FRAME; - } - if ( pv->frame->repeat_pict == 1 ) - { - flags |= PIC_FLAG_REPEAT_FIRST_FIELD; - } - if ( pv->frame->repeat_pict == 2 ) - { - flags |= PIC_FLAG_REPEAT_FRAME; - } - int frametype = get_frame_type(pv->frame->pict_type); - - // Check for CC data - AVFrameSideData *sd; - sd = av_frame_get_side_data(pv->frame, AV_FRAME_DATA_A53_CC); - if (sd != NULL) - { - if (!pv->job && pv->title && sd->size > 0) - { - hb_subtitle_t *subtitle; - int i = 0; - - while ((subtitle = hb_list_item(pv->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) - { - break; - } - } - if (subtitle == NULL) - { - iso639_lang_t * lang; - hb_audio_t * audio; - - subtitle = calloc(sizeof( hb_subtitle_t ), 1); - subtitle->track = hb_list_count(pv->title->list_subtitle); - subtitle->id = 0; - subtitle->format = TEXTSUB; - subtitle->source = CC608SUB; - subtitle->config.dest = PASSTHRUSUB; - subtitle->codec = WORK_DECCC608; - subtitle->attributes = HB_SUBTITLE_ATTR_CC; - - /* - * The language of the subtitles will be the same as the - * first audio track, i.e. the same as the video. - */ - audio = hb_list_item(pv->title->list_audio, 0); - if (audio != NULL) - { - lang = lang_for_code2( audio->config.lang.iso639_2 ); - } else { - lang = lang_for_code2( "und" ); - } - snprintf(subtitle->lang, sizeof(subtitle->lang), - "%s, Closed Caption [%s]", - strlen(lang->native_name) ? lang->native_name : - lang->eng_name, - hb_subsource_name(subtitle->source)); - snprintf(subtitle->iso639_2, sizeof(subtitle->iso639_2), - "%s", lang->iso639_2); - - hb_list_add(pv->title->list_subtitle, subtitle); - } - } - if (pv->list_subtitle != NULL && sd->size > 0) - { - hb_buffer_t *cc_buf; - cc_buf = cc_fill_buffer(pv, sd->data, sd->size); - if (cc_buf != NULL) - { - cc_buf->s.start = out->s.start; - cc_buf->s.scr_sequence = out->s.scr_sequence; - } - cc_send_to_decoder(pv, cc_buf); - } - } - - av_frame_unref(pv->frame); - - out->s.duration = frame_dur; - out->s.flags = flags; - out->s.frametype = frametype; - - hb_buffer_list_append(&pv->list, out); - ++pv->nframes; + filter_video(pv); } while (ret >= 0); if ( global_verbosity_level <= 1 ) @@ -1893,14 +2022,29 @@ static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info ) return 0; info->bitrate = pv->context->bit_rate; - // HandBrake's video pipeline uses yuv420 color. This means all - // dimensions must be even. So we must adjust the dimensions - // of incoming video if not even. - info->geometry.width = pv->context->width & ~1; - info->geometry.height = pv->context->height & ~1; - - info->geometry.par.num = pv->context->sample_aspect_ratio.num; - info->geometry.par.den = pv->context->sample_aspect_ratio.den; + if (w->title->rotation == HB_ROTATION_90 || + w->title->rotation == HB_ROTATION_270) + { + // HandBrake's video pipeline uses yuv420 color. This means all + // dimensions must be even. So we must adjust the dimensions + // of incoming video if not even. + info->geometry.width = pv->context->height & ~1; + info->geometry.height = pv->context->width & ~1; + + info->geometry.par.num = pv->context->sample_aspect_ratio.den; + info->geometry.par.den = pv->context->sample_aspect_ratio.num; + } + else + { + // HandBrake's video pipeline uses yuv420 color. This means all + // dimensions must be even. So we must adjust the dimensions + // of incoming video if not even. + info->geometry.width = pv->context->width & ~1; + info->geometry.height = pv->context->height & ~1; + + info->geometry.par.num = pv->context->sample_aspect_ratio.num; + info->geometry.par.den = pv->context->sample_aspect_ratio.den; + } compute_frame_duration( pv ); info->rate.num = clock; diff --git a/libhb/hb.c b/libhb/hb.c index 77cf6b2bf..f35090e38 100644 --- a/libhb/hb.c +++ b/libhb/hb.c @@ -191,191 +191,6 @@ int hb_picture_crop(uint8_t *data[], int stride[], hb_buffer_t *buf, return 0; } -static int handle_jpeg(enum AVPixelFormat *format) -{ - switch (*format) - { - case AV_PIX_FMT_YUVJ420P: *format = AV_PIX_FMT_YUV420P; return 1; - case AV_PIX_FMT_YUVJ422P: *format = AV_PIX_FMT_YUV422P; return 1; - case AV_PIX_FMT_YUVJ444P: *format = AV_PIX_FMT_YUV444P; return 1; - case AV_PIX_FMT_YUVJ440P: *format = AV_PIX_FMT_YUV440P; return 1; - default: return 0; - } -} - -int hb_ff_get_colorspace(int color_matrix) -{ - int color_space = SWS_CS_DEFAULT; - - switch (color_matrix) - { - case HB_COLR_MAT_SMPTE170M: - color_space = SWS_CS_ITU601; - break; - case HB_COLR_MAT_SMPTE240M: - color_space = SWS_CS_SMPTE240M; - break; - case HB_COLR_MAT_BT709: - color_space = SWS_CS_ITU709; - break; - /* enable this when implemented in Libav - case HB_COLR_MAT_BT2020: - color_space = SWS_CS_BT2020; - break; - */ - default: - break; - } - - return color_space; -} - -struct SwsContext* -hb_sws_get_context(int srcW, int srcH, enum AVPixelFormat srcFormat, - int dstW, int dstH, enum AVPixelFormat dstFormat, - int flags, int colorspace) -{ - struct SwsContext * ctx; - - ctx = sws_alloc_context(); - if ( ctx ) - { - int srcRange, dstRange; - - srcRange = handle_jpeg(&srcFormat); - dstRange = handle_jpeg(&dstFormat); - flags |= SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP; - - av_opt_set_int(ctx, "srcw", srcW, 0); - av_opt_set_int(ctx, "srch", srcH, 0); - av_opt_set_int(ctx, "src_range", srcRange, 0); - av_opt_set_int(ctx, "src_format", srcFormat, 0); - av_opt_set_int(ctx, "dstw", dstW, 0); - av_opt_set_int(ctx, "dsth", dstH, 0); - av_opt_set_int(ctx, "dst_range", dstRange, 0); - av_opt_set_int(ctx, "dst_format", dstFormat, 0); - av_opt_set_int(ctx, "sws_flags", flags, 0); - - sws_setColorspaceDetails( ctx, - sws_getCoefficients( colorspace ), // src colorspace - srcRange, // src range 0 = MPG, 1 = JPG - sws_getCoefficients( colorspace ), // dst colorspace - dstRange, // dst range 0 = MPG, 1 = JPG - 0, // brightness - 1 << 16, // contrast - 1 << 16 ); // saturation - - if (sws_init_context(ctx, NULL, NULL) < 0) { - hb_error("Cannot initialize resampling context"); - sws_freeContext(ctx); - ctx = NULL; - } - } - return ctx; -} - -uint64_t hb_ff_mixdown_xlat(int hb_mixdown, int *downmix_mode) -{ - uint64_t ff_layout = 0; - int mode = AV_MATRIX_ENCODING_NONE; - switch (hb_mixdown) - { - // Passthru - case HB_AMIXDOWN_NONE: - break; - - case HB_AMIXDOWN_MONO: - case HB_AMIXDOWN_LEFT: - case HB_AMIXDOWN_RIGHT: - ff_layout = AV_CH_LAYOUT_MONO; - break; - - case HB_AMIXDOWN_DOLBY: - ff_layout = AV_CH_LAYOUT_STEREO; - mode = AV_MATRIX_ENCODING_DOLBY; - break; - - case HB_AMIXDOWN_DOLBYPLII: - ff_layout = AV_CH_LAYOUT_STEREO; - mode = AV_MATRIX_ENCODING_DPLII; - break; - - case HB_AMIXDOWN_STEREO: - ff_layout = AV_CH_LAYOUT_STEREO; - break; - - case HB_AMIXDOWN_5POINT1: - ff_layout = AV_CH_LAYOUT_5POINT1; - break; - - case HB_AMIXDOWN_6POINT1: - ff_layout = AV_CH_LAYOUT_6POINT1; - break; - - case HB_AMIXDOWN_7POINT1: - ff_layout = AV_CH_LAYOUT_7POINT1; - break; - - case HB_AMIXDOWN_5_2_LFE: - ff_layout = (AV_CH_LAYOUT_5POINT1_BACK| - AV_CH_FRONT_LEFT_OF_CENTER| - AV_CH_FRONT_RIGHT_OF_CENTER); - break; - - default: - ff_layout = AV_CH_LAYOUT_STEREO; - hb_log("hb_ff_mixdown_xlat: unsupported mixdown %d", hb_mixdown); - break; - } - if (downmix_mode != NULL) - *downmix_mode = mode; - return ff_layout; -} - -/* - * Set sample format to the request format if supported by the codec. - * The planar/packed variant of the requested format is the next best thing. - */ -void hb_ff_set_sample_fmt(AVCodecContext *context, AVCodec *codec, - enum AVSampleFormat request_sample_fmt) -{ - if (context != NULL && codec != NULL && - codec->type == AVMEDIA_TYPE_AUDIO && codec->sample_fmts != NULL) - { - const enum AVSampleFormat *fmt; - enum AVSampleFormat next_best_fmt; - - next_best_fmt = (av_sample_fmt_is_planar(request_sample_fmt) ? - av_get_packed_sample_fmt(request_sample_fmt) : - av_get_planar_sample_fmt(request_sample_fmt)); - - context->request_sample_fmt = AV_SAMPLE_FMT_NONE; - - for (fmt = codec->sample_fmts; *fmt != AV_SAMPLE_FMT_NONE; fmt++) - { - if (*fmt == request_sample_fmt) - { - context->request_sample_fmt = request_sample_fmt; - break; - } - else if (*fmt == next_best_fmt) - { - context->request_sample_fmt = next_best_fmt; - } - } - - /* - * When encoding and AVCodec.sample_fmts exists, avcodec_open2() - * will error out if AVCodecContext.sample_fmt isn't set. - */ - if (context->request_sample_fmt == AV_SAMPLE_FMT_NONE) - { - context->request_sample_fmt = codec->sample_fmts[0]; - } - context->sample_fmt = context->request_sample_fmt; - } -} - /** * Registers work objects, by adding the work object to a liked list. * @param w Handle to hb_work_object_t to register. diff --git a/libhb/hbffmpeg.c b/libhb/hbffmpeg.c new file mode 100644 index 000000000..0b3403ed7 --- /dev/null +++ b/libhb/hbffmpeg.c @@ -0,0 +1,276 @@ +#include "hb.h" +#include "hbffmpeg.h" + +static int get_frame_type(int type) +{ + switch (type) + { + case AV_PICTURE_TYPE_B: + return HB_FRAME_B; + + case AV_PICTURE_TYPE_S: + case AV_PICTURE_TYPE_P: + case AV_PICTURE_TYPE_SP: + return HB_FRAME_P; + + case AV_PICTURE_TYPE_BI: + case AV_PICTURE_TYPE_SI: + case AV_PICTURE_TYPE_I: + default: + return HB_FRAME_I; + } +} + +void hb_avframe_set_video_buffer_flags(hb_buffer_t * buf, AVFrame *frame, + AVRational time_base) +{ + if (buf == NULL || frame == NULL) + { + return; + } + + buf->s.start = av_rescale_q(frame->pts, time_base, (AVRational){1, 90000}); + buf->s.duration = frame->reordered_opaque; + + if (frame->top_field_first) + { + buf->s.flags |= PIC_FLAG_TOP_FIELD_FIRST; + } + if (!frame->interlaced_frame) + { + buf->s.flags |= PIC_FLAG_PROGRESSIVE_FRAME; + } + else + { + buf->s.combed = HB_COMB_HEAVY; + } + if (frame->repeat_pict == 1) + { + buf->s.flags |= PIC_FLAG_REPEAT_FIRST_FIELD; + } + if (frame->repeat_pict == 2) + { + buf->s.flags |= PIC_FLAG_REPEAT_FRAME; + } + buf->s.frametype = get_frame_type(frame->pict_type); +} + +hb_buffer_t * hb_avframe_to_video_buffer(AVFrame *frame, AVRational time_base) +{ + hb_buffer_t * buf; + + buf = hb_frame_buffer_init(frame->format, frame->width, frame->height); + if (buf == NULL) + { + return NULL; + } + + hb_avframe_set_video_buffer_flags(buf, frame, time_base); + + int pp; + for (pp = 0; pp < 3; pp++) + { + int yy; + int width = buf->plane[pp].width; + int stride = buf->plane[pp].stride; + int height = buf->plane[pp].height; + int linesize = frame->linesize[pp]; + uint8_t * dst = buf->plane[pp].data; + uint8_t * src = frame->data[pp]; + + for (yy = 0; yy < height; yy++) + { + memcpy(dst, src, width); + dst += stride; + src += linesize; + } + } + + return buf; +} + +static int handle_jpeg(enum AVPixelFormat *format) +{ + switch (*format) + { + case AV_PIX_FMT_YUVJ420P: *format = AV_PIX_FMT_YUV420P; return 1; + case AV_PIX_FMT_YUVJ422P: *format = AV_PIX_FMT_YUV422P; return 1; + case AV_PIX_FMT_YUVJ444P: *format = AV_PIX_FMT_YUV444P; return 1; + case AV_PIX_FMT_YUVJ440P: *format = AV_PIX_FMT_YUV440P; return 1; + default: return 0; + } +} + +struct SwsContext* +hb_sws_get_context(int srcW, int srcH, enum AVPixelFormat srcFormat, + int dstW, int dstH, enum AVPixelFormat dstFormat, + int flags, int colorspace) +{ + struct SwsContext * ctx; + + ctx = sws_alloc_context(); + if ( ctx ) + { + int srcRange, dstRange; + + srcRange = handle_jpeg(&srcFormat); + dstRange = handle_jpeg(&dstFormat); + flags |= SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP; + + av_opt_set_int(ctx, "srcw", srcW, 0); + av_opt_set_int(ctx, "srch", srcH, 0); + av_opt_set_int(ctx, "src_range", srcRange, 0); + av_opt_set_int(ctx, "src_format", srcFormat, 0); + av_opt_set_int(ctx, "dstw", dstW, 0); + av_opt_set_int(ctx, "dsth", dstH, 0); + av_opt_set_int(ctx, "dst_range", dstRange, 0); + av_opt_set_int(ctx, "dst_format", dstFormat, 0); + av_opt_set_int(ctx, "sws_flags", flags, 0); + + sws_setColorspaceDetails( ctx, + sws_getCoefficients( colorspace ), // src colorspace + srcRange, // src range 0 = MPG, 1 = JPG + sws_getCoefficients( colorspace ), // dst colorspace + dstRange, // dst range 0 = MPG, 1 = JPG + 0, // brightness + 1 << 16, // contrast + 1 << 16 ); // saturation + + if (sws_init_context(ctx, NULL, NULL) < 0) { + hb_error("Cannot initialize resampling context"); + sws_freeContext(ctx); + ctx = NULL; + } + } + return ctx; +} + +int hb_ff_get_colorspace(int color_matrix) +{ + int color_space = SWS_CS_DEFAULT; + + switch (color_matrix) + { + case HB_COLR_MAT_SMPTE170M: + color_space = SWS_CS_ITU601; + break; + case HB_COLR_MAT_SMPTE240M: + color_space = SWS_CS_SMPTE240M; + break; + case HB_COLR_MAT_BT709: + color_space = SWS_CS_ITU709; + break; + /* enable this when implemented in Libav + case HB_COLR_MAT_BT2020: + color_space = SWS_CS_BT2020; + break; + */ + default: + break; + } + + return color_space; +} + +uint64_t hb_ff_mixdown_xlat(int hb_mixdown, int *downmix_mode) +{ + uint64_t ff_layout = 0; + int mode = AV_MATRIX_ENCODING_NONE; + switch (hb_mixdown) + { + // Passthru + case HB_AMIXDOWN_NONE: + break; + + case HB_AMIXDOWN_MONO: + case HB_AMIXDOWN_LEFT: + case HB_AMIXDOWN_RIGHT: + ff_layout = AV_CH_LAYOUT_MONO; + break; + + case HB_AMIXDOWN_DOLBY: + ff_layout = AV_CH_LAYOUT_STEREO; + mode = AV_MATRIX_ENCODING_DOLBY; + break; + + case HB_AMIXDOWN_DOLBYPLII: + ff_layout = AV_CH_LAYOUT_STEREO; + mode = AV_MATRIX_ENCODING_DPLII; + break; + + case HB_AMIXDOWN_STEREO: + ff_layout = AV_CH_LAYOUT_STEREO; + break; + + case HB_AMIXDOWN_5POINT1: + ff_layout = AV_CH_LAYOUT_5POINT1; + break; + + case HB_AMIXDOWN_6POINT1: + ff_layout = AV_CH_LAYOUT_6POINT1; + break; + + case HB_AMIXDOWN_7POINT1: + ff_layout = AV_CH_LAYOUT_7POINT1; + break; + + case HB_AMIXDOWN_5_2_LFE: + ff_layout = (AV_CH_LAYOUT_5POINT1_BACK| + AV_CH_FRONT_LEFT_OF_CENTER| + AV_CH_FRONT_RIGHT_OF_CENTER); + break; + + default: + ff_layout = AV_CH_LAYOUT_STEREO; + hb_log("hb_ff_mixdown_xlat: unsupported mixdown %d", hb_mixdown); + break; + } + if (downmix_mode != NULL) + *downmix_mode = mode; + return ff_layout; +} + +/* + * Set sample format to the request format if supported by the codec. + * The planar/packed variant of the requested format is the next best thing. + */ +void hb_ff_set_sample_fmt(AVCodecContext *context, AVCodec *codec, + enum AVSampleFormat request_sample_fmt) +{ + if (context != NULL && codec != NULL && + codec->type == AVMEDIA_TYPE_AUDIO && codec->sample_fmts != NULL) + { + const enum AVSampleFormat *fmt; + enum AVSampleFormat next_best_fmt; + + next_best_fmt = (av_sample_fmt_is_planar(request_sample_fmt) ? + av_get_packed_sample_fmt(request_sample_fmt) : + av_get_planar_sample_fmt(request_sample_fmt)); + + context->request_sample_fmt = AV_SAMPLE_FMT_NONE; + + for (fmt = codec->sample_fmts; *fmt != AV_SAMPLE_FMT_NONE; fmt++) + { + if (*fmt == request_sample_fmt) + { + context->request_sample_fmt = request_sample_fmt; + break; + } + else if (*fmt == next_best_fmt) + { + context->request_sample_fmt = next_best_fmt; + } + } + + /* + * When encoding and AVCodec.sample_fmts exists, avcodec_open2() + * will error out if AVCodecContext.sample_fmt isn't set. + */ + if (context->request_sample_fmt == AV_SAMPLE_FMT_NONE) + { + context->request_sample_fmt = codec->sample_fmts[0]; + } + context->sample_fmt = context->request_sample_fmt; + } +} + diff --git a/libhb/hbffmpeg.h b/libhb/hbffmpeg.h index 82930ad96..76ffbe830 100644 --- a/libhb/hbffmpeg.h +++ b/libhb/hbffmpeg.h @@ -36,3 +36,7 @@ struct SwsContext* hb_sws_get_context(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, int colorspace); + +hb_buffer_t * hb_avframe_to_video_buffer(AVFrame *frame, AVRational time_base); +void hb_avframe_set_video_buffer_flags(hb_buffer_t * buf, AVFrame *frame, + AVRational time_base); diff --git a/libhb/internal.h b/libhb/internal.h index 80b5b4de2..a1de388cf 100644 --- a/libhb/internal.h +++ b/libhb/internal.h @@ -500,6 +500,7 @@ void hb_muxmp4_process_subtitle_style(int height, void hb_deinterlace(hb_buffer_t *dst, hb_buffer_t *src); void hb_avfilter_combine( hb_list_t * list ); +char * hb_append_filter_string(char * graph_str, char * filter_str); struct hb_chapter_queue_item_s { diff --git a/libhb/stream.c b/libhb/stream.c index ba1d41761..d4d03ab12 100644 --- a/libhb/stream.c +++ b/libhb/stream.c @@ -5553,6 +5553,8 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream, hb_title_t *title ) { int rotation = av_display_rotation_get((int32_t *)sd.data); switch (rotation) { + case 0: + title->rotation = HB_ROTATION_0; case 90: title->rotation = HB_ROTATION_90; break; |