[xiph-commits] r15106 - branches/theora-thusnelda/lib/enc

xiphmont at svn.xiph.org xiphmont at svn.xiph.org
Wed Jul 9 13:42:39 PDT 2008


Author: xiphmont
Date: 2008-07-09 13:42:37 -0700 (Wed, 09 Jul 2008)
New Revision: 15106

Modified:
   branches/theora-thusnelda/lib/enc/codec_internal.h
   branches/theora-thusnelda/lib/enc/dct_encode.c
   branches/theora-thusnelda/lib/enc/mode.c
Log:
Add a first cut of [only partially tested] tokenization rollback



Modified: branches/theora-thusnelda/lib/enc/codec_internal.h
===================================================================
--- branches/theora-thusnelda/lib/enc/codec_internal.h	2008-07-09 08:23:30 UTC (rev 15105)
+++ branches/theora-thusnelda/lib/enc/codec_internal.h	2008-07-09 20:42:37 UTC (rev 15106)
@@ -315,10 +315,18 @@
 
 extern void fdct_short ( ogg_int16_t *InputData, ogg_int16_t *OutputData );
 
+typedef struct {
+  int coeff;
+  int count; /* -1 indicates no token, ie, midst of an EOB run */
+  int chroma;
+  int pre;
+  int run;
+} token_checkpoint_t;
+
 extern void dct_tokenize_init (CP_INSTANCE *cpi);
-extern void dct_tokenize_AC (CP_INSTANCE *cpi, int fi, ogg_int16_t *dct, int chroma);
+extern void dct_tokenize_AC (CP_INSTANCE *cpi, int fi, ogg_int16_t *dct, int chroma, token_checkpoint_t **stack);
 extern void dct_tokenize_finish (CP_INSTANCE *cpi);
-extern void dct_tokenize_ac_chroma (CP_INSTANCE *cpi);
+extern void dct_tokenize_mark_ac_chroma (CP_INSTANCE *cpi);
 
 extern void WriteQTables(CP_INSTANCE *cpi,oggpack_buffer *opb);
 extern void InitQTables( CP_INSTANCE *cpi );

Modified: branches/theora-thusnelda/lib/enc/dct_encode.c
===================================================================
--- branches/theora-thusnelda/lib/enc/dct_encode.c	2008-07-09 08:23:30 UTC (rev 15105)
+++ branches/theora-thusnelda/lib/enc/dct_encode.c	2008-07-09 20:42:37 UTC (rev 15106)
@@ -30,53 +30,17 @@
   64,64,64,64,64,64,64,64,
   64,64,64,64,64,64,64,64};
 
