22 #ifndef AVCODEC_SNOW_H 23 #define AVCODEC_SNOW_H 44 #define QROOT (1<<QSHIFT) 45 #define LOSSLESS_QLOG -128 47 #define MAX_REF_FRAMES 8 49 #define LOG2_OBMC_MAX 8 50 #define OBMC_MAX (1<<(LOG2_OBMC_MAX)) 60 //#define TYPE_NOCOLOR 4
65 .
color= {128,128,128},
73 #define LOG2_MB_SIZE 4 74 #define MB_SIZE (1<<LOG2_MB_SIZE) 75 #define ENCODER_EXTRA_BITS 4 164 #define QBIAS_SHIFT 3 172 #define ME_CACHE_SIZE 1024 206 low[(*i)+1] = low[((*i)+1)>>1];
212 for (; (*i)>=0; (*i)-=2){
213 low[(*i)+1] = high[(*i)>>1];
214 low[*
i] = low[(*i)>>1];
220 dst[
i] = src[
i] - ((mul * (ref[
i] + ref[i + 1]) + add) >>
shift);
223 if((width^lift_high)&1){
224 dst[
w] = src[
w] - ((mul * 2 * ref[
w] +
add) >> shift);
230 dst[
i] = src[
i] + ((ref[
i] + ref[(i+1)]+
W_BO + 4 * src[i]) >>
W_BS);
234 dst[
w] = src[
w] + ((2 * ref[
w] +
W_BO + 4 * src[
w]) >>
W_BS);
249 int plane_index,
int w,
int h);
262 (top ->
mx * scale[top ->
ref] + 128) >>8,
263 (tr ->
mx * scale[tr ->
ref] + 128) >>8);
265 (top ->
my * scale[top ->
ref] + 128) >>8,
266 (tr ->
my * scale[tr ->
ref] + 128) >>8);
280 static av_always_inline void add_yblock(
SnowContext *s,
int sliced,
slice_buffer *sb,
IDWTELEM *dst,
uint8_t *dst8,
const uint8_t *obmc,
int src_x,
int src_y,
int b_w,
int b_h,
int w,
int h,
int dst_stride,
int src_stride,
int obmc_stride,
int b_x,
int b_y,
int add,
int offset_dst,
int plane_index){
283 const int b_stride= b_width;
299 }
else if(b_x + 1 >= b_width){
306 }
else if(b_y + 1 >= b_height){
314 if(!sliced && !offset_dst)
322 obmc -= src_y*obmc_stride;
324 if(!sliced && !offset_dst)
325 dst -= src_y*dst_stride;
332 if(b_w<=0 || b_h<=0)
return;
334 if(!sliced && offset_dst)
335 dst += src_x + src_y*dst_stride;
336 dst8+= src_x + src_y*src_stride;
339 ptmp= tmp + 3*tmp_step;
342 ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
349 ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
359 ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
370 ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
373 s->
dwt.
inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
375 for(y=0; y<b_h; y++){
377 const uint8_t *obmc1= obmc + y*obmc_stride;
378 const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
379 const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
381 for(x=0; x<b_w; x++){
382 int v= obmc1[x] * block[3][x + y*src_stride]
383 +obmc2[x] * block[2][x + y*src_stride]
384 +obmc3[x] * block[1][x + y*src_stride]
385 +obmc4[x] * block[0][x + y*src_stride];
392 v += dst[x + y*dst_stride];
394 if(v&(~255)) v= ~(v>>31);
395 dst8[x + y*src_stride] = v;
397 dst[x + y*dst_stride] -= v;
410 int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
411 int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
413 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
424 for(y=block_h*mb_y; y<
FFMIN(
h,block_h*(mb_y+1)); y++){
428 if(v&(~255)) v= ~(v>>31);
429 dst8[x + y*ref_stride]= v;
433 for(y=block_h*mb_y; y<
FFMIN(
h,block_h*(mb_y+1)); y++){
443 for(mb_x=0; mb_x<=mb_w; mb_x++){
445 block_w*mb_x - block_w/2,
446 block_h*mb_y - block_h/2,
449 w, ref_stride, obmc_stride,
451 add, 1, plane_index);
458 for(mb_y=0; mb_y<=mb_h; mb_y++)
462 static inline void set_blocks(
SnowContext *s,
int level,
int x,
int y,
int l,
int cb,
int cr,
int mx,
int my,
int ref,
int type){
465 const int index= (x + y*
w) << rem_depth;
466 const int block_w= 1<<rem_depth;
467 const int block_h= 1<<rem_depth;
480 for(j=0; j<block_h; j++){
481 for(i=0; i<block_w; i++){
496 c->
src[0][
i]= src [
i];
497 c->
ref[0][
i]= ref [
i] + offset[
i];
507 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0 515 const int el=
FFMIN(e, 10);
526 for(i=e-1; i>=el; i--){
527 put_rac(c, state+22+9, (a>>i)&1);
530 put_rac(c, state+22+i, (a>>i)&1);
534 put_rac(c, state+11 + el, v < 0);
554 for(i=e-1; i>=0; i--){
565 int r= log2>=0 ? 1<<log2 : 1;
578 for(i=log2-1; i>=0; i--){
579 put_rac(c, state+31-i, (v>>i)&1);
585 int r= log2>=0 ? 1<<log2 : 1;
590 while(log2<28 &&
get_rac(c, state+4+log2)){
596 for(i=log2-1; i>=0; i--){
623 if(y && prev_xc->
x == 0){
635 if(prev_xc->
x == x + 1)
641 if(x>>1 > parent_xc->
x){
644 if(x>>1 == parent_xc->
x){
649 int context=
av_log2(3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
655 if ((uint16_t)v != v) {
668 if ((uint16_t)v != v) {
680 if(y) max_run=
FFMIN(run, prev_xc->
x - x - 2);
681 else max_run=
FFMIN(run, w-x-1);
683 max_run=
FFMIN(max_run, 2*parent_xc->
x - x - 1);
697 while(parent_xc->
x != parent->
width+1)
700 prev_parent_xc= parent_xc;
702 parent_xc= prev_parent_xc;
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_NUM_DATA_POINTERS
int last_spatial_decomposition_count
static int shift(int a, int b)
This structure describes decoded (raw) audio or video data.
static int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
#define BLOCK_INTRA
Intra block, inter otherwise.
int scenechange_threshold
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static const uint8_t obmc4[16]
static av_always_inline void snow_horizontal_compose_lift_lead_out(int i, IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref, int width, int w, int lift_high, int mul, int add, int shift)
static void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type)
enum AVPictureType last_picture
int ff_snow_common_init_after_header(AVCodecContext *avctx)
int qlog
log(qscale)/log[2^(1/6)]
uint8_t ref
Reference frame index.
static double cb(void *priv, double x, double y)
static int get_symbol2(RangeCoder *c, uint8_t *state, int log2)
The exact code depends on how similar the blocks are and how related they are to the block
int16_t mx
Motion vector component X, see mv_scale.
static int get_rac(RangeCoder *c, uint8_t *const state)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Motion estimation context.
int16_t my
Motion vector component Y, see mv_scale.
static const BlockNode null_block
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
MpegvideoEncDSPContext mpvencdsp
void ff_snow_release_buffer(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
unsigned me_cache_generation
const uint8_t *const ff_obmc_tab[4]
uint8_t * emu_edge_buffer
static float mul(float src0, float src1)
uint8_t color[3]
Color for intra.
const int8_t ff_quant3bA[256]
static void unpack_coeffs(SnowContext *s, SubBand *b, SubBand *parent, int orientation)
static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
int spatial_decomposition_count
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
static av_always_inline void snow_interleave_line_footer(int *i, IDWTELEM *low, IDWTELEM *high)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
void ff_snow_reset_contexts(SnowContext *s)
Describe the class of an AVClass context structure.
int ff_snow_alloc_blocks(SnowContext *s)
static void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index)
DWTELEM * temp_dwt_buffer
int ff_snow_common_init(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int spatial_decomposition_type
AVFrame * current_picture
void ff_snow_common_end(SnowContext *s)
static av_always_inline void snow_interleave_line_header(int *i, int width, IDWTELEM *low, IDWTELEM *high)
#define MAX_DECOMPOSITIONS
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, const BlockNode *block, int plane_index, int w, int h)
GLint GLenum GLboolean GLsizei stride
int temporal_decomposition_type
IDWTELEM * temp_idwt_buffer
static void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
DWTELEM * spatial_dwt_buffer
void(* inner_add_yblock)(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer *sb, int add, uint8_t *dst8)
static void pred_mv(SnowContext *s, int *mx, int *my, int ref, const BlockNode *left, const BlockNode *top, const BlockNode *tr)
IDWTELEM * spatial_idwt_buffer
static const double coeff[2][5]
static float add(float src0, float src1)
uint8_t type
Bitfield of BLOCK_*.
Used to minimize the amount of memory used in order to optimize cache performance.
static double cr(void *priv, double x, double y)
AVFrame * input_picture
new_picture with the internal linesizes
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your local context
int temporal_decomposition_count
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y)
int ff_snow_frame_start(SnowContext *s)
int last_spatial_decomposition_type
static av_always_inline void snow_horizontal_compose_liftS_lead_out(int i, IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref, int width, int w)
int stride_line
Stride measured in lines, not pixels.