Cache the reference frame associated with the current MB mode in each fragment.
[theora.git] / lib / analyze.c
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
7  *                                                                  *
8  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
10  *                                                                  *
11  ********************************************************************
12
13   function: mode selection code
14   last mod: $Id$
15
16  ********************************************************************/
17 #include <limits.h>
18 #include <string.h>
19 #include "encint.h"
20 #include "modedec.h"
21 #if defined(OC_COLLECT_METRICS)
22 # include "collect.c"
23 #endif
24
25
26
27 typedef struct oc_rd_metric          oc_rd_metric;
28 typedef struct oc_mode_choice        oc_mode_choice;
29
30
31
32 /*There are 8 possible schemes used to encode macro block modes.
33   Schemes 0-6 use a maximally-skewed Huffman code to code each of the modes.
34   The same set of Huffman codes is used for each of these 7 schemes, but the
35    mode assigned to each codeword varies.
36   Scheme 0 writes a custom mapping from codeword to MB mode to the bitstream,
37    while schemes 1-6 have a fixed mapping.
38   Scheme 7 just encodes each mode directly in 3 bits.*/
39
40 /*The mode orderings for the various mode coding schemes.
41   Scheme 0 uses a custom alphabet, which is not stored in this table.
42   This is the inverse of the equivalent table OC_MODE_ALPHABETS in the
43    decoder.*/
44 static const unsigned char OC_MODE_RANKS[7][OC_NMODES]={
45   /*Last MV dominates.*/
46   /*L P M N I G GM 4*/
47   {3,4,2,0,1,5,6,7},
48   /*L P N M I G GM 4*/
49   {2,4,3,0,1,5,6,7},
50   /*L M P N I G GM 4*/
51   {3,4,1,0,2,5,6,7},
52   /*L M N P I G GM 4*/
53   {2,4,1,0,3,5,6,7},
54   /*No MV dominates.*/
55   /*N L P M I G GM 4*/
56   {0,4,3,1,2,5,6,7},
57   /*N G L P M I GM 4*/
58   {0,5,4,2,3,1,6,7},
59   /*Default ordering.*/
60   /*N I M L P G GM 4*/
61   {0,1,2,3,4,5,6,7}
62 };
63
64
65
66 /*Initialize the mode scheme chooser.
67   This need only be called once per encoder.*/
68 void oc_mode_scheme_chooser_init(oc_mode_scheme_chooser *_chooser){
69   int si;
70   _chooser->mode_ranks[0]=_chooser->scheme0_ranks;
71   for(si=1;si<8;si++)_chooser->mode_ranks[si]=OC_MODE_RANKS[si-1];
72 }
73
74 /*Reset the mode scheme chooser.
75   This needs to be called once for each frame, including the first.*/
76 static void oc_mode_scheme_chooser_reset(oc_mode_scheme_chooser *_chooser){
77   int si;
78   memset(_chooser->mode_counts,0,OC_NMODES*sizeof(*_chooser->mode_counts));
79   /*Scheme 0 starts with 24 bits to store the mode list in.*/
80   _chooser->scheme_bits[0]=24;
81   memset(_chooser->scheme_bits+1,0,7*sizeof(*_chooser->scheme_bits));
82   for(si=0;si<8;si++){
83     /*Scheme 7 should always start first, and scheme 0 should always start
84        last.*/
85     _chooser->scheme_list[si]=7-si;
86     _chooser->scheme0_list[si]=_chooser->scheme0_ranks[si]=si;
87   }
88 }
89
90 /*Return the cost of coding _mb_mode in the specified scheme.*/
91 static int oc_mode_scheme_chooser_scheme_mb_cost(
92  const oc_mode_scheme_chooser *_chooser,int _scheme,int _mb_mode){
93   int codebook;
94   int ri;
95   codebook=_scheme+1>>3;
96   /*For any scheme except 0, we can just use the bit cost of the mode's rank
97      in that scheme.*/
98   ri=_chooser->mode_ranks[_scheme][_mb_mode];
99   if(_scheme==0){
100     int mc;
101     /*For scheme 0, incrementing the mode count could potentially change the
102        mode's rank.
103       Find the index where the mode would be moved to in the optimal list,
104        and use its bit cost instead of the one for the mode's current
105        position in the list.*/
106     /*We don't actually reorder the list; this is for computing opportunity
107        cost, not an update.*/
108     mc=_chooser->mode_counts[_mb_mode];
109     while(ri>0&&mc>=_chooser->mode_counts[_chooser->scheme0_list[ri-1]])ri--;
110   }
111   return OC_MODE_BITS[codebook][ri];
112 }
113
114 /*This is the real purpose of this data structure: not actually selecting a
115    mode scheme, but estimating the cost of coding a given mode given all the
116    modes selected so far.
117   This is done via opportunity cost: the cost is defined as the number of bits
118    required to encode all the modes selected so far including the current one
119    using the best possible scheme, minus the number of bits required to encode
120    all the modes selected so far not including the current one using the best
121    possible scheme.
122   The computational expense of doing this probably makes it overkill.
123   Just be happy we take a greedy approach instead of trying to solve the
124    global mode-selection problem (which is NP-hard).
125   _mb_mode: The mode to determine the cost of.
126   Return: The number of bits required to code this mode.*/
127 static int oc_mode_scheme_chooser_cost(oc_mode_scheme_chooser *_chooser,
128  int _mb_mode){
129   int scheme0;
130   int scheme1;
131   int best_bits;
132   int mode_bits;
133   int si;
134   int scheme0_bits;
135   int scheme1_bits;
136   scheme0=_chooser->scheme_list[0];
137   scheme1=_chooser->scheme_list[1];
138   scheme0_bits=_chooser->scheme_bits[scheme0];
139   scheme1_bits=_chooser->scheme_bits[scheme1];
140   mode_bits=oc_mode_scheme_chooser_scheme_mb_cost(_chooser,scheme0,_mb_mode);
141   /*Typical case: If the difference between the best scheme and the next best
142      is greater than 6 bits, then adding just one mode cannot change which
143      scheme we use.*/
144   if(scheme1_bits-scheme0_bits>6)return mode_bits;
145   /*Otherwise, check to see if adding this mode selects a different scheme as
146      the best.*/
147   si=1;
148   best_bits=scheme0_bits+mode_bits;
149   do{
150     int cur_bits;
151     cur_bits=scheme1_bits+
152      oc_mode_scheme_chooser_scheme_mb_cost(_chooser,scheme1,_mb_mode);
153     if(cur_bits<best_bits)best_bits=cur_bits;
154     if(++si>=8)break;
155     scheme1=_chooser->scheme_list[si];
156     scheme1_bits=_chooser->scheme_bits[scheme1];
157   }
158   while(scheme1_bits-scheme0_bits<=6);
159   return best_bits-scheme0_bits;
160 }
161
162 /*Incrementally update the mode counts and per-scheme bit counts and re-order
163    the scheme lists once a mode has been selected.
164   _mb_mode: The mode that was chosen.*/
165 static void oc_mode_scheme_chooser_update(oc_mode_scheme_chooser *_chooser,
166  int _mb_mode){
167   int ri;
168   int si;
169   _chooser->mode_counts[_mb_mode]++;
170   /*Re-order the scheme0 mode list if necessary.*/
171   for(ri=_chooser->scheme0_ranks[_mb_mode];ri>0;ri--){
172     int pmode;
173     pmode=_chooser->scheme0_list[ri-1];
174     if(_chooser->mode_counts[pmode]>=_chooser->mode_counts[_mb_mode])break;
175     /*Reorder the mode ranking.*/
176     _chooser->scheme0_ranks[pmode]++;
177     _chooser->scheme0_list[ri]=pmode;
178   }
179   _chooser->scheme0_ranks[_mb_mode]=ri;
180   _chooser->scheme0_list[ri]=_mb_mode;
181   /*Now add the bit cost for the mode to each scheme.*/
182   for(si=0;si<8;si++){
183     _chooser->scheme_bits[si]+=
184      OC_MODE_BITS[si+1>>3][_chooser->mode_ranks[si][_mb_mode]];
185   }
186   /*Finally, re-order the list of schemes.*/
187   for(si=1;si<8;si++){
188     int sj;
189     int scheme0;
190     int bits0;
191     sj=si;
192     scheme0=_chooser->scheme_list[si];
193     bits0=_chooser->scheme_bits[scheme0];
194     do{
195       int scheme1;
196       scheme1=_chooser->scheme_list[sj-1];
197       if(bits0>=_chooser->scheme_bits[scheme1])break;
198       _chooser->scheme_list[sj]=scheme1;
199     }
200     while(--sj>0);
201     _chooser->scheme_list[sj]=scheme0;
202   }
203 }
204
205
206
207 /*The number of bits required to encode a super block run.
208   _run_count: The desired run count; must be positive and less than 4130.*/
209 static int oc_sb_run_bits(int _run_count){
210   int i;
211   for(i=0;_run_count>=OC_SB_RUN_VAL_MIN[i+1];i++);
212   return OC_SB_RUN_CODE_NBITS[i];
213 }
214
215 /*The number of bits required to encode a block run.
216   _run_count: The desired run count; must be positive and less than 30.*/
217 static int oc_block_run_bits(int _run_count){
218   return OC_BLOCK_RUN_CODE_NBITS[_run_count-1];
219 }
220
221
222
223 static void oc_fr_state_init(oc_fr_state *_fr){
224   _fr->bits=0;
225   _fr->sb_partial_count=0;
226   _fr->sb_full_count=0;
227   _fr->b_coded_count_prev=0;
228   _fr->b_coded_count=0;
229   _fr->b_count=0;
230   _fr->sb_prefer_partial=0;
231   _fr->sb_bits=0;
232   _fr->sb_partial=-1;
233   _fr->sb_full=-1;
234   _fr->b_coded_prev=-1;
235   _fr->b_coded=-1;
236 }
237
238
239 static int oc_fr_state_sb_cost(const oc_fr_state *_fr,
240  int _sb_partial,int _sb_full){
241   int bits;
242   int sb_partial_count;
243   int sb_full_count;
244   bits=0;
245   sb_partial_count=_fr->sb_partial_count;
246   /*Extend the sb_partial run, or start a new one.*/
247   if(_fr->sb_partial==_sb_partial){
248     if(sb_partial_count>=4129){
249       bits++;
250       sb_partial_count=0;
251     }
252     else bits-=oc_sb_run_bits(sb_partial_count);
253   }
254   else sb_partial_count=0;
255   bits+=oc_sb_run_bits(++sb_partial_count);
256   if(!_sb_partial){
257     /*Extend the sb_full run, or start a new one.*/
258     sb_full_count=_fr->sb_full_count;
259     if(_fr->sb_full==_sb_full){
260       if(sb_full_count>=4129){
261         bits++;
262         sb_full_count=0;
263       }
264       else bits-=oc_sb_run_bits(sb_full_count);
265     }
266     else sb_full_count=0;
267     bits+=oc_sb_run_bits(++sb_full_count);
268   }
269   return bits;
270 }
271
272 static void oc_fr_state_advance_sb(oc_fr_state *_fr,
273  int _sb_partial,int _sb_full){
274   int sb_partial_count;
275   int sb_full_count;
276   sb_partial_count=_fr->sb_partial_count;
277   if(_fr->sb_partial!=_sb_partial||sb_partial_count>=4129)sb_partial_count=0;
278   sb_partial_count++;
279   if(!_sb_partial){
280     sb_full_count=_fr->sb_full_count;
281     if(_fr->sb_full!=_sb_full||sb_full_count>=4129)sb_full_count=0;
282     sb_full_count++;
283     _fr->sb_full_count=sb_full_count;
284     _fr->sb_full=_sb_full;
285     /*Roll back the partial block state.*/
286     _fr->b_coded=_fr->b_coded_prev;
287     _fr->b_coded_count=_fr->b_coded_count_prev;
288   }
289   else{
290     /*Commit back the partial block state.*/
291     _fr->b_coded_prev=_fr->b_coded;
292     _fr->b_coded_count_prev=_fr->b_coded_count;
293   }
294   _fr->sb_partial_count=sb_partial_count;
295   _fr->sb_partial=_sb_partial;
296   _fr->b_count=0;
297   _fr->sb_prefer_partial=0;
298   _fr->sb_bits=0;
299 }
300
301 /*Commit the state of the current super block and advance to the next.*/
302 static void oc_fr_state_flush_sb(oc_fr_state *_fr){
303   int sb_partial;
304   int sb_full;
305   int b_coded_count;
306   int b_count;
307   b_count=_fr->b_count;
308   b_coded_count=_fr->b_coded_count;
309   sb_full=_fr->b_coded;
310   sb_partial=b_coded_count<b_count;
311   if(!sb_partial){
312     /*If the super block is fully coded/uncoded...*/
313     if(_fr->sb_prefer_partial){
314       /*So far coding this super block as partial was cheaper anyway.*/
315       if(b_coded_count>15||_fr->b_coded_prev<0){
316         int sb_bits;
317         /*If the block run is too long, this will limit how far it can be
318            extended into the next partial super block.
319           If we need to extend it farther, we don't want to have to roll all
320            the way back here (since there could be many full SBs between now
321            and then), so we disallow this.
322           Similarly, if this is the start of a stripe, we don't know how the
323            length of the outstanding block run from the previous stripe.*/
324         sb_bits=oc_fr_state_sb_cost(_fr,sb_partial,sb_full);
325         _fr->bits+=sb_bits-_fr->sb_bits;
326         _fr->sb_bits=sb_bits;
327       }
328       else sb_partial=1;
329     }
330   }
331   oc_fr_state_advance_sb(_fr,sb_partial,sb_full);
332 }
333
334 static void oc_fr_state_advance_block(oc_fr_state *_fr,int _b_coded){
335   ptrdiff_t bits;
336   int       sb_bits;
337   int       b_coded_count;
338   int       b_count;
339   int       sb_prefer_partial;
340   sb_bits=_fr->sb_bits;
341   bits=_fr->bits-sb_bits;
342   b_count=_fr->b_count;
343   b_coded_count=_fr->b_coded_count;
344   sb_prefer_partial=_fr->sb_prefer_partial;
345   if(b_coded_count>=b_count){
346     int sb_partial_bits;
347     /*This super block is currently fully coded/uncoded.*/
348     if(b_count<=0){
349       /*This is the first block in this SB.*/
350       b_count=1;
351       /*Check to see whether it's cheaper to code it partially or fully.*/
352       if(_fr->b_coded==_b_coded){
353         sb_partial_bits=-oc_block_run_bits(b_coded_count);
354         sb_partial_bits+=oc_block_run_bits(++b_coded_count);
355       }
356       else{
357         b_coded_count=1;
358         sb_partial_bits=2;
359       }
360       sb_partial_bits+=oc_fr_state_sb_cost(_fr,1,_b_coded);
361       sb_bits=oc_fr_state_sb_cost(_fr,0,_b_coded);
362       sb_prefer_partial=sb_partial_bits<sb_bits;
363       sb_bits^=(sb_partial_bits^sb_bits)&-sb_prefer_partial;
364     }
365     else if(_fr->b_coded==_b_coded){
366       b_coded_count++;
367       if(++b_count<16){
368         if(sb_prefer_partial){
369           /*Check to see if it's cheaper to code it fully.*/
370           sb_partial_bits=sb_bits;
371           sb_partial_bits+=oc_block_run_bits(b_coded_count);
372           if(b_coded_count>0){
373             sb_partial_bits-=oc_block_run_bits(b_coded_count-1);
374           }
375           sb_bits=oc_fr_state_sb_cost(_fr,0,_b_coded);
376           sb_prefer_partial=sb_partial_bits<sb_bits;
377           sb_bits^=(sb_partial_bits^sb_bits)&-sb_prefer_partial;
378         }
379         /*There's no need to check the converse (whether it's cheaper to code
380            this SB partially if we were coding it fully), since the cost to
381            code a SB partially can only increase as we add more blocks, whereas
382            the cost to code it fully stays constant.*/
383       }
384       else{
385         /*If we get to the end and this SB is still full, then force it to be
386            coded full.
387           Otherwise we might not be able to extend the block run far enough
388            into the next partial SB.*/
389         if(sb_prefer_partial){
390           sb_prefer_partial=0;
391           sb_bits=oc_fr_state_sb_cost(_fr,0,_b_coded);
392         }
393       }
394     }
395     else{
396       /*This SB was full, but now must be made partial.*/
397       if(!sb_prefer_partial){
398         sb_bits=oc_block_run_bits(b_coded_count);
399         if(b_coded_count>b_count){
400           sb_bits-=oc_block_run_bits(b_coded_count-b_count);
401         }
402         sb_bits+=oc_fr_state_sb_cost(_fr,1,_b_coded);
403       }
404       b_count++;
405       b_coded_count=1;
406       sb_prefer_partial=1;
407       sb_bits+=2;
408     }
409   }
410   else{
411     b_count++;
412     if(_fr->b_coded==_b_coded)sb_bits-=oc_block_run_bits(b_coded_count);
413     else b_coded_count=0;
414     sb_bits+=oc_block_run_bits(++b_coded_count);
415   }
416   _fr->bits=bits+sb_bits;
417   _fr->b_coded_count=b_coded_count;
418   _fr->b_coded=_b_coded;
419   _fr->b_count=b_count;
420   _fr->sb_prefer_partial=sb_prefer_partial;
421   _fr->sb_bits=sb_bits;
422 }
423
424 static void oc_fr_skip_block(oc_fr_state *_fr){
425   oc_fr_state_advance_block(_fr,0);
426 }
427
428 static void oc_fr_code_block(oc_fr_state *_fr){
429   oc_fr_state_advance_block(_fr,1);
430 }
431
432 static int oc_fr_cost1(const oc_fr_state *_fr){
433   oc_fr_state tmp;
434   ptrdiff_t   bits;
435   *&tmp=*_fr;
436   oc_fr_skip_block(&tmp);
437   bits=tmp.bits;
438   *&tmp=*_fr;
439   oc_fr_code_block(&tmp);
440   return (int)(tmp.bits-bits);
441 }
442
443 static int oc_fr_cost4(const oc_fr_state *_pre,const oc_fr_state *_post){
444   oc_fr_state tmp;
445   *&tmp=*_pre;
446   oc_fr_skip_block(&tmp);
447   oc_fr_skip_block(&tmp);
448   oc_fr_skip_block(&tmp);
449   oc_fr_skip_block(&tmp);
450   return (int)(_post->bits-tmp.bits);
451 }
452
453
454
455 static void oc_qii_state_init(oc_qii_state *_qs){
456   _qs->bits=0;
457   _qs->qi01_count=0;
458   _qs->qi01=-1;
459   _qs->qi12_count=0;
460   _qs->qi12=-1;
461 }
462
463
464 static void oc_qii_state_advance(oc_qii_state *_qd,
465  const oc_qii_state *_qs,int _qii){
466   ptrdiff_t bits;
467   int       qi01;
468   int       qi01_count;
469   int       qi12;
470   int       qi12_count;
471   bits=_qs->bits;
472   qi01=_qii+1>>1;
473   qi01_count=_qs->qi01_count;
474   if(qi01==_qs->qi01){
475     if(qi01_count>=4129){
476       bits++;
477       qi01_count=0;
478     }
479     else bits-=oc_sb_run_bits(qi01_count);
480   }
481   else qi01_count=0;
482   qi01_count++;
483   bits+=oc_sb_run_bits(qi01_count);
484   qi12_count=_qs->qi12_count;
485   if(_qii){
486     qi12=_qii>>1;
487     if(qi12==_qs->qi12){
488       if(qi12_count>=4129){
489         bits++;
490         qi12_count=0;
491       }
492       else bits-=oc_sb_run_bits(qi12_count);
493     }
494     else qi12_count=0;
495     qi12_count++;
496     bits+=oc_sb_run_bits(qi12_count);
497   }
498   else qi12=_qs->qi12;
499   _qd->bits=bits;
500   _qd->qi01=qi01;
501   _qd->qi01_count=qi01_count;
502   _qd->qi12=qi12;
503   _qd->qi12_count=qi12_count;
504 }
505
506
507
508 static void oc_enc_pipeline_init(oc_enc_ctx *_enc,oc_enc_pipeline_state *_pipe){
509   ptrdiff_t *coded_fragis;
510   unsigned   mcu_nvsbs;
511   ptrdiff_t  mcu_nfrags;
512   int        flimit;
513   int        hdec;
514   int        vdec;
515   int        pli;
516   int        nqis;
517   int        qii;
518   int        qi0;
519   int        qti;
520   /*Initialize the per-plane coded block flag trackers.
521     These are used for bit-estimation purposes only; the real flag bits span
522      all three planes, so we can't compute them in parallel.*/
523   for(pli=0;pli<3;pli++)oc_fr_state_init(_pipe->fr+pli);
524   for(pli=0;pli<3;pli++)oc_qii_state_init(_pipe->qs+pli);
525   /*Set up the per-plane skip SSD storage pointers.*/
526   mcu_nvsbs=_enc->mcu_nvsbs;
527   mcu_nfrags=mcu_nvsbs*_enc->state.fplanes[0].nhsbs*16;
528   hdec=!(_enc->state.info.pixel_fmt&1);
529   vdec=!(_enc->state.info.pixel_fmt&2);
530   _pipe->skip_ssd[0]=_enc->mcu_skip_ssd;
531   _pipe->skip_ssd[1]=_pipe->skip_ssd[0]+mcu_nfrags;
532   _pipe->skip_ssd[2]=_pipe->skip_ssd[1]+(mcu_nfrags>>hdec+vdec);
533   /*Set up per-plane pointers to the coded and uncoded fragments lists.
534     Unlike the decoder, each planes' coded and uncoded fragment list is kept
535      separate during the analysis stage; we only make the coded list for all
536      three planes contiguous right before the final packet is output
537      (destroying the uncoded lists, which are no longer needed).*/
538   coded_fragis=_enc->state.coded_fragis;
539   for(pli=0;pli<3;pli++){
540     _pipe->coded_fragis[pli]=coded_fragis;
541     coded_fragis+=_enc->state.fplanes[pli].nfrags;
542     _pipe->uncoded_fragis[pli]=coded_fragis;
543   }
544   memset(_pipe->ncoded_fragis,0,sizeof(_pipe->ncoded_fragis));
545   memset(_pipe->nuncoded_fragis,0,sizeof(_pipe->nuncoded_fragis));
546   /*Set up condensed quantizer tables.*/
547   qi0=_enc->state.qis[0];
548   nqis=_enc->state.nqis;
549   for(pli=0;pli<3;pli++){
550     for(qii=0;qii<nqis;qii++){
551       int qi;
552       qi=_enc->state.qis[qii];
553       for(qti=0;qti<2;qti++){
554         /*Set the DC coefficient in the dequantization table.*/
555         _enc->state.dequant_tables[qi][pli][qti][0]=
556          _enc->dequant_dc[qi0][pli][qti];
557         _enc->dequant[pli][qii][qti]=_enc->state.dequant_tables[qi][pli][qti];
558         /*Copy over the quantization table.*/
559         memcpy(_enc->enquant[pli][qii][qti],_enc->enquant_tables[qi][pli][qti],
560          _enc->opt_data.enquant_table_size);
561       }
562     }
563   }
564   /*Fix up the DC coefficients in the quantization tables.*/
565   oc_enc_enquant_table_fixup(_enc,_enc->enquant,nqis);
566   /*Initialize the tokenization state.*/
567   for(pli=0;pli<3;pli++){
568     _pipe->ndct_tokens1[pli]=0;
569     _pipe->eob_run1[pli]=0;
570   }
571   /*Initialize the bounding value array for the loop filter.*/
572   flimit=_enc->state.loop_filter_limits[_enc->state.qis[0]];
573   _pipe->loop_filter=flimit!=0;
574   if(flimit!=0)oc_loop_filter_init(&_enc->state,_pipe->bounding_values,flimit);
575 }
576
577 /*Sets the current MCU stripe to super block row _sby.
578   Return: A non-zero value if this was the last MCU.*/
579 static int oc_enc_pipeline_set_stripe(oc_enc_ctx *_enc,
580  oc_enc_pipeline_state *_pipe,int _sby){
581   const oc_fragment_plane *fplane;
582   unsigned                 mcu_nvsbs;
583   int                      sby_end;
584   int                      notdone;
585   int                      vdec;
586   int                      pli;
587   mcu_nvsbs=_enc->mcu_nvsbs;
588   sby_end=_enc->state.fplanes[0].nvsbs;
589   notdone=_sby+mcu_nvsbs<sby_end;
590   if(notdone)sby_end=_sby+mcu_nvsbs;
591   vdec=0;
592   for(pli=0;pli<3;pli++){
593     fplane=_enc->state.fplanes+pli;
594     _pipe->sbi0[pli]=fplane->sboffset+(_sby>>vdec)*fplane->nhsbs;
595     _pipe->fragy0[pli]=_sby<<2-vdec;
596     _pipe->froffset[pli]=fplane->froffset
597      +_pipe->fragy0[pli]*(ptrdiff_t)fplane->nhfrags;
598     if(notdone){
599       _pipe->sbi_end[pli]=fplane->sboffset+(sby_end>>vdec)*fplane->nhsbs;
600       _pipe->fragy_end[pli]=sby_end<<2-vdec;
601     }
602     else{
603       _pipe->sbi_end[pli]=fplane->sboffset+fplane->nsbs;
604       _pipe->fragy_end[pli]=fplane->nvfrags;
605     }
606     vdec=!(_enc->state.info.pixel_fmt&2);
607   }
608   return notdone;
609 }
610
611 static void oc_enc_pipeline_finish_mcu_plane(oc_enc_ctx *_enc,
612  oc_enc_pipeline_state *_pipe,int _pli,int _sdelay,int _edelay){
613   int refi;
614   /*Copy over all the uncoded fragments from this plane and advance the uncoded
615      fragment list.*/
616   if(_pipe->nuncoded_fragis[_pli]>0){
617     _pipe->uncoded_fragis[_pli]-=_pipe->nuncoded_fragis[_pli];
618     oc_frag_copy_list(&_enc->state,
619      _enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_SELF]],
620      _enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_PREV]],
621      _enc->state.ref_ystride[_pli],_pipe->uncoded_fragis[_pli],
622      _pipe->nuncoded_fragis[_pli],_enc->state.frag_buf_offs);
623     _pipe->nuncoded_fragis[_pli]=0;
624   }
625   /*Perform DC prediction.*/
626   oc_enc_pred_dc_frag_rows(_enc,_pli,
627    _pipe->fragy0[_pli],_pipe->fragy_end[_pli]);
628   /*Finish DC tokenization.*/
629   oc_enc_tokenize_dc_frag_list(_enc,_pli,
630    _pipe->coded_fragis[_pli],_pipe->ncoded_fragis[_pli],
631    _pipe->ndct_tokens1[_pli],_pipe->eob_run1[_pli]);
632   _pipe->ndct_tokens1[_pli]=_enc->ndct_tokens[_pli][1];
633   _pipe->eob_run1[_pli]=_enc->eob_run[_pli][1];
634   /*And advance the coded fragment list.*/
635   _enc->state.ncoded_fragis[_pli]+=_pipe->ncoded_fragis[_pli];
636   _pipe->coded_fragis[_pli]+=_pipe->ncoded_fragis[_pli];
637   _pipe->ncoded_fragis[_pli]=0;
638   /*Apply the loop filter if necessary.*/
639   refi=_enc->state.ref_frame_idx[OC_FRAME_SELF];
640   if(_pipe->loop_filter){
641     oc_state_loop_filter_frag_rows(&_enc->state,_pipe->bounding_values,
642      refi,_pli,_pipe->fragy0[_pli]-_sdelay,_pipe->fragy_end[_pli]-_edelay);
643   }
644   else _sdelay=_edelay=0;
645   /*To fill borders, we have an additional two pixel delay, since a fragment
646      in the next row could filter its top edge, using two pixels from a
647      fragment in this row.
648     But there's no reason to delay a full fragment between the two.*/
649   oc_state_borders_fill_rows(&_enc->state,refi,_pli,
650    (_pipe->fragy0[_pli]-_sdelay<<3)-(_sdelay<<1),
651    (_pipe->fragy_end[_pli]-_edelay<<3)-(_edelay<<1));
652 }
653
654
655
656 /*Cost information about the coded blocks in a MB.*/
657 struct oc_rd_metric{
658   int uncoded_ac_ssd;
659   int coded_ac_ssd;
660   int ac_bits;
661   int dc_flag;
662 };
663
664
665
666 static int oc_enc_block_transform_quantize(oc_enc_ctx *_enc,
667  oc_enc_pipeline_state *_pipe,int _pli,ptrdiff_t _fragi,
668  unsigned _rd_scale,unsigned _rd_iscale,oc_rd_metric *_mo,
669  oc_fr_state *_fr,oc_token_checkpoint **_stack){
670   ogg_int16_t            *dct;
671   ogg_int16_t            *data;
672   oc_qii_state            qs;
673   const ogg_uint16_t     *dequant;
674   ogg_uint16_t            dequant_dc;
675   ptrdiff_t               frag_offs;
676   int                     ystride;
677   const unsigned char    *src;
678   const unsigned char    *ref;
679   unsigned char          *dst;
680   int                     nonzero;
681   unsigned                uncoded_ssd;
682   unsigned                coded_ssd;
683   oc_token_checkpoint    *checkpoint;
684   oc_fragment            *frags;
685   int                     mb_mode;
686   int                     refi;
687   int                     mv_offs[2];
688   int                     nmv_offs;
689   int                     ac_bits;
690   int                     borderi;
691   int                     nqis;
692   int                     qti;
693   int                     qii;
694   int                     dc;
695   nqis=_enc->state.nqis;
696   frags=_enc->state.frags;
697   frag_offs=_enc->state.frag_buf_offs[_fragi];
698   ystride=_enc->state.ref_ystride[_pli];
699   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]]
700    +frag_offs;
701   borderi=frags[_fragi].borderi;
702   qii=frags[_fragi].qii;
703   data=_enc->pipe.dct_data;
704   dct=data+64;
705   if(qii&~3){
706 #if !defined(OC_COLLECT_METRICS)
707     if(_enc->sp_level>=OC_SP_LEVEL_EARLY_SKIP){
708       /*Enable early skip detection.*/
709       frags[_fragi].coded=0;
710       frags[_fragi].refi=OC_FRAME_NONE;
711       oc_fr_skip_block(_fr);
712       return 0;
713     }
714 #endif
715     /*Try and code this block anyway.*/
716     qii&=3;
717     frags[_fragi].qii=qii;
718   }
719   refi=frags[_fragi].refi;
720   mb_mode=frags[_fragi].mb_mode;
721   ref=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[refi]]+frag_offs;
722   dst=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_SELF]]
723    +frag_offs;
724   /*Motion compensation:*/
725   switch(mb_mode){
726     case OC_MODE_INTRA:{
727       nmv_offs=0;
728       oc_enc_frag_sub_128(_enc,data,src,ystride);
729     }break;
730     case OC_MODE_GOLDEN_NOMV:
731     case OC_MODE_INTER_NOMV:{
732       nmv_offs=1;
733       mv_offs[0]=0;
734       oc_enc_frag_sub(_enc,data,src,ref,ystride);
735     }break;
736     default:{
737       const oc_mv *frag_mvs;
738       frag_mvs=_enc->state.frag_mvs;
739       nmv_offs=oc_state_get_mv_offsets(&_enc->state,mv_offs,
740        _pli,frag_mvs[_fragi]);
741       if(nmv_offs>1){
742         oc_enc_frag_copy2(_enc,dst,
743          ref+mv_offs[0],ref+mv_offs[1],ystride);
744         oc_enc_frag_sub(_enc,data,src,dst,ystride);
745       }
746       else oc_enc_frag_sub(_enc,data,src,ref+mv_offs[0],ystride);
747     }break;
748   }
749 #if defined(OC_COLLECT_METRICS)
750   {
751     unsigned satd;
752     unsigned dc;
753     switch(nmv_offs){
754       case 0:satd=oc_enc_frag_intra_satd(_enc,&dc,src,ystride);break;
755       case 1:{
756         satd=oc_enc_frag_satd(_enc,&dc,src,ref+mv_offs[0],ystride);
757         satd+=dc;
758       }break;
759       default:{
760         satd=oc_enc_frag_satd(_enc,&dc,src,dst,ystride);
761         satd+=dc;
762       }break;
763     }
764     _enc->frag_satd[_fragi]=satd;
765   }
766 #endif
767   /*Transform:*/
768   oc_enc_fdct8x8(_enc,dct,data);
769   /*Quantize:*/
770   qti=mb_mode!=OC_MODE_INTRA;
771   dequant=_enc->dequant[_pli][qii][qti];
772   nonzero=oc_enc_quantize(_enc,data,dct,dequant,_enc->enquant[_pli][qii][qti]);
773   dc=data[0];
774   /*Tokenize.*/
775   checkpoint=*_stack;
776   if(_enc->sp_level<OC_SP_LEVEL_FAST_ANALYSIS){
777     ac_bits=oc_enc_tokenize_ac(_enc,_pli,_fragi,data,dequant,dct,nonzero+1,
778      _stack,OC_RD_ISCALE(_enc->lambda,_rd_iscale),qti?0:3);
779   }
780   else{
781     ac_bits=oc_enc_tokenize_ac_fast(_enc,_pli,_fragi,data,dequant,dct,nonzero+1,
782      _stack,OC_RD_ISCALE(_enc->lambda,_rd_iscale),qti?0:3);
783   }
784   /*Reconstruct.
785     TODO: nonzero may need to be adjusted after tokenization.*/
786   dequant_dc=dequant[0];
787   if(nonzero==0){
788     ogg_int16_t p;
789     int         ci;
790     int         qi01;
791     int         qi12;
792     /*We round this dequant product (and not any of the others) because there's
793        no iDCT rounding.*/
794     p=(ogg_int16_t)(dc*(ogg_int32_t)dequant_dc+15>>5);
795     /*LOOP VECTORIZES.*/
796     for(ci=0;ci<64;ci++)data[ci]=p;
797     /*We didn't code any AC coefficients, so don't change the quantizer.*/
798     qi01=_pipe->qs[_pli].qi01;
799     qi12=_pipe->qs[_pli].qi12;
800     if(qi01>0)qii=1+qi12;
801     else if(qi01>=0)qii=0;
802   }
803   else{
804     data[0]=dc*dequant_dc;
805     oc_idct8x8(&_enc->state,data,data,nonzero+1);
806   }
807   if(nqis>1){
808     oc_qii_state_advance(&qs,_pipe->qs+_pli,qii);
809     ac_bits+=qs.bits-_pipe->qs[_pli].bits;
810   }
811   if(!qti)oc_enc_frag_recon_intra(_enc,dst,ystride,data);
812   else{
813     oc_enc_frag_recon_inter(_enc,dst,
814      nmv_offs==1?ref+mv_offs[0]:dst,ystride,data);
815   }
816   /*If _fr is NULL, then this is an INTRA frame, and we can't skip blocks.*/
817 #if !defined(OC_COLLECT_METRICS)
818   if(_fr!=NULL)
819 #endif
820   {
821     /*In retrospect, should we have skipped this block?*/
822     if(borderi<0){
823       coded_ssd=oc_enc_frag_ssd(_enc,src,dst,ystride);
824     }
825     else{
826       coded_ssd=oc_enc_frag_border_ssd(_enc,src,dst,ystride,
827        _enc->state.borders[borderi].mask);
828     }
829     /*Scale to match DCT domain.*/
830     coded_ssd<<=4;
831 #if defined(OC_COLLECT_METRICS)
832     _enc->frag_ssd[_fragi]=coded_ssd;
833   }
834   if(_fr!=NULL){
835 #endif
836     coded_ssd=OC_RD_SCALE(coded_ssd,_rd_scale);
837     uncoded_ssd=_pipe->skip_ssd[_pli][_fragi-_pipe->froffset[_pli]];
838     if(uncoded_ssd<UINT_MAX&&
839      /*Don't allow luma blocks to be skipped in 4MV mode when VP3 compatibility
840         is enabled.*/
841      (!_enc->vp3_compatible||mb_mode!=OC_MODE_INTER_MV_FOUR||_pli)){
842       int overhead_bits;
843       overhead_bits=oc_fr_cost1(_fr);
844       /*Although the fragment coding overhead determination is accurate, it is
845          greedy, using very coarse-grained local information.
846         Allowing it to mildly discourage coding turns out to be beneficial, but
847          it's not clear that allowing it to encourage coding through negative
848          coding overhead deltas is useful.
849         For that reason, we disallow negative coding overheads.*/
850       if(overhead_bits<0)overhead_bits=0;
851       if(uncoded_ssd<=coded_ssd+(overhead_bits+ac_bits)*_enc->lambda){
852         /*Hm, not worth it; roll back.*/
853         oc_enc_tokenlog_rollback(_enc,checkpoint,(*_stack)-checkpoint);
854         *_stack=checkpoint;
855         frags[_fragi].coded=0;
856         frags[_fragi].refi=OC_FRAME_NONE;
857         oc_fr_skip_block(_fr);
858         return 0;
859       }
860     }
861     else _mo->dc_flag=1;
862     _mo->uncoded_ac_ssd+=uncoded_ssd;
863     _mo->coded_ac_ssd+=coded_ssd;
864     _mo->ac_bits+=ac_bits;
865     oc_fr_code_block(_fr);
866   }
867   /*GCC 4.4.4 generates a warning here because it can't tell that
868      the init code in the nqis check above will run anytime this
869      line runs.*/
870   if(nqis>1)*(_pipe->qs+_pli)=*&qs;
871   frags[_fragi].dc=dc;
872   frags[_fragi].coded=1;
873   return 1;
874 }
875
876 static int oc_enc_mb_transform_quantize_inter_luma(oc_enc_ctx *_enc,
877  oc_enc_pipeline_state *_pipe,unsigned _mbi,int _mode_overhead,
878  const unsigned _rd_scale[4],const unsigned _rd_iscale[4]){
879   /*Worst case token stack usage for 4 fragments.*/
880   oc_token_checkpoint  stack[64*4];
881   oc_token_checkpoint *stackptr;
882   const oc_sb_map     *sb_maps;
883   signed char         *mb_modes;
884   oc_fragment         *frags;
885   ptrdiff_t           *coded_fragis;
886   ptrdiff_t            ncoded_fragis;
887   ptrdiff_t           *uncoded_fragis;
888   ptrdiff_t            nuncoded_fragis;
889   oc_rd_metric         mo;
890   oc_fr_state          fr_checkpoint;
891   oc_qii_state         qs_checkpoint;
892   int                  mb_mode;
893   int                  refi;
894   int                  ncoded;
895   ptrdiff_t            fragi;
896   int                  bi;
897   *&fr_checkpoint=*(_pipe->fr+0);
898   *&qs_checkpoint=*(_pipe->qs+0);
899   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
900   mb_modes=_enc->state.mb_modes;
901   frags=_enc->state.frags;
902   coded_fragis=_pipe->coded_fragis[0];
903   ncoded_fragis=_pipe->ncoded_fragis[0];
904   uncoded_fragis=_pipe->uncoded_fragis[0];
905   nuncoded_fragis=_pipe->nuncoded_fragis[0];
906   mb_mode=mb_modes[_mbi];
907   refi=OC_FRAME_FOR_MODE(mb_mode);
908   ncoded=0;
909   stackptr=stack;
910   memset(&mo,0,sizeof(mo));
911   for(bi=0;bi<4;bi++){
912     fragi=sb_maps[_mbi>>2][_mbi&3][bi];
913     frags[fragi].refi=refi;
914     frags[fragi].mb_mode=mb_mode;
915     if(oc_enc_block_transform_quantize(_enc,_pipe,0,fragi,
916      _rd_scale[bi],_rd_iscale[bi],&mo,_pipe->fr+0,&stackptr)){
917       coded_fragis[ncoded_fragis++]=fragi;
918       ncoded++;
919     }
920     else *(uncoded_fragis-++nuncoded_fragis)=fragi;
921   }
922   if(ncoded>0&&!mo.dc_flag){
923     int cost;
924     /*Some individual blocks were worth coding.
925       See if that's still true when accounting for mode and MV overhead.*/
926     cost=mo.coded_ac_ssd+_enc->lambda*(mo.ac_bits
927      +oc_fr_cost4(&fr_checkpoint,_pipe->fr+0)+_mode_overhead);
928     if(mo.uncoded_ac_ssd<=cost){
929       /*Taking macroblock overhead into account, it is not worth coding this
930          MB.*/
931       oc_enc_tokenlog_rollback(_enc,stack,stackptr-stack);
932       *(_pipe->fr+0)=*&fr_checkpoint;
933       *(_pipe->qs+0)=*&qs_checkpoint;
934       for(bi=0;bi<4;bi++){
935         fragi=sb_maps[_mbi>>2][_mbi&3][bi];
936         if(frags[fragi].coded){
937           *(uncoded_fragis-++nuncoded_fragis)=fragi;
938           frags[fragi].coded=0;
939           frags[fragi].refi=OC_FRAME_NONE;
940         }
941         oc_fr_skip_block(_pipe->fr+0);
942       }
943       ncoded_fragis-=ncoded;
944       ncoded=0;
945     }
946   }
947   /*If no luma blocks coded, the mode is forced.*/
948   if(ncoded==0)mb_modes[_mbi]=OC_MODE_INTER_NOMV;
949   /*Assume that a 1MV with a single coded block is always cheaper than a 4MV
950      with a single coded block.
951     This may not be strictly true: a 4MV computes chroma MVs using (0,0) for
952      skipped blocks, while a 1MV does not.*/
953   else if(ncoded==1&&mb_mode==OC_MODE_INTER_MV_FOUR){
954     mb_modes[_mbi]=OC_MODE_INTER_MV;
955   }
956   _pipe->ncoded_fragis[0]=ncoded_fragis;
957   _pipe->nuncoded_fragis[0]=nuncoded_fragis;
958   return ncoded;
959 }
960
961 static void oc_enc_sb_transform_quantize_inter_chroma(oc_enc_ctx *_enc,
962  oc_enc_pipeline_state *_pipe,int _pli,int _sbi_start,int _sbi_end){
963   const ogg_uint16_t *mcu_rd_scale;
964   const ogg_uint16_t *mcu_rd_iscale;
965   const oc_sb_map    *sb_maps;
966   oc_sb_flags        *sb_flags;
967   oc_fr_state        *fr;
968   ptrdiff_t          *coded_fragis;
969   ptrdiff_t           ncoded_fragis;
970   ptrdiff_t          *uncoded_fragis;
971   ptrdiff_t           nuncoded_fragis;
972   ptrdiff_t           froffset;
973   int                 sbi;
974   fr=_pipe->fr+_pli;
975   mcu_rd_scale=(const ogg_uint16_t *)_enc->mcu_rd_scale;
976   mcu_rd_iscale=(const ogg_uint16_t *)_enc->mcu_rd_iscale;
977   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
978   sb_flags=_enc->state.sb_flags;
979   coded_fragis=_pipe->coded_fragis[_pli];
980   ncoded_fragis=_pipe->ncoded_fragis[_pli];
981   uncoded_fragis=_pipe->uncoded_fragis[_pli];
982   nuncoded_fragis=_pipe->nuncoded_fragis[_pli];
983   froffset=_pipe->froffset[_pli];
984   for(sbi=_sbi_start;sbi<_sbi_end;sbi++){
985     /*Worst case token stack usage for 1 fragment.*/
986     oc_token_checkpoint stack[64];
987     oc_rd_metric        mo;
988     int                 quadi;
989     int                 bi;
990     memset(&mo,0,sizeof(mo));
991     for(quadi=0;quadi<4;quadi++)for(bi=0;bi<4;bi++){
992       ptrdiff_t fragi;
993       fragi=sb_maps[sbi][quadi][bi];
994       if(fragi>=0){
995         oc_token_checkpoint *stackptr;
996         unsigned             rd_scale;
997         unsigned             rd_iscale;
998         rd_scale=mcu_rd_scale[fragi-froffset];
999         rd_iscale=mcu_rd_iscale[fragi-froffset];
1000         stackptr=stack;
1001         if(oc_enc_block_transform_quantize(_enc,_pipe,_pli,fragi,
1002          rd_scale,rd_iscale,&mo,fr,&stackptr)){
1003           coded_fragis[ncoded_fragis++]=fragi;
1004         }
1005         else *(uncoded_fragis-++nuncoded_fragis)=fragi;
1006       }
1007     }
1008     oc_fr_state_flush_sb(fr);
1009     sb_flags[sbi].coded_fully=fr->sb_full;
1010     sb_flags[sbi].coded_partially=fr->sb_partial;
1011   }
1012   _pipe->ncoded_fragis[_pli]=ncoded_fragis;
1013   _pipe->nuncoded_fragis[_pli]=nuncoded_fragis;
1014 }
1015
1016 /*Mode decision is done by exhaustively examining all potential choices.
1017   Obviously, doing the motion compensation, fDCT, tokenization, and then
1018    counting the bits each token uses is computationally expensive.
1019   Theora's EOB runs can also split the cost of these tokens across multiple
1020    fragments, and naturally we don't know what the optimal choice of Huffman
1021    codes will be until we know all the tokens we're going to encode in all the
1022    fragments.
1023   So we use a simple approach to estimating the bit cost and distortion of each
1024    mode based upon the SATD value of the residual before coding.
1025   The mathematics behind the technique are outlined by Kim \cite{Kim03}, but
1026    the process (modified somewhat from that of the paper) is very simple.
1027   We build a non-linear regression of the mappings from
1028    (pre-transform+quantization) SATD to (post-transform+quantization) bits and
1029    SSD for each qi.
1030   A separate set of mappings is kept for each quantization type and color
1031    plane.
1032   The mappings are constructed by partitioning the SATD values into a small
1033    number of bins (currently 24) and using a linear regression in each bin
1034    (as opposed to the 0th-order regression used by Kim).
1035   The bit counts and SSD measurements are obtained by examining actual encoded
1036    frames, with appropriate lambda values and optimal Huffman codes selected.
1037   EOB bits are assigned to the fragment that started the EOB run (as opposed to
1038    dividing them among all the blocks in the run; the latter approach seems
1039    more theoretically correct, but Monty's testing showed a small improvement
1040    with the former, though that may have been merely statistical noise).
1041
1042   @ARTICLE{Kim03,
1043     author="Hyun Mun Kim",
1044     title="Adaptive Rate Control Using Nonlinear Regression",
1045     journal="IEEE Transactions on Circuits and Systems for Video Technology",
1046     volume=13,
1047     number=5,
1048     pages="432--439",
1049     month=May,
1050     year=2003
1051   }*/
1052
1053 /*Computes (_ssd+_lambda*_rate)/(1<<OC_BIT_SCALE) with rounding, avoiding
1054    overflow for large lambda values.*/
1055 #define OC_MODE_RD_COST(_ssd,_rate,_lambda) \
1056  ((_ssd)>>OC_BIT_SCALE)+((_rate)>>OC_BIT_SCALE)*(_lambda) \
1057  +(((_ssd)&(1<<OC_BIT_SCALE)-1)+((_rate)&(1<<OC_BIT_SCALE)-1)*(_lambda) \
1058  +((1<<OC_BIT_SCALE)>>1)>>OC_BIT_SCALE)
1059
1060 static void oc_enc_mode_rd_init(oc_enc_ctx *_enc){
1061   int qii;
1062 #if defined(OC_COLLECT_METRICS)
1063   oc_enc_mode_metrics_load(_enc);
1064 #endif
1065   for(qii=0;qii<_enc->state.nqis;qii++){
1066     int qi;
1067     int pli;
1068     qi=_enc->state.qis[qii];
1069     for(pli=0;pli<3;pli++){
1070       int qti;
1071       for(qti=0;qti<2;qti++){
1072         int log_plq;
1073         int modeline;
1074         int bin;
1075         int dx;
1076         int dq;
1077         log_plq=_enc->log_plq[qi][pli][qti];
1078         /*Find the pair of rows in the mode table that bracket this quantizer.
1079           If it falls outside the range the table covers, then we just use a
1080            pair on the edge for linear extrapolation.*/
1081         for(modeline=0;modeline<OC_LOGQ_BINS-1&&
1082          OC_MODE_LOGQ[modeline+1][pli][qti]>log_plq;modeline++);
1083         /*Interpolate a row for this quantizer.*/
1084         dx=OC_MODE_LOGQ[modeline][pli][qti]-log_plq;
1085         dq=OC_MODE_LOGQ[modeline][pli][qti]-OC_MODE_LOGQ[modeline+1][pli][qti];
1086         if(dq==0)dq=1;
1087         for(bin=0;bin<OC_SAD_BINS;bin++){
1088           int y0;
1089           int z0;
1090           int dy;
1091           int dz;
1092           y0=OC_MODE_RD[modeline][pli][qti][bin].rate;
1093           z0=OC_MODE_RD[modeline][pli][qti][bin].rmse;
1094           dy=OC_MODE_RD[modeline+1][pli][qti][bin].rate-y0;
1095           dz=OC_MODE_RD[modeline+1][pli][qti][bin].rmse-z0;
1096           _enc->mode_rd[qii][pli][qti][bin].rate=
1097            (ogg_int16_t)OC_CLAMPI(-32768,y0+(dy*dx+(dq>>1))/dq,32767);
1098           _enc->mode_rd[qii][pli][qti][bin].rmse=
1099            (ogg_int16_t)OC_CLAMPI(-32768,z0+(dz*dx+(dq>>1))/dq,32767);
1100         }
1101       }
1102     }
1103   }
1104 }
1105
1106 /*Estimate the R-D cost of the DCT coefficients given the SATD of a block after
1107    prediction.*/
1108 static unsigned oc_dct_cost2(oc_enc_ctx *_enc,unsigned *_ssd,
1109  int _qii,int _pli,int _qti,int _satd){
1110   unsigned rmse;
1111   int      bin;
1112   int      dx;
1113   int      y0;
1114   int      z0;
1115   int      dy;
1116   int      dz;
1117   /*SATD metrics for chroma planes vary much less than luma, so we scale them
1118      by 4 to distribute them into the mode decision bins more evenly.*/
1119   _satd<<=_pli+1&2;
1120   bin=OC_MINI(_satd>>OC_SAD_SHIFT,OC_SAD_BINS-2);
1121   dx=_satd-(bin<<OC_SAD_SHIFT);
1122   y0=_enc->mode_rd[_qii][_pli][_qti][bin].rate;
1123   z0=_enc->mode_rd[_qii][_pli][_qti][bin].rmse;
1124   dy=_enc->mode_rd[_qii][_pli][_qti][bin+1].rate-y0;
1125   dz=_enc->mode_rd[_qii][_pli][_qti][bin+1].rmse-z0;
1126   rmse=OC_MAXI(z0+(dz*dx>>OC_SAD_SHIFT),0);
1127   *_ssd=rmse*rmse>>2*OC_RMSE_SCALE-OC_BIT_SCALE;
1128   return OC_MAXI(y0+(dy*dx>>OC_SAD_SHIFT),0);
1129 }
1130
1131 /*activity_avg must be positive, or flat regions could get a zero weight, which
1132    confounds analysis.
1133   We set the minimum to this value so that it also avoids the need for divide
1134    by zero checks in oc_mb_masking().*/
1135 # define OC_ACTIVITY_AVG_MIN (1<<OC_RD_SCALE_BITS)
1136
1137 static unsigned oc_mb_activity(oc_enc_ctx *_enc,unsigned _mbi,
1138  unsigned _activity[4]){
1139   const unsigned char   *src;
1140   const ptrdiff_t       *frag_buf_offs;
1141   const ptrdiff_t       *sb_map;
1142   unsigned               luma;
1143   int                    ystride;
1144   ptrdiff_t              frag_offs;
1145   ptrdiff_t              fragi;
1146   int                    bi;
1147   frag_buf_offs=_enc->state.frag_buf_offs;
1148   sb_map=_enc->state.sb_maps[_mbi>>2][_mbi&3];
1149   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
1150   ystride=_enc->state.ref_ystride[0];
1151   luma=0;
1152   for(bi=0;bi<4;bi++){
1153     const unsigned char *s;
1154     unsigned             x;
1155     unsigned             x2;
1156     unsigned             act;
1157     int                  i;
1158     int                  j;
1159     fragi=sb_map[bi];
1160     frag_offs=frag_buf_offs[fragi];
1161     /*TODO: This could be replaced with SATD^2, since we already have to
1162        compute SATD.*/
1163     x=x2=0;
1164     s=src+frag_offs;
1165     for(i=0;i<8;i++){
1166       for(j=0;j<8;j++){
1167         unsigned c;
1168         c=s[j];
1169         x+=c;
1170         x2+=c*c;
1171       }
1172       s+=ystride;
1173     }
1174     luma+=x;
1175     act=(x2<<6)-x*x;
1176     if(act<8<<12){
1177       /*The region is flat.*/
1178       act=OC_MINI(act,5<<12);
1179     }
1180     else{
1181       unsigned e1;
1182       unsigned e2;
1183       unsigned e3;
1184       unsigned e4;
1185       /*Test for an edge.
1186         TODO: There are probably much simpler ways to do this (e.g., it could
1187          probably be combined with the SATD calculation).
1188         Alternatively, we could split the block around the mean and compute the
1189          reduction in variance in each half.
1190         For a Gaussian source the reduction should be
1191          (1-2/pi) ~= 0.36338022763241865692446494650994.
1192         Significantly more reduction is a good indication of a bi-level image.
1193         This has the advantage of identifying, in addition to straight edges,
1194          small text regions, which would otherwise be classified as "texture".*/
1195       e1=e2=e3=e4=0;
1196       s=src+frag_offs-1;
1197       for(i=0;i<8;i++){
1198         for(j=0;j<8;j++){
1199           e1+=abs((s[j+2]-s[j]<<1)+(s-ystride)[j+2]-(s-ystride)[j]
1200            +(s+ystride)[j+2]-(s+ystride)[j]);
1201           e2+=abs(((s+ystride)[j+1]-(s-ystride)[j+1]<<1)
1202            +(s+ystride)[j]-(s-ystride)[j]+(s+ystride)[j+2]-(s-ystride)[j+2]);
1203           e3+=abs(((s+ystride)[j+2]-(s-ystride)[j]<<1)
1204            +(s+ystride)[j+1]-s[j]+s[j+2]-(s-ystride)[j+1]);
1205           e4+=abs(((s+ystride)[j]-(s-ystride)[j+2]<<1)
1206            +(s+ystride)[j+1]-s[j+2]+s[j]-(s-ystride)[j+1]);
1207         }
1208         s+=ystride;
1209       }
1210       /*If the largest component of the edge energy is at least 40% of the
1211          total, then classify the block as an edge block.*/
1212       if(5*OC_MAXI(OC_MAXI(e1,e2),OC_MAXI(e3,e4))>2*(e1+e2+e3+e4)){
1213          /*act=act_th*(act/act_th)**0.7
1214               =exp(log(act_th)+0.7*(log(act)-log(act_th))).
1215            Here act_th=5.0 and 0x394A=oc_blog32_q10(5<<12).*/
1216          act=oc_bexp32_q10(0x394A+(7*(oc_blog32_q10(act)-0x394A+5)/10));
1217       }
1218     }
1219     _activity[bi]=act;
1220   }
1221   return luma;
1222 }
1223
1224 static unsigned oc_mb_activity_fast(oc_enc_ctx *_enc,unsigned _mbi,
1225  unsigned _activity[4], unsigned _intra_satd[12]){
1226   int bi;
1227   for(bi=0;bi<4;bi++){
1228     unsigned act;
1229     act=(11*_intra_satd[bi]>>8)*_intra_satd[bi];
1230     if(act<8<<12){
1231       /*The region is flat.*/
1232       act=OC_MINI(act,5<<12);
1233     }
1234     _activity[bi]=act;
1235   }
1236   /*TODO: Once frag_intra_satd returns the signed DC value instead
1237      of the absolute value, this should pass it through.*/
1238   return 1;
1239 }
1240
1241 /*Compute the masking scales for the blocks in a macro block.
1242   All masking is computed from the luma blocks.
1243   We derive scaling factors for the chroma blocks from these, and use the same
1244    ones for all chroma blocks, regardless of the subsampling.
1245   It's possible for luma to be perfectly flat and yet have high chroma energy,
1246    but this is unlikely in non-artificial images, and not a case that has been
1247    addressed by any research to my knowledge.
1248   The output of the masking process is two scale factors, which are fed into
1249    the various R-D optimizations.
1250   The first, rd_scale, is applied to D in the equation
1251     D*rd_scale+lambda*R.
1252   This is the form that must be used to properly combine scores from multiple
1253    blocks, and can be interpreted as scaling distortions by their visibility.
1254   The inverse, rd_iscale, is applied to lambda in the equation
1255     D+rd_iscale*lambda*R.
1256   This is equivalent to the first form within a single block, but much faster
1257    to use when evaluating many possible distortions (e.g., during actual
1258    quantization, where separate distortions are evaluated for every
1259    coefficient).
1260   The two macros OC_RD_SCALE(rd_scale,d) and OC_RD_ISCALE(rd_iscale,lambda) are
1261    used to perform the multiplications with the proper re-scaling for the range
1262    of the scaling factors.
1263   Many researchers apply masking values directly to the quantizers used, and
1264    not to the R-D cost.
1265   Since we generally use MSE for D, rd_scale must use the square of their
1266    values to generate an equivalent effect.*/
1267 static unsigned oc_mb_masking(unsigned _rd_scale[5],unsigned _rd_iscale[5],
1268  const ogg_uint16_t _chroma_rd_scale[2],const unsigned _activity[4],
1269  unsigned _activity_avg,unsigned _luma,unsigned _luma_avg){
1270   unsigned activity_sum;
1271   unsigned la;
1272   unsigned lb;
1273   unsigned d;
1274   int      bi;
1275   int      bi_min;
1276   int      bi_min2;
1277   /*The ratio lb/la is meant to approximate
1278      ((((_luma-16)/219)*(255/128))**0.649**0.4**2), which is the
1279      effective luminance masking from~\cite{LKW06} (including the self-masking
1280      deflator).
1281     The following actually turns out to be a pretty good approximation for
1282      _luma>75 or so.
1283     For smaller values luminance does not really follow Weber's Law anyway, and
1284      this approximation gives a much less aggressive bitrate boost in this
1285      region.
1286     Though some researchers claim that contrast sensitivity actually decreases
1287      for very low luminance values, in my experience excessive brightness on
1288      LCDs or buggy color conversions (e.g., treating Y' as full-range instead
1289      of the CCIR 601 range) make artifacts in such regions extremely visible.
1290     We substitute _luma_avg for 128 to allow the strength of the masking to
1291      vary with the actual average image luminance, within certain limits (the
1292      caller has clamped _luma_avg to the range [90,160], inclusive).
1293     @ARTICLE{LKW06,
1294       author="Zhen Liu and Lina J. Karam and Andrew B. Watson",
1295       title="{JPEG2000} Encoding With Perceptual Distortion Control",
1296       journal="{IEEE} Transactions on Image Processing",
1297       volume=15,
1298       number=7,
1299       pages="1763--1778",
1300       month=Jul,
1301       year=2006
1302     }*/
1303 #if 0
1304   la=_luma+4*_luma_avg;
1305   lb=4*_luma+_luma_avg;
1306 #else
1307   /*Disable luminance masking.*/
1308   la=lb=1;
1309 #endif
1310   activity_sum=0;
1311   for(bi=0;bi<4;bi++){
1312     unsigned a;
1313     unsigned b;
1314     activity_sum+=_activity[bi];
1315     /*Apply activity masking.*/
1316     a=_activity[bi]+4*_activity_avg;
1317     b=4*_activity[bi]+_activity_avg;
1318     d=OC_RD_SCALE(b,1);
1319     /*And luminance masking.*/
1320     d=(a+(d>>1))/d;
1321     _rd_scale[bi]=(d*la+(lb>>1))/lb;
1322     /*And now the inverse.*/
1323     d=OC_MAXI(OC_RD_ISCALE(a,1),1);
1324     d=(b+(d>>1))/d;
1325     _rd_iscale[bi]=(d*lb+(la>>1))/la;
1326   }
1327   /*Now compute scaling factors for chroma blocks.
1328     We start by finding the two smallest iscales from the luma blocks.*/
1329   bi_min=_rd_iscale[1]<_rd_iscale[0];
1330   bi_min2=1-bi_min;
1331   for(bi=2;bi<4;bi++){
1332     if(_rd_iscale[bi]<_rd_iscale[bi_min]){
1333       bi_min2=bi_min;
1334       bi_min=bi;
1335     }
1336     else if(_rd_iscale[bi]<_rd_iscale[bi_min2])bi_min2=bi;
1337   }
1338   /*If the minimum iscale is less than 1.0, use the second smallest instead,
1339      and force the value to at least 1.0 (inflating chroma is a waste).*/
1340   if(_rd_iscale[bi_min]<(1<<OC_RD_ISCALE_BITS))bi_min=bi_min2;
1341   d=OC_MINI(_rd_scale[bi_min],1<<OC_RD_SCALE_BITS);
1342   _rd_scale[4]=OC_RD_SCALE(d,_chroma_rd_scale[0]);
1343   d=OC_MAXI(_rd_iscale[bi_min],1<<OC_RD_ISCALE_BITS);
1344   _rd_iscale[4]=OC_RD_ISCALE(d,_chroma_rd_scale[1]);
1345   return activity_sum;
1346 }
1347
1348 static void oc_mb_intra_satd(oc_enc_ctx *_enc,unsigned _mbi,
1349  unsigned _frag_satd[12]){
1350   const unsigned char   *src;
1351   const ptrdiff_t       *frag_buf_offs;
1352   const ptrdiff_t       *sb_map;
1353   const oc_mb_map_plane *mb_map;
1354   const unsigned char   *map_idxs;
1355   int                    map_nidxs;
1356   int                    mapii;
1357   int                    mapi;
1358   int                    ystride;
1359   int                    pli;
1360   int                    bi;
1361   ptrdiff_t              fragi;
1362   ptrdiff_t              frag_offs;
1363   unsigned               dc;
1364   frag_buf_offs=_enc->state.frag_buf_offs;
1365   sb_map=_enc->state.sb_maps[_mbi>>2][_mbi&3];
1366   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
1367   ystride=_enc->state.ref_ystride[0];
1368   for(bi=0;bi<4;bi++){
1369     fragi=sb_map[bi];
1370     frag_offs=frag_buf_offs[fragi];
1371     _frag_satd[bi]=oc_enc_frag_intra_satd(_enc,&dc,src+frag_offs,ystride);
1372   }
1373   mb_map=(const oc_mb_map_plane *)_enc->state.mb_maps[_mbi];
1374   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
1375   map_nidxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
1376   /*Note: This assumes ref_ystride[1]==ref_ystride[2].*/
1377   ystride=_enc->state.ref_ystride[1];
1378   for(mapii=4;mapii<map_nidxs;mapii++){
1379     mapi=map_idxs[mapii];
1380     pli=mapi>>2;
1381     bi=mapi&3;
1382     fragi=mb_map[pli][bi];
1383     frag_offs=frag_buf_offs[fragi];
1384     _frag_satd[mapii]=oc_enc_frag_intra_satd(_enc,&dc,src+frag_offs,ystride);
1385   }
1386 }
1387
1388 /*Select luma block-level quantizers for a MB in an INTRA frame.*/
1389 static unsigned oc_analyze_intra_mb_luma(oc_enc_ctx *_enc,
1390  const oc_qii_state *_qs,unsigned _mbi,const unsigned _rd_scale[4]){
1391   const unsigned char *src;
1392   const ptrdiff_t     *frag_buf_offs;
1393   const oc_sb_map     *sb_maps;
1394   oc_fragment         *frags;
1395   ptrdiff_t            frag_offs;
1396   ptrdiff_t            fragi;
1397   oc_qii_state         qs[4][3];
1398   unsigned             cost[4][3];
1399   unsigned             ssd[4][3];
1400   unsigned             rate[4][3];
1401   int                  prev[3][3];
1402   unsigned             satd;
1403   unsigned             dc;
1404   unsigned             best_cost;
1405   unsigned             best_ssd;
1406   unsigned             best_rate;
1407   int                  best_qii;
1408   int                  qii;
1409   int                  lambda;
1410   int                  ystride;
1411   int                  nqis;
1412   int                  bi;
1413   frag_buf_offs=_enc->state.frag_buf_offs;
1414   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
1415   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
1416   ystride=_enc->state.ref_ystride[0];
1417   fragi=sb_maps[_mbi>>2][_mbi&3][0];
1418   frag_offs=frag_buf_offs[fragi];
1419   satd=oc_enc_frag_intra_satd(_enc,&dc,src+frag_offs,ystride);
1420   nqis=_enc->state.nqis;
1421   lambda=_enc->lambda;
1422   for(qii=0;qii<nqis;qii++){
1423     oc_qii_state_advance(qs[0]+qii,_qs,qii);
1424     rate[0][qii]=oc_dct_cost2(_enc,ssd[0]+qii,qii,0,0,satd)
1425      +(qs[0][qii].bits-_qs->bits<<OC_BIT_SCALE);
1426     ssd[0][qii]=OC_RD_SCALE(ssd[0][qii],_rd_scale[0]);
1427     cost[0][qii]=OC_MODE_RD_COST(ssd[0][qii],rate[0][qii],lambda);
1428   }
1429   for(bi=1;bi<4;bi++){
1430     fragi=sb_maps[_mbi>>2][_mbi&3][bi];
1431     frag_offs=frag_buf_offs[fragi];
1432     satd=oc_enc_frag_intra_satd(_enc,&dc,src+frag_offs,ystride);
1433     for(qii=0;qii<nqis;qii++){
1434       oc_qii_state qt[3];
1435       unsigned     cur_ssd;
1436       unsigned     cur_rate;
1437       int          best_qij;
1438       int          qij;
1439       oc_qii_state_advance(qt+0,qs[bi-1]+0,qii);
1440       cur_rate=oc_dct_cost2(_enc,&cur_ssd,qii,0,0,satd);
1441       cur_ssd=OC_RD_SCALE(cur_ssd,_rd_scale[bi]);
1442       best_ssd=ssd[bi-1][0]+cur_ssd;
1443       best_rate=rate[bi-1][0]+cur_rate
1444        +(qt[0].bits-qs[bi-1][0].bits<<OC_BIT_SCALE);
1445       best_cost=OC_MODE_RD_COST(best_ssd,best_rate,lambda);
1446       best_qij=0;
1447       for(qij=1;qij<nqis;qij++){
1448         unsigned chain_ssd;
1449         unsigned chain_rate;
1450         unsigned chain_cost;
1451         oc_qii_state_advance(qt+qij,qs[bi-1]+qij,qii);
1452         chain_ssd=ssd[bi-1][qij]+cur_ssd;
1453         chain_rate=rate[bi-1][qij]+cur_rate
1454          +(qt[qij].bits-qs[bi-1][qij].bits<<OC_BIT_SCALE);
1455         chain_cost=OC_MODE_RD_COST(chain_ssd,chain_rate,lambda);
1456         if(chain_cost<best_cost){
1457           best_cost=chain_cost;
1458           best_ssd=chain_ssd;
1459           best_rate=chain_rate;
1460           best_qij=qij;
1461         }
1462       }
1463       *(qs[bi]+qii)=*(qt+best_qij);
1464       cost[bi][qii]=best_cost;
1465       ssd[bi][qii]=best_ssd;
1466       rate[bi][qii]=best_rate;
1467       prev[bi-1][qii]=best_qij;
1468     }
1469   }
1470   best_qii=0;
1471   best_cost=cost[3][0];
1472   for(qii=1;qii<nqis;qii++){
1473     if(cost[3][qii]<best_cost){
1474       best_cost=cost[3][qii];
1475       best_qii=qii;
1476     }
1477   }
1478   frags=_enc->state.frags;
1479   for(bi=3;;){
1480     fragi=sb_maps[_mbi>>2][_mbi&3][bi];
1481     frags[fragi].qii=best_qii;
1482     if(bi--<=0)break;
1483     best_qii=prev[bi][best_qii];
1484   }
1485   return best_cost;
1486 }
1487
1488 /*Select a block-level quantizer for a single chroma block in an INTRA frame.*/
1489 static unsigned oc_analyze_intra_chroma_block(oc_enc_ctx *_enc,
1490  const oc_qii_state *_qs,int _pli,ptrdiff_t _fragi,unsigned _rd_scale){
1491   const unsigned char *src;
1492   oc_fragment         *frags;
1493   ptrdiff_t            frag_offs;
1494   oc_qii_state         qt[3];
1495   unsigned             cost[3];
1496   unsigned             satd;
1497   unsigned             dc;
1498   unsigned             best_cost;
1499   int                  best_qii;
1500   int                  qii;
1501   int                  lambda;
1502   int                  ystride;
1503   int                  nqis;
1504   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
1505   ystride=_enc->state.ref_ystride[_pli];
1506   frag_offs=_enc->state.frag_buf_offs[_fragi];
1507   satd=oc_enc_frag_intra_satd(_enc,&dc,src+frag_offs,ystride);
1508   /*Most chroma blocks have no AC coefficients to speak of anyway, so it's not
1509      worth spending the bits to change the AC quantizer.
1510     TODO: This may be worth revisiting when we separate out DC and AC
1511      predictions from SATD.*/
1512 #if 0
1513   nqis=_enc->state.nqis;
1514 #else
1515   nqis=1;
1516 #endif
1517   lambda=_enc->lambda;
1518   best_qii=0;
1519   for(qii=0;qii<nqis;qii++){
1520     unsigned cur_rate;
1521     unsigned cur_ssd;
1522     oc_qii_state_advance(qt+qii,_qs,qii);
1523     cur_rate=oc_dct_cost2(_enc,&cur_ssd,qii,_pli,0,satd)
1524      +(qt[qii].bits-_qs->bits<<OC_BIT_SCALE);
1525     cur_ssd=OC_RD_SCALE(cur_ssd,_rd_scale);
1526     cost[qii]=OC_MODE_RD_COST(cur_ssd,cur_rate,lambda);
1527   }
1528   best_cost=cost[0];
1529   for(qii=1;qii<nqis;qii++){
1530     if(cost[qii]<best_cost){
1531       best_cost=cost[qii];
1532       best_qii=qii;
1533     }
1534   }
1535   frags=_enc->state.frags;
1536   frags[_fragi].qii=best_qii;
1537   return best_cost;
1538 }
1539
1540 static void oc_enc_mb_transform_quantize_intra_luma(oc_enc_ctx *_enc,
1541  oc_enc_pipeline_state *_pipe,unsigned _mbi,
1542  const unsigned _rd_scale[4],const unsigned _rd_iscale[4]){
1543   /*Worst case token stack usage for 4 fragments.*/
1544   oc_token_checkpoint  stack[64*4];
1545   oc_token_checkpoint *stackptr;
1546   const oc_sb_map     *sb_maps;
1547   signed char         *mb_modes;
1548   oc_fragment         *frags;
1549   ptrdiff_t           *coded_fragis;
1550   ptrdiff_t            ncoded_fragis;
1551   ptrdiff_t            fragi;
1552   int                  bi;
1553   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
1554   mb_modes=_enc->state.mb_modes;
1555   frags=_enc->state.frags;
1556   coded_fragis=_pipe->coded_fragis[0];
1557   ncoded_fragis=_pipe->ncoded_fragis[0];
1558   stackptr=stack;
1559   for(bi=0;bi<4;bi++){
1560     fragi=sb_maps[_mbi>>2][_mbi&3][bi];
1561     frags[fragi].refi=OC_FRAME_SELF;
1562     frags[fragi].mb_mode=OC_MODE_INTRA;
1563     oc_enc_block_transform_quantize(_enc,_pipe,0,fragi,
1564      _rd_scale[bi],_rd_iscale[bi],NULL,NULL,&stackptr);
1565     coded_fragis[ncoded_fragis++]=fragi;
1566   }
1567   _pipe->ncoded_fragis[0]=ncoded_fragis;
1568 }
1569
1570 static void oc_enc_sb_transform_quantize_intra_chroma(oc_enc_ctx *_enc,
1571  oc_enc_pipeline_state *_pipe,int _pli,int _sbi_start,int _sbi_end){
1572   const ogg_uint16_t *mcu_rd_scale;
1573   const ogg_uint16_t *mcu_rd_iscale;
1574   const oc_sb_map    *sb_maps;
1575   ptrdiff_t          *coded_fragis;
1576   ptrdiff_t           ncoded_fragis;
1577   ptrdiff_t           froffset;
1578   int                 sbi;
1579   mcu_rd_scale=(const ogg_uint16_t *)_enc->mcu_rd_scale;
1580   mcu_rd_iscale=(const ogg_uint16_t *)_enc->mcu_rd_iscale;
1581   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
1582   coded_fragis=_pipe->coded_fragis[_pli];
1583   ncoded_fragis=_pipe->ncoded_fragis[_pli];
1584   froffset=_pipe->froffset[_pli];
1585   for(sbi=_sbi_start;sbi<_sbi_end;sbi++){
1586     /*Worst case token stack usage for 1 fragment.*/
1587     oc_token_checkpoint stack[64];
1588     int                 quadi;
1589     int                 bi;
1590     for(quadi=0;quadi<4;quadi++)for(bi=0;bi<4;bi++){
1591       ptrdiff_t fragi;
1592       fragi=sb_maps[sbi][quadi][bi];
1593       if(fragi>=0){
1594         oc_token_checkpoint *stackptr;
1595         unsigned             rd_scale;
1596         unsigned             rd_iscale;
1597         rd_scale=mcu_rd_scale[fragi-froffset];
1598         rd_iscale=mcu_rd_iscale[fragi-froffset];
1599         oc_analyze_intra_chroma_block(_enc,_pipe->qs+_pli,_pli,fragi,rd_scale);
1600         stackptr=stack;
1601         oc_enc_block_transform_quantize(_enc,_pipe,_pli,fragi,
1602          rd_scale,rd_iscale,NULL,NULL,&stackptr);
1603         coded_fragis[ncoded_fragis++]=fragi;
1604       }
1605     }
1606   }
1607   _pipe->ncoded_fragis[_pli]=ncoded_fragis;
1608 }
1609
1610 /*Analysis stage for an INTRA frame.*/
1611 void oc_enc_analyze_intra(oc_enc_ctx *_enc,int _recode){
1612   ogg_int64_t             activity_sum;
1613   ogg_int64_t             luma_sum;
1614   unsigned                activity_avg;
1615   unsigned                luma_avg;
1616   const ogg_uint16_t     *chroma_rd_scale;
1617   ogg_uint16_t           *mcu_rd_scale;
1618   ogg_uint16_t           *mcu_rd_iscale;
1619   const unsigned char    *map_idxs;
1620   int                     nmap_idxs;
1621   oc_sb_flags            *sb_flags;
1622   signed char            *mb_modes;
1623   const oc_mb_map        *mb_maps;
1624   const oc_sb_map        *sb_maps;
1625   oc_fragment            *frags;
1626   unsigned                stripe_sby;
1627   unsigned                mcu_nvsbs;
1628   int                     notstart;
1629   int                     notdone;
1630   int                     refi;
1631   int                     pli;
1632   _enc->state.frame_type=OC_INTRA_FRAME;
1633   oc_enc_tokenize_start(_enc);
1634   oc_enc_pipeline_init(_enc,&_enc->pipe);
1635   oc_enc_mode_rd_init(_enc);
1636   activity_sum=luma_sum=0;
1637   activity_avg=_enc->activity_avg;
1638   luma_avg=OC_CLAMPI(90<<8,_enc->luma_avg,160<<8);
1639   chroma_rd_scale=_enc->chroma_rd_scale[OC_INTRA_FRAME][_enc->state.qis[0]];
1640   mcu_rd_scale=_enc->mcu_rd_scale;
1641   mcu_rd_iscale=_enc->mcu_rd_iscale;
1642   /*Choose MVs and MB modes and quantize and code luma.
1643     Must be done in Hilbert order.*/
1644   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
1645   nmap_idxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
1646   _enc->state.ncoded_fragis[0]=0;
1647   _enc->state.ncoded_fragis[1]=0;
1648   _enc->state.ncoded_fragis[2]=0;
1649   sb_flags=_enc->state.sb_flags;
1650   mb_modes=_enc->state.mb_modes;
1651   mb_maps=(const oc_mb_map *)_enc->state.mb_maps;
1652   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
1653   frags=_enc->state.frags;
1654   notstart=0;
1655   notdone=1;
1656   mcu_nvsbs=_enc->mcu_nvsbs;
1657   for(stripe_sby=0;notdone;stripe_sby+=mcu_nvsbs){
1658     ptrdiff_t cfroffset;
1659     unsigned  sbi;
1660     unsigned  sbi_end;
1661     notdone=oc_enc_pipeline_set_stripe(_enc,&_enc->pipe,stripe_sby);
1662     sbi_end=_enc->pipe.sbi_end[0];
1663     cfroffset=_enc->pipe.froffset[1];
1664     for(sbi=_enc->pipe.sbi0[0];sbi<sbi_end;sbi++){
1665       int quadi;
1666       /*Mode addressing is through Y plane, always 4 MB per SB.*/
1667       for(quadi=0;quadi<4;quadi++)if(sb_flags[sbi].quad_valid&1<<quadi){
1668         unsigned  activity[4];
1669         unsigned  rd_scale[5];
1670         unsigned  rd_iscale[5];
1671         unsigned  luma;
1672         unsigned  mbi;
1673         int       mapii;
1674         int       mapi;
1675         int       bi;
1676         ptrdiff_t fragi;
1677         mbi=sbi<<2|quadi;
1678         /*Activity masking.*/
1679         if(_enc->sp_level<OC_SP_LEVEL_FAST_ANALYSIS){
1680           luma=oc_mb_activity(_enc,mbi,activity);
1681         }
1682         else{
1683           unsigned intra_satd[12];
1684           oc_mb_intra_satd(_enc,mbi,intra_satd);
1685           luma=oc_mb_activity_fast(_enc,mbi,activity,intra_satd);
1686           for(bi=0;bi<4;bi++)frags[sb_maps[mbi>>2][mbi&3][bi]].qii=0;
1687         }
1688         activity_sum+=oc_mb_masking(rd_scale,rd_iscale,
1689          chroma_rd_scale,activity,activity_avg,luma,luma_avg);
1690         luma_sum+=luma;
1691         /*Motion estimation:
1692           We do a basic 1MV search for all macroblocks, coded or not,
1693            keyframe or not, unless we aren't using motion estimation at all.*/
1694         if(!_recode&&_enc->state.curframe_num>0&&
1695          _enc->sp_level<OC_SP_LEVEL_NOMC&&_enc->keyframe_frequency_force>1){
1696           oc_mcenc_search(_enc,mbi);
1697         }
1698         if(_enc->sp_level<OC_SP_LEVEL_FAST_ANALYSIS){
1699           oc_analyze_intra_mb_luma(_enc,_enc->pipe.qs+0,mbi,rd_scale);
1700         }
1701         mb_modes[mbi]=OC_MODE_INTRA;
1702         oc_enc_mb_transform_quantize_intra_luma(_enc,&_enc->pipe,
1703          mbi,rd_scale,rd_iscale);
1704         /*Propagate final MB mode and MVs to the chroma blocks.*/
1705         for(mapii=4;mapii<nmap_idxs;mapii++){
1706           mapi=map_idxs[mapii];
1707           pli=mapi>>2;
1708           bi=mapi&3;
1709           fragi=mb_maps[mbi][pli][bi];
1710           frags[fragi].refi=OC_FRAME_SELF;
1711           frags[fragi].mb_mode=OC_MODE_INTRA;
1712         }
1713         /*Save masking scale factors for chroma blocks.*/
1714         for(mapii=4;mapii<(nmap_idxs-4>>1)+4;mapii++){
1715           mapi=map_idxs[mapii];
1716           bi=mapi&3;
1717           fragi=mb_maps[mbi][1][bi];
1718           mcu_rd_scale[fragi-cfroffset]=(ogg_uint16_t)rd_scale[4];
1719           mcu_rd_iscale[fragi-cfroffset]=(ogg_uint16_t)rd_iscale[4];
1720         }
1721       }
1722     }
1723     oc_enc_pipeline_finish_mcu_plane(_enc,&_enc->pipe,0,notstart,notdone);
1724     /*Code chroma planes.*/
1725     for(pli=1;pli<3;pli++){
1726       oc_enc_sb_transform_quantize_intra_chroma(_enc,&_enc->pipe,
1727        pli,_enc->pipe.sbi0[pli],_enc->pipe.sbi_end[pli]);
1728       oc_enc_pipeline_finish_mcu_plane(_enc,&_enc->pipe,pli,notstart,notdone);
1729     }
1730     notstart=1;
1731   }
1732   /*Compute the average block activity and MB luma score for the frame.*/
1733   _enc->activity_avg=OC_MAXI(OC_ACTIVITY_AVG_MIN,
1734    (unsigned)((activity_sum+(_enc->state.fplanes[0].nfrags>>1))/
1735    _enc->state.fplanes[0].nfrags));
1736   _enc->luma_avg=(unsigned)((luma_sum+(_enc->state.nmbs>>1))/_enc->state.nmbs);
1737   /*Finish filling in the reference frame borders.*/
1738   refi=_enc->state.ref_frame_idx[OC_FRAME_SELF];
1739   for(pli=0;pli<3;pli++)oc_state_borders_fill_caps(&_enc->state,refi,pli);
1740   _enc->state.ntotal_coded_fragis=_enc->state.nfrags;
1741 }
1742
1743
1744
1745 /*Cost information about a MB mode.*/
1746 struct oc_mode_choice{
1747   unsigned      cost;
1748   unsigned      ssd;
1749   unsigned      rate;
1750   unsigned      overhead;
1751   unsigned char qii[12];
1752 };
1753
1754
1755
1756 static void oc_mode_set_cost(oc_mode_choice *_modec,int _lambda){
1757   _modec->cost=OC_MODE_RD_COST(_modec->ssd,
1758    _modec->rate+_modec->overhead,_lambda);
1759 }
1760
1761 /*A set of skip SSD's to use to disable early skipping.*/
1762 static const unsigned OC_NOSKIP[12]={
1763   UINT_MAX,UINT_MAX,UINT_MAX,UINT_MAX,
1764   UINT_MAX,UINT_MAX,UINT_MAX,UINT_MAX,
1765   UINT_MAX,UINT_MAX,UINT_MAX,UINT_MAX
1766 };
1767
1768 /*The estimated number of bits used by a coded chroma block to specify the AC
1769    quantizer.
1770   TODO: Currently this is just 0.5*log2(3) (estimating about 50% compression);
1771    measurements suggest this is in the right ballpark, but it varies somewhat
1772    with lambda.*/
1773 #define OC_CHROMA_QII_RATE ((0xCAE00D1DU>>31-OC_BIT_SCALE)+1>>1)
1774
1775 static void oc_analyze_mb_mode_luma(oc_enc_ctx *_enc,
1776  oc_mode_choice *_modec,const oc_fr_state *_fr,const oc_qii_state *_qs,
1777  const unsigned _frag_satd[12],const unsigned _skip_ssd[12],
1778  const unsigned _rd_scale[4],int _qti){
1779   oc_fr_state  fr;
1780   oc_qii_state qs;
1781   unsigned     ssd;
1782   unsigned     rate;
1783   unsigned     satd;
1784   unsigned     best_ssd;
1785   unsigned     best_rate;
1786   int          best_fri;
1787   int          best_qii;
1788   int          lambda;
1789   int          nqis;
1790   int          nskipped;
1791   int          bi;
1792   lambda=_enc->lambda;
1793   nqis=_enc->state.nqis;
1794   /*We could do a trellis optimization here, but we don't make final skip
1795      decisions until after transform+quantization, so the result wouldn't be
1796      optimal anyway.
1797     Instead we just use a greedy approach; for most SATD values, the
1798      differences between the qiis are large enough to drown out the cost to
1799      code the flags, anyway.*/
1800   *&fr=*_fr;
1801   *&qs=*_qs;
1802   ssd=rate=nskipped=0;
1803   for(bi=0;bi<4;bi++){
1804     oc_fr_state  ft[2];
1805     oc_qii_state qt[3];
1806     unsigned     best_cost;
1807     unsigned     cur_cost;
1808     unsigned     cur_ssd;
1809     unsigned     cur_rate;
1810     unsigned     cur_overhead;
1811     int          qii;
1812     satd=_frag_satd[bi];
1813     *(ft+0)=*&fr;
1814     oc_fr_code_block(ft+0);
1815     cur_overhead=ft[0].bits-fr.bits;
1816     best_rate=oc_dct_cost2(_enc,&best_ssd,0,0,_qti,satd)
1817      +(cur_overhead<<OC_BIT_SCALE);
1818     if(nqis>1){
1819       oc_qii_state_advance(qt+0,&qs,0);
1820       best_rate+=qt[0].bits-qs.bits<<OC_BIT_SCALE;
1821     }
1822     best_ssd=OC_RD_SCALE(best_ssd,_rd_scale[bi]);
1823     best_cost=OC_MODE_RD_COST(ssd+best_ssd,rate+best_rate,lambda);
1824     best_fri=0;
1825     best_qii=0;
1826     for(qii=1;qii<nqis;qii++){
1827       oc_qii_state_advance(qt+qii,&qs,qii);
1828       cur_rate=oc_dct_cost2(_enc,&cur_ssd,qii,0,_qti,satd)
1829        +(cur_overhead+qt[qii].bits-qs.bits<<OC_BIT_SCALE);
1830       cur_ssd=OC_RD_SCALE(cur_ssd,_rd_scale[bi]);
1831       cur_cost=OC_MODE_RD_COST(ssd+cur_ssd,rate+cur_rate,lambda);
1832       if(cur_cost<best_cost){
1833         best_cost=cur_cost;
1834         best_ssd=cur_ssd;
1835         best_rate=cur_rate;
1836         best_qii=qii;
1837       }
1838     }
1839     if(_skip_ssd[bi]<(UINT_MAX>>OC_BIT_SCALE)&&nskipped<3){
1840       *(ft+1)=*&fr;
1841       oc_fr_skip_block(ft+1);
1842       cur_overhead=ft[1].bits-fr.bits<<OC_BIT_SCALE;
1843       cur_ssd=_skip_ssd[bi]<<OC_BIT_SCALE;
1844       cur_cost=OC_MODE_RD_COST(ssd+cur_ssd,rate+cur_overhead,lambda);
1845       if(cur_cost<=best_cost){
1846         best_ssd=cur_ssd;
1847         best_rate=cur_overhead;
1848         best_fri=1;
1849         best_qii+=4;
1850       }
1851     }
1852     rate+=best_rate;
1853     ssd+=best_ssd;
1854     *&fr=*(ft+best_fri);
1855     if(best_fri==0)*&qs=*(qt+best_qii);
1856     else nskipped++;
1857     _modec->qii[bi]=best_qii;
1858   }
1859   _modec->ssd=ssd;
1860   _modec->rate=rate;
1861 }
1862
1863 static void oc_analyze_mb_mode_chroma(oc_enc_ctx *_enc,
1864  oc_mode_choice *_modec,const oc_fr_state *_fr,const oc_qii_state *_qs,
1865  const unsigned _frag_satd[12],const unsigned _skip_ssd[12],
1866  unsigned _rd_scale,int _qti){
1867   unsigned ssd;
1868   unsigned rate;
1869   unsigned satd;
1870   unsigned best_ssd;
1871   unsigned best_rate;
1872   int      best_qii;
1873   unsigned cur_cost;
1874   unsigned cur_ssd;
1875   unsigned cur_rate;
1876   int      lambda;
1877   int      nblocks;
1878   int      nqis;
1879   int      pli;
1880   int      bi;
1881   int      qii;
1882   lambda=_enc->lambda;
1883   /*Most chroma blocks have no AC coefficients to speak of anyway, so it's not
1884      worth spending the bits to change the AC quantizer.
1885     TODO: This may be worth revisiting when we separate out DC and AC
1886      predictions from SATD.*/
1887 #if 0
1888   nqis=_enc->state.nqis;
1889 #else
1890   nqis=1;
1891 #endif
1892   ssd=_modec->ssd;
1893   rate=_modec->rate;
1894   /*Because (except in 4:4:4 mode) we aren't considering chroma blocks in coded
1895      order, we assume a constant overhead for coded block and qii flags.*/
1896   nblocks=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
1897   nblocks=(nblocks-4>>1)+4;
1898   bi=4;
1899   for(pli=1;pli<3;pli++){
1900     for(;bi<nblocks;bi++){
1901       unsigned best_cost;
1902       satd=_frag_satd[bi];
1903       best_rate=oc_dct_cost2(_enc,&best_ssd,0,pli,_qti,satd)
1904        +OC_CHROMA_QII_RATE;
1905       best_ssd=OC_RD_SCALE(best_ssd,_rd_scale);
1906       best_cost=OC_MODE_RD_COST(ssd+best_ssd,rate+best_rate,lambda);
1907       best_qii=0;
1908       for(qii=1;qii<nqis;qii++){
1909         cur_rate=oc_dct_cost2(_enc,&cur_ssd,qii,pli,_qti,satd)
1910          +OC_CHROMA_QII_RATE;
1911         cur_ssd=OC_RD_SCALE(cur_ssd,_rd_scale);
1912         cur_cost=OC_MODE_RD_COST(ssd+cur_ssd,rate+cur_rate,lambda);
1913         if(cur_cost<best_cost){
1914           best_cost=cur_cost;
1915           best_ssd=cur_ssd;
1916           best_rate=cur_rate;
1917           best_qii=qii;
1918         }
1919       }
1920       if(_skip_ssd[bi]<(UINT_MAX>>OC_BIT_SCALE)){
1921         cur_ssd=_skip_ssd[bi]<<OC_BIT_SCALE;
1922         cur_cost=OC_MODE_RD_COST(ssd+cur_ssd,rate,lambda);
1923         if(cur_cost<=best_cost){
1924           best_ssd=cur_ssd;
1925           best_rate=0;
1926           best_qii+=4;
1927         }
1928       }
1929       rate+=best_rate;
1930       ssd+=best_ssd;
1931       _modec->qii[bi]=best_qii;
1932     }
1933     nblocks=(nblocks-4<<1)+4;
1934   }
1935   _modec->ssd=ssd;
1936   _modec->rate=rate;
1937 }
1938
1939 static void oc_skip_cost(oc_enc_ctx *_enc,oc_enc_pipeline_state *_pipe,
1940  unsigned _mbi,const unsigned _rd_scale[4],unsigned _ssd[12]){
1941   const unsigned char   *src;
1942   const unsigned char   *ref;
1943   int                    ystride;
1944   const oc_fragment     *frags;
1945   const ptrdiff_t       *frag_buf_offs;
1946   const ptrdiff_t       *sb_map;
1947   const oc_mb_map_plane *mb_map;
1948   const unsigned char   *map_idxs;
1949   oc_mv                 *mvs;
1950   int                    map_nidxs;
1951   unsigned               uncoded_ssd;
1952   int                    mapii;
1953   int                    mapi;
1954   int                    pli;
1955   int                    bi;
1956   ptrdiff_t              fragi;
1957   ptrdiff_t              frag_offs;
1958   int                    borderi;
1959   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
1960   ref=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_PREV]];
1961   ystride=_enc->state.ref_ystride[0];
1962   frags=_enc->state.frags;
1963   frag_buf_offs=_enc->state.frag_buf_offs;
1964   sb_map=_enc->state.sb_maps[_mbi>>2][_mbi&3];
1965   mvs=_enc->mb_info[_mbi].block_mv;
1966   for(bi=0;bi<4;bi++){
1967     fragi=sb_map[bi];
1968     borderi=frags[fragi].borderi;
1969     frag_offs=frag_buf_offs[fragi];
1970     if(borderi<0){
1971       uncoded_ssd=oc_enc_frag_ssd(_enc,src+frag_offs,ref+frag_offs,ystride);
1972     }
1973     else{
1974       uncoded_ssd=oc_enc_frag_border_ssd(_enc,
1975        src+frag_offs,ref+frag_offs,ystride,_enc->state.borders[borderi].mask);
1976     }
1977     /*Scale to match DCT domain and RD.*/
1978     uncoded_ssd=OC_RD_SKIP_SCALE(uncoded_ssd,_rd_scale[bi]);
1979     /*Motion is a special case; if there is more than a full-pixel motion
1980        against the prior frame, penalize skipping.
1981       TODO: The factor of two here is a kludge, but it tested out better than a
1982        hard limit.*/
1983     if(mvs[bi]!=0)uncoded_ssd*=2;
1984     _pipe->skip_ssd[0][fragi-_pipe->froffset[0]]=_ssd[bi]=uncoded_ssd;
1985   }
1986   mb_map=(const oc_mb_map_plane *)_enc->state.mb_maps[_mbi];
1987   map_nidxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
1988   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
1989   map_nidxs=(map_nidxs-4>>1)+4;
1990   mapii=4;
1991   mvs=_enc->mb_info[_mbi].unref_mv;
1992   for(pli=1;pli<3;pli++){
1993     ystride=_enc->state.ref_ystride[pli];
1994     for(;mapii<map_nidxs;mapii++){
1995       mapi=map_idxs[mapii];
1996       bi=mapi&3;
1997       fragi=mb_map[pli][bi];
1998       borderi=frags[fragi].borderi;
1999       frag_offs=frag_buf_offs[fragi];
2000       if(borderi<0){
2001         uncoded_ssd=oc_enc_frag_ssd(_enc,src+frag_offs,ref+frag_offs,ystride);
2002       }
2003       else{
2004         uncoded_ssd=oc_enc_frag_border_ssd(_enc,
2005          src+frag_offs,ref+frag_offs,ystride,_enc->state.borders[borderi].mask);
2006       }
2007       /*Scale to match DCT domain and RD.*/
2008       uncoded_ssd=OC_RD_SKIP_SCALE(uncoded_ssd,_rd_scale[4]);
2009       /*Motion is a special case; if there is more than a full-pixel motion
2010          against the prior frame, penalize skipping.
2011         TODO: The factor of two here is a kludge, but it tested out better than
2012          a hard limit*/
2013       if(mvs[OC_FRAME_PREV]!=0)uncoded_ssd*=2;
2014       _pipe->skip_ssd[pli][fragi-_pipe->froffset[pli]]=_ssd[mapii]=uncoded_ssd;
2015     }
2016     map_nidxs=(map_nidxs-4<<1)+4;
2017   }
2018 }
2019
2020
2021 static void oc_cost_intra(oc_enc_ctx *_enc,oc_mode_choice *_modec,
2022  unsigned _mbi,const oc_fr_state *_fr,const oc_qii_state *_qs,
2023  const unsigned _frag_satd[12],const unsigned _skip_ssd[12],
2024  const unsigned _rd_scale[5]){
2025   oc_analyze_mb_mode_luma(_enc,_modec,_fr,_qs,_frag_satd,_skip_ssd,_rd_scale,0);
2026   oc_analyze_mb_mode_chroma(_enc,_modec,_fr,_qs,
2027    _frag_satd,_skip_ssd,_rd_scale[4],0);
2028   _modec->overhead=
2029    oc_mode_scheme_chooser_cost(&_enc->chooser,OC_MODE_INTRA)<<OC_BIT_SCALE;
2030   oc_mode_set_cost(_modec,_enc->lambda);
2031 }
2032
2033 static void oc_cost_inter(oc_enc_ctx *_enc,oc_mode_choice *_modec,
2034  unsigned _mbi,int _mb_mode,oc_mv _mv,
2035  const oc_fr_state *_fr,const oc_qii_state *_qs,
2036  const unsigned _skip_ssd[12],const unsigned _rd_scale[5]){
2037   unsigned               frag_satd[12];
2038   const unsigned char   *src;
2039   const unsigned char   *ref;
2040   int                    ystride;
2041   const ptrdiff_t       *frag_buf_offs;
2042   const ptrdiff_t       *sb_map;
2043   const oc_mb_map_plane *mb_map;
2044   const unsigned char   *map_idxs;
2045   int                    map_nidxs;
2046   int                    mapii;
2047   int                    mapi;
2048   int                    mv_offs[2];
2049   int                    pli;
2050   int                    bi;
2051   ptrdiff_t              fragi;
2052   ptrdiff_t              frag_offs;
2053   unsigned               dc;
2054   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
2055   ref=_enc->state.ref_frame_data[
2056    _enc->state.ref_frame_idx[OC_FRAME_FOR_MODE(_mb_mode)]];
2057   ystride=_enc->state.ref_ystride[0];
2058   frag_buf_offs=_enc->state.frag_buf_offs;
2059   sb_map=_enc->state.sb_maps[_mbi>>2][_mbi&3];
2060   _modec->rate=_modec->ssd=0;
2061   if(oc_state_get_mv_offsets(&_enc->state,mv_offs,0,_mv)>1){
2062     for(bi=0;bi<4;bi++){
2063       fragi=sb_map[bi];
2064       frag_offs=frag_buf_offs[fragi];
2065       frag_satd[bi]=oc_enc_frag_satd2(_enc,&dc,src+frag_offs,
2066        ref+frag_offs+mv_offs[0],ref+frag_offs+mv_offs[1],ystride);
2067       frag_satd[bi]+=dc;
2068     }
2069   }
2070   else{
2071     for(bi=0;bi<4;bi++){
2072       fragi=sb_map[bi];
2073       frag_offs=frag_buf_offs[fragi];
2074       frag_satd[bi]=oc_enc_frag_satd(_enc,&dc,src+frag_offs,
2075        ref+frag_offs+mv_offs[0],ystride);
2076       frag_satd[bi]+=dc;
2077     }
2078   }
2079   mb_map=(const oc_mb_map_plane *)_enc->state.mb_maps[_mbi];
2080   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
2081   map_nidxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
2082   /*Note: This assumes ref_ystride[1]==ref_ystride[2].*/
2083   ystride=_enc->state.ref_ystride[1];
2084   if(oc_state_get_mv_offsets(&_enc->state,mv_offs,1,_mv)>1){
2085     for(mapii=4;mapii<map_nidxs;mapii++){
2086       mapi=map_idxs[mapii];
2087       pli=mapi>>2;
2088       bi=mapi&3;
2089       fragi=mb_map[pli][bi];
2090       frag_offs=frag_buf_offs[fragi];
2091       frag_satd[mapii]=oc_enc_frag_satd2(_enc,&dc,src+frag_offs,
2092        ref+frag_offs+mv_offs[0],ref+frag_offs+mv_offs[1],ystride);
2093       frag_satd[mapii]+=dc;
2094     }
2095   }
2096   else{
2097     for(mapii=4;mapii<map_nidxs;mapii++){
2098       mapi=map_idxs[mapii];
2099       pli=mapi>>2;
2100       bi=mapi&3;
2101       fragi=mb_map[pli][bi];
2102       frag_offs=frag_buf_offs[fragi];
2103       frag_satd[mapii]=oc_enc_frag_satd(_enc,&dc,src+frag_offs,
2104        ref+frag_offs+mv_offs[0],ystride);
2105       frag_satd[mapii]+=dc;
2106     }
2107   }
2108   oc_analyze_mb_mode_luma(_enc,_modec,_fr,_qs,frag_satd,_skip_ssd,_rd_scale,1);
2109   oc_analyze_mb_mode_chroma(_enc,_modec,_fr,_qs,
2110    frag_satd,_skip_ssd,_rd_scale[4],1);
2111   _modec->overhead=
2112    oc_mode_scheme_chooser_cost(&_enc->chooser,_mb_mode)<<OC_BIT_SCALE;
2113   oc_mode_set_cost(_modec,_enc->lambda);
2114 }
2115
2116 static void oc_cost_inter_nomv(oc_enc_ctx *_enc,oc_mode_choice *_modec,
2117  unsigned _mbi,int _mb_mode,const oc_fr_state *_fr,const oc_qii_state *_qs,
2118  const unsigned _skip_ssd[12],const unsigned _rd_scale[4]){
2119   oc_cost_inter(_enc,_modec,_mbi,_mb_mode,0,_fr,_qs,_skip_ssd,_rd_scale);
2120 }
2121
2122 static int oc_cost_inter1mv(oc_enc_ctx *_enc,oc_mode_choice *_modec,
2123  unsigned _mbi,int _mb_mode,oc_mv _mv,
2124  const oc_fr_state *_fr,const oc_qii_state *_qs,const unsigned _skip_ssd[12],
2125  const unsigned _rd_scale[4]){
2126   int bits0;
2127   oc_cost_inter(_enc,_modec,_mbi,_mb_mode,_mv,_fr,_qs,_skip_ssd,_rd_scale);
2128   bits0=OC_MV_BITS[0][OC_MV_X(_mv)+31]+OC_MV_BITS[0][OC_MV_Y(_mv)+31];
2129   _modec->overhead+=OC_MINI(_enc->mv_bits[0]+bits0,_enc->mv_bits[1]+12)
2130    -OC_MINI(_enc->mv_bits[0],_enc->mv_bits[1])<<OC_BIT_SCALE;
2131   oc_mode_set_cost(_modec,_enc->lambda);
2132   return bits0;
2133 }
2134
2135 /*A mapping from oc_mb_map (raster) ordering to oc_sb_map (Hilbert) ordering.*/
2136 static const unsigned char OC_MB_PHASE[4][4]={
2137   {0,1,3,2},{0,3,1,2},{0,3,1,2},{2,3,1,0}
2138 };
2139
2140 static void oc_cost_inter4mv(oc_enc_ctx *_enc,oc_mode_choice *_modec,
2141  unsigned _mbi,oc_mv _mv[4],const oc_fr_state *_fr,const oc_qii_state *_qs,
2142  const unsigned _skip_ssd[12],const unsigned _rd_scale[5]){
2143   unsigned               frag_satd[12];
2144   oc_mv                  lbmvs[4];
2145   oc_mv                  cbmvs[4];
2146   const unsigned char   *src;
2147   const unsigned char   *ref;
2148   int                    ystride;
2149   const ptrdiff_t       *frag_buf_offs;
2150   oc_mv                 *frag_mvs;
2151   const oc_mb_map_plane *mb_map;
2152   const unsigned char   *map_idxs;
2153   int                    map_nidxs;
2154   int                    nqis;
2155   int                    mapii;
2156   int                    mapi;
2157   int                    mv_offs[2];
2158   int                    pli;
2159   int                    bi;
2160   ptrdiff_t              fragi;
2161   ptrdiff_t              frag_offs;
2162   int                    bits0;
2163   int                    bits1;
2164   unsigned               satd;
2165   unsigned               dc;
2166   src=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_IO]];
2167   ref=_enc->state.ref_frame_data[_enc->state.ref_frame_idx[OC_FRAME_PREV]];
2168   ystride=_enc->state.ref_ystride[0];
2169   frag_buf_offs=_enc->state.frag_buf_offs;
2170   frag_mvs=_enc->state.frag_mvs;
2171   mb_map=(const oc_mb_map_plane *)_enc->state.mb_maps[_mbi];
2172   _modec->rate=_modec->ssd=0;
2173   for(bi=0;bi<4;bi++){
2174     fragi=mb_map[0][bi];
2175     /*Save the block MVs as the current ones while we're here; we'll replace
2176        them if we don't ultimately choose 4MV mode.*/
2177     frag_mvs[fragi]=_mv[bi];
2178     frag_offs=frag_buf_offs[fragi];
2179     if(oc_state_get_mv_offsets(&_enc->state,mv_offs,0,_mv[bi])>1){
2180       satd=oc_enc_frag_satd2(_enc,&dc,src+frag_offs,
2181        ref+frag_offs+mv_offs[0],ref+frag_offs+mv_offs[1],ystride);
2182     }
2183     else{
2184       satd=oc_enc_frag_satd(_enc,&dc,src+frag_offs,
2185        ref+frag_offs+mv_offs[0],ystride);
2186     }
2187     frag_satd[OC_MB_PHASE[_mbi&3][bi]]=satd+dc;
2188   }
2189   oc_analyze_mb_mode_luma(_enc,_modec,_fr,_qs,frag_satd,
2190    _enc->vp3_compatible?OC_NOSKIP:_skip_ssd,_rd_scale,1);
2191   /*Figure out which blocks are being skipped and give them (0,0) MVs.*/
2192   bits0=0;
2193   bits1=0;
2194   nqis=_enc->state.nqis;
2195   for(bi=0;bi<4;bi++){
2196     if(_modec->qii[OC_MB_PHASE[_mbi&3][bi]]>=nqis)lbmvs[bi]=0;
2197     else{
2198       lbmvs[bi]=_mv[bi];
2199       bits0+=OC_MV_BITS[0][OC_MV_X(_mv[bi])+31]
2200        +OC_MV_BITS[0][OC_MV_Y(_mv[bi])+31];
2201       bits1+=12;
2202     }
2203   }
2204   (*OC_SET_CHROMA_MVS_TABLE[_enc->state.info.pixel_fmt])(cbmvs,lbmvs);
2205   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
2206   map_nidxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
2207   /*Note: This assumes ref_ystride[1]==ref_ystride[2].*/
2208   ystride=_enc->state.ref_ystride[1];
2209   for(mapii=4;mapii<map_nidxs;mapii++){
2210     mapi=map_idxs[mapii];
2211     pli=mapi>>2;
2212     bi=mapi&3;
2213     fragi=mb_map[pli][bi];
2214     frag_offs=frag_buf_offs[fragi];
2215     /*TODO: We could save half these calls by re-using the results for the Cb
2216        and Cr planes; is it worth it?*/
2217     if(oc_state_get_mv_offsets(&_enc->state,mv_offs,pli,cbmvs[bi])>1){
2218       satd=oc_enc_frag_satd2(_enc,&dc,src+frag_offs,
2219        ref+frag_offs+mv_offs[0],ref+frag_offs+mv_offs[1],ystride);
2220     }
2221     else{
2222       satd=oc_enc_frag_satd(_enc,&dc,src+frag_offs,
2223        ref+frag_offs+mv_offs[0],ystride);
2224     }
2225     frag_satd[mapii]=satd+dc;
2226   }
2227   oc_analyze_mb_mode_chroma(_enc,_modec,_fr,_qs,
2228    frag_satd,_skip_ssd,_rd_scale[4],1);
2229   _modec->overhead=
2230    oc_mode_scheme_chooser_cost(&_enc->chooser,OC_MODE_INTER_MV_FOUR)
2231    +OC_MINI(_enc->mv_bits[0]+bits0,_enc->mv_bits[1]+bits1)
2232    -OC_MINI(_enc->mv_bits[0],_enc->mv_bits[1])<<OC_BIT_SCALE;
2233   oc_mode_set_cost(_modec,_enc->lambda);
2234 }
2235
2236 int oc_enc_analyze_inter(oc_enc_ctx *_enc,int _allow_keyframe,int _recode){
2237   oc_set_chroma_mvs_func  set_chroma_mvs;
2238   oc_qii_state            intra_luma_qs;
2239   oc_mv                   last_mv;
2240   oc_mv                   prior_mv;
2241   ogg_int64_t             interbits;
2242   ogg_int64_t             intrabits;
2243   ogg_int64_t             activity_sum;
2244   ogg_int64_t             luma_sum;
2245   unsigned                activity_avg;
2246   unsigned                luma_avg;
2247   const ogg_uint16_t     *chroma_rd_scale;
2248   ogg_uint16_t           *mcu_rd_scale;
2249   ogg_uint16_t           *mcu_rd_iscale;
2250   const unsigned char    *map_idxs;
2251   int                     nmap_idxs;
2252   unsigned               *coded_mbis;
2253   unsigned               *uncoded_mbis;
2254   size_t                  ncoded_mbis;
2255   size_t                  nuncoded_mbis;
2256   oc_sb_flags            *sb_flags;
2257   signed char            *mb_modes;
2258   const oc_sb_map        *sb_maps;
2259   const oc_mb_map        *mb_maps;
2260   oc_mb_enc_info         *embs;
2261   oc_fragment            *frags;
2262   oc_mv                  *frag_mvs;
2263   unsigned                stripe_sby;
2264   unsigned                mcu_nvsbs;
2265   int                     notstart;
2266   int                     notdone;
2267   unsigned                sbi;
2268   unsigned                sbi_end;
2269   int                     refi;
2270   int                     pli;
2271   int                     sp_level;
2272   sp_level=_enc->sp_level;
2273   set_chroma_mvs=OC_SET_CHROMA_MVS_TABLE[_enc->state.info.pixel_fmt];
2274   _enc->state.frame_type=OC_INTER_FRAME;
2275   oc_mode_scheme_chooser_reset(&_enc->chooser);
2276   oc_enc_tokenize_start(_enc);
2277   oc_enc_pipeline_init(_enc,&_enc->pipe);
2278   oc_enc_mode_rd_init(_enc);
2279   if(_allow_keyframe)oc_qii_state_init(&intra_luma_qs);
2280   _enc->mv_bits[0]=_enc->mv_bits[1]=0;
2281   interbits=intrabits=0;
2282   activity_sum=luma_sum=0;
2283   activity_avg=_enc->activity_avg;
2284   luma_avg=OC_CLAMPI(90<<8,_enc->luma_avg,160<<8);
2285   chroma_rd_scale=_enc->chroma_rd_scale[OC_INTER_FRAME][_enc->state.qis[0]];
2286   mcu_rd_scale=_enc->mcu_rd_scale;
2287   mcu_rd_iscale=_enc->mcu_rd_iscale;
2288   last_mv=prior_mv=0;
2289   /*Choose MVs and MB modes and quantize and code luma.
2290     Must be done in Hilbert order.*/
2291   map_idxs=OC_MB_MAP_IDXS[_enc->state.info.pixel_fmt];
2292   nmap_idxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
2293   coded_mbis=_enc->coded_mbis;
2294   uncoded_mbis=coded_mbis+_enc->state.nmbs;
2295   ncoded_mbis=0;
2296   nuncoded_mbis=0;
2297   _enc->state.ncoded_fragis[0]=0;
2298   _enc->state.ncoded_fragis[1]=0;
2299   _enc->state.ncoded_fragis[2]=0;
2300   sb_flags=_enc->state.sb_flags;
2301   mb_modes=_enc->state.mb_modes;
2302   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
2303   mb_maps=(const oc_mb_map *)_enc->state.mb_maps;
2304   embs=_enc->mb_info;
2305   frags=_enc->state.frags;
2306   frag_mvs=_enc->state.frag_mvs;
2307   notstart=0;
2308   notdone=1;
2309   mcu_nvsbs=_enc->mcu_nvsbs;
2310   for(stripe_sby=0;notdone;stripe_sby+=mcu_nvsbs){
2311     ptrdiff_t cfroffset;
2312     notdone=oc_enc_pipeline_set_stripe(_enc,&_enc->pipe,stripe_sby);
2313     sbi_end=_enc->pipe.sbi_end[0];
2314     cfroffset=_enc->pipe.froffset[1];
2315     for(sbi=_enc->pipe.sbi0[0];sbi<sbi_end;sbi++){
2316       int quadi;
2317       /*Mode addressing is through Y plane, always 4 MB per SB.*/
2318       for(quadi=0;quadi<4;quadi++)if(sb_flags[sbi].quad_valid&1<<quadi){
2319         oc_mode_choice modes[8];
2320         unsigned       activity[4];
2321         unsigned       rd_scale[5];
2322         unsigned       rd_iscale[5];
2323         unsigned       skip_ssd[12];
2324         unsigned       intra_satd[12];
2325         unsigned       luma;
2326         int            mb_mv_bits_0;
2327         int            mb_gmv_bits_0;
2328         int            inter_mv_pref;
2329         int            mb_mode;
2330         int            refi;
2331         int            mv;
2332         unsigned       mbi;
2333         int            mapii;
2334         int            mapi;
2335         int            bi;
2336         ptrdiff_t      fragi;
2337         mbi=sbi<<2|quadi;
2338         oc_mb_intra_satd(_enc,mbi,intra_satd);
2339         /*Activity masking.*/
2340         if(sp_level<OC_SP_LEVEL_FAST_ANALYSIS){
2341           luma=oc_mb_activity(_enc,mbi,activity);
2342         }
2343         else{
2344           luma=oc_mb_activity_fast(_enc,mbi,activity,intra_satd);
2345         }
2346         luma_sum+=luma;
2347         activity_sum+=oc_mb_masking(rd_scale,rd_iscale,
2348          chroma_rd_scale,activity,activity_avg,luma,luma_avg);
2349         /*Motion estimation:
2350           We always do a basic 1MV search for all macroblocks, coded or not,
2351            keyframe or not.*/
2352         if(!_recode&&sp_level<OC_SP_LEVEL_NOMC)oc_mcenc_search(_enc,mbi);
2353         mv=0;
2354         /*Find the block choice with the lowest estimated coding cost.
2355           If a Cb or Cr block is coded but no Y' block from a macro block then
2356            the mode MUST be OC_MODE_INTER_NOMV.
2357           This is the default state to which the mode data structure is
2358            initialised in encoder and decoder at the start of each frame.*/
2359         /*Block coding cost is estimated from correlated SATD metrics.*/
2360         /*At this point, all blocks that are in frame are still marked coded.*/
2361         if(!_recode){
2362           embs[mbi].unref_mv[OC_FRAME_GOLD]=
2363            embs[mbi].analysis_mv[0][OC_FRAME_GOLD];
2364           embs[mbi].unref_mv[OC_FRAME_PREV]=
2365            embs[mbi].analysis_mv[0][OC_FRAME_PREV];
2366           embs[mbi].refined=0;
2367         }
2368         /*Estimate the cost of coding this MB in a keyframe.*/
2369         if(_allow_keyframe){
2370           oc_cost_intra(_enc,modes+OC_MODE_INTRA,mbi,
2371            _enc->pipe.fr+0,&intra_luma_qs,intra_satd,OC_NOSKIP,rd_scale);
2372           intrabits+=modes[OC_MODE_INTRA].rate;
2373           for(bi=0;bi<4;bi++){
2374             oc_qii_state_advance(&intra_luma_qs,&intra_luma_qs,
2375              modes[OC_MODE_INTRA].qii[bi]);
2376           }
2377         }
2378         /*Estimate the cost in a delta frame for various modes.*/
2379         oc_skip_cost(_enc,&_enc->pipe,mbi,rd_scale,skip_ssd);
2380         if(sp_level<OC_SP_LEVEL_NOMC){
2381           oc_cost_inter_nomv(_enc,modes+OC_MODE_INTER_NOMV,mbi,
2382            OC_MODE_INTER_NOMV,_enc->pipe.fr+0,_enc->pipe.qs+0,
2383            skip_ssd,rd_scale);
2384           oc_cost_intra(_enc,modes+OC_MODE_INTRA,mbi,
2385            _enc->pipe.fr+0,_enc->pipe.qs+0,intra_satd,skip_ssd,rd_scale);
2386           mb_mv_bits_0=oc_cost_inter1mv(_enc,modes+OC_MODE_INTER_MV,mbi,
2387            OC_MODE_INTER_MV,embs[mbi].unref_mv[OC_FRAME_PREV],
2388            _enc->pipe.fr+0,_enc->pipe.qs+0,skip_ssd,rd_scale);
2389           oc_cost_inter(_enc,modes+OC_MODE_INTER_MV_LAST,mbi,
2390            OC_MODE_INTER_MV_LAST,last_mv,_enc->pipe.fr+0,_enc->pipe.qs+0,
2391            skip_ssd,rd_scale);
2392           oc_cost_inter(_enc,modes+OC_MODE_INTER_MV_LAST2,mbi,
2393            OC_MODE_INTER_MV_LAST2,prior_mv,_enc->pipe.fr+0,_enc->pipe.qs+0,
2394            skip_ssd,rd_scale);
2395           oc_cost_inter_nomv(_enc,modes+OC_MODE_GOLDEN_NOMV,mbi,
2396            OC_MODE_GOLDEN_NOMV,_enc->pipe.fr+0,_enc->pipe.qs+0,
2397            skip_ssd,rd_scale);
2398           mb_gmv_bits_0=oc_cost_inter1mv(_enc,modes+OC_MODE_GOLDEN_MV,mbi,
2399            OC_MODE_GOLDEN_MV,embs[mbi].unref_mv[OC_FRAME_GOLD],
2400            _enc->pipe.fr+0,_enc->pipe.qs+0,skip_ssd,rd_scale);
2401           /*The explicit MV modes (2,6,7) have not yet gone through halfpel
2402              refinement.
2403             We choose the explicit MV mode that's already furthest ahead on
2404              R-D cost and refine only that one.
2405             We have to be careful to remember which ones we've refined so that
2406              we don't refine it again if we re-encode this frame.*/
2407           inter_mv_pref=_enc->lambda*3;
2408           if(sp_level<OC_SP_LEVEL_FAST_ANALYSIS){
2409             oc_cost_inter4mv(_enc,modes+OC_MODE_INTER_MV_FOUR,mbi,
2410              embs[mbi].block_mv,_enc->pipe.fr+0,_enc->pipe.qs+0,
2411              skip_ssd,rd_scale);
2412           }
2413           else{
2414             modes[OC_MODE_INTER_MV_FOUR].cost=UINT_MAX;
2415           }
2416           if(modes[OC_MODE_INTER_MV_FOUR].cost<modes[OC_MODE_INTER_MV].cost&&
2417            modes[OC_MODE_INTER_MV_FOUR].cost<modes[OC_MODE_GOLDEN_MV].cost){
2418             if(!(embs[mbi].refined&0x80)){
2419               oc_mcenc_refine4mv(_enc,mbi);
2420               embs[mbi].refined|=0x80;
2421             }
2422             oc_cost_inter4mv(_enc,modes+OC_MODE_INTER_MV_FOUR,mbi,
2423              embs[mbi].ref_mv,_enc->pipe.fr+0,_enc->pipe.qs+0,
2424              skip_ssd,rd_scale);
2425           }
2426           else if(modes[OC_MODE_GOLDEN_MV].cost+inter_mv_pref<
2427            modes[OC_MODE_INTER_MV].cost){
2428             if(!(embs[mbi].refined&0x40)){
2429               oc_mcenc_refine1mv(_enc,mbi,OC_FRAME_GOLD);
2430               embs[mbi].refined|=0x40;
2431             }
2432             mb_gmv_bits_0=oc_cost_inter1mv(_enc,modes+OC_MODE_GOLDEN_MV,mbi,
2433              OC_MODE_GOLDEN_MV,embs[mbi].analysis_mv[0][OC_FRAME_GOLD],
2434              _enc->pipe.fr+0,_enc->pipe.qs+0,skip_ssd,rd_scale);
2435           }
2436           if(!(embs[mbi].refined&0x04)){
2437             oc_mcenc_refine1mv(_enc,mbi,OC_FRAME_PREV);
2438             embs[mbi].refined|=0x04;
2439           }
2440           mb_mv_bits_0=oc_cost_inter1mv(_enc,modes+OC_MODE_INTER_MV,mbi,
2441            OC_MODE_INTER_MV,embs[mbi].analysis_mv[0][OC_FRAME_PREV],
2442            _enc->pipe.fr+0,_enc->pipe.qs+0,skip_ssd,rd_scale);
2443           /*Finally, pick the mode with the cheapest estimated R-D cost.*/
2444           mb_mode=OC_MODE_INTER_NOMV;
2445           if(modes[OC_MODE_INTRA].cost<modes[OC_MODE_INTER_NOMV].cost){
2446             mb_mode=OC_MODE_INTRA;
2447           }
2448           if(modes[OC_MODE_INTER_MV_LAST].cost<modes[mb_mode].cost){
2449             mb_mode=OC_MODE_INTER_MV_LAST;
2450           }
2451           if(modes[OC_MODE_INTER_MV_LAST2].cost<modes[mb_mode].cost){
2452             mb_mode=OC_MODE_INTER_MV_LAST2;
2453           }
2454           if(modes[OC_MODE_GOLDEN_NOMV].cost<modes[mb_mode].cost){
2455             mb_mode=OC_MODE_GOLDEN_NOMV;
2456           }
2457           if(modes[OC_MODE_GOLDEN_MV].cost<modes[mb_mode].cost){
2458             mb_mode=OC_MODE_GOLDEN_MV;
2459           }
2460           if(modes[OC_MODE_INTER_MV_FOUR].cost<modes[mb_mode].cost){
2461             mb_mode=OC_MODE_INTER_MV_FOUR;
2462           }
2463           /*We prefer OC_MODE_INTER_MV, but not over LAST and LAST2.*/
2464           if(mb_mode==OC_MODE_INTER_MV_LAST||mb_mode==OC_MODE_INTER_MV_LAST2){
2465             inter_mv_pref=0;
2466           }
2467           if(modes[OC_MODE_INTER_MV].cost<modes[mb_mode].cost+inter_mv_pref){
2468             mb_mode=OC_MODE_INTER_MV;
2469           }
2470         }
2471         else{
2472           oc_cost_inter_nomv(_enc,modes+OC_MODE_INTER_NOMV,mbi,
2473            OC_MODE_INTER_NOMV,_enc->pipe.fr+0,_enc->pipe.qs+0,
2474            skip_ssd,rd_scale);
2475           oc_cost_intra(_enc,modes+OC_MODE_INTRA,mbi,
2476            _enc->pipe.fr+0,_enc->pipe.qs+0,intra_satd,skip_ssd,rd_scale);
2477           oc_cost_inter_nomv(_enc,modes+OC_MODE_GOLDEN_NOMV,mbi,
2478            OC_MODE_GOLDEN_NOMV,_enc->pipe.fr+0,_enc->pipe.qs+0,
2479            skip_ssd,rd_scale);
2480           mb_mode=OC_MODE_INTER_NOMV;
2481           if(modes[OC_MODE_INTRA].cost<modes[OC_MODE_INTER_NOMV].cost){
2482             mb_mode=OC_MODE_INTRA;
2483           }
2484           if(modes[OC_MODE_GOLDEN_NOMV].cost<modes[mb_mode].cost){
2485             mb_mode=OC_MODE_GOLDEN_NOMV;
2486           }
2487           mb_mv_bits_0=mb_gmv_bits_0=0;
2488         }
2489         mb_modes[mbi]=mb_mode;
2490         /*Propagate the MVs to the luma blocks.*/
2491         if(mb_mode!=OC_MODE_INTER_MV_FOUR){
2492           switch(mb_mode){
2493             case OC_MODE_INTER_MV:{
2494               mv=embs[mbi].analysis_mv[0][OC_FRAME_PREV];
2495             }break;
2496             case OC_MODE_INTER_MV_LAST:mv=last_mv;break;
2497             case OC_MODE_INTER_MV_LAST2:mv=prior_mv;break;
2498             case OC_MODE_GOLDEN_MV:{
2499               mv=embs[mbi].analysis_mv[0][OC_FRAME_GOLD];
2500             }break;
2501           }
2502           for(bi=0;bi<4;bi++){
2503             fragi=mb_maps[mbi][0][bi];
2504             frag_mvs[fragi]=mv;
2505           }
2506         }
2507         for(bi=0;bi<4;bi++){
2508           fragi=sb_maps[mbi>>2][mbi&3][bi];
2509           frags[fragi].qii=modes[mb_mode].qii[bi];
2510         }
2511         if(oc_enc_mb_transform_quantize_inter_luma(_enc,&_enc->pipe,mbi,
2512          modes[mb_mode].overhead>>OC_BIT_SCALE,rd_scale,rd_iscale)>0){
2513           int orig_mb_mode;
2514           orig_mb_mode=mb_mode;
2515           mb_mode=mb_modes[mbi];
2516           refi=OC_FRAME_FOR_MODE(mb_mode);
2517           switch(mb_mode){
2518             case OC_MODE_INTER_MV:{
2519               prior_mv=last_mv;
2520               /*If we're backing out from 4MV, find the MV we're actually
2521                  using.*/
2522               if(orig_mb_mode==OC_MODE_INTER_MV_FOUR){
2523                 for(bi=0;;bi++){
2524                   fragi=mb_maps[mbi][0][bi];
2525                   if(frags[fragi].coded){
2526                     mv=last_mv=frag_mvs[fragi];
2527                     break;
2528                   }
2529                 }
2530                 mb_mv_bits_0=OC_MV_BITS[0][OC_MV_X(mv)+31]
2531                  +OC_MV_BITS[0][OC_MV_Y(mv)+31];
2532               }
2533               /*Otherwise we used the original analysis MV.*/
2534               else last_mv=embs[mbi].analysis_mv[0][OC_FRAME_PREV];
2535               _enc->mv_bits[0]+=mb_mv_bits_0;
2536               _enc->mv_bits[1]+=12;
2537             }break;
2538             case OC_MODE_INTER_MV_LAST2:{
2539               oc_mv tmp_mv;
2540               tmp_mv=prior_mv;
2541               prior_mv=last_mv;
2542               last_mv=tmp_mv;
2543             }break;
2544             case OC_MODE_GOLDEN_MV:{
2545               _enc->mv_bits[0]+=mb_gmv_bits_0;
2546               _enc->mv_bits[1]+=12;
2547             }break;
2548             case OC_MODE_INTER_MV_FOUR:{
2549               oc_mv lbmvs[4];
2550               oc_mv cbmvs[4];
2551               prior_mv=last_mv;
2552               for(bi=0;bi<4;bi++){
2553                 fragi=mb_maps[mbi][0][bi];
2554                 if(frags[fragi].coded){
2555                   lbmvs[bi]=last_mv=frag_mvs[fragi];
2556                   _enc->mv_bits[0]+=OC_MV_BITS[0][OC_MV_X(last_mv)+31]
2557                    +OC_MV_BITS[0][OC_MV_Y(last_mv)+31];
2558                   _enc->mv_bits[1]+=12;
2559                 }
2560                 /*Replace the block MVs for not-coded blocks with (0,0).*/
2561                 else lbmvs[bi]=0;
2562               }
2563               (*set_chroma_mvs)(cbmvs,lbmvs);
2564               for(mapii=4;mapii<nmap_idxs;mapii++){
2565                 mapi=map_idxs[mapii];
2566                 pli=mapi>>2;
2567                 bi=mapi&3;
2568                 fragi=mb_maps[mbi][pli][bi];
2569                 frags[fragi].qii=modes[OC_MODE_INTER_MV_FOUR].qii[mapii];
2570                 frags[fragi].refi=refi;
2571                 frags[fragi].mb_mode=mb_mode;
2572                 frag_mvs[fragi]=cbmvs[bi];
2573               }
2574             }break;
2575           }
2576           coded_mbis[ncoded_mbis++]=mbi;
2577           oc_mode_scheme_chooser_update(&_enc->chooser,mb_mode);
2578           interbits+=modes[mb_mode].rate+modes[mb_mode].overhead;
2579         }
2580         else{
2581           *(uncoded_mbis-++nuncoded_mbis)=mbi;
2582           mb_mode=OC_MODE_INTER_NOMV;
2583           refi=OC_FRAME_PREV;
2584           mv=0;
2585         }
2586         /*Propagate final MB mode and MVs to the chroma blocks.
2587           This has already been done for 4MV mode, since it requires individual
2588            block motion vectors.*/
2589         if(mb_mode!=OC_MODE_INTER_MV_FOUR){
2590           for(mapii=4;mapii<nmap_idxs;mapii++){
2591             mapi=map_idxs[mapii];
2592             pli=mapi>>2;
2593             bi=mapi&3;
2594             fragi=mb_maps[mbi][pli][bi];
2595             /*If we switched from 4MV mode to INTER_MV mode, then the qii
2596                values won't have been chosen with the right MV, but it's
2597                probaby not worth re-estimating them.*/
2598             frags[fragi].qii=modes[mb_mode].qii[mapii];
2599             frags[fragi].refi=refi;
2600             frags[fragi].mb_mode=mb_mode;
2601             frag_mvs[fragi]=mv;
2602           }
2603         }
2604         /*Save masking scale factors for chroma blocks.*/
2605         for(mapii=4;mapii<(nmap_idxs-4>>1)+4;mapii++){
2606           mapi=map_idxs[mapii];
2607           bi=mapi&3;
2608           fragi=mb_maps[mbi][1][bi];
2609           mcu_rd_scale[fragi-cfroffset]=(ogg_uint16_t)rd_scale[4];
2610           mcu_rd_iscale[fragi-cfroffset]=(ogg_uint16_t)rd_iscale[4];
2611         }
2612       }
2613       oc_fr_state_flush_sb(_enc->pipe.fr+0);
2614       sb_flags[sbi].coded_fully=_enc->pipe.fr[0].sb_full;
2615       sb_flags[sbi].coded_partially=_enc->pipe.fr[0].sb_partial;
2616     }
2617     oc_enc_pipeline_finish_mcu_plane(_enc,&_enc->pipe,0,notstart,notdone);
2618     /*Code chroma planes.*/
2619     for(pli=1;pli<3;pli++){
2620       oc_enc_sb_transform_quantize_inter_chroma(_enc,&_enc->pipe,
2621        pli,_enc->pipe.sbi0[pli],_enc->pipe.sbi_end[pli]);
2622       oc_enc_pipeline_finish_mcu_plane(_enc,&_enc->pipe,pli,notstart,notdone);
2623     }
2624     notstart=1;
2625   }
2626   /*Update the average block activity and MB luma score for the frame.
2627     We could use a Bessel follower here, but fast reaction is probably almost
2628      always best.*/
2629   _enc->activity_avg=OC_MAXI(OC_ACTIVITY_AVG_MIN,
2630    (unsigned)((activity_sum+(_enc->state.fplanes[0].nfrags>>1))/
2631    _enc->state.fplanes[0].nfrags));
2632   _enc->luma_avg=(unsigned)((luma_sum+(_enc->state.nmbs>>1))/_enc->state.nmbs);
2633   /*Finish filling in the reference frame borders.*/
2634   refi=_enc->state.ref_frame_idx[OC_FRAME_SELF];
2635   for(pli=0;pli<3;pli++)oc_state_borders_fill_caps(&_enc->state,refi,pli);
2636   /*Finish adding flagging overhead costs to inter bit counts to determine if
2637      we should have coded a key frame instead.*/
2638   if(_allow_keyframe){
2639     /*Technically the chroma plane counts are over-estimations, because they
2640        don't account for continuing runs from the luma planes, but the
2641        inaccuracy is small.
2642       We don't need to add the luma plane coding flag costs, because they are
2643        already included in the MB rate estimates.*/
2644     for(pli=1;pli<3;pli++)interbits+=_enc->pipe.fr[pli].bits<<OC_BIT_SCALE;
2645     if(interbits>intrabits)return 1;
2646   }
2647   _enc->ncoded_mbis=ncoded_mbis;
2648   /*Compact the coded fragment list.*/
2649   {
2650     ptrdiff_t ncoded_fragis;
2651     ncoded_fragis=_enc->state.ncoded_fragis[0];
2652     for(pli=1;pli<3;pli++){
2653       memmove(_enc->state.coded_fragis+ncoded_fragis,
2654        _enc->state.coded_fragis+_enc->state.fplanes[pli].froffset,
2655        _enc->state.ncoded_fragis[pli]*sizeof(*_enc->state.coded_fragis));
2656       ncoded_fragis+=_enc->state.ncoded_fragis[pli];
2657     }
2658     _enc->state.ntotal_coded_fragis=ncoded_fragis;
2659   }
2660   return 0;
2661 }