-typedef struct {
-  int coeff;
-  int count;
-  int chroma;
-  int pre;
-  int run;
-} token_checkpoint_t;
-
-void tokenize_rollback(CP_INSTANCE *cpi, token_checkpoint_t *stack,int n){
+void tokenlog_rollback(CP_INSTANCE *cpi, token_checkpoint_t *stack,int n){
   int i;
   for(i=n-1;i>=0;i--){
     int coeff = stack[i].coeff;
-    cpi->dct_token_count[coeff] = stack[i].count; 
+    if(stack[i].count>=0) cpi->dct_token_count[coeff] = stack[i].count; 
     cpi->eob_run[coeff] = stack[i].run;
     cpi->eob_pre[coeff] = stack[i].pre;
   }
 }
 
-void tokenize_commit(CP_INSTANCE *cpi, token_checkpoint_t *stack, int n){
-  int i;
-  for(i=0;i<n;i++){
-    int coeff = stack[i].coeff;
-    int pos = stack[i].count;
-    int token = cpi->dct_token[coeff][pos];
-    int chroma = stack[i].chroma;
-
-    if (coeff == 1){
-      /* AC == 1*/
-    int i,offset = acoffset[1];
-    for ( i = 0; i < AC_HUFF_CHOICES; i++)
-      cpi->ac1_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[offset+i][token];
-    }else{
-      /* AC > 1*/
-      int i,offset = acoffset[coeff];
-      for ( i = 0; i < AC_HUFF_CHOICES; i++)
-	cpi->acN_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[offset+i][token];
-    }
-  }
-}
-
-static void add_token(CP_INSTANCE *cpi, int chroma, int coeff, 
-		      unsigned char token, ogg_uint16_t eb){
-  cpi->dct_token[coeff][cpi->dct_token_count[coeff]] = token;
-  cpi->dct_token_eb[coeff][cpi->dct_token_count[coeff]] = eb;
-  cpi->dct_token_count[coeff]++;
-
-  /* coeff 0 (DC) is always undconditionally/immediately committed */
+static void tokenlog_metrics(CP_INSTANCE *cpi, int coeff, int chroma, int token){
   if(coeff == 0){
     /* DC */
     int i;
@@ -93,12 +57,51 @@
     for ( i = 0; i < AC_HUFF_CHOICES; i++)
       cpi->acN_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[offset+i][token];
   }
+}
 
+void tokenlog_commit(CP_INSTANCE *cpi, token_checkpoint_t *stack, int n){
+  int i;
+  for(i=0;i<n;i++){
+    int pos = stack[i].count;
+    if(pos>=0){
+      int coeff = stack[i].coeff;
+      int token = cpi->dct_token[coeff][pos];
+      int chroma = stack[i].chroma;
+      tokenlog_metrics(cpi,coeff,chroma,token);
+    }
+  }
 }
 
-static void prepend_token(CP_INSTANCE *cpi, int chroma, int coeff, 
+static void tokenlog_mark(CP_INSTANCE *cpi, int coeff, token_checkpoint_t **stack){
+  (*stack)->coeff = coeff;
+  (*stack)->count = -1;
+  (*stack)->run = cpi->eob_run[coeff];
+  (*stack)->pre = cpi->eob_pre[coeff];
+  (*stack)++;
+}
+
+static void token_add(CP_INSTANCE *cpi, int chroma, int coeff, 
+			 unsigned char token, ogg_uint16_t eb,
+			 token_checkpoint_t **stack){
+  int pos = cpi->dct_token_count[coeff]++;
+  cpi->dct_token[coeff][pos] = token;
+  cpi->dct_token_eb[coeff][pos] = eb;
+  if(stack){
+    (*stack)->coeff = coeff;
+    (*stack)->count = pos;
+    (*stack)->chroma = chroma;
+    (*stack)->run = cpi->eob_run[coeff];
+    (*stack)->pre = cpi->eob_pre[coeff];
+    (*stack)++;
+  }else{
+    tokenlog_metrics(cpi,coeff,chroma,token);
+  }
+}
+
+/* does not offer logging option; only used in nonconditional EOBrun welding */
+static void token_prepend(CP_INSTANCE *cpi, int chroma, int coeff, 
 			  unsigned char token, ogg_uint16_t eb){
-
+  
   cpi->dct_token[coeff]--;
   cpi->dct_token_eb[coeff]--;
 #ifdef COLLECT_METRICS
@@ -107,26 +110,10 @@
   cpi->dct_token[coeff][0] = token;
   cpi->dct_token_eb[coeff][0] = eb;
   cpi->dct_token_count[coeff]++;
-
-  if(coeff == 0){
-    /* DC */
-    int i;
-    for ( i = 0; i < DC_HUFF_CHOICES; i++)
-      cpi->dc_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[i][token];
-  }else if (coeff == 1){
-    /* AC == 1*/
-    int i,offset = acoffset[1];
-    for ( i = 0; i < AC_HUFF_CHOICES; i++)
-      cpi->ac1_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[offset+i][token];
-  }else{
-    /* AC > 1*/
-    int i,offset = acoffset[coeff];
-    for ( i = 0; i < AC_HUFF_CHOICES; i++)
-      cpi->acN_bits[chroma][i] += cpi->HuffCodeLengthArray_VP3x[offset+i][token];
-  }
+  tokenlog_metrics(cpi,coeff,chroma,token);
 }
 
-static void tokenize_eob_run(int run, int *token, int *eb){
+static void make_eobrun_token(int run, int *token, int *eb){
   if ( run <= 3 ) {
     if ( run == 1 ) {
       *token = DCT_EOB_TOKEN;
@@ -155,62 +142,52 @@
   }
 }
 
-static void add_eob_run(CP_INSTANCE *cpi, int pos, int run){
+static void tokenize_eobrun(CP_INSTANCE *cpi, int pos, int run, token_checkpoint_t **stack){
   int token=0,eb=0;
   int chroma = !(run&0x8000);
-  tokenize_eob_run(run&0x7fff, &token, &eb);
-  add_token(cpi, chroma, pos, token, eb);
+  make_eobrun_token(run&0x7fff, &token, &eb);
+  token_add(cpi, chroma, pos, token, eb, stack);
 }
 
-static void prepend_eob_run(CP_INSTANCE *cpi, int chroma, int pos, int run){
+
+static void tokenize_prepend_eobrun(CP_INSTANCE *cpi, int chroma, int pos, int run){
   int token=0,eb=0;
-  tokenize_eob_run(run, &token, &eb);
-  prepend_token(cpi, chroma, pos, token, eb);
+  make_eobrun_token(run, &token, &eb);
+  token_prepend(cpi, chroma, pos, token, eb);
 }
 
-static void emit_raw(CP_INSTANCE *cpi, 
-		     int chroma,
-		     int fi,
-		     int coeff,
-		     int token,
-		     int eb){
+/* only used in nonconditional DC/stack1 fixups */
+static void token_add_raw(CP_INSTANCE *cpi, 
+			  int chroma,
+			  int fi,
+			  int coeff,
+			  int token,
+			  int eb){
   
   /* Emit pending EOB run if any */
   if(cpi->eob_run[coeff]){
-    add_eob_run(cpi,coeff,cpi->eob_run[coeff]);
+    tokenize_eobrun(cpi,coeff,cpi->eob_run[coeff],NULL);
     cpi->eob_run[coeff]=0;
   }
 #ifdef COLLECT_METRICS
   cpi->dct_token_frag[coeff][cpi->dct_token_count[coeff]] = fi;
 #endif
-  add_token(cpi,chroma,coeff,token,eb);
-
+  token_add(cpi,chroma,coeff,token,eb,NULL);
+  
 }
 
-static int emit_token(CP_INSTANCE *cpi, 
-		      int chroma,
-		      int fi,
-		      int coeff,
-		      int coeff2,
-		      int val){
+static int make_dct_token(CP_INSTANCE *cpi, 
+			  int coeff,
+			  int coeff2,
+			  int val,
+			  int *eb){
   
-  
   ogg_uint32_t absval = abs(val);
   int neg = (val<0);
   int zero_run = coeff2-coeff;
-  int ret = 1;
   int token;
-  int eb=0;
+  *eb=0;
 
-  /* Emit pending EOB run if any */
-  if(cpi->eob_run[coeff]){
-    add_eob_run(cpi,coeff,cpi->eob_run[coeff]);
-    cpi->eob_run[coeff]=0;
-  }
-#ifdef COLLECT_METRICS
-  cpi->dct_token_frag[coeff][cpi->dct_token_count[coeff]] = fi;
-#endif
-
   if (zero_run){
     int adj = (coeff!=1); /* implement a minor restriction on
 			     stack 1 so that we know during DC
@@ -219,29 +196,28 @@
     if ((absval==1) && (zero_run<17+adj)){
       if ( zero_run <= 5 ) {
 	token = DCT_RUN_CATEGORY1+zero_run-1; 
-	eb    = neg;
+	*eb   = neg;
       }else if ( zero_run <= 9 ) {
 	token = DCT_RUN_CATEGORY1B; 
-	eb    = zero_run-6+(neg<<2);
+	*eb   = zero_run-6+(neg<<2);
       }else{
 	token = DCT_RUN_CATEGORY1C;
-	eb    = zero_run-10+(neg<<3);
+	*eb   = zero_run-10+(neg<<3);
       }
     }else if((absval==2 || absval==3) && (zero_run < 3+adj)){
       if ( zero_run == 1 ) {
 	token = DCT_RUN_CATEGORY2;
-	eb    = absval-2+(neg<<1);
+	*eb   = absval-2+(neg<<1);
       }else{
 	token = DCT_RUN_CATEGORY2B;
-	eb    = (neg<<2)+((absval-2)<<1)+zero_run-2;
+	*eb   = (neg<<2)+((absval-2)<<1)+zero_run-2;
       }
     }else{
       if ( zero_run <= 8 )
 	token = DCT_SHORT_ZRL_TOKEN;
       else
 	token = DCT_ZRL_TOKEN;
-      eb = zero_run-1;
-      if(val) ret=0;
+      *eb = zero_run-1;
     }
   } else if ( absval == 1 ){
     token = (neg ? MINUS_ONE_TOKEN : ONE_TOKEN);
@@ -249,47 +225,75 @@
     token = (neg ? MINUS_TWO_TOKEN : TWO_TOKEN);
   } else if ( absval <= MAX_SINGLE_TOKEN_VALUE ) {
     token = LOW_VAL_TOKENS + (absval - DCT_VAL_CAT2_MIN);
-    eb    = neg;
+    *eb   = neg;
   } else if ( absval <= 8 ) {
     token = DCT_VAL_CATEGORY3;
-    eb    = (absval - DCT_VAL_CAT3_MIN) + (neg << 1);
+    *eb   = (absval - DCT_VAL_CAT3_MIN) + (neg << 1);
   } else if ( absval <= 12 ) {
     token = DCT_VAL_CATEGORY4;
-    eb    = (absval - DCT_VAL_CAT4_MIN) + (neg << 2);
+    *eb   = (absval - DCT_VAL_CAT4_MIN) + (neg << 2);
   } else if ( absval <= 20 ) {
     token = DCT_VAL_CATEGORY5;
-    eb    = (absval - DCT_VAL_CAT5_MIN) + (neg << 3);
+    *eb   = (absval - DCT_VAL_CAT5_MIN) + (neg << 3);
   } else if ( absval <= 36 ) {
     token = DCT_VAL_CATEGORY6;
-    eb    = (absval - DCT_VAL_CAT6_MIN) + (neg << 4);
+    *eb   = (absval - DCT_VAL_CAT6_MIN) + (neg << 4);
   } else if ( absval <= 68 ) {
     token = DCT_VAL_CATEGORY7;
-    eb    = (absval - DCT_VAL_CAT7_MIN) + (neg << 5);
+    *eb   = (absval - DCT_VAL_CAT7_MIN) + (neg << 5);
   } else {
     token = DCT_VAL_CATEGORY8;
-    eb    = (absval - DCT_VAL_CAT8_MIN) + (neg << 9);
+    *eb   = (absval - DCT_VAL_CAT8_MIN) + (neg << 9);
   } 
 
-  add_token(cpi,chroma,coeff,token,eb);
+  return token;
+}
 
-  return ret;
+/* NULL stack to force commit */
+static int tokenize_dctval(CP_INSTANCE *cpi, 
+			   int chroma,
+			   int fi,
+			   int coeff,
+			   int coeff2,
+			   int val,
+			   token_checkpoint_t **stack){
+  int eb=0;
+  int token=make_dct_token(cpi,coeff,coeff2,val,&eb);
+  
+  /* Emit pending EOB run if any */
+  if(cpi->eob_run[coeff]){
+    tokenize_eobrun(cpi,coeff,cpi->eob_run[coeff],stack);
+    cpi->eob_run[coeff]=0;
+  }
+#ifdef COLLECT_METRICS
+  cpi->dct_token_frag[coeff][cpi->dct_token_count[coeff]] = fi;
+#endif
+  
+  token_add(cpi,chroma,coeff,token,eb,stack);
+  
+  if( ((token==DCT_SHORT_ZRL_TOKEN) || (token==DCT_ZRL_TOKEN)) && val)
+    return 0; /* we only flushed a preceeding zero run, not the value token. */
+  
+  return 1;
 }
 
-static void increment_run(CP_INSTANCE *cpi, 
-			  int chroma,
-			  int fi,
-			  int pre,
-			  int coeff){
-
+static void tokenize_mark_run(CP_INSTANCE *cpi, 
+			      int chroma,
+			      int fi,
+			      int pre,
+			      int coeff,
+			      token_checkpoint_t **stack){
+  
   if(pre && cpi->dct_token_count[coeff] == 0){
-    /* track pre-run */
+    if(stack)tokenlog_mark(cpi,coeff,stack); /* log an undo without logging a token */
     cpi->eob_pre[coeff]++;
   }else{
     if((cpi->eob_run[coeff]&0x7fff) == 4095){
-      add_eob_run(cpi,coeff,cpi->eob_run[coeff]);
+      tokenize_eobrun(cpi,coeff,cpi->eob_run[coeff],stack);
       cpi->eob_run[coeff] = 0;
     }
     
+    if(stack)tokenlog_mark(cpi,coeff,stack); /* log an undo without logging a token */
     cpi->eob_run[coeff]++;
     cpi->eob_run[coeff]|= !chroma<<15;
   }	  
@@ -298,8 +302,6 @@
 #endif
 }
 
-
-
 static int decode_eob_token(int token, int eb){
   switch(token){
   case DCT_EOB_TOKEN:
@@ -393,7 +395,7 @@
    not a true assumption but it can be fixed-up as DC is tokenized
    later */
 
-void dct_tokenize_AC(CP_INSTANCE *cpi, int fi, ogg_int16_t *dct, int chroma){
+void dct_tokenize_AC(CP_INSTANCE *cpi, int fi, ogg_int16_t *dct, int chroma, token_checkpoint_t **stack){
   int coeff = 1; /* skip DC for now */
   while(coeff < BLOCK_SIZE){
     ogg_int16_t val = dct[coeff];
@@ -406,11 +408,11 @@
       
       /* if there are no other tokens in this group yet, set up to be
 	 prepended later.  */
-      increment_run(cpi,chroma,fi,coeff>1,coeff);
+      tokenize_mark_run(cpi,chroma,fi,coeff>1,coeff,stack);
       coeff = BLOCK_SIZE;
     }else{
       
-      coeff = i+emit_token(cpi, chroma, fi, coeff, i, val);
+      coeff = tokenize_dctval(cpi, chroma, fi, coeff, i, val, stack) + i;
     }
   }
 }
@@ -418,39 +420,38 @@
 /* called after AC tokenization is complete, because DC coding has to
    happen after DC predict, which has to happen after the
    Hilbert-ordered TQT loop */
-/* Convention: All EOB runs in the coeff1 stack are regenerated as the
-   runs are tracked.  Other tokens are adjusted in-place (potentially
-   replaced with NOOP tokens.  The size of the coeff 1 stack is not
-   altered */
+/* Convention: All tokens and runs in the coeff1 stack are
+   'regenerated' as the stack is tracked. This can be done in-place;
+   stack 1 can only shrink or stay the same size */
 static void tokenize_DC(CP_INSTANCE *cpi, int fi, int chroma,
 			int *idx1, int *run1){
   
   unsigned char *cp=cpi->frag_coded;
-
+  
   if ( cp[fi] ) {
     int val = cpi->frag_dc[fi];
     int token1 = cpi->dct_token[1][*idx1];
     int eb1 = cpi->dct_token_eb[1][*idx1];
-
+    
     if(!*run1) *run1 = decode_eob_token(token1, eb1);
-
+    
     if(val){
       /* nonzero DC val, no coeff 1 stack 'fixup'. */
+      
+      tokenize_dctval(cpi,chroma,fi,0,0,val,NULL);
 
-      emit_token(cpi,chroma,fi,0,0,val);
-
       /* there was a nonzero DC value, so there's no alteration to the
 	 track1 stack for this fragment; track/regenerate stack 1
 	 state unchanged */
       if(*run1){
 	/* in the midst of an EOB run in stack 1 */
-	increment_run(cpi,chroma,fi,1,1);
+	tokenize_mark_run(cpi,chroma,fi,1,1,NULL);
 	(*run1)--;
 
       }else{
 
 	/* non-EOB run token to emit for stack 1 */
-	emit_raw(cpi,chroma,fi,1,token1,eb1);
+	token_add_raw(cpi,chroma,fi,1,token1,eb1);
 
       }
 
@@ -463,7 +464,7 @@
       if(*run1){
 
 	/* current stack 1 token an EOB run; conceptually move this fragment's EOBness to stack 0 */
-	increment_run(cpi,chroma,fi,0,0);
+	tokenize_mark_run(cpi,chroma,fi,0,0,NULL);
 	      
 	/* decrement current EOB run for coeff 1 without adding to coded run */
 	(*run1)--;
@@ -483,8 +484,8 @@
 
 	run = decode_token(token1,eb1,&val)+1;
 
-	if(!emit_token(cpi,chroma,fi,0,run,val)){
-	  emit_raw(cpi,chroma,fi,1,token1,eb1);
+	if(!tokenize_dctval(cpi,chroma,fi,0,run,val,NULL)){
+	  token_add_raw(cpi,chroma,fi,1,token1,eb1);
 	}
       }
     }
@@ -519,7 +520,7 @@
   }
 }
 
-void dct_tokenize_ac_chroma (CP_INSTANCE *cpi){
+void dct_tokenize_mark_ac_chroma (CP_INSTANCE *cpi){
   int i;
   for(i=1;i<64;i++){
     cpi->dct_token_ycount[i]=cpi->dct_token_count[i];
@@ -541,7 +542,7 @@
      reparse the stack in the DC code loop.  The current state will be
      recreated by the end of DC encode */
 
-  if(cpi->eob_run[1]) add_eob_run(cpi,1,cpi->eob_run[1]);
+  if(cpi->eob_run[1]) tokenize_eobrun(cpi,1,cpi->eob_run[1],NULL);
   memset(cpi->ac1_bits, 0, sizeof(cpi->ac1_bits));
   cpi->dct_token_count[1]=0;
   cpi->eob_pre[1]=cpi->eob_run[1]=0;
@@ -589,7 +590,7 @@
 	/* special case the ongoing run + eob is at or over the max run size;
 	   we know the ongoing run is < 4095 or it would have been flushed already. */
 	if(run && (run&0x7fff) + cpi->eob_pre[i] >= 4095){ /* 1 */
-	  add_eob_run(cpi,coeff,4095 | (run&0x8000));
+	  tokenize_eobrun(cpi,coeff,4095 | (run&0x8000),NULL);
 	  cpi->eob_pre[i] -= 4095-(run&0x7fff); 
 	  cpi->eob_ypre[i] -= 4095-(run&0x7fff); 
 	  run = 0;
@@ -599,7 +600,7 @@
 	if(run){
 	  if(cpi->dct_token_count[i]){ /* 2 */
 	    /* group is not only an EOB run; emit the run token */
-	    add_eob_run(cpi,coeff,run + cpi->eob_pre[i]);
+	    tokenize_eobrun(cpi,coeff,run + cpi->eob_pre[i],NULL);
 	    cpi->eob_ypre[i] = 0;
 	    cpi->eob_pre[i] = 0;
 	    run = cpi->eob_run[i];
@@ -616,13 +617,13 @@
 	    /* there are other tokens in this group; work backwards as we need to prepend */
 	    while(cpi->eob_pre[i] >= 4095){ /* 4 */
 	      int lchroma = (cpi->eob_pre[i]-4095 >= cpi->eob_ypre[i]);
-	      prepend_eob_run(cpi,lchroma,i,4095);
+	      tokenize_prepend_eobrun(cpi,lchroma,i,4095);
 	      if(!lchroma)cpi->dct_token_ycount[i]++;
 	      cpi->eob_pre[i] -= 4095;
 	    }
 	    if(cpi->eob_pre[i]){ /* 5 */
 	      int lchroma = (cpi->eob_ypre[i]<=0); /* possible when case 1 triggered */
-	      prepend_eob_run(cpi, lchroma, i, cpi->eob_pre[i]);
+	      tokenize_prepend_eobrun(cpi, lchroma, i, cpi->eob_pre[i]);
 	      if(!lchroma)cpi->dct_token_ycount[i]++;
 	      cpi->eob_pre[i] = 0;
 	      cpi->eob_ypre[i] = 0;
@@ -633,7 +634,7 @@
 	    /* group consists entirely of EOB run.  Add, flush overs, iterate */
 	    int lchroma = (cpi->eob_ypre[i]<=0);
 	    while(cpi->eob_pre[i] >= 4095){
-	      add_eob_run(cpi,i,4095|(!lchroma<<15));
+	      tokenize_eobrun(cpi,i,4095|(!lchroma<<15),NULL);
 	      if(!lchroma)cpi->dct_token_ycount[i]++;
 	      cpi->eob_pre[i] -= 4095;
 	      cpi->eob_ypre[i] -= 4095;
@@ -649,7 +650,7 @@
 	/* no eob run to begin group */
 	if(i==0 || cpi->dct_token_count[i]){
 	  if(run)
-	    add_eob_run(cpi,coeff,run);
+	    tokenize_eobrun(cpi,coeff,run,NULL);
 	  
 	  run = cpi->eob_run[i];
 	  coeff = i;
@@ -658,7 +659,7 @@
     }
     
     if(run)
-      add_eob_run(cpi,coeff,run);
+      tokenize_eobrun(cpi,coeff,run,NULL);
     
   }
 }

Modified: branches/theora-thusnelda/lib/enc/mode.c
===================================================================
--- branches/theora-thusnelda/lib/enc/mode.c	2008-07-09 08:23:30 UTC (rev 15105)
+++ branches/theora-thusnelda/lib/enc/mode.c	2008-07-09 20:42:37 UTC (rev 15106)
@@ -804,7 +804,7 @@
   for ( i=0; i<4; i++ ){
     int fi = mb->Hyuv[0][i];
     if(cp[fi]) 
-      dct_tokenize_AC(cpi, fi, dct[i], 0);
+      dct_tokenize_AC(cpi, fi, dct[i], 0, NULL);
   }
 
   return coded;  
@@ -860,7 +860,7 @@
 	
       if(TQB(cpi,ps,mb->mode,fi,mv,0,0,&mo,rc,dct)){
 	fr_codeblock(cpi,fr);
-	dct_tokenize_AC(cpi, fi, dct, 1);
+	dct_tokenize_AC(cpi, fi, dct, 1, NULL);
 	coded++;
       }else{
 	fr_skipblock(cpi,fr);
@@ -1074,7 +1074,7 @@
     fr_finishsb(cpi,&fr);
   }
 
-  dct_tokenize_ac_chroma(cpi);
+  dct_tokenize_mark_ac_chroma(cpi);
 
   /* code chroma U */
   sb = cpi->super[1];



More information about the commits mailing list