// cache of OBUs that make up a single frame before we submit them // to a frame worker to be decoded struct Dav1dTileGroup *tile; int n_tile_data_alloc; int n_tile_data; int n_tiles;
Dav1dMemPool *seq_hdr_pool;
Dav1dRef *seq_hdr_ref;
Dav1dSequenceHeader *seq_hdr;
Dav1dMemPool *frame_hdr_pool;
Dav1dRef *frame_hdr_ref;
Dav1dFrameHeader *frame_hdr;
// decoded output picture queue
Dav1dData in;
Dav1dThreadPicture out, cache; // dummy is a pointer to prevent compiler errors about atomic_load() // not taking const arguments
atomic_int flush_mem, *flush; struct {
Dav1dThreadPicture *out_delayed; unsigned next;
} frame_thread;
// task threading (refer to tc[] for per_thread thingies) struct TaskThreadData {
pthread_mutex_t lock;
pthread_cond_t cond;
atomic_uint first; unsigned cur; // This is used for delayed reset of the task cur pointer when // such operation is needed but the thread doesn't enter a critical // section (typically when executing the next sbrow task locklessly). // See src/thread_task.c:reset_task_cur().
atomic_uint reset_task_cur;
atomic_int cond_signaled; struct { int exec, finished;
pthread_cond_t cond; const Dav1dPicture *in;
Dav1dPicture *out; enum TaskType type;
atomic_int progress[2]; /* [0]=started, [1]=completed */ union { struct {
ALIGN(int8_t grain_lut_8bpc[3][GRAIN_HEIGHT + 1][GRAIN_WIDTH], 16);
ALIGN(uint8_t scaling_8bpc[3][256], 64);
}; struct {
ALIGN(int16_t grain_lut_16bpc[3][GRAIN_HEIGHT + 1][GRAIN_WIDTH], 16);
ALIGN(uint8_t scaling_16bpc[3][4096], 64);
};
};
} delayed_fg; int inited;
} task_thread;
Dav1dPicAllocator allocator; int apply_grain; int operating_point; unsigned operating_point_idc; int all_layers; int max_spatial_id; unsigned frame_size_limit; int strict_std_compliance; int output_invisible_frames; enum Dav1dInloopFilterType inloop_filters; enum Dav1dDecodeFrameType decode_frame_type; int drain; enum PictureFlags frame_flags; enum Dav1dEventFlags event_flags;
Dav1dDataProps cached_error_props; int cached_error;
// for scalable references struct ScalableMotionParams { int scale; // if no scaling, this is 0 int step;
} svc[7][2 /* x, y */]; int resize_step[2 /* y, uv */], resize_start[2 /* y, uv */];
struct { int next_tile_row[2 /* 0: reconstruction, 1: entropy */];
atomic_int entropy_progress;
atomic_int deblock_progress; // in sby units
atomic_uint *frame_progress, *copy_lpf_progress; // indexed using t->by * f->b4_stride + t->bx
Av1Block *b;
int16_t *cbi; /* bits 0-4: txtp, bits 5-15: eob */ // indexed using (t->by >> 1) * (f->b4_stride >> 1) + (t->bx >> 1)
pixel (*pal)[3 /* plane */][8 /* idx */]; // iterated over inside tile state
uint8_t *pal_idx;
coef *cf; int prog_sz; int cbi_sz, pal_sz, pal_idx_sz, cf_sz; // start offsets per tile unsigned *tile_start_off;
} frame_thread;
// loopfilter struct {
uint8_t (*level)[4];
Av1Filter *mask;
Av1Restoration *lr_mask; int mask_sz /* w*h */, lr_mask_sz; int cdef_buf_plane_sz[2]; /* stride*sbh*4 */ int cdef_buf_sbh; int lr_buf_plane_sz[2]; /* (stride*sbh*4) << sb128 if n_tc > 1, else stride*4 */ int re_sz /* h */;
ALIGN(Av1FilterLUT lim_lut, 16);
ALIGN(uint8_t lvl[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */], 16); int last_sharpness;
uint8_t *tx_lpf_right_edge[2];
uint8_t *cdef_line_buf, *lr_line_buf;
pixel *cdef_line[2 /* pre, post */][3 /* plane */];
pixel *cdef_lpf_line[3 /* plane */];
pixel *lr_lpf_line[3 /* plane */];
// in-loop filter per-frame state keeping
uint8_t *start_of_tile_row; int start_of_tile_row_sz; int need_cdef_lpf_copy;
pixel *p[3], *sr_p[3]; int restore_planes; // enum LrRestorePlanes
} lf;
struct {
pthread_mutex_t lock;
pthread_cond_t cond; struct TaskThreadData *ttd; struct Dav1dTask *tasks, *tile_tasks[2], init_task; int num_tasks, num_tile_tasks;
atomic_int init_done;
atomic_int done[2]; int retval; int update_set; // whether we need to update CDF reference
atomic_int error;
atomic_int task_counter; struct Dav1dTask *task_head, *task_tail; // Points to the task directly before the cur pointer in the queue. // This cur pointer is theoretical here, we actually keep track of the // "prev_t" variable. This is needed to not loose the tasks in // [head;cur-1] when picking one for execution. struct Dav1dTask *task_cur_prev; struct { // async task insertion
atomic_int merge;
pthread_mutex_t lock;
Dav1dTask *head, *tail;
} pending_tasks;
} task_thread;
// threading (refer to tc[] for per-thread things) struct FrameTileThreadData { int (*lowest_pixel_mem)[7][2]; int lowest_pixel_mem_sz;
} tile_thread;
};
// in fullpel units, [0] = Y, [1] = UV, used for progress requirements // each entry is one tile-sbrow; middle index is refidx int (*lowest_pixel)[7][2];
Dav1dWarpedMotionParams warpmv;
Av1Filter *lf_mask; int top_pre_cdef_toggle;
int8_t *cur_sb_cdef_idx_ptr; // for chroma sub8x8, we need to know the filter for all 4 subblocks in // a 4x4 area, but the top/left one can go out of cache already, so this // keeps it accessible enum Filter2d tl_4x4_filter;
struct { int pass;
} frame_thread; struct { struct thread_data td; struct TaskThreadData *ttd; struct FrameTileThreadData *fttd; int flushed; int die;
} task_thread;
};
#endif/* DAV1D_SRC_INTERNAL_H */
Messung V0.5
¤ Dauer der Verarbeitung: 0.10 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
