lavc/ffv1: move RangeCoder to per-slice context

6 files changed, 87 insertions, 85 deletions

diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 7bc4f1b135..490baac233 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -53,7 +53,7 @@ av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
 }
 
 av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
-                                     FFV1Context *fs, FFV1SliceContext *sc)
+                                     FFV1SliceContext *sc)
 {
     int j, i;
 
@@ -82,8 +82,8 @@ av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
     if (f->ac == AC_RANGE_CUSTOM_TAB) {
         //FIXME only redo if state_transition changed
         for (j = 1; j < 256; j++) {
-            fs->c. one_state[      j] = f->state_transition[j];
-            fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
+            sc->c. one_state[      j] = f->state_transition[j];
+            sc->c.zero_state[256 - j] = 256 - sc->c.one_state[j];
         }
     }
 
@@ -94,8 +94,7 @@ av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
 {
     int i, ret;
     for (i = 0; i < f->max_slice_count; i++) {
-        FFV1Context *fs = f->slice_context[i];
-        if ((ret = ff_ffv1_init_slice_state(f, fs, &f->slices[i])) < 0)
+        if ((ret = ff_ffv1_init_slice_state(f, &f->slices[i])) < 0)
             return AVERROR(ENOMEM);
     }
     return 0;
diff --git a/libavcodec/ffv1.h b/libavcodec/ffv1.h
index 68e59b300b..01c35dc942 100644
--- a/libavcodec/ffv1.h
+++ b/libavcodec/ffv1.h
@@ -83,12 +83,12 @@ typedef struct FFV1SliceContext {
 
     PlaneContext plane[MAX_PLANES];
     PutBitContext pb;
+    RangeCoder c;
 } FFV1SliceContext;
 
 typedef struct FFV1Context {
     AVClass *class;
     AVCodecContext *avctx;
-    RangeCoder c;
     uint64_t rc_stat[256][2];
     uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
     int version;
@@ -138,8 +138,7 @@ typedef struct FFV1Context {
 } FFV1Context;
 
 int ff_ffv1_common_init(AVCodecContext *avctx);
-int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs,
-                             FFV1SliceContext *sc);
+int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1SliceContext *sc);
 int ff_ffv1_init_slices_state(FFV1Context *f);
 int ff_ffv1_init_slice_contexts(FFV1Context *f);
 int ff_ffv1_allocate_initial_states(FFV1Context *f);
diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c
index c46edbf940..187359c9c6 100644
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -168,7 +168,7 @@ static int decode_plane(FFV1Context *f,
 static int decode_slice_header(const FFV1Context *f, FFV1Context *fs,
                                FFV1SliceContext *sc, AVFrame *frame)
 {
-    RangeCoder *c = &fs->c;
+    RangeCoder *c = &sc->c;
     uint8_t state[CONTEXT_SIZE];
     unsigned ps, context_count;
     int sx, sy, sw, sh;
@@ -299,7 +299,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
     sc->slice_rct_ry_coef = 1;
 
     if (f->version > 2) {
-        if (ff_ffv1_init_slice_state(f, fs, sc) < 0)
+        if (ff_ffv1_init_slice_state(f, sc) < 0)
             return AVERROR(ENOMEM);
         if (decode_slice_header(f, fs, sc, p) < 0) {
             sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
@@ -307,7 +307,7 @@ static int decode_slice(AVCodecContext *c, void *arg)
             return AVERROR_INVALIDDATA;
         }
     }
-    if ((ret = ff_ffv1_init_slice_state(f, fs, sc)) < 0)
+    if ((ret = ff_ffv1_init_slice_state(f, sc)) < 0)
         return ret;
     if ((p->flags & AV_FRAME_FLAG_KEY) || fs->slice_reset_contexts) {
         ff_ffv1_clear_slice_state(f, sc);
@@ -322,11 +322,11 @@ static int decode_slice(AVCodecContext *c, void *arg)
 
     if (f->ac == AC_GOLOMB_RICE) {
         if (f->version == 3 && f->micro_version > 1 || f->version > 3)
-            get_rac(&fs->c, (uint8_t[]) { 129 });
-        fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
+            get_rac(&sc->c, (uint8_t[]) { 129 });
+        fs->ac_byte_count = f->version > 2 || (!x && !y) ? sc->c.bytestream - sc->c.bytestream_start - 1 : 0;
         init_get_bits(&gb,
-                      fs->c.bytestream_start + fs->ac_byte_count,
-                      (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
+                      sc->c.bytestream_start + fs->ac_byte_count,
+                      (sc->c.bytestream_end - sc->c.bytestream_start - fs->ac_byte_count) * 8);
     }
 
     av_assert1(width && height);
@@ -361,8 +361,8 @@ static int decode_slice(AVCodecContext *c, void *arg)
     }
     if (f->ac != AC_GOLOMB_RICE && f->version > 2) {
         int v;
-        get_rac(&fs->c, (uint8_t[]) { 129 });
-        v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec;
+        get_rac(&sc->c, (uint8_t[]) { 129 });
+        v = sc->c.bytestream_end - sc->c.bytestream - 2 - 5*f->ec;
         if (v) {
             av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
             fs->slice_damaged = 1;
@@ -421,7 +421,7 @@ static int read_quant_tables(RangeCoder *c,
 
 static int read_extra_header(FFV1Context *f)
 {
-    RangeCoder *const c = &f->c;
+    RangeCoder c;
     uint8_t state[CONTEXT_SIZE];
     int ret;
     uint8_t state2[32][CONTEXT_SIZE];
@@ -430,10 +430,10 @@ static int read_extra_header(FFV1Context *f)
     memset(state2, 128, sizeof(state2));
     memset(state, 128, sizeof(state));
 
-    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
-    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
+    ff_init_range_decoder(&c, f->avctx->extradata, f->avctx->extradata_size);
+    ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 
-    f->version = get_symbol(c, state, 0);
+    f->version = get_symbol(&c, state, 0);
     if (f->version < 2) {
         av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
         return AVERROR_INVALIDDATA;
@@ -444,27 +444,27 @@ static int read_extra_header(FFV1Context *f)
         return AVERROR_PATCHWELCOME;
     }
     if (f->version > 2) {
-        c->bytestream_end -= 4;
-        f->micro_version = get_symbol(c, state, 0);
+        c.bytestream_end -= 4;
+        f->micro_version = get_symbol(&c, state, 0);
         if (f->micro_version < 0)
             return AVERROR_INVALIDDATA;
     }
-    f->ac = get_symbol(c, state, 0);
+    f->ac = get_symbol(&c, state, 0);
 
     if (f->ac == AC_RANGE_CUSTOM_TAB) {
         for (int i = 1; i < 256; i++)
-            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
+            f->state_transition[i] = get_symbol(&c, state, 1) + c.one_state[i];
     }
 
-    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
-    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
-    f->chroma_planes              = get_rac(c, state);
-    f->chroma_h_shift             = get_symbol(c, state, 0);
-    f->chroma_v_shift             = get_symbol(c, state, 0);
-    f->transparency               = get_rac(c, state);
+    f->colorspace                 = get_symbol(&c, state, 0); //YUV cs type
+    f->avctx->bits_per_raw_sample = get_symbol(&c, state, 0);
+    f->chroma_planes              = get_rac(&c, state);
+    f->chroma_h_shift             = get_symbol(&c, state, 0);
+    f->chroma_v_shift             = get_symbol(&c, state, 0);
+    f->transparency               = get_rac(&c, state);
     f->plane_count                = 1 + (f->chroma_planes || f->version<4) + f->transparency;
-    f->num_h_slices               = 1 + get_symbol(c, state, 0);
-    f->num_v_slices               = 1 + get_symbol(c, state, 0);
+    f->num_h_slices               = 1 + get_symbol(&c, state, 0);
+    f->num_v_slices               = 1 + get_symbol(&c, state, 0);
 
     if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
         av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
@@ -484,7 +484,7 @@ static int read_extra_header(FFV1Context *f)
         return AVERROR_PATCHWELCOME;
     }
 
-    f->quant_table_count = get_symbol(c, state, 0);
+    f->quant_table_count = get_symbol(&c, state, 0);
     if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
         av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
         f->quant_table_count = 0;
@@ -492,7 +492,7 @@ static int read_extra_header(FFV1Context *f)
     }
 
     for (int i = 0; i < f->quant_table_count; i++) {
-        f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
+        f->context_count[i] = read_quant_tables(&c, f->quant_tables[i]);
         if (f->context_count[i] < 0) {
             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
             return AVERROR_INVALIDDATA;
@@ -502,19 +502,19 @@ static int read_extra_header(FFV1Context *f)
         return ret;
 
     for (int i = 0; i < f->quant_table_count; i++)
-        if (get_rac(c, state)) {
+        if (get_rac(&c, state)) {
             for (int j = 0; j < f->context_count[i]; j++)
                 for (int k = 0; k < CONTEXT_SIZE; k++) {
                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
                     f->initial_states[i][j][k] =
-                        (pred + get_symbol(c, state2[k], 1)) & 0xFF;
+                        (pred + get_symbol(&c, state2[k], 1)) & 0xFF;
                 }
         }
 
     if (f->version > 2) {
-        f->ec = get_symbol(c, state, 0);
+        f->ec = get_symbol(&c, state, 0);
         if (f->micro_version > 2)
-            f->intra = get_symbol(c, state, 0);
+            f->intra = get_symbol(&c, state, 0);
     }
 
     if (f->version > 2) {
@@ -550,7 +550,7 @@ static int read_header(FFV1Context *f)
 {
     uint8_t state[CONTEXT_SIZE];
     int context_count = -1; //-1 to avoid warning
-    RangeCoder *const c = &f->slice_context[0]->c;
+    RangeCoder *const c = &f->slices[0].c;
 
     memset(state, 128, sizeof(state));
 
@@ -868,7 +868,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
     uint8_t *buf        = avpkt->data;
     int buf_size        = avpkt->size;
     FFV1Context *f      = avctx->priv_data;
-    RangeCoder *const c = &f->slice_context[0]->c;
+    RangeCoder *const c = &f->slices[0].c;
     int ret, key_frame;
     uint8_t keystate = 128;
     uint8_t *buf_p;
@@ -939,6 +939,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
     buf_p = buf + buf_size;
     for (int i = f->slice_count - 1; i >= 0; i--) {
         FFV1Context *fs = f->slice_context[i];
+        FFV1SliceContext *sc = &f->slices[i];
         int trailer = 3 + 5*!!f->ec;
         int v;
 
@@ -973,9 +974,10 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
         }
 
         if (i) {
-            ff_init_range_decoder(&fs->c, buf_p, v);
+            ff_init_range_decoder(&sc->c, buf_p, v);
+            ff_build_rac_states(&sc->c, 0.05 * (1LL << 32), 256 - 8);
         } else
-            fs->c.bytestream_end = buf_p + v;
+            sc->c.bytestream_end = buf_p + v;
 
         fs->avctx = avctx;
     }
diff --git a/libavcodec/ffv1dec_template.c b/libavcodec/ffv1dec_template.c
index df25d6889e..9790fd7149 100644
--- a/libavcodec/ffv1dec_template.c
+++ b/libavcodec/ffv1dec_template.c
@@ -30,7 +30,7 @@ RENAME(decode_line)(FFV1Context *f,
                     int ac)
 {
     PlaneContext *const p = &sc->plane[plane_index];
-    RangeCoder *const c   = &s->c;
+    RangeCoder *const c   = &sc->c;
     const int16_t (*quant_table)[256] = f->quant_tables[p->quant_table_index];
     int x;
     int run_count = 0;
diff --git a/libavcodec/ffv1enc.c b/libavcodec/ffv1enc.c
index 80ad641b92..6790366149 100644
--- a/libavcodec/ffv1enc.c
+++ b/libavcodec/ffv1enc.c
@@ -349,7 +349,7 @@ static void write_header(FFV1Context *f)
 {
     uint8_t state[CONTEXT_SIZE];
     int i, j;
-    RangeCoder *const c = &f->slice_context[0]->c;
+    RangeCoder *const c = &f->slices[0].c;
 
     memset(state, 128, sizeof(state));
 
@@ -394,7 +394,7 @@ static void write_header(FFV1Context *f)
 
 static int write_extradata(FFV1Context *f)
 {
-    RangeCoder *const c = &f->c;
+    RangeCoder c;
     uint8_t state[CONTEXT_SIZE];
     int i, j, k;
     uint8_t state2[32][CONTEXT_SIZE];
@@ -408,56 +408,56 @@ static int write_extradata(FFV1Context *f)
     f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!f->avctx->extradata)
         return AVERROR(ENOMEM);
-    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
-    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
+    ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
+    ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 
-    put_symbol(c, state, f->version, 0);
+    put_symbol(&c, state, f->version, 0);
     if (f->version > 2) {
         if (f->version == 3) {
             f->micro_version = 4;
         } else if (f->version == 4)
             f->micro_version = 2;
-        put_symbol(c, state, f->micro_version, 0);
+        put_symbol(&c, state, f->micro_version, 0);
     }
 
-    put_symbol(c, state, f->ac, 0);
+    put_symbol(&c, state, f->ac, 0);
     if (f->ac == AC_RANGE_CUSTOM_TAB)
         for (i = 1; i < 256; i++)
-            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
-
-    put_symbol(c, state, f->colorspace, 0); // YUV cs type
-    put_symbol(c, state, f->bits_per_raw_sample, 0);
-    put_rac(c, state, f->chroma_planes);
-    put_symbol(c, state, f->chroma_h_shift, 0);
-    put_symbol(c, state, f->chroma_v_shift, 0);
-    put_rac(c, state, f->transparency);
-    put_symbol(c, state, f->num_h_slices - 1, 0);
-    put_symbol(c, state, f->num_v_slices - 1, 0);
-
-    put_symbol(c, state, f->quant_table_count, 0);
+            put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
+
+    put_symbol(&c, state, f->colorspace, 0); // YUV cs type
+    put_symbol(&c, state, f->bits_per_raw_sample, 0);
+    put_rac(&c, state, f->chroma_planes);
+    put_symbol(&c, state, f->chroma_h_shift, 0);
+    put_symbol(&c, state, f->chroma_v_shift, 0);
+    put_rac(&c, state, f->transparency);
+    put_symbol(&c, state, f->num_h_slices - 1, 0);
+    put_symbol(&c, state, f->num_v_slices - 1, 0);
+
+    put_symbol(&c, state, f->quant_table_count, 0);
     for (i = 0; i < f->quant_table_count; i++)
-        write_quant_tables(c, f->quant_tables[i]);
+        write_quant_tables(&c, f->quant_tables[i]);
 
     for (i = 0; i < f->quant_table_count; i++) {
         if (contains_non_128(f->initial_states[i], f->context_count[i])) {
-            put_rac(c, state, 1);
+            put_rac(&c, state, 1);
             for (j = 0; j < f->context_count[i]; j++)
                 for (k = 0; k < CONTEXT_SIZE; k++) {
                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
-                    put_symbol(c, state2[k],
+                    put_symbol(&c, state2[k],
                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
                 }
         } else {
-            put_rac(c, state, 0);
+            put_rac(&c, state, 0);
         }
     }
 
     if (f->version > 2) {
-        put_symbol(c, state, f->ec, 0);
-        put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
+        put_symbol(&c, state, f->ec, 0);
+        put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
     }
 
-    f->avctx->extradata_size = ff_rac_terminate(c, 0);
+    f->avctx->extradata_size = ff_rac_terminate(&c, 0);
     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
     f->avctx->extradata_size += 4;
@@ -883,6 +883,8 @@ slices_ok:
             p->quant_table_index = s->context_model;
             p->context_count     = s->context_count[p->quant_table_index];
         }
+
+        ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
     }
 
     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
@@ -910,7 +912,7 @@ slices_ok:
 static void encode_slice_header(FFV1Context *f, FFV1Context *fs,
                                 FFV1SliceContext *sc)
 {
-    RangeCoder *c = &fs->c;
+    RangeCoder *c = &sc->c;
     uint8_t state[CONTEXT_SIZE];
     int j;
     memset(state, 128, sizeof(state));
@@ -1037,7 +1039,7 @@ static int encode_slice(AVCodecContext *c, void *arg)
     const AVFrame *const p = f->cur_enc_frame;
     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
     int ret;
-    RangeCoder c_bak = fs->c;
+    RangeCoder c_bak = sc->c;
     const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
@@ -1058,10 +1060,10 @@ retry:
         encode_slice_header(f, fs, sc);
     }
     if (f->ac == AC_GOLOMB_RICE) {
-        fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
+        fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
         init_put_bits(&sc->pb,
-                      fs->c.bytestream_start + fs->ac_byte_count,
-                      fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
+                      sc->c.bytestream_start + fs->ac_byte_count,
+                      sc->c.bytestream_end - sc->c.bytestream_start - fs->ac_byte_count);
     }
 
     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
@@ -1095,7 +1097,7 @@ retry:
         }
         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
         sc->slice_coding_mode = 1;
-        fs->c = c_bak;
+        sc->c = c_bak;
         goto retry;
     }
 
@@ -1106,7 +1108,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                         const AVFrame *pict, int *got_packet)
 {
     FFV1Context *f      = avctx->priv_data;
-    RangeCoder *const c = &f->slice_context[0]->c;
+    RangeCoder *const c = &f->slices[0].c;
     uint8_t keystate    = 128;
     uint8_t *buf_p;
     int i, ret;
@@ -1194,15 +1196,15 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     }
 
     for (i = 0; i < f->slice_count; i++) {
-        FFV1Context *fs = f->slice_context[i];
+        FFV1SliceContext *sc = &f->slices[i];
         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
         int len         = pkt->size / f->slice_count;
         if (i) {
-            ff_init_range_encoder(&fs->c, start, len);
+            ff_init_range_encoder(&sc->c, start, len);
         } else {
-            av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
-            av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
-            fs->c.bytestream_end = fs->c.bytestream_start + len;
+            av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
+            av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
+            sc->c.bytestream_end = sc->c.bytestream_start + len;
         }
     }
     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
@@ -1215,14 +1217,14 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         int bytes;
 
         if (f->ac != AC_GOLOMB_RICE) {
-            bytes = ff_rac_terminate(&fs->c, 1);
+            bytes = ff_rac_terminate(&sc->c, 1);
         } else {
             flush_put_bits(&sc->pb); // FIXME: nicer padding
             bytes = fs->ac_byte_count + put_bytes_output(&sc->pb);
         }
         if (i > 0 || f->version > 2) {
             av_assert0(bytes < pkt->size / f->slice_count);
-            memmove(buf_p, fs->c.bytestream_start, bytes);
+            memmove(buf_p, sc->c.bytestream_start, bytes);
             av_assert0(bytes < (1 << 24));
             AV_WB24(buf_p + bytes, bytes);
             bytes += 3;
diff --git a/libavcodec/ffv1enc_template.c b/libavcodec/ffv1enc_template.c
index d5fcaf0f00..1339b2bd4c 100644
--- a/libavcodec/ffv1enc_template.c
+++ b/libavcodec/ffv1enc_template.c
@@ -29,7 +29,7 @@ RENAME(encode_line)(FFV1Context *f,
                     int ac)
 {
     PlaneContext *const p = &sc->plane[plane_index];
-    RangeCoder *const c   = &s->c;
+    RangeCoder *const c   = &sc->c;
     int x;
     int run_index = sc->run_index;
     int run_count = 0;