mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-11-21 10:55:51 +02:00
H264/MPEG frame-level multi-threading.
Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
This commit is contained in:
Alexander Strange
Ronald S. Bultje
parent
53be7b23e9
commit
6a9c859444
@ -32,6 +32,7 @@
|
||||
#include "mpegvideo.h"
|
||||
#include "h264.h"
|
||||
#include "rectangle.h"
|
||||
#include "thread.h"
|
||||
|
||||
/*
|
||||
* H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264)
|
||||
@ -428,8 +429,7 @@ int score_sum=0;
|
||||
int best_score=256*256*256*64;
|
||||
int best_pred=0;
|
||||
const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
|
||||
int prev_x= s->current_picture.motion_val[0][mot_index][0];
|
||||
int prev_y= s->current_picture.motion_val[0][mot_index][1];
|
||||
int prev_x, prev_y, prev_ref;
|
||||
|
||||
if((mb_x^mb_y^pass)&1) continue;
|
||||
|
||||
@ -527,11 +527,26 @@ skip_mean_and_median:
|
||||
/* zero MV */
|
||||
pred_count++;
|
||||
|
||||
if (!fixed[mb_xy]) {
|
||||
if (s->avctx->codec_id == CODEC_ID_H264) {
|
||||
// FIXME
|
||||
} else {
|
||||
ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
|
||||
mb_y, 0);
|
||||
}
|
||||
prev_x = s->last_picture.motion_val[0][mot_index][0];
|
||||
prev_y = s->last_picture.motion_val[0][mot_index][1];
|
||||
prev_ref = s->last_picture.ref_index[0][4*mb_xy];
|
||||
} else {
|
||||
prev_x = s->current_picture.motion_val[0][mot_index][0];
|
||||
prev_y = s->current_picture.motion_val[0][mot_index][1];
|
||||
prev_ref = s->current_picture.ref_index[0][4*mb_xy];
|
||||
}
|
||||
|
||||
/* last MV */
|
||||
mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index][0];
|
||||
mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index][1];
|
||||
ref [pred_count] = s->current_picture.ref_index[0][4*mb_xy];
|
||||
pred_count++;
|
||||
mv_predictor[pred_count][0]= prev_x;
|
||||
mv_predictor[pred_count][1]= prev_y;
|
||||
ref [pred_count] = prev_ref;
|
||||
|
||||
s->mv_dir = MV_DIR_FORWARD;
|
||||
s->mb_intra=0;
|
||||
@ -662,6 +677,12 @@ static int is_intra_more_likely(MpegEncContext *s){
|
||||
uint8_t *mb_ptr = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
|
||||
uint8_t *last_mb_ptr= s->last_picture.data [0] + mb_x*16 + mb_y*16*s->linesize;
|
||||
|
||||
if (s->avctx->codec_id == CODEC_ID_H264) {
|
||||
// FIXME
|
||||
} else {
|
||||
ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
|
||||
mb_y, 0);
|
||||
}
|
||||
is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr , s->linesize, 16);
|
||||
is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);
|
||||
}else{
|
||||
@ -681,6 +702,7 @@ void ff_er_frame_start(MpegEncContext *s){
|
||||
|
||||
memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_stride*s->mb_height*sizeof(uint8_t));
|
||||
s->error_count= 3*s->mb_num;
|
||||
s->error_occurred = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -720,7 +742,10 @@ void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int en
|
||||
s->error_count -= end_i - start_i + 1;
|
||||
}
|
||||
|
||||
if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) s->error_count= INT_MAX;
|
||||
if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) {
|
||||
s->error_occurred = 1;
|
||||
s->error_count= INT_MAX;
|
||||
}
|
||||
|
||||
if(mask == ~0x7F){
|
||||
memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));
|
||||
@ -995,6 +1020,12 @@ void ff_er_frame_end(MpegEncContext *s){
|
||||
int time_pp= s->pp_time;
|
||||
int time_pb= s->pb_time;
|
||||
|
||||
if (s->avctx->codec_id == CODEC_ID_H264) {
|
||||
//FIXME
|
||||
} else {
|
||||
ff_thread_await_progress((AVFrame *) s->next_picture_ptr,
|
||||
mb_y, 0);
|
||||
}
|
||||
s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp;
|
||||
s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp;
|
||||
s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
|
||||
|
||||
@ -35,6 +35,7 @@
|
||||
#include "mpeg4video_parser.h"
|
||||
#include "msmpeg4.h"
|
||||
#include "vdpau_internal.h"
|
||||
#include "thread.h"
|
||||
#include "flv.h"
|
||||
#include "mpeg4video.h"
|
||||
|
||||
@ -229,6 +230,7 @@ static int decode_slice(MpegEncContext *s){
|
||||
if(++s->mb_x >= s->mb_width){
|
||||
s->mb_x=0;
|
||||
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
|
||||
MPV_report_decode_progress(s);
|
||||
s->mb_y++;
|
||||
}
|
||||
return 0;
|
||||
@ -249,6 +251,7 @@ static int decode_slice(MpegEncContext *s){
|
||||
}
|
||||
|
||||
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
|
||||
MPV_report_decode_progress(s);
|
||||
|
||||
s->mb_x= 0;
|
||||
}
|
||||
@ -609,6 +612,8 @@ retry:
|
||||
if(MPV_frame_start(s, avctx) < 0)
|
||||
return -1;
|
||||
|
||||
if (!s->divx_packed) ff_thread_finish_setup(avctx);
|
||||
|
||||
if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) {
|
||||
ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer);
|
||||
goto frame_end;
|
||||
@ -639,8 +644,11 @@ retry:
|
||||
if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
|
||||
break;
|
||||
}else{
|
||||
int prev_x=s->mb_x, prev_y=s->mb_y;
|
||||
if(ff_h263_resync(s)<0)
|
||||
break;
|
||||
if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
|
||||
s->error_occurred = 1;
|
||||
}
|
||||
|
||||
if(s->msmpeg4_version<4 && s->h263_pred)
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
#include "golomb.h"
|
||||
#include "mathops.h"
|
||||
#include "rectangle.h"
|
||||
#include "thread.h"
|
||||
#include "vdpau_internal.h"
|
||||
#include "libavutil/avassert.h"
|
||||
|
||||
@ -245,6 +246,141 @@ static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,
|
||||
int y_offset, int list){
|
||||
int raw_my= h->mv_cache[list][ scan8[n] ][1];
|
||||
int filter_height= (raw_my&3) ? 2 : 0;
|
||||
int full_my= (raw_my>>2) + y_offset;
|
||||
int top = full_my - filter_height, bottom = full_my + height + filter_height;
|
||||
|
||||
return FFMAX(abs(top), bottom);
|
||||
}
|
||||
|
||||
static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,
|
||||
int y_offset, int list0, int list1, int *nrefs){
|
||||
MpegEncContext * const s = &h->s;
|
||||
int my;
|
||||
|
||||
y_offset += 16*(s->mb_y >> MB_FIELD);
|
||||
|
||||
if(list0){
|
||||
int ref_n = h->ref_cache[0][ scan8[n] ];
|
||||
Picture *ref= &h->ref_list[0][ref_n];
|
||||
|
||||
// Error resilience puts the current picture in the ref list.
|
||||
// Don't try to wait on these as it will cause a deadlock.
|
||||
// Fields can wait on each other, though.
|
||||
if(ref->thread_opaque != s->current_picture.thread_opaque ||
|
||||
(ref->reference&3) != s->picture_structure) {
|
||||
my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);
|
||||
if (refs[0][ref_n] < 0) nrefs[0] += 1;
|
||||
refs[0][ref_n] = FFMAX(refs[0][ref_n], my);
|
||||
}
|
||||
}
|
||||
|
||||
if(list1){
|
||||
int ref_n = h->ref_cache[1][ scan8[n] ];
|
||||
Picture *ref= &h->ref_list[1][ref_n];
|
||||
|
||||
if(ref->thread_opaque != s->current_picture.thread_opaque ||
|
||||
(ref->reference&3) != s->picture_structure) {
|
||||
my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);
|
||||
if (refs[1][ref_n] < 0) nrefs[1] += 1;
|
||||
refs[1][ref_n] = FFMAX(refs[1][ref_n], my);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait until all reference frames are available for MC operations.
|
||||
*
|
||||
* @param h the H264 context
|
||||
*/
|
||||
static void await_references(H264Context *h){
|
||||
MpegEncContext * const s = &h->s;
|
||||
const int mb_xy= h->mb_xy;
|
||||
const int mb_type= s->current_picture.mb_type[mb_xy];
|
||||
int refs[2][48];
|
||||
int nrefs[2] = {0};
|
||||
int ref, list;
|
||||
|
||||
memset(refs, -1, sizeof(refs));
|
||||
|
||||
if(IS_16X16(mb_type)){
|
||||
get_lowest_part_y(h, refs, 0, 16, 0,
|
||||
IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
|
||||
}else if(IS_16X8(mb_type)){
|
||||
get_lowest_part_y(h, refs, 0, 8, 0,
|
||||
IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
|
||||
get_lowest_part_y(h, refs, 8, 8, 8,
|
||||
IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
|
||||
}else if(IS_8X16(mb_type)){
|
||||
get_lowest_part_y(h, refs, 0, 16, 0,
|
||||
IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
|
||||
get_lowest_part_y(h, refs, 4, 16, 0,
|
||||
IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
|
||||
}else{
|
||||
int i;
|
||||
|
||||
assert(IS_8X8(mb_type));
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int sub_mb_type= h->sub_mb_type[i];
|
||||
const int n= 4*i;
|
||||
int y_offset= (i&2)<<2;
|
||||
|
||||
if(IS_SUB_8X8(sub_mb_type)){
|
||||
get_lowest_part_y(h, refs, n , 8, y_offset,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
}else if(IS_SUB_8X4(sub_mb_type)){
|
||||
get_lowest_part_y(h, refs, n , 4, y_offset,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
get_lowest_part_y(h, refs, n+2, 4, y_offset+4,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
}else if(IS_SUB_4X8(sub_mb_type)){
|
||||
get_lowest_part_y(h, refs, n , 8, y_offset,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
get_lowest_part_y(h, refs, n+1, 8, y_offset,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
}else{
|
||||
int j;
|
||||
assert(IS_SUB_4X4(sub_mb_type));
|
||||
for(j=0; j<4; j++){
|
||||
int sub_y_offset= y_offset + 2*(j&2);
|
||||
get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,
|
||||
IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(list=h->list_count-1; list>=0; list--){
|
||||
for(ref=0; ref<48 && nrefs[list]; ref++){
|
||||
int row = refs[list][ref];
|
||||
if(row >= 0){
|
||||
Picture *ref_pic = &h->ref_list[list][ref];
|
||||
int ref_field = ref_pic->reference - 1;
|
||||
int ref_field_picture = ref_pic->field_picture;
|
||||
int pic_height = 16*s->mb_height >> ref_field_picture;
|
||||
|
||||
row <<= MB_MBAFF;
|
||||
nrefs[list]--;
|
||||
|
||||
if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields
|
||||
ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);
|
||||
ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) , pic_height-1), 0);
|
||||
}else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame
|
||||
ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field , pic_height-1), 0);
|
||||
}else if(FIELD_PICTURE){
|
||||
ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);
|
||||
}else{
|
||||
ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/**
|
||||
* DCT transforms the 16 dc values.
|
||||
@ -518,6 +654,8 @@ static av_always_inline void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t
|
||||
|
||||
assert(IS_INTER(mb_type));
|
||||
|
||||
if(HAVE_PTHREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
|
||||
await_references(h);
|
||||
prefetch_motion(h, 0, pixel_shift);
|
||||
|
||||
if(IS_16X16(mb_type)){
|
||||
@ -626,6 +764,7 @@ hl_motion_fn(1, 16);
|
||||
static void free_tables(H264Context *h, int free_rbsp){
|
||||
int i;
|
||||
H264Context *hx;
|
||||
|
||||
av_freep(&h->intra4x4_pred_mode);
|
||||
av_freep(&h->chroma_pred_mode_table);
|
||||
av_freep(&h->cbp_table);
|
||||
@ -898,7 +1037,7 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx){
|
||||
h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;
|
||||
|
||||
h->thread_context[0] = h;
|
||||
h->outputed_poc = INT_MIN;
|
||||
h->outputed_poc = h->next_outputed_poc = INT_MIN;
|
||||
h->prev_poc_msb= 1<<16;
|
||||
h->x264_build = -1;
|
||||
ff_h264_reset_sei(h);
|
||||
@ -921,10 +1060,135 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx){
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))
|
||||
static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0; i<count; i++){
|
||||
assert((IN_RANGE(from[i], old_base, sizeof(*old_base)) ||
|
||||
IN_RANGE(from[i], old_base->picture, sizeof(Picture) * old_base->picture_count) ||
|
||||
!from[i]));
|
||||
to[i] = REBASE_PICTURE(from[i], new_base, old_base);
|
||||
}
|
||||
}
|
||||
|
||||
static void copy_parameter_set(void **to, void **from, int count, int size)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0; i<count; i++){
|
||||
if (to[i] && !from[i]) av_freep(&to[i]);
|
||||
else if (from[i] && !to[i]) to[i] = av_malloc(size);
|
||||
|
||||
if (from[i]) memcpy(to[i], from[i], size);
|
||||
}
|
||||
}
|
||||
|
||||
static int decode_init_thread_copy(AVCodecContext *avctx){
|
||||
H264Context *h= avctx->priv_data;
|
||||
|
||||
if (!avctx->is_copy) return 0;
|
||||
memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
|
||||
memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
|
||||
static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){
|
||||
H264Context *h= dst->priv_data, *h1= src->priv_data;
|
||||
MpegEncContext * const s = &h->s, * const s1 = &h1->s;
|
||||
int inited = s->context_initialized, err;
|
||||
int i;
|
||||
|
||||
if(dst == src || !s1->context_initialized) return 0;
|
||||
|
||||
err = ff_mpeg_update_thread_context(dst, src);
|
||||
if(err) return err;
|
||||
|
||||
//FIXME handle width/height changing
|
||||
if(!inited){
|
||||
for(i = 0; i < MAX_SPS_COUNT; i++)
|
||||
av_freep(h->sps_buffers + i);
|
||||
|
||||
for(i = 0; i < MAX_PPS_COUNT; i++)
|
||||
av_freep(h->pps_buffers + i);
|
||||
|
||||
memcpy(&h->s + 1, &h1->s + 1, sizeof(H264Context) - sizeof(MpegEncContext)); //copy all fields after MpegEnc
|
||||
memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
|
||||
memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
|
||||
ff_h264_alloc_tables(h);
|
||||
context_init(h);
|
||||
|
||||
for(i=0; i<2; i++){
|
||||
h->rbsp_buffer[i] = NULL;
|
||||
h->rbsp_buffer_size[i] = 0;
|
||||
}
|
||||
|
||||
h->thread_context[0] = h;
|
||||
|
||||
// frame_start may not be called for the next thread (if it's decoding a bottom field)
|
||||
// so this has to be allocated here
|
||||
h->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
|
||||
|
||||
s->dsp.clear_blocks(h->mb);
|
||||
}
|
||||
|
||||
//extradata/NAL handling
|
||||
h->is_avc = h1->is_avc;
|
||||
|
||||
//SPS/PPS
|
||||
copy_parameter_set((void**)h->sps_buffers, (void**)h1->sps_buffers, MAX_SPS_COUNT, sizeof(SPS));
|
||||
h->sps = h1->sps;
|
||||
copy_parameter_set((void**)h->pps_buffers, (void**)h1->pps_buffers, MAX_PPS_COUNT, sizeof(PPS));
|
||||
h->pps = h1->pps;
|
||||
|
||||
//Dequantization matrices
|
||||
//FIXME these are big - can they be only copied when PPS changes?
|
||||
copy_fields(h, h1, dequant4_buffer, dequant4_coeff);
|
||||
|
||||
for(i=0; i<6; i++)
|
||||
h->dequant4_coeff[i] = h->dequant4_buffer[0] + (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);
|
||||
|
||||
for(i=0; i<2; i++)
|
||||
h->dequant8_coeff[i] = h->dequant8_buffer[0] + (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);
|
||||
|
||||
h->dequant_coeff_pps = h1->dequant_coeff_pps;
|
||||
|
||||
//POC timing
|
||||
copy_fields(h, h1, poc_lsb, redundant_pic_count);
|
||||
|
||||
//reference lists
|
||||
copy_fields(h, h1, ref_count, list_count);
|
||||
copy_fields(h, h1, ref_list, intra_gb);
|
||||
copy_fields(h, h1, short_ref, cabac_init_idc);
|
||||
|
||||
copy_picture_range(h->short_ref, h1->short_ref, 32, s, s1);
|
||||
copy_picture_range(h->long_ref, h1->long_ref, 32, s, s1);
|
||||
copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);
|
||||
|
||||
h->last_slice_type = h1->last_slice_type;
|
||||
|
||||
if(!s->current_picture_ptr) return 0;
|
||||
|
||||
if(!s->dropable) {
|
||||
ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
|
||||
h->prev_poc_msb = h->poc_msb;
|
||||
h->prev_poc_lsb = h->poc_lsb;
|
||||
}
|
||||
h->prev_frame_num_offset= h->frame_num_offset;
|
||||
h->prev_frame_num = h->frame_num;
|
||||
h->outputed_poc = h->next_outputed_poc;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ff_h264_frame_start(H264Context *h){
|
||||
MpegEncContext * const s = &h->s;
|
||||
int i;
|
||||
const int pixel_shift = h->pixel_shift;
|
||||
int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
|
||||
|
||||
if(MPV_frame_start(s, s->avctx) < 0)
|
||||
return -1;
|
||||
@ -953,7 +1217,7 @@ int ff_h264_frame_start(H264Context *h){
|
||||
|
||||
/* can't be in alloc_tables because linesize isn't known there.
|
||||
* FIXME: redo bipred weight to not require extra buffer? */
|
||||
for(i = 0; i < s->avctx->thread_count; i++)
|
||||
for(i = 0; i < thread_count; i++)
|
||||
if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)
|
||||
h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
|
||||
|
||||
@ -973,11 +1237,173 @@ int ff_h264_frame_start(H264Context *h){
|
||||
|
||||
s->current_picture_ptr->field_poc[0]=
|
||||
s->current_picture_ptr->field_poc[1]= INT_MAX;
|
||||
|
||||
h->next_output_pic = NULL;
|
||||
|
||||
assert(s->current_picture_ptr->long_ref==0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run setup operations that must be run after slice header decoding.
|
||||
* This includes finding the next displayed frame.
|
||||
*
|
||||
* @param h h264 master context
|
||||
* @param setup_finished enough NALs have been read that we can call
|
||||
* ff_thread_finish_setup()
|
||||
*/
|
||||
static void decode_postinit(H264Context *h, int setup_finished){
|
||||
MpegEncContext * const s = &h->s;
|
||||
Picture *out = s->current_picture_ptr;
|
||||
Picture *cur = s->current_picture_ptr;
|
||||
int i, pics, out_of_order, out_idx;
|
||||
|
||||
s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
|
||||
s->current_picture_ptr->pict_type= s->pict_type;
|
||||
|
||||
if (h->next_output_pic) return;
|
||||
|
||||
if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
|
||||
//FIXME: if we have two PAFF fields in one packet, we can't start the next thread here.
|
||||
//If we have one field per packet, we can. The check in decode_nal_units() is not good enough
|
||||
//to find this yet, so we assume the worst for now.
|
||||
//if (setup_finished)
|
||||
// ff_thread_finish_setup(s->avctx);
|
||||
return;
|
||||
}
|
||||
|
||||
cur->interlaced_frame = 0;
|
||||
cur->repeat_pict = 0;
|
||||
|
||||
/* Signal interlacing information externally. */
|
||||
/* Prioritize picture timing SEI information over used decoding process if it exists. */
|
||||
|
||||
if(h->sps.pic_struct_present_flag){
|
||||
switch (h->sei_pic_struct)
|
||||
{
|
||||
case SEI_PIC_STRUCT_FRAME:
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_FIELD:
|
||||
case SEI_PIC_STRUCT_BOTTOM_FIELD:
|
||||
cur->interlaced_frame = 1;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_BOTTOM:
|
||||
case SEI_PIC_STRUCT_BOTTOM_TOP:
|
||||
if (FIELD_OR_MBAFF_PICTURE)
|
||||
cur->interlaced_frame = 1;
|
||||
else
|
||||
// try to flag soft telecine progressive
|
||||
cur->interlaced_frame = h->prev_interlaced_frame;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
|
||||
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
|
||||
// Signal the possibility of telecined film externally (pic_struct 5,6)
|
||||
// From these hints, let the applications decide if they apply deinterlacing.
|
||||
cur->repeat_pict = 1;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_FRAME_DOUBLING:
|
||||
// Force progressive here, as doubling interlaced frame is a bad idea.
|
||||
cur->repeat_pict = 2;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_FRAME_TRIPLING:
|
||||
cur->repeat_pict = 4;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
|
||||
cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;
|
||||
}else{
|
||||
/* Derive interlacing flag from used decoding process. */
|
||||
cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
|
||||
}
|
||||
h->prev_interlaced_frame = cur->interlaced_frame;
|
||||
|
||||
if (cur->field_poc[0] != cur->field_poc[1]){
|
||||
/* Derive top_field_first from field pocs. */
|
||||
cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
|
||||
}else{
|
||||
if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
|
||||
/* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
|
||||
if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
|
||||
|| h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
|
||||
cur->top_field_first = 1;
|
||||
else
|
||||
cur->top_field_first = 0;
|
||||
}else{
|
||||
/* Most likely progressive */
|
||||
cur->top_field_first = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//FIXME do something with unavailable reference frames
|
||||
|
||||
/* Sort B-frames into display order */
|
||||
|
||||
if(h->sps.bitstream_restriction_flag
|
||||
&& s->avctx->has_b_frames < h->sps.num_reorder_frames){
|
||||
s->avctx->has_b_frames = h->sps.num_reorder_frames;
|
||||
s->low_delay = 0;
|
||||
}
|
||||
|
||||
if( s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
|
||||
&& !h->sps.bitstream_restriction_flag){
|
||||
s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
|
||||
s->low_delay= 0;
|
||||
}
|
||||
|
||||
pics = 0;
|
||||
while(h->delayed_pic[pics]) pics++;
|
||||
|
||||
assert(pics <= MAX_DELAYED_PIC_COUNT);
|
||||
|
||||
h->delayed_pic[pics++] = cur;
|
||||
if(cur->reference == 0)
|
||||
cur->reference = DELAYED_PIC_REF;
|
||||
|
||||
out = h->delayed_pic[0];
|
||||
out_idx = 0;
|
||||
for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
|
||||
if(h->delayed_pic[i]->poc < out->poc){
|
||||
out = h->delayed_pic[i];
|
||||
out_idx = i;
|
||||
}
|
||||
if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))
|
||||
h->next_outputed_poc= INT_MIN;
|
||||
out_of_order = out->poc < h->next_outputed_poc;
|
||||
|
||||
if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
|
||||
{ }
|
||||
else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
|
||||
|| (s->low_delay &&
|
||||
((h->next_outputed_poc != INT_MIN && out->poc > h->next_outputed_poc + 2)
|
||||
|| cur->pict_type == AV_PICTURE_TYPE_B)))
|
||||
{
|
||||
s->low_delay = 0;
|
||||
s->avctx->has_b_frames++;
|
||||
}
|
||||
|
||||
if(out_of_order || pics > s->avctx->has_b_frames){
|
||||
out->reference &= ~DELAYED_PIC_REF;
|
||||
out->owner2 = s; // for frame threading, the owner must be the second field's thread
|
||||
// or else the first thread can release the picture and reuse it unsafely
|
||||
for(i=out_idx; h->delayed_pic[i]; i++)
|
||||
h->delayed_pic[i] = h->delayed_pic[i+1];
|
||||
}
|
||||
if(!out_of_order && pics > s->avctx->has_b_frames){
|
||||
h->next_output_pic = out;
|
||||
if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {
|
||||
h->next_outputed_poc = INT_MIN;
|
||||
} else
|
||||
h->next_outputed_poc = out->poc;
|
||||
}else{
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");
|
||||
}
|
||||
|
||||
if (setup_finished)
|
||||
ff_thread_finish_setup(s->avctx);
|
||||
}
|
||||
|
||||
static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){
|
||||
MpegEncContext * const s = &h->s;
|
||||
uint8_t *top_border;
|
||||
@ -1573,7 +1999,7 @@ static void flush_dpb(AVCodecContext *avctx){
|
||||
h->delayed_pic[i]->reference= 0;
|
||||
h->delayed_pic[i]= NULL;
|
||||
}
|
||||
h->outputed_poc= INT_MIN;
|
||||
h->outputed_poc=h->next_outputed_poc= INT_MIN;
|
||||
h->prev_interlaced_frame = 1;
|
||||
idr(h);
|
||||
if(h->s.current_picture_ptr)
|
||||
@ -1697,24 +2123,28 @@ static void init_scan_tables(H264Context *h){
|
||||
}
|
||||
}
|
||||
|
||||
static void field_end(H264Context *h){
|
||||
static void field_end(H264Context *h, int in_setup){
|
||||
MpegEncContext * const s = &h->s;
|
||||
AVCodecContext * const avctx= s->avctx;
|
||||
s->mb_y= 0;
|
||||
|
||||
s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
|
||||
s->current_picture_ptr->pict_type= s->pict_type;
|
||||
if (!in_setup && !s->dropable)
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,
|
||||
s->picture_structure==PICT_BOTTOM_FIELD);
|
||||
|
||||
if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
|
||||
ff_vdpau_h264_set_reference_frames(s);
|
||||
|
||||
if(!s->dropable) {
|
||||
ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
|
||||
h->prev_poc_msb= h->poc_msb;
|
||||
h->prev_poc_lsb= h->poc_lsb;
|
||||
if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){
|
||||
if(!s->dropable) {
|
||||
ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
|
||||
h->prev_poc_msb= h->poc_msb;
|
||||
h->prev_poc_lsb= h->poc_lsb;
|
||||
}
|
||||
h->prev_frame_num_offset= h->frame_num_offset;
|
||||
h->prev_frame_num= h->frame_num;
|
||||
h->outputed_poc = h->next_outputed_poc;
|
||||
}
|
||||
h->prev_frame_num_offset= h->frame_num_offset;
|
||||
h->prev_frame_num= h->frame_num;
|
||||
|
||||
if (avctx->hwaccel) {
|
||||
if (avctx->hwaccel->end_frame(avctx) < 0)
|
||||
@ -1831,7 +2261,7 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
|
||||
if(first_mb_in_slice == 0){ //FIXME better field boundary detection
|
||||
if(h0->current_slice && FIELD_PICTURE){
|
||||
field_end(h);
|
||||
field_end(h, 1);
|
||||
}
|
||||
|
||||
h0->current_slice = 0;
|
||||
@ -1900,8 +2330,10 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
if (s->context_initialized
|
||||
&& ( s->width != s->avctx->width || s->height != s->avctx->height
|
||||
|| av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
|
||||
if(h != h0)
|
||||
if(h != h0) {
|
||||
av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);
|
||||
return -1; // width / height changed during parallelized decoding
|
||||
}
|
||||
free_tables(h, 0);
|
||||
flush_dpb(s->avctx);
|
||||
MPV_common_end(s);
|
||||
@ -1960,22 +2392,27 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
init_scan_tables(h);
|
||||
ff_h264_alloc_tables(h);
|
||||
|
||||
for(i = 1; i < s->avctx->thread_count; i++) {
|
||||
H264Context *c;
|
||||
c = h->thread_context[i] = av_malloc(sizeof(H264Context));
|
||||
memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
|
||||
memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
|
||||
c->h264dsp = h->h264dsp;
|
||||
c->sps = h->sps;
|
||||
c->pps = h->pps;
|
||||
c->pixel_shift = h->pixel_shift;
|
||||
init_scan_tables(c);
|
||||
clone_tables(c, h, i);
|
||||
}
|
||||
|
||||
for(i = 0; i < s->avctx->thread_count; i++)
|
||||
if(context_init(h->thread_context[i]) < 0)
|
||||
if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {
|
||||
if (context_init(h) < 0)
|
||||
return -1;
|
||||
} else {
|
||||
for(i = 1; i < s->avctx->thread_count; i++) {
|
||||
H264Context *c;
|
||||
c = h->thread_context[i] = av_malloc(sizeof(H264Context));
|
||||
memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
|
||||
memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
|
||||
c->h264dsp = h->h264dsp;
|
||||
c->sps = h->sps;
|
||||
c->pps = h->pps;
|
||||
c->pixel_shift = h->pixel_shift;
|
||||
init_scan_tables(c);
|
||||
clone_tables(c, h, i);
|
||||
}
|
||||
|
||||
for(i = 0; i < s->avctx->thread_count; i++)
|
||||
if(context_init(h->thread_context[i]) < 0)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
|
||||
@ -1996,6 +2433,10 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
|
||||
|
||||
if(h0->current_slice == 0){
|
||||
if(h->frame_num != h->prev_frame_num &&
|
||||
(h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num) < (h->frame_num - h->sps.ref_frame_count))
|
||||
h->prev_frame_num = h->frame_num - h->sps.ref_frame_count - 1;
|
||||
|
||||
while(h->frame_num != h->prev_frame_num &&
|
||||
h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
|
||||
Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
|
||||
@ -2005,6 +2446,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
h->prev_frame_num++;
|
||||
h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
|
||||
s->current_picture_ptr->frame_num= h->prev_frame_num;
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);
|
||||
ff_generate_sliding_window_mmcos(h);
|
||||
ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
|
||||
/* Error concealment: if a ref is missing, copy the previous ref in its place.
|
||||
@ -2064,9 +2507,13 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
s0->first_field = FIELD_PICTURE;
|
||||
}
|
||||
|
||||
if((!FIELD_PICTURE || s0->first_field) && ff_h264_frame_start(h) < 0) {
|
||||
s0->first_field = 0;
|
||||
return -1;
|
||||
if(!FIELD_PICTURE || s0->first_field) {
|
||||
if (ff_h264_frame_start(h) < 0) {
|
||||
s0->first_field = 0;
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
ff_release_unused_pictures(s, 0);
|
||||
}
|
||||
}
|
||||
if(h != h0)
|
||||
@ -2309,7 +2756,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
|
||||
+(h->ref_list[j][i].reference&3);
|
||||
}
|
||||
|
||||
h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
|
||||
//FIXME: fix draw_edges+PAFF+frame threads
|
||||
h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE || (!h->sps.frame_mbs_only_flag && s->avctx->active_thread_type)) ? 0 : 16;
|
||||
h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
|
||||
|
||||
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
|
||||
@ -2631,6 +3079,40 @@ static void predict_field_decoding_flag(H264Context *h){
|
||||
h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw edges and report progress for the last MB row.
|
||||
*/
|
||||
static void decode_finish_row(H264Context *h){
|
||||
MpegEncContext * const s = &h->s;
|
||||
int top = 16*(s->mb_y >> FIELD_PICTURE);
|
||||
int height = 16 << FRAME_MBAFF;
|
||||
int deblock_border = (16 + 4) << FRAME_MBAFF;
|
||||
int pic_height = 16*s->mb_height >> FIELD_PICTURE;
|
||||
|
||||
if (h->deblocking_filter) {
|
||||
if((top + height) >= pic_height)
|
||||
height += deblock_border;
|
||||
|
||||
top -= deblock_border;
|
||||
}
|
||||
|
||||
if (top >= pic_height || (top + height) < h->emu_edge_height)
|
||||
return;
|
||||
|
||||
height = FFMIN(height, pic_height - top);
|
||||
if (top < h->emu_edge_height) {
|
||||
height = top+height;
|
||||
top = 0;
|
||||
}
|
||||
|
||||
ff_draw_horiz_band(s, top, height);
|
||||
|
||||
if (s->dropable) return;
|
||||
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,
|
||||
s->picture_structure==PICT_BOTTOM_FIELD);
|
||||
}
|
||||
|
||||
static int decode_slice(struct AVCodecContext *avctx, void *arg){
|
||||
H264Context *h = *(void**)arg;
|
||||
MpegEncContext * const s = &h->s;
|
||||
@ -2686,7 +3168,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg){
|
||||
if( ++s->mb_x >= s->mb_width ) {
|
||||
loop_filter(h, lf_x_start, s->mb_x);
|
||||
s->mb_x = lf_x_start = 0;
|
||||
ff_draw_horiz_band(s, 16*s->mb_y, 16);
|
||||
decode_finish_row(h);
|
||||
++s->mb_y;
|
||||
if(FIELD_OR_MBAFF_PICTURE) {
|
||||
++s->mb_y;
|
||||
@ -2726,7 +3208,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg){
|
||||
if(++s->mb_x >= s->mb_width){
|
||||
loop_filter(h, lf_x_start, s->mb_x);
|
||||
s->mb_x = lf_x_start = 0;
|
||||
ff_draw_horiz_band(s, 16*s->mb_y, 16);
|
||||
decode_finish_row(h);
|
||||
++s->mb_y;
|
||||
if(FIELD_OR_MBAFF_PICTURE) {
|
||||
++s->mb_y;
|
||||
@ -2855,12 +3337,15 @@ static void execute_decode_slices(H264Context *h, int context_count){
|
||||
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
|
||||
MpegEncContext * const s = &h->s;
|
||||
AVCodecContext * const avctx= s->avctx;
|
||||
int buf_index=0;
|
||||
H264Context *hx; ///< thread context
|
||||
int context_count = 0;
|
||||
int next_avc= h->is_avc ? 0 : buf_size;
|
||||
int buf_index;
|
||||
int context_count;
|
||||
int next_avc;
|
||||
int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
|
||||
int nals_needed=0; ///< number of NALs that need decoding before the next frame thread starts
|
||||
int nal_index;
|
||||
|
||||
h->max_contexts = avctx->thread_count;
|
||||
h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;
|
||||
if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
|
||||
h->current_slice = 0;
|
||||
if (!s->first_field)
|
||||
@ -2868,6 +3353,11 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
|
||||
ff_h264_reset_sei(h);
|
||||
}
|
||||
|
||||
for(;pass <= 1;pass++){
|
||||
buf_index = 0;
|
||||
context_count = 0;
|
||||
next_avc = h->is_avc ? 0 : buf_size;
|
||||
nal_index = 0;
|
||||
for(;;){
|
||||
int consumed;
|
||||
int dst_length;
|
||||
@ -2926,6 +3416,19 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
|
||||
}
|
||||
|
||||
buf_index += consumed;
|
||||
nal_index++;
|
||||
|
||||
if(pass == 0) {
|
||||
// packets can sometimes contain multiple PPS/SPS
|
||||
// e.g. two PAFF field pictures in one packet, or a demuxer which splits NALs strangely
|
||||
// if so, when frame threading we can't start the next thread until we've read all of them
|
||||
switch (hx->nal_unit_type) {
|
||||
case NAL_SPS:
|
||||
case NAL_PPS:
|
||||
nals_needed = nal_index;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
//FIXME do not discard SEI id
|
||||
if(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)
|
||||
@ -2949,16 +3452,21 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
|
||||
if((err = decode_slice_header(hx, h)))
|
||||
break;
|
||||
|
||||
s->current_picture_ptr->key_frame |=
|
||||
(hx->nal_unit_type == NAL_IDR_SLICE) ||
|
||||
(h->sei_recovery_frame_cnt >= 0);
|
||||
|
||||
if (h->current_slice == 1) {
|
||||
if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {
|
||||
decode_postinit(h, nal_index >= nals_needed);
|
||||
}
|
||||
|
||||
if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)
|
||||
return -1;
|
||||
if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
|
||||
ff_vdpau_h264_picture_start(s);
|
||||
}
|
||||
|
||||
s->current_picture_ptr->key_frame |=
|
||||
(hx->nal_unit_type == NAL_IDR_SLICE) ||
|
||||
(h->sei_recovery_frame_cnt >= 0);
|
||||
if(hx->redundant_pic_count==0
|
||||
&& (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
|
||||
&& (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=AV_PICTURE_TYPE_B)
|
||||
@ -3066,6 +3574,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(context_count)
|
||||
execute_decode_slices(h, context_count);
|
||||
return buf_index;
|
||||
@ -3101,6 +3610,8 @@ static int decode_frame(AVCodecContext *avctx,
|
||||
Picture *out;
|
||||
int i, out_idx;
|
||||
|
||||
s->current_picture_ptr = NULL;
|
||||
|
||||
//FIXME factorize this with the output code below
|
||||
out = h->delayed_pic[0];
|
||||
out_idx = 0;
|
||||
@ -3138,143 +3649,18 @@ static int decode_frame(AVCodecContext *avctx,
|
||||
}
|
||||
|
||||
if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){
|
||||
Picture *out = s->current_picture_ptr;
|
||||
Picture *cur = s->current_picture_ptr;
|
||||
int i, pics, out_of_order, out_idx;
|
||||
|
||||
field_end(h);
|
||||
if(s->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h, 1);
|
||||
|
||||
if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
|
||||
field_end(h, 0);
|
||||
|
||||
if (!h->next_output_pic) {
|
||||
/* Wait for second field. */
|
||||
*data_size = 0;
|
||||
|
||||
} else {
|
||||
cur->interlaced_frame = 0;
|
||||
cur->repeat_pict = 0;
|
||||
|
||||
/* Signal interlacing information externally. */
|
||||
/* Prioritize picture timing SEI information over used decoding process if it exists. */
|
||||
|
||||
if(h->sps.pic_struct_present_flag){
|
||||
switch (h->sei_pic_struct)
|
||||
{
|
||||
case SEI_PIC_STRUCT_FRAME:
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_FIELD:
|
||||
case SEI_PIC_STRUCT_BOTTOM_FIELD:
|
||||
cur->interlaced_frame = 1;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_BOTTOM:
|
||||
case SEI_PIC_STRUCT_BOTTOM_TOP:
|
||||
if (FIELD_OR_MBAFF_PICTURE)
|
||||
cur->interlaced_frame = 1;
|
||||
else
|
||||
// try to flag soft telecine progressive
|
||||
cur->interlaced_frame = h->prev_interlaced_frame;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
|
||||
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
|
||||
// Signal the possibility of telecined film externally (pic_struct 5,6)
|
||||
// From these hints, let the applications decide if they apply deinterlacing.
|
||||
cur->repeat_pict = 1;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_FRAME_DOUBLING:
|
||||
// Force progressive here, as doubling interlaced frame is a bad idea.
|
||||
cur->repeat_pict = 2;
|
||||
break;
|
||||
case SEI_PIC_STRUCT_FRAME_TRIPLING:
|
||||
cur->repeat_pict = 4;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
|
||||
cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;
|
||||
}else{
|
||||
/* Derive interlacing flag from used decoding process. */
|
||||
cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
|
||||
}
|
||||
h->prev_interlaced_frame = cur->interlaced_frame;
|
||||
|
||||
if (cur->field_poc[0] != cur->field_poc[1]){
|
||||
/* Derive top_field_first from field pocs. */
|
||||
cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
|
||||
}else{
|
||||
if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
|
||||
/* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
|
||||
if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
|
||||
|| h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
|
||||
cur->top_field_first = 1;
|
||||
else
|
||||
cur->top_field_first = 0;
|
||||
}else{
|
||||
/* Most likely progressive */
|
||||
cur->top_field_first = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//FIXME do something with unavailable reference frames
|
||||
|
||||
/* Sort B-frames into display order */
|
||||
|
||||
if(h->sps.bitstream_restriction_flag
|
||||
&& s->avctx->has_b_frames < h->sps.num_reorder_frames){
|
||||
s->avctx->has_b_frames = h->sps.num_reorder_frames;
|
||||
s->low_delay = 0;
|
||||
}
|
||||
|
||||
if( s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
|
||||
&& !h->sps.bitstream_restriction_flag){
|
||||
s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
|
||||
s->low_delay= 0;
|
||||
}
|
||||
|
||||
pics = 0;
|
||||
while(h->delayed_pic[pics]) pics++;
|
||||
|
||||
assert(pics <= MAX_DELAYED_PIC_COUNT);
|
||||
|
||||
h->delayed_pic[pics++] = cur;
|
||||
if(cur->reference == 0)
|
||||
cur->reference = DELAYED_PIC_REF;
|
||||
|
||||
out = h->delayed_pic[0];
|
||||
out_idx = 0;
|
||||
for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
|
||||
if(h->delayed_pic[i]->poc < out->poc){
|
||||
out = h->delayed_pic[i];
|
||||
out_idx = i;
|
||||
}
|
||||
if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))
|
||||
h->outputed_poc= INT_MIN;
|
||||
out_of_order = out->poc < h->outputed_poc;
|
||||
|
||||
if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
|
||||
{ }
|
||||
else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
|
||||
|| (s->low_delay &&
|
||||
((h->outputed_poc != INT_MIN && out->poc > h->outputed_poc + 2)
|
||||
|| cur->pict_type == AV_PICTURE_TYPE_B)))
|
||||
{
|
||||
s->low_delay = 0;
|
||||
s->avctx->has_b_frames++;
|
||||
}
|
||||
|
||||
if(out_of_order || pics > s->avctx->has_b_frames){
|
||||
out->reference &= ~DELAYED_PIC_REF;
|
||||
for(i=out_idx; h->delayed_pic[i]; i++)
|
||||
h->delayed_pic[i] = h->delayed_pic[i+1];
|
||||
}
|
||||
if(!out_of_order && pics > s->avctx->has_b_frames){
|
||||
*data_size = sizeof(AVFrame);
|
||||
|
||||
if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {
|
||||
h->outputed_poc = INT_MIN;
|
||||
} else
|
||||
h->outputed_poc = out->poc;
|
||||
*pict= *(AVFrame*)out;
|
||||
}else{
|
||||
av_log(avctx, AV_LOG_DEBUG, "no picture\n");
|
||||
}
|
||||
*data_size = sizeof(AVFrame);
|
||||
*pict = *(AVFrame*)h->next_output_pic;
|
||||
}
|
||||
}
|
||||
|
||||
@ -3534,9 +3920,11 @@ AVCodec ff_h264_decoder = {
|
||||
ff_h264_decode_end,
|
||||
decode_frame,
|
||||
/*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
|
||||
CODEC_CAP_SLICE_THREADS,
|
||||
CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
|
||||
.flush= flush_dpb,
|
||||
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
|
||||
.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
|
||||
.update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),
|
||||
.profiles = NULL_IF_CONFIG_SMALL(profiles),
|
||||
};
|
||||
|
||||
|
||||
@ -506,7 +506,9 @@ typedef struct H264Context{
|
||||
Picture *long_ref[32];
|
||||
Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
|
||||
Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size?
|
||||
Picture *next_output_pic;
|
||||
int outputed_poc;
|
||||
int next_outputed_poc;
|
||||
|
||||
/**
|
||||
* memory management control operations buffer.
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
#include "mpegvideo.h"
|
||||
#include "h264.h"
|
||||
#include "rectangle.h"
|
||||
#include "thread.h"
|
||||
|
||||
//#undef NDEBUG
|
||||
#include <assert.h>
|
||||
@ -126,7 +127,7 @@ void ff_h264_direct_ref_list_init(H264Context * const h){
|
||||
h->col_parity= (FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc));
|
||||
ref1sidx=sidx= h->col_parity;
|
||||
}else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){ // FL -> FL & differ parity
|
||||
h->col_fieldoff= s->mb_stride*(2*(h->ref_list[1][0].reference) - 3);
|
||||
h->col_fieldoff= 2*(h->ref_list[1][0].reference) - 3;
|
||||
}
|
||||
|
||||
if(cur->pict_type != AV_PICTURE_TYPE_B || h->direct_spatial_mv_pred)
|
||||
@ -140,11 +141,27 @@ void ff_h264_direct_ref_list_init(H264Context * const h){
|
||||
}
|
||||
}
|
||||
|
||||
static void await_reference_mb_row(H264Context * const h, Picture *ref, int mb_y)
|
||||
{
|
||||
int ref_field = ref->reference - 1;
|
||||
int ref_field_picture = ref->field_picture;
|
||||
int ref_height = 16*h->s.mb_height >> ref_field_picture;
|
||||
|
||||
if(!HAVE_PTHREADS || !(h->s.avctx->active_thread_type&FF_THREAD_FRAME))
|
||||
return;
|
||||
|
||||
//FIXME it can be safe to access mb stuff
|
||||
//even if pixels aren't deblocked yet
|
||||
|
||||
ff_thread_await_progress((AVFrame*)ref, FFMIN(16*mb_y >> ref_field_picture, ref_height-1),
|
||||
ref_field_picture && ref_field);
|
||||
}
|
||||
|
||||
static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){
|
||||
MpegEncContext * const s = &h->s;
|
||||
int b8_stride = 2;
|
||||
int b4_stride = h->b_stride;
|
||||
int mb_xy = h->mb_xy;
|
||||
int mb_xy = h->mb_xy, mb_y = s->mb_y;
|
||||
int mb_type_col[2];
|
||||
const int16_t (*l1mv0)[2], (*l1mv1)[2];
|
||||
const int8_t *l1ref0, *l1ref1;
|
||||
@ -157,6 +174,8 @@ static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){
|
||||
|
||||
assert(h->ref_list[1][0].reference&3);
|
||||
|
||||
await_reference_mb_row(h, &h->ref_list[1][0], s->mb_y + !!IS_INTERLACED(*mb_type));
|
||||
|
||||
#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
|
||||
|
||||
|
||||
@ -217,14 +236,17 @@ static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){
|
||||
|
||||
if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
|
||||
if(!IS_INTERLACED(*mb_type)){ // AFR/FR -> AFL/FL
|
||||
mb_y = (s->mb_y&~1) + h->col_parity;
|
||||
mb_xy= s->mb_x + ((s->mb_y&~1) + h->col_parity)*s->mb_stride;
|
||||
b8_stride = 0;
|
||||
}else{
|
||||
mb_xy += h->col_fieldoff; // non zero for FL -> FL & differ parity
|
||||
mb_y += h->col_fieldoff;
|
||||
mb_xy += s->mb_stride*h->col_fieldoff; // non zero for FL -> FL & differ parity
|
||||
}
|
||||
goto single_col;
|
||||
}else{ // AFL/AFR/FR/FL -> AFR/FR
|
||||
if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR
|
||||
mb_y = s->mb_y&~1;
|
||||
mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;
|
||||
mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
|
||||
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
|
||||
@ -260,6 +282,8 @@ single_col:
|
||||
}
|
||||
}
|
||||
|
||||
await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
|
||||
|
||||
l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
|
||||
l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
|
||||
l1ref0 = &h->ref_list[1][0].ref_index [0][4*mb_xy];
|
||||
@ -384,7 +408,7 @@ static void pred_temp_direct_motion(H264Context * const h, int *mb_type){
|
||||
MpegEncContext * const s = &h->s;
|
||||
int b8_stride = 2;
|
||||
int b4_stride = h->b_stride;
|
||||
int mb_xy = h->mb_xy;
|
||||
int mb_xy = h->mb_xy, mb_y = s->mb_y;
|
||||
int mb_type_col[2];
|
||||
const int16_t (*l1mv0)[2], (*l1mv1)[2];
|
||||
const int8_t *l1ref0, *l1ref1;
|
||||
@ -394,16 +418,21 @@ static void pred_temp_direct_motion(H264Context * const h, int *mb_type){
|
||||
|
||||
assert(h->ref_list[1][0].reference&3);
|
||||
|
||||
await_reference_mb_row(h, &h->ref_list[1][0], s->mb_y + !!IS_INTERLACED(*mb_type));
|
||||
|
||||
if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
|
||||
if(!IS_INTERLACED(*mb_type)){ // AFR/FR -> AFL/FL
|
||||
mb_y = (s->mb_y&~1) + h->col_parity;
|
||||
mb_xy= s->mb_x + ((s->mb_y&~1) + h->col_parity)*s->mb_stride;
|
||||
b8_stride = 0;
|
||||
}else{
|
||||
mb_xy += h->col_fieldoff; // non zero for FL -> FL & differ parity
|
||||
mb_y += h->col_fieldoff;
|
||||
mb_xy += s->mb_stride*h->col_fieldoff; // non zero for FL -> FL & differ parity
|
||||
}
|
||||
goto single_col;
|
||||
}else{ // AFL/AFR/FR/FL -> AFR/FR
|
||||
if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR
|
||||
mb_y = s->mb_y&~1;
|
||||
mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;
|
||||
mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
|
||||
mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
|
||||
@ -440,6 +469,8 @@ single_col:
|
||||
}
|
||||
}
|
||||
|
||||
await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
|
||||
|
||||
l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
|
||||
l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
|
||||
l1ref0 = &h->ref_list[1][0].ref_index [0][4*mb_xy];
|
||||
|
||||
@ -37,6 +37,7 @@
|
||||
#include "bytestream.h"
|
||||
#include "vdpau_internal.h"
|
||||
#include "xvmc_internal.h"
|
||||
#include "thread.h"
|
||||
|
||||
//#undef NDEBUG
|
||||
//#include <assert.h>
|
||||
@ -1179,6 +1180,27 @@ static av_cold int mpeg_decode_init(AVCodecContext *avctx)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mpeg_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
|
||||
{
|
||||
Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
|
||||
MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
|
||||
int err;
|
||||
|
||||
if(avctx == avctx_from || !ctx_from->mpeg_enc_ctx_allocated || !s1->context_initialized)
|
||||
return 0;
|
||||
|
||||
err = ff_mpeg_update_thread_context(avctx, avctx_from);
|
||||
if(err) return err;
|
||||
|
||||
if(!ctx->mpeg_enc_ctx_allocated)
|
||||
memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
|
||||
|
||||
if(!(s->pict_type == FF_B_TYPE || s->low_delay))
|
||||
s->picture_number++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
|
||||
const uint8_t *new_perm){
|
||||
uint16_t temp_matrix[64];
|
||||
@ -1595,6 +1617,9 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
|
||||
}
|
||||
|
||||
*s->current_picture_ptr->pan_scan= s1->pan_scan;
|
||||
|
||||
if (HAVE_PTHREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
|
||||
ff_thread_finish_setup(avctx);
|
||||
}else{ //second field
|
||||
int i;
|
||||
|
||||
@ -1769,6 +1794,7 @@ static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
|
||||
const int mb_size= 16>>s->avctx->lowres;
|
||||
|
||||
ff_draw_horiz_band(s, mb_size*(s->mb_y>>field_pic), mb_size);
|
||||
MPV_report_decode_progress(s);
|
||||
|
||||
s->mb_x = 0;
|
||||
s->mb_y += 1<<field_pic;
|
||||
@ -1926,7 +1952,8 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)
|
||||
*pict= *(AVFrame*)s->current_picture_ptr;
|
||||
ff_print_debug_info(s, pict);
|
||||
} else {
|
||||
s->picture_number++;
|
||||
if (avctx->active_thread_type & FF_THREAD_FRAME)
|
||||
s->picture_number++;
|
||||
/* latency of 1 frame for I- and P-frames */
|
||||
/* XXX: use another variable than picture_number */
|
||||
if (s->last_picture_ptr != NULL) {
|
||||
@ -2262,7 +2289,7 @@ static int decode_chunks(AVCodecContext *avctx,
|
||||
buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
|
||||
if (start_code > 0x1ff){
|
||||
if(s2->pict_type != AV_PICTURE_TYPE_B || avctx->skip_frame <= AVDISCARD_DEFAULT){
|
||||
if((avctx->active_thread_type & FF_THREAD_SLICE) && avctx->thread_count > 1){
|
||||
if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){
|
||||
int i;
|
||||
|
||||
avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
|
||||
@ -2430,7 +2457,7 @@ static int decode_chunks(AVCodecContext *avctx,
|
||||
break;
|
||||
}
|
||||
|
||||
if((avctx->active_thread_type & FF_THREAD_SLICE) && avctx->thread_count > 1){
|
||||
if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){
|
||||
int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
|
||||
if(threshold <= mb_y){
|
||||
MpegEncContext *thread_context= s2->thread_context[s->slice_count];
|
||||
@ -2505,6 +2532,7 @@ AVCodec ff_mpeg1video_decoder = {
|
||||
.flush= flush,
|
||||
.max_lowres= 3,
|
||||
.long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
|
||||
.update_thread_context= ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
|
||||
};
|
||||
|
||||
AVCodec ff_mpeg2video_decoder = {
|
||||
@ -2541,7 +2569,7 @@ AVCodec ff_mpegvideo_decoder = {
|
||||
|
||||
#if CONFIG_MPEG_XVMC_DECODER
|
||||
static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
|
||||
if((avctx->active_thread_type & FF_THREAD_SLICE) && avctx->thread_count > 1)
|
||||
if( avctx->active_thread_type & FF_THREAD_SLICE )
|
||||
return -1;
|
||||
if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
|
||||
return -1;
|
||||
|
||||
@ -23,6 +23,7 @@
|
||||
#include "mpegvideo.h"
|
||||
#include "mpeg4video.h"
|
||||
#include "h263.h"
|
||||
#include "thread.h"
|
||||
|
||||
// The defines below define the number of bits that are read at once for
|
||||
// reading vlc values. Changing these may improve speed and data cache needs
|
||||
@ -373,7 +374,13 @@ int mpeg4_decode_video_packet_header(MpegEncContext *s)
|
||||
return -1;
|
||||
}
|
||||
if(s->pict_type == AV_PICTURE_TYPE_B){
|
||||
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
|
||||
int mb_x = 0, mb_y = 0;
|
||||
|
||||
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) {
|
||||
if (!mb_x) ff_thread_await_progress((AVFrame*)s->next_picture_ptr, mb_y++, 0);
|
||||
mb_num++;
|
||||
if (++mb_x == s->mb_width) mb_x = 0;
|
||||
}
|
||||
if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
|
||||
}
|
||||
|
||||
@ -1303,6 +1310,8 @@ static int mpeg4_decode_mb(MpegEncContext *s,
|
||||
s->last_mv[i][1][0]=
|
||||
s->last_mv[i][1][1]= 0;
|
||||
}
|
||||
|
||||
ff_thread_await_progress((AVFrame*)s->next_picture_ptr, s->mb_y, 0);
|
||||
}
|
||||
|
||||
/* if we skipped it in the future P Frame than skip it now too */
|
||||
@ -1482,6 +1491,12 @@ end:
|
||||
if(s->codec_id==CODEC_ID_MPEG4){
|
||||
if(mpeg4_is_resync(s)){
|
||||
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
|
||||
|
||||
if(s->pict_type==AV_PICTURE_TYPE_B && s->next_picture.mbskip_table[xy + delta]){
|
||||
ff_thread_await_progress((AVFrame*)s->next_picture_ptr,
|
||||
(s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);
|
||||
}
|
||||
|
||||
if(s->pict_type==AV_PICTURE_TYPE_B && s->next_picture.mbskip_table[xy + delta])
|
||||
return SLICE_OK;
|
||||
return SLICE_END;
|
||||
@ -2235,11 +2250,12 @@ AVCodec ff_mpeg4_decoder = {
|
||||
NULL,
|
||||
ff_h263_decode_end,
|
||||
ff_h263_decode_frame,
|
||||
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
|
||||
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,
|
||||
.flush= ff_mpeg_flush,
|
||||
.max_lowres= 3,
|
||||
.long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
|
||||
.pix_fmts= ff_hwaccel_pixfmt_list_420,
|
||||
.update_thread_context= ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context)
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -38,6 +38,7 @@
|
||||
#include "msmpeg4.h"
|
||||
#include "faandct.h"
|
||||
#include "xvmc_internal.h"
|
||||
#include "thread.h"
|
||||
#include <limits.h>
|
||||
|
||||
//#undef NDEBUG
|
||||
@ -205,7 +206,7 @@ void ff_copy_picture(Picture *dst, Picture *src){
|
||||
*/
|
||||
static void free_frame_buffer(MpegEncContext *s, Picture *pic)
|
||||
{
|
||||
s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
|
||||
ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
|
||||
av_freep(&pic->hwaccel_picture_private);
|
||||
}
|
||||
|
||||
@ -227,7 +228,7 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
|
||||
}
|
||||
}
|
||||
|
||||
r = s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
|
||||
r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
|
||||
|
||||
if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
|
||||
@ -315,6 +316,7 @@ int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
|
||||
s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
|
||||
if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
|
||||
pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
|
||||
pic->owner2 = NULL;
|
||||
|
||||
return 0;
|
||||
fail: //for the FF_ALLOCZ_OR_GOTO macro
|
||||
@ -458,6 +460,81 @@ void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
|
||||
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
|
||||
}
|
||||
|
||||
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
|
||||
{
|
||||
MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
|
||||
|
||||
if(dst == src || !s1->context_initialized) return 0;
|
||||
|
||||
//FIXME can parameters change on I-frames? in that case dst may need a reinit
|
||||
if(!s->context_initialized){
|
||||
memcpy(s, s1, sizeof(MpegEncContext));
|
||||
|
||||
s->avctx = dst;
|
||||
s->picture_range_start += MAX_PICTURE_COUNT;
|
||||
s->picture_range_end += MAX_PICTURE_COUNT;
|
||||
s->bitstream_buffer = NULL;
|
||||
s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
|
||||
|
||||
MPV_common_init(s);
|
||||
}
|
||||
|
||||
s->avctx->coded_height = s1->avctx->coded_height;
|
||||
s->avctx->coded_width = s1->avctx->coded_width;
|
||||
s->avctx->width = s1->avctx->width;
|
||||
s->avctx->height = s1->avctx->height;
|
||||
|
||||
s->coded_picture_number = s1->coded_picture_number;
|
||||
s->picture_number = s1->picture_number;
|
||||
s->input_picture_number = s1->input_picture_number;
|
||||
|
||||
memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
|
||||
memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
|
||||
|
||||
s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
|
||||
s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
|
||||
s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
|
||||
|
||||
memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
|
||||
|
||||
//Error/bug resilience
|
||||
s->next_p_frame_damaged = s1->next_p_frame_damaged;
|
||||
s->workaround_bugs = s1->workaround_bugs;
|
||||
|
||||
//MPEG4 timing info
|
||||
memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
|
||||
|
||||
//B-frame info
|
||||
s->max_b_frames = s1->max_b_frames;
|
||||
s->low_delay = s1->low_delay;
|
||||
s->dropable = s1->dropable;
|
||||
|
||||
//DivX handling (doesn't work)
|
||||
s->divx_packed = s1->divx_packed;
|
||||
|
||||
if(s1->bitstream_buffer){
|
||||
if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
|
||||
av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
|
||||
s->bitstream_buffer_size = s1->bitstream_buffer_size;
|
||||
memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
|
||||
memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
|
||||
}
|
||||
|
||||
//MPEG2/interlacing info
|
||||
memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
|
||||
|
||||
if(!s1->first_field){
|
||||
s->last_pict_type= s1->pict_type;
|
||||
if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;
|
||||
|
||||
if(s1->pict_type!=FF_B_TYPE){
|
||||
s->last_non_b_pict_type= s1->pict_type;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* sets the given MpegEncContext to common defaults (same for encoding and decoding).
|
||||
* the changed fields will not depend upon the prior state of the MpegEncContext.
|
||||
@ -478,6 +555,9 @@ void MPV_common_defaults(MpegEncContext *s){
|
||||
|
||||
s->f_code = 1;
|
||||
s->b_code = 1;
|
||||
|
||||
s->picture_range_start = 0;
|
||||
s->picture_range_end = MAX_PICTURE_COUNT;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -506,7 +586,8 @@ av_cold int MPV_common_init(MpegEncContext *s)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
|
||||
if((s->avctx->active_thread_type & FF_THREAD_SLICE) &&
|
||||
(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
|
||||
av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
|
||||
return -1;
|
||||
}
|
||||
@ -602,8 +683,9 @@ av_cold int MPV_common_init(MpegEncContext *s)
|
||||
}
|
||||
}
|
||||
|
||||
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, MAX_PICTURE_COUNT * sizeof(Picture), fail)
|
||||
for(i = 0; i < MAX_PICTURE_COUNT; i++) {
|
||||
s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
|
||||
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
|
||||
for(i = 0; i < s->picture_count; i++) {
|
||||
avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
|
||||
}
|
||||
|
||||
@ -665,9 +747,10 @@ av_cold int MPV_common_init(MpegEncContext *s)
|
||||
}
|
||||
|
||||
s->context_initialized = 1;
|
||||
s->thread_context[0]= s;
|
||||
|
||||
if (s->width && s->height) {
|
||||
s->thread_context[0]= s;
|
||||
if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
|
||||
threads = s->avctx->thread_count;
|
||||
|
||||
for(i=1; i<threads; i++){
|
||||
@ -681,6 +764,11 @@ av_cold int MPV_common_init(MpegEncContext *s)
|
||||
s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
|
||||
s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
|
||||
}
|
||||
} else {
|
||||
if(init_duplicate_context(s, s) < 0) goto fail;
|
||||
s->start_mb_y = 0;
|
||||
s->end_mb_y = s->mb_height;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -694,12 +782,14 @@ void MPV_common_end(MpegEncContext *s)
|
||||
{
|
||||
int i, j, k;
|
||||
|
||||
for(i=0; i<s->avctx->thread_count; i++){
|
||||
free_duplicate_context(s->thread_context[i]);
|
||||
}
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
av_freep(&s->thread_context[i]);
|
||||
}
|
||||
if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
|
||||
for(i=0; i<s->avctx->thread_count; i++){
|
||||
free_duplicate_context(s->thread_context[i]);
|
||||
}
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
av_freep(&s->thread_context[i]);
|
||||
}
|
||||
} else free_duplicate_context(s);
|
||||
|
||||
av_freep(&s->parse_context.buffer);
|
||||
s->parse_context.buffer_size=0;
|
||||
@ -754,8 +844,8 @@ void MPV_common_end(MpegEncContext *s)
|
||||
av_freep(&s->reordered_input_picture);
|
||||
av_freep(&s->dct_offset);
|
||||
|
||||
if(s->picture){
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
if(s->picture && !s->avctx->is_copy){
|
||||
for(i=0; i<s->picture_count; i++){
|
||||
free_picture(s, &s->picture[i]);
|
||||
}
|
||||
}
|
||||
@ -769,7 +859,8 @@ void MPV_common_end(MpegEncContext *s)
|
||||
for(i=0; i<3; i++)
|
||||
av_freep(&s->visualization_buffer[i]);
|
||||
|
||||
avcodec_default_free_buffers(s->avctx);
|
||||
if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
|
||||
avcodec_default_free_buffers(s->avctx);
|
||||
}
|
||||
|
||||
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
|
||||
@ -863,18 +954,33 @@ void init_vlc_rl(RLTable *rl)
|
||||
}
|
||||
}
|
||||
|
||||
void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* release non reference frames */
|
||||
for(i=0; i<s->picture_count; i++){
|
||||
if(s->picture[i].data[0] && !s->picture[i].reference
|
||||
&& (!s->picture[i].owner2 || s->picture[i].owner2 == s)
|
||||
&& (remove_current || &s->picture[i] != s->current_picture_ptr)
|
||||
/*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
|
||||
free_frame_buffer(s, &s->picture[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int ff_find_unused_picture(MpegEncContext *s, int shared){
|
||||
int i;
|
||||
|
||||
if(shared){
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
||||
if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
|
||||
}
|
||||
}else{
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
||||
if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
|
||||
}
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
||||
if(s->picture[i].data[0]==NULL) return i;
|
||||
}
|
||||
}
|
||||
@ -931,7 +1037,7 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
/* release forgotten pictures */
|
||||
/* if(mpeg124/h263) */
|
||||
if(!s->encoding){
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=0; i<s->picture_count; i++){
|
||||
if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
|
||||
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
|
||||
free_frame_buffer(s, &s->picture[i]);
|
||||
@ -942,12 +1048,7 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
}
|
||||
|
||||
if(!s->encoding){
|
||||
/* release non reference frames */
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
|
||||
free_frame_buffer(s, &s->picture[i]);
|
||||
}
|
||||
}
|
||||
ff_release_unused_pictures(s, 1);
|
||||
|
||||
if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
|
||||
pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
|
||||
@ -977,6 +1078,7 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
|
||||
}
|
||||
s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
|
||||
s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
|
||||
}
|
||||
|
||||
s->current_picture_ptr->pict_type= s->pict_type;
|
||||
@ -1010,6 +1112,8 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
s->last_picture_ptr= &s->picture[i];
|
||||
if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
|
||||
return -1;
|
||||
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
|
||||
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
|
||||
}
|
||||
if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
|
||||
/* Allocate a dummy frame */
|
||||
@ -1017,6 +1121,8 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
s->next_picture_ptr= &s->picture[i];
|
||||
if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
|
||||
return -1;
|
||||
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
|
||||
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1068,11 +1174,12 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||
void MPV_frame_end(MpegEncContext *s)
|
||||
{
|
||||
int i;
|
||||
/* draw edge for correct motion prediction if outside */
|
||||
/* redraw edges for the frame if decoding didn't complete */
|
||||
//just to make sure that all data is rendered.
|
||||
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
|
||||
ff_xvmc_field_end(s);
|
||||
}else if(!s->avctx->hwaccel
|
||||
}else if((s->error_count || s->encoding)
|
||||
&& !s->avctx->hwaccel
|
||||
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
|
||||
&& s->unrestricted_mv
|
||||
&& s->current_picture.reference
|
||||
@ -1088,6 +1195,7 @@ void MPV_frame_end(MpegEncContext *s)
|
||||
s->h_edge_pos>>1, s->v_edge_pos>>1,
|
||||
EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
|
||||
}
|
||||
|
||||
emms_c();
|
||||
|
||||
s->last_pict_type = s->pict_type;
|
||||
@ -1108,7 +1216,7 @@ void MPV_frame_end(MpegEncContext *s)
|
||||
|
||||
if(s->encoding){
|
||||
/* release non-reference frames */
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=0; i<s->picture_count; i++){
|
||||
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
|
||||
free_frame_buffer(s, &s->picture[i]);
|
||||
}
|
||||
@ -1121,6 +1229,10 @@ void MPV_frame_end(MpegEncContext *s)
|
||||
memset(&s->current_picture, 0, sizeof(Picture));
|
||||
#endif
|
||||
s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
|
||||
|
||||
if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1785,6 +1897,43 @@ static inline void MPV_motion_lowres(MpegEncContext *s,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* find the lowest MB row referenced in the MVs
|
||||
*/
|
||||
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
|
||||
{
|
||||
int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
|
||||
int my, off, i, mvs;
|
||||
|
||||
if (s->picture_structure != PICT_FRAME) goto unhandled;
|
||||
|
||||
switch (s->mv_type) {
|
||||
case MV_TYPE_16X16:
|
||||
mvs = 1;
|
||||
break;
|
||||
case MV_TYPE_16X8:
|
||||
mvs = 2;
|
||||
break;
|
||||
case MV_TYPE_8X8:
|
||||
mvs = 4;
|
||||
break;
|
||||
default:
|
||||
goto unhandled;
|
||||
}
|
||||
|
||||
for (i = 0; i < mvs; i++) {
|
||||
my = s->mv[dir][i][1]<<qpel_shift;
|
||||
my_max = FFMAX(my_max, my);
|
||||
my_min = FFMIN(my_min, my);
|
||||
}
|
||||
|
||||
off = (FFMAX(-my_min, my_max) + 63) >> 6;
|
||||
|
||||
return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
|
||||
unhandled:
|
||||
return s->mb_height-1;
|
||||
}
|
||||
|
||||
/* put block[] to dest[] */
|
||||
static inline void put_dct(MpegEncContext *s,
|
||||
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
|
||||
@ -1949,6 +2098,16 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
|
||||
/* motion handling */
|
||||
/* decoding or more than one mb_type (MC was already done otherwise) */
|
||||
if(!s->encoding){
|
||||
|
||||
if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
|
||||
if (s->mv_dir & MV_DIR_FORWARD) {
|
||||
ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
|
||||
}
|
||||
if (s->mv_dir & MV_DIR_BACKWARD) {
|
||||
ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
|
||||
}
|
||||
}
|
||||
|
||||
if(lowres_flag){
|
||||
h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
|
||||
|
||||
@ -2112,19 +2271,37 @@ void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
|
||||
* @param h is the normal height, this will be reduced automatically if needed for the last row
|
||||
*/
|
||||
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
|
||||
const int field_pic= s->picture_structure != PICT_FRAME;
|
||||
if(field_pic){
|
||||
h <<= 1;
|
||||
y <<= 1;
|
||||
}
|
||||
|
||||
if (!s->avctx->hwaccel
|
||||
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
|
||||
&& s->unrestricted_mv
|
||||
&& s->current_picture.reference
|
||||
&& !s->intra_only
|
||||
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
|
||||
int sides = 0, edge_h;
|
||||
if (y==0) sides |= EDGE_TOP;
|
||||
if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
|
||||
|
||||
edge_h= FFMIN(h, s->v_edge_pos - y);
|
||||
|
||||
s->dsp.draw_edges(s->current_picture_ptr->data[0] + y *s->linesize , s->linesize , s->h_edge_pos , edge_h , EDGE_WIDTH , sides);
|
||||
s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
|
||||
s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
|
||||
}
|
||||
|
||||
h= FFMIN(h, s->avctx->height - y);
|
||||
|
||||
if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
|
||||
|
||||
if (s->avctx->draw_horiz_band) {
|
||||
AVFrame *src;
|
||||
const int field_pic= s->picture_structure != PICT_FRAME;
|
||||
int offset[4];
|
||||
|
||||
h= FFMIN(h, (s->avctx->height>>field_pic) - y);
|
||||
|
||||
if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
|
||||
h <<= 1;
|
||||
y <<= 1;
|
||||
if(s->first_field) return;
|
||||
}
|
||||
|
||||
if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
|
||||
src= (AVFrame*)s->current_picture_ptr;
|
||||
else if(s->last_picture_ptr)
|
||||
@ -2190,7 +2367,7 @@ void ff_mpeg_flush(AVCodecContext *avctx){
|
||||
if(s==NULL || s->picture==NULL)
|
||||
return;
|
||||
|
||||
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
||||
for(i=0; i<s->picture_count; i++){
|
||||
if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
|
||||
|| s->picture[i].type == FF_BUFFER_TYPE_USER))
|
||||
free_frame_buffer(s, &s->picture[i]);
|
||||
@ -2444,3 +2621,9 @@ void ff_set_qscale(MpegEncContext * s, int qscale)
|
||||
s->y_dc_scale= s->y_dc_scale_table[ qscale ];
|
||||
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
|
||||
}
|
||||
|
||||
void MPV_report_decode_progress(MpegEncContext *s)
|
||||
{
|
||||
if (s->pict_type != FF_B_TYPE && !s->partitioned_frame && !s->error_occurred)
|
||||
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
|
||||
}
|
||||
|
||||
@ -76,6 +76,8 @@ enum OutputFormat {
|
||||
#define EXT_START_CODE 0x000001b5
|
||||
#define USER_START_CODE 0x000001b2
|
||||
|
||||
struct MpegEncContext;
|
||||
|
||||
/**
|
||||
* Picture.
|
||||
*/
|
||||
@ -123,6 +125,7 @@ typedef struct Picture{
|
||||
int ref_poc[2][2][16]; ///< h264 POCs of the frames used as reference (FIXME need per slice)
|
||||
int ref_count[2][2]; ///< number of entries in ref_poc (FIXME need per slice)
|
||||
int mbaff; ///< h264 1 -> MBAFF frame 0-> not MBAFF
|
||||
int field_picture; ///< whether or not the picture was encoded in seperate fields
|
||||
|
||||
int mb_var_sum; ///< sum of MB variance for current frame
|
||||
int mc_mb_var_sum; ///< motion compensated MB variance for current frame
|
||||
@ -131,10 +134,9 @@ typedef struct Picture{
|
||||
uint8_t *mb_mean; ///< Table for MB luminance
|
||||
int32_t *mb_cmp_score; ///< Table for MB cmp scores, for mb decision FIXME remove
|
||||
int b_frame_score; /* */
|
||||
struct MpegEncContext *owner2; ///< pointer to the MpegEncContext that allocated this picture
|
||||
} Picture;
|
||||
|
||||
struct MpegEncContext;
|
||||
|
||||
/**
|
||||
* Motion estimation context.
|
||||
*/
|
||||
@ -291,6 +293,8 @@ typedef struct MpegEncContext {
|
||||
Picture *last_picture_ptr; ///< pointer to the previous picture.
|
||||
Picture *next_picture_ptr; ///< pointer to the next picture (for bidir pred)
|
||||
Picture *current_picture_ptr; ///< pointer to the current picture
|
||||
int picture_count; ///< number of allocated pictures (MAX_PICTURE_COUNT * avctx->thread_count)
|
||||
int picture_range_start, picture_range_end; ///< the part of picture that this context can allocate in
|
||||
uint8_t *visualization_buffer[3]; //< temporary buffer vor MV visualization
|
||||
int last_dc[3]; ///< last DC values for MPEG1
|
||||
int16_t *dc_val_base;
|
||||
@ -470,7 +474,7 @@ typedef struct MpegEncContext {
|
||||
int last_bits; ///< temp var used for calculating the above vars
|
||||
|
||||
/* error concealment / resync */
|
||||
int error_count;
|
||||
int error_count, error_occurred;
|
||||
uint8_t *error_status_table; ///< table of the error status of each MB
|
||||
#define VP_START 1 ///< current MB is the first after a resync marker
|
||||
#define AC_ERROR 2
|
||||
@ -677,6 +681,10 @@ typedef struct MpegEncContext {
|
||||
void (*denoise_dct)(struct MpegEncContext *s, DCTELEM *block);
|
||||
} MpegEncContext;
|
||||
|
||||
#define REBASE_PICTURE(pic, new_ctx, old_ctx) (pic ? \
|
||||
(pic >= old_ctx->picture && pic < old_ctx->picture+old_ctx->picture_count ?\
|
||||
&new_ctx->picture[pic - old_ctx->picture] : pic - (Picture*)old_ctx + (Picture*)new_ctx)\
|
||||
: NULL)
|
||||
|
||||
void MPV_decode_defaults(MpegEncContext *s);
|
||||
int MPV_common_init(MpegEncContext *s);
|
||||
@ -699,9 +707,13 @@ void ff_draw_horiz_band(MpegEncContext *s, int y, int h);
|
||||
void ff_mpeg_flush(AVCodecContext *avctx);
|
||||
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict);
|
||||
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix);
|
||||
void ff_release_unused_pictures(MpegEncContext *s, int remove_current);
|
||||
int ff_find_unused_picture(MpegEncContext *s, int shared);
|
||||
void ff_denoise_dct(MpegEncContext *s, DCTELEM *block);
|
||||
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src);
|
||||
int MPV_lowest_referenced_row(MpegEncContext *s, int dir);
|
||||
void MPV_report_decode_progress(MpegEncContext *s);
|
||||
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src);
|
||||
const uint8_t *ff_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state);
|
||||
void ff_set_qscale(MpegEncContext * s, int qscale);
|
||||
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
#include "mjpegenc.h"
|
||||
#include "msmpeg4.h"
|
||||
#include "faandct.h"
|
||||
#include "thread.h"
|
||||
#include "aandcttab.h"
|
||||
#include "flv.h"
|
||||
#include "mpeg4video.h"
|
||||
@ -1225,9 +1226,9 @@ int MPV_encode_picture(AVCodecContext *avctx,
|
||||
{
|
||||
MpegEncContext *s = avctx->priv_data;
|
||||
AVFrame *pic_arg = data;
|
||||
int i, stuffing_count;
|
||||
int i, stuffing_count, context_count = avctx->active_thread_type&FF_THREAD_SLICE ? avctx->thread_count : 1;
|
||||
|
||||
for(i=0; i<avctx->thread_count; i++){
|
||||
for(i=0; i<context_count; i++){
|
||||
int start_y= s->thread_context[i]->start_mb_y;
|
||||
int end_y= s->thread_context[i]-> end_mb_y;
|
||||
int h= s->mb_height;
|
||||
@ -1291,7 +1292,7 @@ vbv_retry:
|
||||
s->last_non_b_time= s->time - s->pp_time;
|
||||
}
|
||||
// av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
|
||||
for(i=0; i<avctx->thread_count; i++){
|
||||
for(i=0; i<context_count; i++){
|
||||
PutBitContext *pb= &s->thread_context[i]->pb;
|
||||
init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
|
||||
}
|
||||
@ -2758,6 +2759,7 @@ static int encode_picture(MpegEncContext *s, int picture_number)
|
||||
{
|
||||
int i;
|
||||
int bits;
|
||||
int context_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
|
||||
|
||||
s->picture_number = picture_number;
|
||||
|
||||
@ -2797,7 +2799,7 @@ static int encode_picture(MpegEncContext *s, int picture_number)
|
||||
}
|
||||
|
||||
s->mb_intra=0; //for the rate distortion & bit compare functions
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
for(i=1; i<context_count; i++){
|
||||
ff_update_duplicate_context(s->thread_context[i], s);
|
||||
}
|
||||
|
||||
@ -2810,11 +2812,11 @@ static int encode_picture(MpegEncContext *s, int picture_number)
|
||||
s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
|
||||
if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
|
||||
if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
|
||||
s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*));
|
||||
s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
|
||||
}
|
||||
}
|
||||
|
||||
s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*));
|
||||
s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
|
||||
}else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
|
||||
/* I-Frame */
|
||||
for(i=0; i<s->mb_stride*s->mb_height; i++)
|
||||
@ -2822,10 +2824,10 @@ static int encode_picture(MpegEncContext *s, int picture_number)
|
||||
|
||||
if(!s->fixed_qscale){
|
||||
/* finding spatial complexity for I-frame rate control */
|
||||
s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*));
|
||||
s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
|
||||
}
|
||||
}
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
for(i=1; i<context_count; i++){
|
||||
merge_context_after_me(s, s->thread_context[i]);
|
||||
}
|
||||
s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
|
||||
@ -2961,11 +2963,11 @@ static int encode_picture(MpegEncContext *s, int picture_number)
|
||||
bits= put_bits_count(&s->pb);
|
||||
s->header_bits= bits - s->last_bits;
|
||||
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
for(i=1; i<context_count; i++){
|
||||
update_duplicate_context_after_me(s->thread_context[i], s);
|
||||
}
|
||||
s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*));
|
||||
for(i=1; i<s->avctx->thread_count; i++){
|
||||
s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
|
||||
for(i=1; i<context_count; i++){
|
||||
merge_context_after_encode(s, s->thread_context[i]);
|
||||
}
|
||||
emms_c();
|
||||
|
||||
@ -55,7 +55,7 @@ typedef struct ThreadContext {
|
||||
} ThreadContext;
|
||||
|
||||
/// Max number of frame buffers that can be allocated when using frame threads.
|
||||
#define MAX_BUFFERS 32
|
||||
#define MAX_BUFFERS (32+1)
|
||||
|
||||
/**
|
||||
* Context used by codec threads and stored in their AVCodecContext thread_opaque.
|
||||
|
||||
@ -115,7 +115,7 @@ typedef struct InternalBuffer{
|
||||
enum PixelFormat pix_fmt;
|
||||
}InternalBuffer;
|
||||
|
||||
#define INTERNAL_BUFFER_SIZE 32
|
||||
#define INTERNAL_BUFFER_SIZE (32+1)
|
||||
|
||||
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[4]){
|
||||
int w_align= 1;
|
||||
@ -360,6 +360,7 @@ void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
|
||||
assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
|
||||
assert(s->internal_buffer_count);
|
||||
|
||||
if(s->internal_buffer){
|
||||
buf = NULL; /* avoids warning */
|
||||
for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
|
||||
buf= &((InternalBuffer*)s->internal_buffer)[i];
|
||||
@ -371,6 +372,7 @@ void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
|
||||
last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
|
||||
|
||||
FFSWAP(InternalBuffer, *buf, *last);
|
||||
}
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
pic->data[i]=NULL;
|
||||
|
||||
@ -179,23 +179,23 @@ FATE_H264 := $(FATE_H264:%=fate-h264-conformance-%) \
|
||||
FATE_TESTS += $(FATE_H264)
|
||||
fate-h264: $(FATE_H264)
|
||||
|
||||
fate-h264-conformance-aud_mw_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/AUD_MW_E.264
|
||||
fate-h264-conformance-ba1_ft_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/BA1_FT_C.264
|
||||
fate-h264-conformance-ba1_sony_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/BA1_Sony_D.jsv
|
||||
fate-h264-conformance-ba2_sony_f: CMD = framecrc -i $(SAMPLES)/h264-conformance/BA2_Sony_F.jsv
|
||||
fate-h264-conformance-aud_mw_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/AUD_MW_E.264
|
||||
fate-h264-conformance-ba1_ft_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BA1_FT_C.264
|
||||
fate-h264-conformance-ba1_sony_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BA1_Sony_D.jsv
|
||||
fate-h264-conformance-ba2_sony_f: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BA2_Sony_F.jsv
|
||||
fate-h264-conformance-ba3_sva_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/BA3_SVA_C.264
|
||||
fate-h264-conformance-ba_mw_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/BA_MW_D.264
|
||||
fate-h264-conformance-bamq1_jvc_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/BAMQ1_JVC_C.264
|
||||
fate-h264-conformance-bamq2_jvc_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/BAMQ2_JVC_C.264
|
||||
fate-h264-conformance-banm_mw_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/BANM_MW_D.264
|
||||
fate-h264-conformance-basqp1_sony_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/BASQP1_Sony_C.jsv
|
||||
fate-h264-conformance-caba1_sony_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/CABA1_Sony_D.jsv
|
||||
fate-h264-conformance-caba1_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CABA1_SVA_B.264
|
||||
fate-h264-conformance-caba2_sony_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CABA2_Sony_E.jsv
|
||||
fate-h264-conformance-caba2_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CABA2_SVA_B.264
|
||||
fate-h264-conformance-ba_mw_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BA_MW_D.264
|
||||
fate-h264-conformance-bamq1_jvc_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BAMQ1_JVC_C.264
|
||||
fate-h264-conformance-bamq2_jvc_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BAMQ2_JVC_C.264
|
||||
fate-h264-conformance-banm_mw_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BANM_MW_D.264
|
||||
fate-h264-conformance-basqp1_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/BASQP1_Sony_C.jsv
|
||||
fate-h264-conformance-caba1_sony_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CABA1_Sony_D.jsv
|
||||
fate-h264-conformance-caba1_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CABA1_SVA_B.264
|
||||
fate-h264-conformance-caba2_sony_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CABA2_Sony_E.jsv
|
||||
fate-h264-conformance-caba2_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CABA2_SVA_B.264
|
||||
fate-h264-conformance-caba3_sony_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CABA3_Sony_C.jsv
|
||||
fate-h264-conformance-caba3_sva_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CABA3_SVA_B.264
|
||||
fate-h264-conformance-caba3_toshiba_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CABA3_TOSHIBA_E.264
|
||||
fate-h264-conformance-caba3_toshiba_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CABA3_TOSHIBA_E.264
|
||||
fate-h264-conformance-cabac_mot_fld0_full: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/camp_mot_fld0_full.26l
|
||||
fate-h264-conformance-cabac_mot_frm0_full: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/camp_mot_frm0_full.26l
|
||||
fate-h264-conformance-cabac_mot_mbaff0_full: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/camp_mot_mbaff0_full.26l
|
||||
@ -206,7 +206,7 @@ fate-h264-conformance-cabastbr3_sony_b: CMD = framecrc -vsync 0 -strict 1 -i $(
|
||||
fate-h264-conformance-cabref3_sand_d: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CABREF3_Sand_D.264
|
||||
fate-h264-conformance-cacqp3_sony_d: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CACQP3_Sony_D.jsv
|
||||
fate-h264-conformance-cafi1_sva_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAFI1_SVA_C.264
|
||||
fate-h264-conformance-cama1_sony_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CAMA1_Sony_C.jsv
|
||||
fate-h264-conformance-cama1_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CAMA1_Sony_C.jsv
|
||||
fate-h264-conformance-cama1_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAMA1_TOSHIBA_B.264
|
||||
fate-h264-conformance-cama1_vtc_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/cama1_vtc_c.avc
|
||||
fate-h264-conformance-cama2_vtc_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/cama2_vtc_b.avc
|
||||
@ -219,37 +219,37 @@ fate-h264-conformance-camanl3_sand_e: CMD = framecrc -vsync 0 -strict 1 -i $(SA
|
||||
fate-h264-conformance-camasl3_sony_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAMASL3_Sony_B.jsv
|
||||
fate-h264-conformance-camp_mot_mbaff_l30: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAMP_MOT_MBAFF_L30.26l
|
||||
fate-h264-conformance-camp_mot_mbaff_l31: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAMP_MOT_MBAFF_L31.26l
|
||||
fate-h264-conformance-canl1_sony_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL1_Sony_E.jsv
|
||||
fate-h264-conformance-canl1_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL1_SVA_B.264
|
||||
fate-h264-conformance-canl1_toshiba_g: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL1_TOSHIBA_G.264
|
||||
fate-h264-conformance-canl2_sony_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL2_Sony_E.jsv
|
||||
fate-h264-conformance-canl2_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL2_SVA_B.264
|
||||
fate-h264-conformance-canl1_sony_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL1_Sony_E.jsv
|
||||
fate-h264-conformance-canl1_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL1_SVA_B.264
|
||||
fate-h264-conformance-canl1_toshiba_g: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL1_TOSHIBA_G.264
|
||||
fate-h264-conformance-canl2_sony_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL2_Sony_E.jsv
|
||||
fate-h264-conformance-canl2_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL2_SVA_B.264
|
||||
fate-h264-conformance-canl3_sony_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CANL3_Sony_C.jsv
|
||||
fate-h264-conformance-canl3_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL3_SVA_B.264
|
||||
fate-h264-conformance-canl4_sva_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANL4_SVA_B.264
|
||||
fate-h264-conformance-canlma2_sony_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANLMA2_Sony_C.jsv
|
||||
fate-h264-conformance-canlma3_sony_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CANLMA3_Sony_C.jsv
|
||||
fate-h264-conformance-canl3_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL3_SVA_B.264
|
||||
fate-h264-conformance-canl4_sva_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANL4_SVA_B.264
|
||||
fate-h264-conformance-canlma2_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANLMA2_Sony_C.jsv
|
||||
fate-h264-conformance-canlma3_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CANLMA3_Sony_C.jsv
|
||||
fate-h264-conformance-capa1_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAPA1_TOSHIBA_B.264
|
||||
fate-h264-conformance-capama3_sand_f: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAPAMA3_Sand_F.264
|
||||
fate-h264-conformance-capcm1_sand_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CAPCM1_Sand_E.264
|
||||
fate-h264-conformance-capcmnl1_sand_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CAPCMNL1_Sand_E.264
|
||||
fate-h264-conformance-capcm1_sand_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CAPCM1_Sand_E.264
|
||||
fate-h264-conformance-capcmnl1_sand_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CAPCMNL1_Sand_E.264
|
||||
fate-h264-conformance-capm3_sony_d: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAPM3_Sony_D.jsv
|
||||
fate-h264-conformance-caqp1_sony_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CAQP1_Sony_B.jsv
|
||||
fate-h264-conformance-caqp1_sony_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CAQP1_Sony_B.jsv
|
||||
fate-h264-conformance-cavlc_mot_fld0_full_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/cvmp_mot_fld0_full_B.26l
|
||||
fate-h264-conformance-cavlc_mot_frm0_full_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/cvmp_mot_frm0_full_B.26l
|
||||
fate-h264-conformance-cavlc_mot_mbaff0_full_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/cvmp_mot_mbaff0_full_B.26l
|
||||
fate-h264-conformance-cavlc_mot_picaff0_full_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/cvmp_mot_picaff0_full_B.26l
|
||||
fate-h264-conformance-cawp1_toshiba_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CAWP1_TOSHIBA_E.264
|
||||
fate-h264-conformance-cawp1_toshiba_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CAWP1_TOSHIBA_E.264
|
||||
fate-h264-conformance-cawp5_toshiba_e: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CAWP5_TOSHIBA_E.264
|
||||
fate-h264-conformance-ci1_ft_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/CI1_FT_B.264
|
||||
fate-h264-conformance-ci_mw_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/CI_MW_D.264
|
||||
fate-h264-conformance-ci1_ft_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CI1_FT_B.264
|
||||
fate-h264-conformance-ci_mw_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CI_MW_D.264
|
||||
fate-h264-conformance-cvbs3_sony_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVBS3_Sony_C.jsv
|
||||
fate-h264-conformance-cvcanlma2_sony_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CVCANLMA2_Sony_C.jsv
|
||||
fate-h264-conformance-cvcanlma2_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVCANLMA2_Sony_C.jsv
|
||||
fate-h264-conformance-cvfi1_sony_d: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVFI1_Sony_D.jsv
|
||||
fate-h264-conformance-cvfi1_sva_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVFI1_SVA_C.264
|
||||
fate-h264-conformance-cvfi2_sony_h: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVFI2_Sony_H.jsv
|
||||
fate-h264-conformance-cvfi2_sva_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVFI2_SVA_C.264
|
||||
fate-h264-conformance-cvma1_sony_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/CVMA1_Sony_D.jsv
|
||||
fate-h264-conformance-cvma1_sony_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVMA1_Sony_D.jsv
|
||||
fate-h264-conformance-cvma1_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVMA1_TOSHIBA_B.264
|
||||
fate-h264-conformance-cvmanl1_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVMANL1_TOSHIBA_B.264
|
||||
fate-h264-conformance-cvmanl2_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVMANL2_TOSHIBA_B.264
|
||||
@ -261,68 +261,68 @@ fate-h264-conformance-cvmp_mot_frm_l31_b: CMD = framecrc -vsync 0 -strict 1 -i
|
||||
fate-h264-conformance-cvnlfi1_sony_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVNLFI1_Sony_C.jsv
|
||||
fate-h264-conformance-cvnlfi2_sony_h: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVNLFI2_Sony_H.jsv
|
||||
fate-h264-conformance-cvpa1_toshiba_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVPA1_TOSHIBA_B.264
|
||||
fate-h264-conformance-cvpcmnl1_sva_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CVPCMNL1_SVA_C.264
|
||||
fate-h264-conformance-cvpcmnl2_sva_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/CVPCMNL2_SVA_C.264
|
||||
fate-h264-conformance-cvwp1_toshiba_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/CVWP1_TOSHIBA_E.264
|
||||
fate-h264-conformance-cvpcmnl1_sva_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVPCMNL1_SVA_C.264
|
||||
fate-h264-conformance-cvpcmnl2_sva_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVPCMNL2_SVA_C.264
|
||||
fate-h264-conformance-cvwp1_toshiba_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/CVWP1_TOSHIBA_E.264
|
||||
fate-h264-conformance-cvwp2_toshiba_e: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVWP2_TOSHIBA_E.264
|
||||
fate-h264-conformance-cvwp3_toshiba_e: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVWP3_TOSHIBA_E.264
|
||||
fate-h264-conformance-cvwp5_toshiba_e: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/CVWP5_TOSHIBA_E.264
|
||||
fate-h264-conformance-fi1_sony_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FI1_Sony_E.jsv
|
||||
fate-h264-conformance-frext-alphaconformanceg: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/test8b43.264
|
||||
fate-h264-conformance-frext-bcrm_freh10: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh10.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh11: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh11.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh3: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh3.264
|
||||
fate-h264-conformance-frext-brcm_freh4: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh4.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh5: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh5.264
|
||||
fate-h264-conformance-frext-brcm_freh8: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh8.264
|
||||
fate-h264-conformance-frext-brcm_freh9: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh9.264
|
||||
fate-h264-conformance-frext-freh12_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/Freh12_B.264
|
||||
fate-h264-conformance-frext-freh1_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/Freh1_B.264
|
||||
fate-h264-conformance-frext-freh2_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/Freh2_B.264
|
||||
fate-h264-conformance-frext-freh6: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/freh6.264 -vsync 0
|
||||
fate-h264-conformance-frext-freh7_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/Freh7_B.264 -vsync 0
|
||||
fate-h264-conformance-frext-frext01_jvc_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FREXT01_JVC_D.264
|
||||
fate-h264-conformance-frext-frext02_jvc_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FREXT02_JVC_C.264
|
||||
fate-h264-conformance-frext-frext1_panasonic_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FRExt1_Panasonic.avc
|
||||
fate-h264-conformance-frext-frext2_panasonic_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FRExt2_Panasonic.avc -vsync 0
|
||||
fate-h264-conformance-frext-frext3_panasonic_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FRExt3_Panasonic.avc
|
||||
fate-h264-conformance-frext-frext4_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/FRExt4_Panasonic.avc
|
||||
fate-h264-conformance-frext-alphaconformanceg: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/test8b43.264
|
||||
fate-h264-conformance-frext-bcrm_freh10: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh10.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh11: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh11.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh3: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh3.264
|
||||
fate-h264-conformance-frext-brcm_freh4: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh4.264 -vsync 0
|
||||
fate-h264-conformance-frext-brcm_freh5: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh5.264
|
||||
fate-h264-conformance-frext-brcm_freh8: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh8.264
|
||||
fate-h264-conformance-frext-brcm_freh9: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh9.264
|
||||
fate-h264-conformance-frext-freh12_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/Freh12_B.264
|
||||
fate-h264-conformance-frext-freh1_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/Freh1_B.264
|
||||
fate-h264-conformance-frext-freh2_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/Freh2_B.264
|
||||
fate-h264-conformance-frext-freh6: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/freh6.264 -vsync 0
|
||||
fate-h264-conformance-frext-freh7_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/Freh7_B.264 -vsync 0
|
||||
fate-h264-conformance-frext-frext01_jvc_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FREXT01_JVC_D.264
|
||||
fate-h264-conformance-frext-frext02_jvc_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FREXT02_JVC_C.264
|
||||
fate-h264-conformance-frext-frext1_panasonic_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FRExt1_Panasonic.avc
|
||||
fate-h264-conformance-frext-frext2_panasonic_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FRExt2_Panasonic.avc -vsync 0
|
||||
fate-h264-conformance-frext-frext3_panasonic_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FRExt3_Panasonic.avc
|
||||
fate-h264-conformance-frext-frext4_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FRExt4_Panasonic.avc
|
||||
fate-h264-conformance-frext-frext_mmco4_sony_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/FRExt_MMCO4_Sony_B.264
|
||||
fate-h264-conformance-frext-hcaff1_hhi_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAFF1_HHI.264
|
||||
fate-h264-conformance-frext-hcafr1_hhi_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAFR1_HHI.264
|
||||
fate-h264-conformance-frext-hcafr2_hhi_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAFR2_HHI.264
|
||||
fate-h264-conformance-frext-hcafr3_hhi_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAFR3_HHI.264
|
||||
fate-h264-conformance-frext-hcafr4_hhi_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAFR4_HHI.264
|
||||
fate-h264-conformance-frext-hcamff1_hhi_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HCAMFF1_HHI.264
|
||||
fate-h264-conformance-frext-hpca_brcm_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCA_BRCM_C.264
|
||||
fate-h264-conformance-frext-hpcadq_brcm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCADQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcafl_bcrm_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCAFL_BRCM_C.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcaflnl_bcrm_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCAFLNL_BRCM_C.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcalq_brcm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCALQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcamapalq_bcrm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCAMAPALQ_BRCM_B.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcamolq_brcm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCAMOLQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcanl_brcm_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCANL_BRCM_C.264
|
||||
fate-h264-conformance-frext-hpcaq2lq_brcm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCAQ2LQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcv_brcm_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCV_BRCM_A.264
|
||||
fate-h264-conformance-frext-hpcvfl_bcrm_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCVFL_BRCM_A.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcvflnl_bcrm_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCVFLNL_BRCM_A.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcvmolq_brcm_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCVMOLQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcvnl_brcm_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/HPCVNL_BRCM_A.264
|
||||
fate-h264-conformance-frext-pph10i1_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I1_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i2_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I2_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i3_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I3_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i4_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I4_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i5_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I5_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i6_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I6_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i7_panasonic_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/FRext/PPH10I7_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-hcaff1_hhi_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAFF1_HHI.264
|
||||
fate-h264-conformance-frext-hcafr1_hhi_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAFR1_HHI.264
|
||||
fate-h264-conformance-frext-hcafr2_hhi_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAFR2_HHI.264
|
||||
fate-h264-conformance-frext-hcafr3_hhi_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAFR3_HHI.264
|
||||
fate-h264-conformance-frext-hcafr4_hhi_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAFR4_HHI.264
|
||||
fate-h264-conformance-frext-hcamff1_hhi_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HCAMFF1_HHI.264
|
||||
fate-h264-conformance-frext-hpca_brcm_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCA_BRCM_C.264
|
||||
fate-h264-conformance-frext-hpcadq_brcm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCADQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcafl_bcrm_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCAFL_BRCM_C.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcaflnl_bcrm_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCAFLNL_BRCM_C.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcalq_brcm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCALQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcamapalq_bcrm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCAMAPALQ_BRCM_B.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcamolq_brcm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCAMOLQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcanl_brcm_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCANL_BRCM_C.264
|
||||
fate-h264-conformance-frext-hpcaq2lq_brcm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCAQ2LQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcv_brcm_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCV_BRCM_A.264
|
||||
fate-h264-conformance-frext-hpcvfl_bcrm_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCVFL_BRCM_A.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcvflnl_bcrm_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCVFLNL_BRCM_A.264 -vsync 0
|
||||
fate-h264-conformance-frext-hpcvmolq_brcm_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCVMOLQ_BRCM_B.264
|
||||
fate-h264-conformance-frext-hpcvnl_brcm_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/HPCVNL_BRCM_A.264
|
||||
fate-h264-conformance-frext-pph10i1_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I1_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i2_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I2_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i3_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I3_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i4_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I4_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i5_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I5_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i6_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I6_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-frext-pph10i7_panasonic_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/FRext/PPH10I7_Panasonic_A.264 -pix_fmt yuv420p10le
|
||||
fate-h264-conformance-hcbp2_hhi_a: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/HCBP2_HHI_A.264
|
||||
fate-h264-conformance-hcmp1_hhi_a: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/HCMP1_HHI_A.264
|
||||
fate-h264-conformance-ls_sva_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/LS_SVA_D.264
|
||||
fate-h264-conformance-midr_mw_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/MIDR_MW_D.264
|
||||
fate-h264-conformance-mps_mw_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/MPS_MW_A.264
|
||||
fate-h264-conformance-mr1_bt_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/MR1_BT_A.h264
|
||||
fate-h264-conformance-mr1_mw_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/MR1_MW_A.264
|
||||
fate-h264-conformance-mr2_mw_a: CMD = framecrc -i $(SAMPLES)/h264-conformance/MR2_MW_A.264
|
||||
fate-h264-conformance-ls_sva_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/LS_SVA_D.264
|
||||
fate-h264-conformance-midr_mw_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/MIDR_MW_D.264
|
||||
fate-h264-conformance-mps_mw_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/MPS_MW_A.264
|
||||
fate-h264-conformance-mr1_bt_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/MR1_BT_A.h264
|
||||
fate-h264-conformance-mr1_mw_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/MR1_MW_A.264
|
||||
fate-h264-conformance-mr2_mw_a: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/MR2_MW_A.264
|
||||
fate-h264-conformance-mr2_tandberg_e: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/MR2_TANDBERG_E.264
|
||||
fate-h264-conformance-mr3_tandberg_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/MR3_TANDBERG_B.264
|
||||
fate-h264-conformance-mr4_tandberg_c: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/MR4_TANDBERG_C.264
|
||||
@ -332,26 +332,26 @@ fate-h264-conformance-mr7_bt_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)
|
||||
fate-h264-conformance-mr8_bt_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/MR8_BT_B.h264
|
||||
fate-h264-conformance-mr9_bt_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/MR9_BT_B.h264
|
||||
fate-h264-conformance-mv1_brcm_d: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/src19td.IBP.264
|
||||
fate-h264-conformance-nl1_sony_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/NL1_Sony_D.jsv
|
||||
fate-h264-conformance-nl2_sony_h: CMD = framecrc -i $(SAMPLES)/h264-conformance/NL2_Sony_H.jsv
|
||||
fate-h264-conformance-nl3_sva_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/NL3_SVA_E.264
|
||||
fate-h264-conformance-nlmq1_jvc_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/NLMQ1_JVC_C.264
|
||||
fate-h264-conformance-nlmq2_jvc_c: CMD = framecrc -i $(SAMPLES)/h264-conformance/NLMQ2_JVC_C.264
|
||||
fate-h264-conformance-nrf_mw_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/NRF_MW_E.264
|
||||
fate-h264-conformance-nl1_sony_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NL1_Sony_D.jsv
|
||||
fate-h264-conformance-nl2_sony_h: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NL2_Sony_H.jsv
|
||||
fate-h264-conformance-nl3_sva_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NL3_SVA_E.264
|
||||
fate-h264-conformance-nlmq1_jvc_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NLMQ1_JVC_C.264
|
||||
fate-h264-conformance-nlmq2_jvc_c: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NLMQ2_JVC_C.264
|
||||
fate-h264-conformance-nrf_mw_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/NRF_MW_E.264
|
||||
fate-h264-conformance-sharp_mp_field_1_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/Sharp_MP_Field_1_B.jvt
|
||||
fate-h264-conformance-sharp_mp_field_2_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/Sharp_MP_Field_2_B.jvt
|
||||
fate-h264-conformance-sharp_mp_field_3_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/Sharp_MP_Field_3_B.jvt
|
||||
fate-h264-conformance-sharp_mp_paff_1r2: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/Sharp_MP_PAFF_1r2.jvt
|
||||
fate-h264-conformance-sharp_mp_paff_2r: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/Sharp_MP_PAFF_2.jvt
|
||||
fate-h264-conformance-sl1_sva_b: CMD = framecrc -vsync 0 -strict 1 -i $(SAMPLES)/h264-conformance/SL1_SVA_B.264
|
||||
fate-h264-conformance-sva_ba1_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_BA1_B.264
|
||||
fate-h264-conformance-sva_ba2_d: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_BA2_D.264
|
||||
fate-h264-conformance-sva_base_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_Base_B.264
|
||||
fate-h264-conformance-sva_cl1_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_CL1_E.264
|
||||
fate-h264-conformance-sva_fm1_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_FM1_E.264
|
||||
fate-h264-conformance-sva_nl1_b: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_NL1_B.264
|
||||
fate-h264-conformance-sva_nl2_e: CMD = framecrc -i $(SAMPLES)/h264-conformance/SVA_NL2_E.264
|
||||
fate-h264-conformance-sva_ba1_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_BA1_B.264
|
||||
fate-h264-conformance-sva_ba2_d: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_BA2_D.264
|
||||
fate-h264-conformance-sva_base_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_Base_B.264
|
||||
fate-h264-conformance-sva_cl1_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_CL1_E.264
|
||||
fate-h264-conformance-sva_fm1_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_FM1_E.264
|
||||
fate-h264-conformance-sva_nl1_b: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_NL1_B.264
|
||||
fate-h264-conformance-sva_nl2_e: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264-conformance/SVA_NL2_E.264
|
||||
|
||||
fate-h264-interlace-crop: CMD = framecrc -vframes 3 -i $(SAMPLES)/h264/interlaced_crop.mp4
|
||||
fate-h264-lossless: CMD = framecrc -i $(SAMPLES)/h264/lossless.h264
|
||||
fate-h264-interlace-crop: CMD = framecrc -vsync 0 -vframes 3 -i $(SAMPLES)/h264/interlaced_crop.mp4
|
||||
fate-h264-lossless: CMD = framecrc -vsync 0 -i $(SAMPLES)/h264/lossless.h264
|
||||
fate-h264-extreme-plane-pred: CMD = framemd5 -strict 1 -vsync 0 -i $(SAMPLES)/h264/extreme-plane-pred.h264
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
7416dfd319f04044d4575dc9d1b406e1 *./tests/data/vsynth1/error-mpeg4-adv.avi
|
||||
756836 ./tests/data/vsynth1/error-mpeg4-adv.avi
|
||||
ef8bfcd6e0883daba95d0f32486ebe2d *./tests/data/error.vsynth1.out.yuv
|
||||
stddev: 18.05 PSNR: 23.00 MAXDIFF: 245 bytes: 7603200/ 7603200
|
||||
756836 ./tests/data/vsynth1/error-mpeg4-adv.avi
|
||||
54342963593ba08bcde95244a011efe5 *./tests/data/error.vsynth1.out.yuv
|
||||
stddev: 17.59 PSNR: 23.22 MAXDIFF: 240 bytes: 7603200/ 7603200
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
90e65096aa9ebafa3fe3f44a5a47cdc4 *./tests/data/vsynth2/error-mpeg4-adv.avi
|
||||
176588 ./tests/data/vsynth2/error-mpeg4-adv.avi
|
||||
9fe1082179f80179439953c7397a46ef *./tests/data/error.vsynth2.out.yuv
|
||||
stddev: 9.00 PSNR: 29.04 MAXDIFF: 168 bytes: 7603200/ 7603200
|
||||
176588 ./tests/data/vsynth2/error-mpeg4-adv.avi
|
||||
ce12aa852126f2740838dd2da9e21a03 *./tests/data/error.vsynth2.out.yuv
|
||||
stddev: 10.06 PSNR: 28.08 MAXDIFF: 193 bytes: 7603200/ 7603200
|
||||
|
||||
@ -102,7 +102,7 @@ do_ffmpeg_crc()
|
||||
|
||||
do_video_decoding()
|
||||
{
|
||||
do_ffmpeg $raw_dst $DEC_OPTS $1 -i $target_path/$file -f rawvideo $ENC_OPTS $2
|
||||
do_ffmpeg $raw_dst $DEC_OPTS $1 -i $target_path/$file -f rawvideo $ENC_OPTS -vsync 0 $2
|
||||
}
|
||||
|
||||
do_video_encoding()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user