// 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 */;
Av1FilterLUT lim_lut;
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 in Prozent
¤ Dauer der Verarbeitung: 0.14 Sekunden
(vorverarbeitet am 2026-08-28)
¤
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.
