90dc46c04af2b813fb1dfa4ab7c0c5869973eebd
[theora.git] / lib / encode.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:
14   last mod: $Id$
15
16  ********************************************************************/
17 #include <stdlib.h>
18 #include <string.h>
19 #include "encint.h"
20 #include "dequant.h"
21
22
23
24 /*The default quantization parameters used by VP3.1.*/
25 static const int OC_VP31_RANGE_SIZES[1]={63};
26 static const th_quant_base OC_VP31_BASES_INTRA_Y[2]={
27   {
28      16, 11, 10, 16, 24, 40, 51, 61,
29      12, 12, 14, 19, 26, 58, 60, 55,
30      14, 13, 16, 24, 40, 57, 69, 56,
31      14, 17, 22, 29, 51, 87, 80, 62,
32      18, 22, 37, 58, 68,109,103, 77,
33      24, 35, 55, 64, 81,104,113, 92,
34      49, 64, 78, 87,103,121,120,101,
35      72, 92, 95, 98,112,100,103, 99
36   },
37   {
38      16, 11, 10, 16, 24, 40, 51, 61,
39      12, 12, 14, 19, 26, 58, 60, 55,
40      14, 13, 16, 24, 40, 57, 69, 56,
41      14, 17, 22, 29, 51, 87, 80, 62,
42      18, 22, 37, 58, 68,109,103, 77,
43      24, 35, 55, 64, 81,104,113, 92,
44      49, 64, 78, 87,103,121,120,101,
45      72, 92, 95, 98,112,100,103, 99
46   }
47 };
48 static const th_quant_base OC_VP31_BASES_INTRA_C[2]={
49   {
50      17, 18, 24, 47, 99, 99, 99, 99,
51      18, 21, 26, 66, 99, 99, 99, 99,
52      24, 26, 56, 99, 99, 99, 99, 99,
53      47, 66, 99, 99, 99, 99, 99, 99,
54      99, 99, 99, 99, 99, 99, 99, 99,
55      99, 99, 99, 99, 99, 99, 99, 99,
56      99, 99, 99, 99, 99, 99, 99, 99,
57      99, 99, 99, 99, 99, 99, 99, 99
58   },
59   {
60      17, 18, 24, 47, 99, 99, 99, 99,
61      18, 21, 26, 66, 99, 99, 99, 99,
62      24, 26, 56, 99, 99, 99, 99, 99,
63      47, 66, 99, 99, 99, 99, 99, 99,
64      99, 99, 99, 99, 99, 99, 99, 99,
65      99, 99, 99, 99, 99, 99, 99, 99,
66      99, 99, 99, 99, 99, 99, 99, 99,
67      99, 99, 99, 99, 99, 99, 99, 99
68   }
69 };
70 static const th_quant_base OC_VP31_BASES_INTER[2]={
71   {
72      16, 16, 16, 20, 24, 28, 32, 40,
73      16, 16, 20, 24, 28, 32, 40, 48,
74      16, 20, 24, 28, 32, 40, 48, 64,
75      20, 24, 28, 32, 40, 48, 64, 64,
76      24, 28, 32, 40, 48, 64, 64, 64,
77      28, 32, 40, 48, 64, 64, 64, 96,
78      32, 40, 48, 64, 64, 64, 96,128,
79      40, 48, 64, 64, 64, 96,128,128
80   },
81   {
82      16, 16, 16, 20, 24, 28, 32, 40,
83      16, 16, 20, 24, 28, 32, 40, 48,
84      16, 20, 24, 28, 32, 40, 48, 64,
85      20, 24, 28, 32, 40, 48, 64, 64,
86      24, 28, 32, 40, 48, 64, 64, 64,
87      28, 32, 40, 48, 64, 64, 64, 96,
88      32, 40, 48, 64, 64, 64, 96,128,
89      40, 48, 64, 64, 64, 96,128,128
90   }
91 };
92
93 const th_quant_info TH_VP31_QUANT_INFO={
94   {
95     220,200,190,180,170,170,160,160,
96     150,150,140,140,130,130,120,120,
97     110,110,100,100, 90, 90, 90, 80,
98      80, 80, 70, 70, 70, 60, 60, 60,
99      60, 50, 50, 50, 50, 40, 40, 40,
100      40, 40, 30, 30, 30, 30, 30, 30,
101      30, 20, 20, 20, 20, 20, 20, 20,
102      20, 10, 10, 10, 10, 10, 10, 10
103   },
104   {
105     500,450,400,370,340,310,285,265,
106     245,225,210,195,185,180,170,160,
107     150,145,135,130,125,115,110,107,
108     100, 96, 93, 89, 85, 82, 75, 74,
109      70, 68, 64, 60, 57, 56, 52, 50,
110      49, 45, 44, 43, 40, 38, 37, 35,
111      33, 32, 30, 29, 28, 25, 24, 22,
112      21, 19, 18, 17, 15, 13, 12, 10
113   },
114   {
115     30,25,20,20,15,15,14,14,
116     13,13,12,12,11,11,10,10,
117      9, 9, 8, 8, 7, 7, 7, 7,
118      6, 6, 6, 6, 5, 5, 5, 5,
119      4, 4, 4, 4, 3, 3, 3, 3,
120      2, 2, 2, 2, 2, 2, 2, 2,
121      0, 0, 0, 0, 0, 0, 0, 0,
122      0, 0, 0, 0, 0, 0, 0, 0
123   },
124   {
125     {
126       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_Y},
127       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C},
128       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C}
129     },
130     {
131       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
132       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
133       {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER}
134     }
135   }
136 };
137
138 /*The current default quantization parameters.*/
139 static const int OC_DEF_QRANGE_SIZES[3]={32,16,15};
140 static const th_quant_base OC_DEF_BASES_INTRA_Y[4]={
141   {
142      15, 15, 15, 15, 15, 15, 15, 15,
143      15, 15, 15, 15, 15, 15, 15, 15,
144      15, 15, 15, 15, 15, 15, 15, 15,
145      15, 15, 15, 15, 15, 15, 15, 15,
146      15, 15, 15, 15, 15, 15, 15, 15,
147      15, 15, 15, 15, 15, 15, 15, 15,
148      15, 15, 15, 15, 15, 15, 15, 15,
149      15, 15, 15, 15, 15, 15, 15, 15,
150   },
151   {
152      15, 12, 12, 15, 18, 20, 20, 21,
153      13, 13, 14, 17, 18, 21, 21, 20,
154      14, 14, 15, 18, 20, 21, 21, 21,
155      14, 16, 17, 19, 20, 21, 21, 21,
156      16, 17, 20, 21, 21, 21, 21, 21,
157      18, 19, 20, 21, 21, 21, 21, 21,
158      20, 21, 21, 21, 21, 21, 21, 21,
159      21, 21, 21, 21, 21, 21, 21, 21
160   },
161   {
162      16, 12, 11, 16, 20, 25, 27, 28,
163      13, 13, 14, 18, 21, 28, 28, 27,
164      14, 13, 16, 20, 25, 28, 28, 28,
165      14, 16, 19, 22, 27, 29, 29, 28,
166      17, 19, 25, 28, 28, 30, 30, 29,
167      20, 24, 27, 28, 29, 30, 30, 29,
168      27, 28, 29, 29, 30, 30, 30, 30,
169      29, 29, 29, 29, 30, 30, 30, 29
170   },
171   {
172      16, 11, 10, 16, 24, 40, 51, 61,
173      12, 12, 14, 19, 26, 58, 60, 55,
174      14, 13, 16, 24, 40, 57, 69, 56,
175      14, 17, 22, 29, 51, 87, 80, 62,
176      18, 22, 37, 58, 68,109,103, 77,
177      24, 35, 55, 64, 81,104,113, 92,
178      49, 64, 78, 87,103,121,120,101,
179      72, 92, 95, 98,112,100,103, 99
180   }
181 };
182 static const th_quant_base OC_DEF_BASES_INTRA_C[4]={
183   {
184      19, 19, 19, 19, 19, 19, 19, 19,
185      19, 19, 19, 19, 19, 19, 19, 19,
186      19, 19, 19, 19, 19, 19, 19, 19,
187      19, 19, 19, 19, 19, 19, 19, 19,
188      19, 19, 19, 19, 19, 19, 19, 19,
189      19, 19, 19, 19, 19, 19, 19, 19,
190      19, 19, 19, 19, 19, 19, 19, 19,
191      19, 19, 19, 19, 19, 19, 19, 19
192   },
193   {
194      18, 18, 21, 25, 26, 26, 26, 26,
195      18, 20, 22, 26, 26, 26, 26, 26,
196      21, 22, 25, 26, 26, 26, 26, 26,
197      25, 26, 26, 26, 26, 26, 26, 26,
198      26, 26, 26, 26, 26, 26, 26, 26,
199      26, 26, 26, 26, 26, 26, 26, 26,
200      26, 26, 26, 26, 26, 26, 26, 26,
201      26, 26, 26, 26, 26, 26, 26, 26
202   },
203   {
204      17, 18, 22, 31, 36, 36, 36, 36,
205      18, 20, 24, 34, 36, 36, 36, 36,
206      22, 24, 33, 36, 36, 36, 36, 36,
207      31, 34, 36, 36, 36, 36, 36, 36,
208      36, 36, 36, 36, 36, 36, 36, 36,
209      36, 36, 36, 36, 36, 36, 36, 36,
210      36, 36, 36, 36, 36, 36, 36, 36,
211      36, 36, 36, 36, 36, 36, 36, 36
212   },
213   {
214      17, 18, 24, 47, 99, 99, 99, 99,
215      18, 21, 26, 66, 99, 99, 99, 99,
216      24, 26, 56, 99, 99, 99, 99, 99,
217      47, 66, 99, 99, 99, 99, 99, 99,
218      99, 99, 99, 99, 99, 99, 99, 99,
219      99, 99, 99, 99, 99, 99, 99, 99,
220      99, 99, 99, 99, 99, 99, 99, 99,
221      99, 99, 99, 99, 99, 99, 99, 99
222   }
223 };
224 static const th_quant_base OC_DEF_BASES_INTER[4]={
225   {
226      21, 21, 21, 21, 21, 21, 21, 21,
227      21, 21, 21, 21, 21, 21, 21, 21,
228      21, 21, 21, 21, 21, 21, 21, 21,
229      21, 21, 21, 21, 21, 21, 21, 21,
230      21, 21, 21, 21, 21, 21, 21, 21,
231      21, 21, 21, 21, 21, 21, 21, 21,
232      21, 21, 21, 21, 21, 21, 21, 21,
233      21, 21, 21, 21, 21, 21, 21, 21
234   },
235   {
236      18, 18, 18, 21, 23, 24, 25, 27,
237      18, 18, 21, 23, 24, 25, 27, 28,
238      18, 21, 23, 24, 25, 27, 28, 29,
239      21, 23, 24, 25, 27, 28, 29, 29,
240      23, 24, 25, 27, 28, 29, 29, 29,
241      24, 25, 27, 28, 29, 29, 29, 30,
242      25, 27, 28, 29, 29, 29, 30, 30,
243      27, 28, 29, 29, 29, 30, 30, 30
244   },
245   {
246      17, 17, 17, 20, 23, 26, 28, 32,
247      17, 17, 20, 23, 26, 28, 32, 34,
248      17, 20, 23, 26, 28, 32, 34, 37,
249      20, 23, 26, 28, 32, 34, 37, 37,
250      23, 26, 28, 32, 34, 37, 37, 37,
251      26, 28, 32, 34, 37, 37, 37, 41,
252      28, 32, 34, 37, 37, 37, 41, 42,
253      32, 34, 37, 37, 37, 41, 42, 42
254   },
255   {
256      16, 16, 16, 20, 24, 28, 32, 40,
257      16, 16, 20, 24, 28, 32, 40, 48,
258      16, 20, 24, 28, 32, 40, 48, 64,
259      20, 24, 28, 32, 40, 48, 64, 64,
260      24, 28, 32, 40, 48, 64, 64, 64,
261      28, 32, 40, 48, 64, 64, 64, 96,
262      32, 40, 48, 64, 64, 64, 96,128,
263      40, 48, 64, 64, 64, 96,128,128
264   }
265 };
266
267 const th_quant_info TH_DEF_QUANT_INFO={
268   {
269     365,348,333,316,300,287,277,265,
270     252,240,229,219,206,197,189,180,
271     171,168,160,153,146,139,132,127,
272     121,115,110,107,101, 97, 94, 89,
273      85, 83, 78, 73, 72, 67, 66, 62,
274      60, 59, 56, 53, 52, 48, 47, 43,
275      42, 40, 36, 35, 34, 33, 31, 30,
276      28, 25, 24, 22, 20, 17, 14, 10
277   },
278   {
279     365,348,333,316,300,287,277,265,
280     252,240,229,219,206,197,189,180,
281     171,168,160,153,146,139,132,127,
282     121,115,110,107,101, 97, 94, 89,
283      85, 83, 78, 73, 72, 67, 66, 62,
284      60, 59, 56, 53, 52, 48, 47, 43,
285      42, 40, 36, 35, 34, 33, 31, 30,
286      28, 25, 24, 22, 20, 17, 14, 10
287   },
288   {
289     15,12, 9, 8, 6, 6, 5, 5,
290      5, 5, 5, 5, 5, 5, 5, 5,
291      4, 4, 4, 4, 4, 4, 3, 3,
292      3, 3, 3, 3, 3, 3, 3, 3,
293      2, 2, 2, 2, 2, 2, 2, 2,
294      2, 2, 2, 2, 2, 2, 2, 0,
295      0, 0, 0, 0, 0, 0, 0, 0,
296      0, 0, 0, 0, 0, 0, 0, 0
297   },
298   {
299     {
300       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_Y},
301       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C},
302       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C}
303     },
304     {
305       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
306       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
307       {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER}
308     }
309   }
310 };
311
312
313
314 /*The Huffman codes used for macro block modes.*/
315
316 const unsigned char OC_MODE_BITS[2][OC_NMODES]={
317   /*Codebook 0: a maximally skewed prefix code.*/
318   {1,2,3,4,5,6,7,7},
319   /*Codebook 1: a fixed-length code.*/
320   {3,3,3,3,3,3,3,3}
321 };
322
323 static const unsigned char OC_MODE_CODES[2][OC_NMODES]={
324   /*Codebook 0: a maximally skewed prefix code.*/
325   {0x00,0x02,0x06,0x0E,0x1E,0x3E,0x7E,0x7F},
326   /*Codebook 1: a fixed-length code.*/
327   {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07}
328 };
329
330
331 /*The Huffman codes used for motion vectors.*/
332
333 const unsigned char OC_MV_BITS[2][64]={
334   /*Codebook 0: VLC code.*/
335   {
336       8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
337     8,7,7,7,7,7,7,7,7,6,6,6,6,4,4,3,
338     3,
339     3,4,4,6,6,6,6,7,7,7,7,7,7,7,7,8,
340     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
341   },
342   /*Codebook 1: (5 bit magnitude, 1 bit sign).
343     This wastes a code word (0x01, negative zero), or a bit (0x00, positive
344      zero, requires only 5 bits to uniquely decode), but is hopefully not used
345      very often.*/
346   {
347       6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
348     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
349     6,
350     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
351     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
352   }
353 };
354
355 static const unsigned char OC_MV_CODES[2][64]={
356   /*Codebook 0: VLC code.*/
357   {
358          0xFF,0xFD,0xFB,0xF9,0xF7,0xF5,0xF3,
359     0xF1,0xEF,0xED,0xEB,0xE9,0xE7,0xE5,0xE3,
360     0xE1,0x6F,0x6D,0x6B,0x69,0x67,0x65,0x63,
361     0x61,0x2F,0x2D,0x2B,0x29,0x09,0x07,0x02,
362     0x00,
363     0x01,0x06,0x08,0x28,0x2A,0x2C,0x2E,0x60,
364     0x62,0x64,0x66,0x68,0x6A,0x6C,0x6E,0xE0,
365     0xE2,0xE4,0xE6,0xE8,0xEA,0xEC,0xEE,0xF0,
366     0xF2,0xF4,0xF6,0xF8,0xFA,0xFC,0xFE
367   },
368   /*Codebook 1: (5 bit magnitude, 1 bit sign).*/
369   {
370          0x3F,0x3D,0x3B,0x39,0x37,0x35,0x33,
371     0x31,0x2F,0x2D,0x2B,0x29,0x27,0x25,0x23,
372     0x21,0x1F,0x1D,0x1B,0x19,0x17,0x15,0x13,
373     0x11,0x0F,0x0D,0x0B,0x09,0x07,0x05,0x03,
374     0x00,
375     0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,
376     0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
377     0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
378     0x32,0x34,0x36,0x38,0x3A,0x3C,0x3E
379   }
380 };
381
382
383
384 /*Super block run coding scheme:
385    Codeword             Run Length
386    0                       1
387    10x                     2-3
388    110x                    4-5
389    1110xx                  6-9
390    11110xxx                10-17
391    111110xxxx              18-33
392    111111xxxxxxxxxxxx      34-4129*/
393 const ogg_uint16_t    OC_SB_RUN_VAL_MIN[8]={1,2,4,6,10,18,34,4130};
394 static const unsigned OC_SB_RUN_CODE_PREFIX[7]={
395   0,4,0xC,0x38,0xF0,0x3E0,0x3F000
396 };
397 const unsigned char   OC_SB_RUN_CODE_NBITS[7]={1,3,4,6,8,10,18};
398
399
400 /*Writes the bit pattern for the run length of a super block run to the given
401    oggpack_buffer.
402   _opb:       The buffer to write to.
403   _run_count: The length of the run, which must be positive.
404   _flag:      The current flag.
405   _done:      Whether or not more flags are to be encoded.*/
406 static void oc_sb_run_pack(oggpack_buffer *_opb,ptrdiff_t _run_count,
407  int _flag,int _done){
408   int i;
409   if(_run_count>=4129){
410     do{
411       oggpackB_write(_opb,0x3FFFF,18);
412       _run_count-=4129;
413       if(_run_count>0)oggpackB_write(_opb,_flag,1);
414       else if(!_done)oggpackB_write(_opb,!_flag,1);
415     }
416     while(_run_count>=4129);
417     if(_run_count<=0)return;
418   }
419   for(i=0;_run_count>=OC_SB_RUN_VAL_MIN[i+1];i++);
420   oggpackB_write(_opb,OC_SB_RUN_CODE_PREFIX[i]+_run_count-OC_SB_RUN_VAL_MIN[i],
421    OC_SB_RUN_CODE_NBITS[i]);
422 }
423
424
425
426 /*Block run coding scheme:
427    Codeword             Run Length
428    0x                      1-2
429    10x                     3-4
430    110x                    5-6
431    1110xx                  7-10
432    11110xx                 11-14
433    11111xxxx               15-30*/
434 const unsigned char OC_BLOCK_RUN_CODE_NBITS[30]={
435   2,2,3,3,4,4,6,6,6,6,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
436 };
437 static const ogg_uint16_t  OC_BLOCK_RUN_CODE_PATTERN[30]={
438         0x000,0x001,0x004,0x005,0x00C,0x00D,0x038,
439   0x039,0x03A,0x03B,0x078,0x079,0x07A,0x07B,0x1F0,
440   0x1F1,0x1F2,0x1F3,0x1F4,0x1F5,0x1F6,0x1F7,0x1F8,
441   0x1F9,0x1FA,0x1FB,0x1FC,0x1FD,0x1FE,0x1FF
442 };
443
444
445 /*Writes the bit pattern for the run length of a block run to the given
446    oggpack_buffer.
447   _opb:       The buffer to write to.
448   _run_count: The length of the run.
449               This must be positive, and no more than 30.*/
450 static void oc_block_run_pack(oggpack_buffer *_opb,int _run_count){
451   oggpackB_write(_opb,OC_BLOCK_RUN_CODE_PATTERN[_run_count-1],
452    OC_BLOCK_RUN_CODE_NBITS[_run_count-1]);
453 }
454
455
456
457 static void oc_enc_frame_header_pack(oc_enc_ctx *_enc){
458   /*Mark this as a data packet.*/
459   oggpackB_write(&_enc->opb,0,1);
460   /*Output the frame type (key frame or delta frame).*/
461   oggpackB_write(&_enc->opb,_enc->state.frame_type,1);
462   /*Write out the current qi list.*/
463   oggpackB_write(&_enc->opb,_enc->state.qis[0],6);
464   if(_enc->state.nqis>1){
465     oggpackB_write(&_enc->opb,1,1);
466     oggpackB_write(&_enc->opb,_enc->state.qis[1],6);
467     if(_enc->state.nqis>2){
468       oggpackB_write(&_enc->opb,1,1);
469       oggpackB_write(&_enc->opb,_enc->state.qis[2],6);
470     }
471     else oggpackB_write(&_enc->opb,0,1);
472   }
473   else oggpackB_write(&_enc->opb,0,1);
474   if(_enc->state.frame_type==OC_INTRA_FRAME){
475     /*Key frames have 3 unused configuration bits, holdovers from the VP3 days.
476       Most of the other unused bits in the VP3 headers were eliminated.
477       Monty kept these to leave us some wiggle room for future expansion,
478        though a single bit in all frames would have been far more useful.*/
479     oggpackB_write(&_enc->opb,0,3);
480   }
481 }
482
483 /*Writes the bit flags for whether or not each super block is partially coded
484    or not.
485   These flags are run-length encoded, with the flag value alternating between
486    each run.
487   Return: The number partially coded SBs.*/
488 static unsigned oc_enc_partial_sb_flags_pack(oc_enc_ctx *_enc){
489   const oc_sb_flags *sb_flags;
490   unsigned           nsbs;
491   unsigned           sbi;
492   unsigned           npartial;
493   int                flag;
494   sb_flags=_enc->state.sb_flags;
495   nsbs=_enc->state.nsbs;
496   flag=sb_flags[0].coded_partially;
497   oggpackB_write(&_enc->opb,flag,1);
498   sbi=npartial=0;
499   do{
500     unsigned run_count;
501     for(run_count=0;sbi<nsbs;sbi++){
502       if(sb_flags[sbi].coded_partially!=flag)break;
503       run_count++;
504       npartial+=flag;
505     }
506     oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
507     flag=!flag;
508   }
509   while(sbi<nsbs);
510   return npartial;
511 }
512
513 /*Writes the coded/not coded flags for each super block that is not partially
514    coded.
515   These flags are run-length encoded, with the flag value altenating between
516    each run.*/
517 static void oc_enc_coded_sb_flags_pack(oc_enc_ctx *_enc){
518   const oc_sb_flags *sb_flags;
519   unsigned           nsbs;
520   unsigned           sbi;
521   int                flag;
522   sb_flags=_enc->state.sb_flags;
523   nsbs=_enc->state.nsbs;
524   /*Skip partially coded super blocks; their flags have already been coded.*/
525   for(sbi=0;sb_flags[sbi].coded_partially;sbi++);
526   flag=sb_flags[sbi].coded_fully;
527   oggpackB_write(&_enc->opb,flag,1);
528   do{
529     unsigned run_count;
530     for(run_count=0;sbi<nsbs;sbi++){
531       if(sb_flags[sbi].coded_partially)continue;
532       if(sb_flags[sbi].coded_fully!=flag)break;
533       run_count++;
534     }
535     oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
536     flag=!flag;
537   }
538   while(sbi<nsbs);
539 }
540
541 static void oc_enc_coded_flags_pack(oc_enc_ctx *_enc){
542   const oc_sb_map   *sb_maps;
543   const oc_sb_flags *sb_flags;
544   unsigned           nsbs;
545   const oc_fragment *frags;
546   unsigned           npartial;
547   int                run_count;
548   int                flag;
549   int                pli;
550   unsigned           sbi;
551   npartial=oc_enc_partial_sb_flags_pack(_enc);
552   if(npartial<_enc->state.nsbs)oc_enc_coded_sb_flags_pack(_enc);
553   sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
554   sb_flags=_enc->state.sb_flags;
555   nsbs=_enc->state.nsbs;
556   frags=_enc->state.frags;
557   for(sbi=0;sbi<nsbs&&!sb_flags[sbi].coded_partially;sbi++);
558   /*If there's at least one partial SB, store individual coded block flags.*/
559   if(sbi<nsbs){
560     flag=frags[sb_maps[sbi][0][0]].coded;
561     oggpackB_write(&_enc->opb,flag,1);
562     run_count=0;
563     nsbs=sbi=0;
564     for(pli=0;pli<3;pli++){
565       nsbs+=_enc->state.fplanes[pli].nsbs;
566       for(;sbi<nsbs;sbi++){
567         int       quadi;
568         int       bi;
569         ptrdiff_t fragi;
570         if(sb_flags[sbi].coded_partially){
571           for(quadi=0;quadi<4;quadi++){
572             for(bi=0;bi<4;bi++){
573               fragi=sb_maps[sbi][quadi][bi];
574               if(fragi>=0){
575                 if(frags[fragi].coded!=flag){
576                   oc_block_run_pack(&_enc->opb,run_count);
577                   flag=!flag;
578                   run_count=1;
579                 }
580                 else run_count++;
581               }
582             }
583           }
584         }
585       }
586     }
587     /*Flush any trailing block coded run.*/
588     if(run_count>0)oc_block_run_pack(&_enc->opb,run_count);
589   }
590 }
591
592 static void oc_enc_mb_modes_pack(oc_enc_ctx *_enc){
593   const unsigned char *mode_codes;
594   const unsigned char *mode_bits;
595   const unsigned char *mode_ranks;
596   unsigned            *coded_mbis;
597   size_t               ncoded_mbis;
598   const signed char   *mb_modes;
599   unsigned             mbii;
600   int                  scheme;
601   int                  mb_mode;
602   scheme=_enc->chooser.scheme_list[0];
603   /*Encode the best scheme.*/
604   oggpackB_write(&_enc->opb,scheme,3);
605   /*If the chosen scheme is scheme 0, send the mode frequency ordering.*/
606   if(scheme==0){
607     for(mb_mode=0;mb_mode<OC_NMODES;mb_mode++){
608       oggpackB_write(&_enc->opb,_enc->chooser.scheme0_ranks[mb_mode],3);
609     }
610   }
611   mode_ranks=_enc->chooser.mode_ranks[scheme];
612   mode_bits=OC_MODE_BITS[scheme+1>>3];
613   mode_codes=OC_MODE_CODES[scheme+1>>3];
614   coded_mbis=_enc->coded_mbis;
615   ncoded_mbis=_enc->ncoded_mbis;
616   mb_modes=_enc->state.mb_modes;
617   for(mbii=0;mbii<ncoded_mbis;mbii++){
618     int rank;
619     rank=mode_ranks[mb_modes[coded_mbis[mbii]]];
620     oggpackB_write(&_enc->opb,mode_codes[rank],mode_bits[rank]);
621   }
622 }
623
624 static void oc_enc_mv_pack(oc_enc_ctx *_enc,int _mv_scheme,oc_mv _mv){
625   int dx;
626   int dy;
627   dx=OC_MV_X(_mv);
628   dy=OC_MV_Y(_mv);
629   oggpackB_write(&_enc->opb,
630    OC_MV_CODES[_mv_scheme][dx+31],OC_MV_BITS[_mv_scheme][dx+31]);
631   oggpackB_write(&_enc->opb,
632    OC_MV_CODES[_mv_scheme][dy+31],OC_MV_BITS[_mv_scheme][dy+31]);
633 }
634
635 static void oc_enc_mvs_pack(oc_enc_ctx *_enc){
636   const unsigned     *coded_mbis;
637   size_t              ncoded_mbis;
638   const oc_mb_map    *mb_maps;
639   const signed char  *mb_modes;
640   const oc_fragment  *frags;
641   const oc_mv        *frag_mvs;
642   unsigned            mbii;
643   int                 mv_scheme;
644   /*Choose the coding scheme.*/
645   mv_scheme=_enc->mv_bits[1]<_enc->mv_bits[0];
646   oggpackB_write(&_enc->opb,mv_scheme,1);
647   /*Encode the motion vectors.
648     Macro blocks are iterated in Hilbert scan order, but the MVs within the
649      macro block are coded in raster order.*/
650   coded_mbis=_enc->coded_mbis;
651   ncoded_mbis=_enc->ncoded_mbis;
652   mb_modes=_enc->state.mb_modes;
653   mb_maps=(const oc_mb_map *)_enc->state.mb_maps;
654   frags=_enc->state.frags;
655   frag_mvs=_enc->state.frag_mvs;
656   for(mbii=0;mbii<ncoded_mbis;mbii++){
657     ptrdiff_t fragi;
658     unsigned  mbi;
659     int       bi;
660     mbi=coded_mbis[mbii];
661     switch(mb_modes[mbi]){
662       case OC_MODE_INTER_MV:
663       case OC_MODE_GOLDEN_MV:{
664         for(bi=0;;bi++){
665           fragi=mb_maps[mbi][0][bi];
666           if(frags[fragi].coded){
667             oc_enc_mv_pack(_enc,mv_scheme,frag_mvs[fragi]);
668             /*Only code a single MV for this macro block.*/
669             break;
670           }
671         }
672       }break;
673       case OC_MODE_INTER_MV_FOUR:{
674         for(bi=0;bi<4;bi++){
675           fragi=mb_maps[mbi][0][bi];
676           if(frags[fragi].coded){
677             oc_enc_mv_pack(_enc,mv_scheme,frag_mvs[fragi]);
678             /*Keep coding all the MVs for this macro block.*/
679           }
680         }
681       }break;
682     }
683   }
684 }
685
686 static void oc_enc_block_qis_pack(oc_enc_ctx *_enc){
687   const oc_fragment *frags;
688   ptrdiff_t         *coded_fragis;
689   ptrdiff_t          ncoded_fragis;
690   ptrdiff_t          fragii;
691   ptrdiff_t          run_count;
692   ptrdiff_t          nqi0;
693   int                flag;
694   if(_enc->state.nqis<=1)return;
695   ncoded_fragis=_enc->state.ntotal_coded_fragis;
696   if(ncoded_fragis<=0)return;
697   coded_fragis=_enc->state.coded_fragis;
698   frags=_enc->state.frags;
699   flag=!!frags[coded_fragis[0]].qii;
700   oggpackB_write(&_enc->opb,flag,1);
701   nqi0=0;
702   for(fragii=0;fragii<ncoded_fragis;){
703     for(run_count=0;fragii<ncoded_fragis;fragii++){
704       if(!!frags[coded_fragis[fragii]].qii!=flag)break;
705       run_count++;
706       nqi0+=!flag;
707     }
708     oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
709     flag=!flag;
710   }
711   if(_enc->state.nqis<3||nqi0>=ncoded_fragis)return;
712   for(fragii=0;!frags[coded_fragis[fragii]].qii;fragii++);
713   flag=frags[coded_fragis[fragii]].qii-1;
714   oggpackB_write(&_enc->opb,flag,1);
715   while(fragii<ncoded_fragis){
716     for(run_count=0;fragii<ncoded_fragis;fragii++){
717       int qii;
718       qii=frags[coded_fragis[fragii]].qii;
719       if(!qii)continue;
720       if(qii-1!=flag)break;
721       run_count++;
722     }
723     oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
724     flag=!flag;
725   }
726 }
727
728 /*Counts the tokens of each type used for the given range of coefficient
729    indices in zig-zag order.
730   _zzi_start:      The first zig-zag index to include.
731   _zzi_end:        The first zig-zag index to not include.
732   _token_counts_y: Returns the token counts for the Y' plane.
733   _token_counts_c: Returns the token counts for the Cb and Cr planes.*/
734 static void oc_enc_count_tokens(oc_enc_ctx *_enc,int _zzi_start,int _zzi_end,
735  ptrdiff_t _token_counts_y[32],ptrdiff_t _token_counts_c[32]){
736   const unsigned char *dct_tokens;
737   ptrdiff_t            ndct_tokens;
738   int                  pli;
739   int                  zzi;
740   ptrdiff_t            ti;
741   memset(_token_counts_y,0,32*sizeof(*_token_counts_y));
742   memset(_token_counts_c,0,32*sizeof(*_token_counts_c));
743   for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
744     dct_tokens=_enc->dct_tokens[0][zzi];
745     ndct_tokens=_enc->ndct_tokens[0][zzi];
746     for(ti=_enc->dct_token_offs[0][zzi];ti<ndct_tokens;ti++){
747       _token_counts_y[dct_tokens[ti]]++;
748     }
749   }
750   for(pli=1;pli<3;pli++){
751     for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
752       dct_tokens=_enc->dct_tokens[pli][zzi];
753       ndct_tokens=_enc->ndct_tokens[pli][zzi];
754       for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
755         _token_counts_c[dct_tokens[ti]]++;
756       }
757     }
758   }
759 }
760
761 /*Computes the number of bits used for each of the potential Huffman code for
762    the given list of token counts.
763   The bits are added to whatever the current bit counts are.*/
764 static void oc_enc_count_bits(oc_enc_ctx *_enc,int _hgi,
765  const ptrdiff_t _token_counts[32],size_t _bit_counts[16]){
766   int huffi;
767   int huff_offs;
768   int token;
769   huff_offs=_hgi<<4;
770   for(huffi=0;huffi<16;huffi++){
771     for(token=0;token<32;token++){
772       _bit_counts[huffi]+=
773        _token_counts[token]*_enc->huff_codes[huffi+huff_offs][token].nbits;
774     }
775   }
776 }
777
778 /*Returns the Huffman index using the fewest number of bits.*/
779 static int oc_select_huff_idx(size_t _bit_counts[16]){
780   int best_huffi;
781   int huffi;
782   best_huffi=0;
783   for(huffi=1;huffi<16;huffi++)if(_bit_counts[huffi]<_bit_counts[best_huffi]){
784     best_huffi=huffi;
785   }
786   return best_huffi;
787 }
788
789 static void oc_enc_huff_group_pack(oc_enc_ctx *_enc,
790  int _zzi_start,int _zzi_end,const int _huff_idxs[2]){
791   int zzi;
792   for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
793     int pli;
794     for(pli=0;pli<3;pli++){
795       const unsigned char *dct_tokens;
796       const ogg_uint16_t  *extra_bits;
797       ptrdiff_t            ndct_tokens;
798       const th_huff_code  *huff_codes;
799       ptrdiff_t            ti;
800       dct_tokens=_enc->dct_tokens[pli][zzi];
801       extra_bits=_enc->extra_bits[pli][zzi];
802       ndct_tokens=_enc->ndct_tokens[pli][zzi];
803       huff_codes=_enc->huff_codes[_huff_idxs[pli+1>>1]];
804       for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
805         int token;
806         int neb;
807         token=dct_tokens[ti];
808         oggpackB_write(&_enc->opb,huff_codes[token].pattern,
809          huff_codes[token].nbits);
810         neb=OC_DCT_TOKEN_EXTRA_BITS[token];
811         if(neb)oggpackB_write(&_enc->opb,extra_bits[ti],neb);
812       }
813     }
814   }
815 }
816
817 static void oc_enc_residual_tokens_pack(oc_enc_ctx *_enc){
818   static const unsigned char  OC_HUFF_GROUP_MIN[6]={0,1,6,15,28,64};
819   static const unsigned char *OC_HUFF_GROUP_MAX=OC_HUFF_GROUP_MIN+1;
820   ptrdiff_t token_counts_y[32];
821   ptrdiff_t token_counts_c[32];
822   size_t    bits_y[16];
823   size_t    bits_c[16];
824   int       huff_idxs[2];
825   int       frame_type;
826   int       hgi;
827   frame_type=_enc->state.frame_type;
828   /*Choose which Huffman tables to use for the DC token list.*/
829   oc_enc_count_tokens(_enc,0,1,token_counts_y,token_counts_c);
830   memset(bits_y,0,sizeof(bits_y));
831   memset(bits_c,0,sizeof(bits_c));
832   oc_enc_count_bits(_enc,0,token_counts_y,bits_y);
833   oc_enc_count_bits(_enc,0,token_counts_c,bits_c);
834   huff_idxs[0]=oc_select_huff_idx(bits_y);
835   huff_idxs[1]=oc_select_huff_idx(bits_c);
836   /*Write the DC token list with the chosen tables.*/
837   oggpackB_write(&_enc->opb,huff_idxs[0],4);
838   oggpackB_write(&_enc->opb,huff_idxs[1],4);
839   _enc->huff_idxs[frame_type][0][0]=(unsigned char)huff_idxs[0];
840   _enc->huff_idxs[frame_type][0][1]=(unsigned char)huff_idxs[1];
841   oc_enc_huff_group_pack(_enc,0,1,huff_idxs);
842   /*Choose which Huffman tables to use for the AC token lists.*/
843   memset(bits_y,0,sizeof(bits_y));
844   memset(bits_c,0,sizeof(bits_c));
845   for(hgi=1;hgi<5;hgi++){
846     oc_enc_count_tokens(_enc,OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],
847      token_counts_y,token_counts_c);
848     oc_enc_count_bits(_enc,hgi,token_counts_y,bits_y);
849     oc_enc_count_bits(_enc,hgi,token_counts_c,bits_c);
850   }
851   huff_idxs[0]=oc_select_huff_idx(bits_y);
852   huff_idxs[1]=oc_select_huff_idx(bits_c);
853   /*Write the AC token lists using the chosen tables.*/
854   oggpackB_write(&_enc->opb,huff_idxs[0],4);
855   oggpackB_write(&_enc->opb,huff_idxs[1],4);
856   _enc->huff_idxs[frame_type][1][0]=(unsigned char)huff_idxs[0];
857   _enc->huff_idxs[frame_type][1][1]=(unsigned char)huff_idxs[1];
858   for(hgi=1;hgi<5;hgi++){
859     huff_idxs[0]+=16;
860     huff_idxs[1]+=16;
861     oc_enc_huff_group_pack(_enc,
862      OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],huff_idxs);
863   }
864 }
865
866 /*Packs an explicit drop frame, instead of using the more efficient 0-byte
867    packet.
868   This is only enabled in VP3-compatibility mode, even though it is not
869    strictly required for VP3 compatibility (VP3 could be encoded in AVI, which
870    also supports dropping frames by inserting 0 byte packets).
871   However, almost every _Theora_ player used to get this wrong (and many still
872    do), and it wasn't until we started shipping a post-VP3 encoder that
873    actually used non-VP3 features that this began to be discovered and fixed,
874    despite being in the standard since 2004.
875   The pack buffer must be reset before calling this function.*/
876 static void oc_enc_drop_frame_pack(oc_enc_ctx *_enc){
877   unsigned nsbs;
878   /*Mark this as a data packet.*/
879   oggpackB_write(&_enc->opb,0,1);
880   /*Output the frame type (key frame or delta frame).*/
881   oggpackB_write(&_enc->opb,OC_INTER_FRAME,1);
882   /*Write out the current qi list.
883     We always use just 1 qi, to avoid wasting bits on the others.*/
884   oggpackB_write(&_enc->opb,_enc->state.qis[0],6);
885   oggpackB_write(&_enc->opb,0,1);
886   /*Coded block flags: everything is uncoded.*/
887   nsbs=_enc->state.nsbs;
888   /*No partially coded SBs.*/
889   oggpackB_write(&_enc->opb,0,1);
890   oc_sb_run_pack(&_enc->opb,nsbs,0,1);
891   /*No fully coded SBs.*/
892   oggpackB_write(&_enc->opb,0,1);
893   oc_sb_run_pack(&_enc->opb,nsbs,0,1);
894   /*MB modes: just need write which scheme to use.
895     Since we have no coded MBs, we can pick any of them except 0, which would
896      require writing out an additional mode list.*/
897   oggpackB_write(&_enc->opb,7,3);
898   /*MVs: just need write which scheme to use.
899     We can pick either one, since we have no MVs.*/
900   oggpackB_write(&_enc->opb,1,1);
901   /*Write the chosen DC token tables.*/
902   oggpackB_write(&_enc->opb,_enc->huff_idxs[OC_INTER_FRAME][0][0],4);
903   oggpackB_write(&_enc->opb,_enc->huff_idxs[OC_INTER_FRAME][0][1],4);
904   /*Write the chosen AC token tables.*/
905   oggpackB_write(&_enc->opb,_enc->huff_idxs[OC_INTER_FRAME][1][0],4);
906   oggpackB_write(&_enc->opb,_enc->huff_idxs[OC_INTER_FRAME][1][1],4);
907 }
908
909 static void oc_enc_frame_pack(oc_enc_ctx *_enc){
910   oggpackB_reset(&_enc->opb);
911   /*Only proceed if we have some coded blocks.*/
912   if(_enc->state.ntotal_coded_fragis>0){
913     oc_enc_frame_header_pack(_enc);
914     if(_enc->state.frame_type==OC_INTER_FRAME){
915       /*Coded block flags, MB modes, and MVs are only needed for delta frames.*/
916       oc_enc_coded_flags_pack(_enc);
917       oc_enc_mb_modes_pack(_enc);
918       oc_enc_mvs_pack(_enc);
919     }
920     oc_enc_block_qis_pack(_enc);
921     oc_enc_tokenize_finish(_enc);
922     oc_enc_residual_tokens_pack(_enc);
923   }
924   /*If there are no coded blocks, we can drop this frame simply by emitting a
925      0 byte packet.
926     We emit an inter frame with no coded blocks in VP3-compatibility mode.*/
927   else if(_enc->vp3_compatible)oc_enc_drop_frame_pack(_enc);
928   /*Success: Mark the packet as ready to be flushed.*/
929   _enc->packet_state=OC_PACKET_READY;
930 #if defined(OC_COLLECT_METRICS)
931   oc_enc_mode_metrics_collect(_enc);
932 #endif
933 }
934
935
936 void oc_enc_accel_init_c(oc_enc_ctx *_enc){
937   /*The implementations prefixed with oc_enc_ are encoder-specific.
938     The rest we re-use from the decoder.*/
939 # if defined(OC_ENC_USE_VTABLE)
940   _enc->opt_vtable.frag_sub=oc_enc_frag_sub_c;
941   _enc->opt_vtable.frag_sub_128=oc_enc_frag_sub_128_c;
942   _enc->opt_vtable.frag_sad=oc_enc_frag_sad_c;
943   _enc->opt_vtable.frag_sad_thresh=oc_enc_frag_sad_thresh_c;
944   _enc->opt_vtable.frag_sad2_thresh=oc_enc_frag_sad2_thresh_c;
945   _enc->opt_vtable.frag_intra_sad=oc_enc_frag_intra_sad_c;
946   _enc->opt_vtable.frag_satd=oc_enc_frag_satd_c;
947   _enc->opt_vtable.frag_satd2=oc_enc_frag_satd2_c;
948   _enc->opt_vtable.frag_intra_satd=oc_enc_frag_intra_satd_c;
949   _enc->opt_vtable.frag_ssd=oc_enc_frag_ssd_c;
950   _enc->opt_vtable.frag_border_ssd=oc_enc_frag_border_ssd_c;
951   _enc->opt_vtable.frag_copy2=oc_enc_frag_copy2_c;
952   _enc->opt_vtable.enquant_table_init=oc_enc_enquant_table_init_c;
953   _enc->opt_vtable.enquant_table_fixup=oc_enc_enquant_table_fixup_c;
954   _enc->opt_vtable.quantize=oc_enc_quantize_c;
955   _enc->opt_vtable.frag_recon_intra=oc_frag_recon_intra_c;
956   _enc->opt_vtable.frag_recon_inter=oc_frag_recon_inter_c;
957   _enc->opt_vtable.fdct8x8=oc_enc_fdct8x8_c;
958 # endif
959   _enc->opt_data.enquant_table_size=64*sizeof(oc_iquant);
960   _enc->opt_data.enquant_table_alignment=16;
961 }
962
963 /*Initialize the macro block neighbor lists for MC analysis.
964   This assumes that the entire mb_info memory region has been initialized with
965    zeros.*/
966 static void oc_enc_mb_info_init(oc_enc_ctx *_enc){
967   oc_mb_enc_info    *embs;
968   const signed char *mb_modes;
969   unsigned           nhsbs;
970   unsigned           nvsbs;
971   unsigned           nhmbs;
972   unsigned           nvmbs;
973   unsigned           sby;
974   mb_modes=_enc->state.mb_modes;
975   embs=_enc->mb_info;
976   nhsbs=_enc->state.fplanes[0].nhsbs;
977   nvsbs=_enc->state.fplanes[0].nvsbs;
978   nhmbs=_enc->state.nhmbs;
979   nvmbs=_enc->state.nvmbs;
980   for(sby=0;sby<nvsbs;sby++){
981     unsigned sbx;
982     for(sbx=0;sbx<nhsbs;sbx++){
983       int quadi;
984       for(quadi=0;quadi<4;quadi++){
985         /*Because of the Hilbert curve ordering the macro blocks are
986            visited in, the available neighbors change depending on where in
987            a super block the macro block is located.
988           Only the first three vectors are used in the median calculation
989            for the optimal predictor, and so the most important should be
990            listed first.
991           Additional vectors are used, so there will always be at least 3,
992            except for in the upper-left most macro block.*/
993         /*The number of current neighbors for each macro block position.*/
994         static const unsigned char NCNEIGHBORS[4]={4,3,2,4};
995         /*The offset of each current neighbor in the X direction.*/
996         static const signed char   CDX[4][4]={
997           {-1,0,1,-1},
998           {-1,0,-1,},
999           {-1,-1},
1000           {-1,0,0,1}
1001         };
1002         /*The offset of each current neighbor in the Y direction.*/
1003         static const signed char   CDY[4][4]={
1004           {0,-1,-1,-1},
1005           {0,-1,-1},
1006           {0,-1},
1007           {0,-1,1,-1}
1008         };
1009         /*The offset of each previous neighbor in the X direction.*/
1010         static const signed char   PDX[4]={-1,0,1,0};
1011         /*The offset of each previous neighbor in the Y direction.*/
1012         static const signed char   PDY[4]={0,-1,0,1};
1013         unsigned mbi;
1014         int      mbx;
1015         int      mby;
1016         unsigned nmbi;
1017         int      nmbx;
1018         int      nmby;
1019         int      ni;
1020         mbi=(sby*nhsbs+sbx<<2)+quadi;
1021         if(mb_modes[mbi]==OC_MODE_INVALID)continue;
1022         mbx=2*sbx+(quadi>>1);
1023         mby=2*sby+(quadi+1>>1&1);
1024         /*Fill in the neighbors with current motion vectors available.*/
1025         for(ni=0;ni<NCNEIGHBORS[quadi];ni++){
1026           nmbx=mbx+CDX[quadi][ni];
1027           nmby=mby+CDY[quadi][ni];
1028           if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
1029           nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
1030           if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
1031           embs[mbi].cneighbors[embs[mbi].ncneighbors++]=nmbi;
1032         }
1033         /*Fill in the neighbors with previous motion vectors available.*/
1034         for(ni=0;ni<4;ni++){
1035           nmbx=mbx+PDX[ni];
1036           nmby=mby+PDY[ni];
1037           if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
1038           nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
1039           if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
1040           embs[mbi].pneighbors[embs[mbi].npneighbors++]=nmbi;
1041         }
1042       }
1043     }
1044   }
1045 }
1046
1047 static int oc_enc_set_huffman_codes(oc_enc_ctx *_enc,
1048  const th_huff_code _codes[TH_NHUFFMAN_TABLES][TH_NDCT_TOKENS]){
1049   int ret;
1050   if(_enc==NULL)return TH_EFAULT;
1051   if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
1052   if(_codes==NULL)_codes=TH_VP31_HUFF_CODES;
1053   /*Validate the codes.*/
1054   oggpackB_reset(&_enc->opb);
1055   ret=oc_huff_codes_pack(&_enc->opb,_codes);
1056   if(ret<0)return ret;
1057   memcpy(_enc->huff_codes,_codes,sizeof(_enc->huff_codes));
1058   return 0;
1059 }
1060
1061 static void oc_enc_enquant_tables_init(oc_enc_ctx *_enc,
1062  const th_quant_info *_qinfo){
1063   unsigned char *etd;
1064   size_t         ets;
1065   int            align;
1066   int            qii;
1067   int            qi;
1068   int            pli;
1069   int            qti;
1070   for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
1071     _enc->state.dequant_tables[qi][pli][qti]=
1072      _enc->state.dequant_table_data[qi][pli][qti];
1073   }
1074   /*Initialize the dequantization tables.*/
1075   oc_dequant_tables_init(_enc->state.dequant_tables,NULL,_qinfo);
1076   /*And save off the DC values.*/
1077   for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
1078     _enc->dequant_dc[qi][pli][qti]=_enc->state.dequant_tables[qi][pli][qti][0];
1079   }
1080   /*Set up storage for the quantization tables.*/
1081   etd=_enc->enquant_table_data;
1082   ets=_enc->opt_data.enquant_table_size;
1083   align=-(etd-(unsigned char *)0)&_enc->opt_data.enquant_table_alignment-1;
1084   etd+=align;
1085   /*Set up the main tables.*/
1086   for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
1087     _enc->enquant_tables[qi][pli][qti]=etd;
1088     oc_enc_enquant_table_init(_enc,etd,
1089      _enc->state.dequant_tables[qi][pli][qti]);
1090     etd+=ets;
1091   }
1092   /*Set up storage for the local copies we modify for each frame.*/
1093   for(pli=0;pli<3;pli++)for(qii=0;qii<3;qii++)for(qti=0;qti<2;qti++){
1094     _enc->enquant[pli][qii][qti]=etd;
1095     etd+=ets;
1096   }
1097 }
1098
1099 /*Updates the encoder state after the quantization parameters have been
1100    changed.*/
1101 static void oc_enc_quant_params_updated(oc_enc_ctx *_enc,
1102  const th_quant_info *_qinfo){
1103   oc_enc_enquant_tables_init(_enc,_qinfo);
1104   memcpy(_enc->state.loop_filter_limits,_qinfo->loop_filter_limits,
1105    sizeof(_enc->state.loop_filter_limits));
1106   oc_enquant_qavg_init(_enc->log_qavg,_enc->log_plq,_enc->chroma_rd_scale,
1107    _enc->state.dequant_tables,_enc->state.info.pixel_fmt);
1108 }
1109
1110 /*Sets the quantization parameters to use.
1111   This may only be called before the setup header is written.
1112   If it is called multiple times, only the last call has any effect.
1113   _qinfo: The quantization parameters.
1114           These are described in more detail in theoraenc.h.
1115           This can be NULL, in which case the default quantization parameters
1116            will be used.*/
1117 static int oc_enc_set_quant_params(oc_enc_ctx *_enc,
1118  const th_quant_info *_qinfo){
1119   th_quant_info old_qinfo;
1120   int           ret;
1121   if(_enc==NULL)return TH_EFAULT;
1122   if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
1123   if(_qinfo==NULL)_qinfo=&TH_DEF_QUANT_INFO;
1124   memcpy(&old_qinfo,&_enc->qinfo,sizeof(old_qinfo));
1125   ret=oc_quant_params_clone(&_enc->qinfo,_qinfo);
1126   if(ret<0){
1127     oc_quant_params_clear(&_enc->qinfo);
1128     memcpy(&_enc->qinfo,&old_qinfo,sizeof(old_qinfo));
1129     return ret;
1130   }
1131   else oc_quant_params_clear(&old_qinfo);
1132   oc_enc_quant_params_updated(_enc,_qinfo);
1133   return 0;
1134 }
1135
1136 static void oc_enc_clear(oc_enc_ctx *_enc);
1137
1138 static int oc_enc_init(oc_enc_ctx *_enc,const th_info *_info){
1139   th_info   info;
1140   size_t    mcu_nmbs;
1141   ptrdiff_t mcu_ncfrags;
1142   ptrdiff_t mcu_nfrags;
1143   int       hdec;
1144   int       vdec;
1145   int       ret;
1146   int       pli;
1147   /*Clean up the requested settings.*/
1148   memcpy(&info,_info,sizeof(info));
1149   info.version_major=TH_VERSION_MAJOR;
1150   info.version_minor=TH_VERSION_MINOR;
1151   info.version_subminor=TH_VERSION_SUB;
1152   if(info.quality>63)info.quality=63;
1153   if(info.quality<0)info.quality=32;
1154   if(info.target_bitrate<0)info.target_bitrate=0;
1155   /*Initialize the shared encoder/decoder state.*/
1156   ret=oc_state_init(&_enc->state,&info,6);
1157   if(ret<0)return ret;
1158   oc_enc_accel_init(_enc);
1159   _enc->mb_info=_ogg_calloc(_enc->state.nmbs,sizeof(*_enc->mb_info));
1160   _enc->frag_dc=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_dc));
1161   _enc->coded_mbis=
1162    (unsigned *)_ogg_malloc(_enc->state.nmbs*sizeof(*_enc->coded_mbis));
1163   hdec=!(_enc->state.info.pixel_fmt&1);
1164   vdec=!(_enc->state.info.pixel_fmt&2);
1165   /*If chroma is sub-sampled in the vertical direction, we have to encode two
1166      super block rows of Y' for each super block row of Cb and Cr.*/
1167   _enc->mcu_nvsbs=1<<vdec;
1168   mcu_nmbs=_enc->mcu_nvsbs*_enc->state.fplanes[0].nhsbs*(size_t)4;
1169   mcu_ncfrags=mcu_nmbs<<3-(hdec+vdec);
1170   mcu_nfrags=4*mcu_nmbs+mcu_ncfrags;
1171   _enc->mcu_skip_ssd=(unsigned *)_ogg_malloc(
1172    mcu_nfrags*sizeof(*_enc->mcu_skip_ssd));
1173   _enc->mcu_rd_scale=(ogg_uint16_t *)_ogg_malloc(
1174    (mcu_ncfrags>>1)*sizeof(*_enc->mcu_rd_scale));
1175   _enc->mcu_rd_iscale=(ogg_uint16_t *)_ogg_malloc(
1176    (mcu_ncfrags>>1)*sizeof(*_enc->mcu_rd_iscale));
1177   for(pli=0;pli<3;pli++){
1178     _enc->dct_tokens[pli]=(unsigned char **)oc_malloc_2d(64,
1179      _enc->state.fplanes[pli].nfrags,sizeof(**_enc->dct_tokens));
1180     _enc->extra_bits[pli]=(ogg_uint16_t **)oc_malloc_2d(64,
1181      _enc->state.fplanes[pli].nfrags,sizeof(**_enc->extra_bits));
1182   }
1183 #if defined(OC_COLLECT_METRICS)
1184   _enc->frag_sad=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_sad));
1185   _enc->frag_satd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_satd));
1186   _enc->frag_ssd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_ssd));
1187 #endif
1188   _enc->enquant_table_data=(unsigned char *)_ogg_malloc(
1189    (64+3)*3*2*_enc->opt_data.enquant_table_size
1190    +_enc->opt_data.enquant_table_alignment-1);
1191   _enc->keyframe_frequency_force=1<<_enc->state.info.keyframe_granule_shift;
1192   _enc->state.qis[0]=_enc->state.info.quality;
1193   _enc->state.nqis=1;
1194   _enc->activity_avg=90<<12;
1195   _enc->luma_avg=128<<8;
1196   oc_rc_state_init(&_enc->rc,_enc);
1197   oggpackB_writeinit(&_enc->opb);
1198   memcpy(_enc->huff_codes,TH_VP31_HUFF_CODES,sizeof(_enc->huff_codes));
1199   memset(_enc->qinfo.qi_ranges,0,sizeof(_enc->qinfo.qi_ranges));
1200   /*Reset the packet-out state machine.*/
1201   _enc->packet_state=OC_PACKET_INFO_HDR;
1202   _enc->dup_count=0;
1203   _enc->nqueued_dups=0;
1204   _enc->prev_dup_count=0;
1205   /*Enable speed optimizations up through early skip by default.*/
1206   _enc->sp_level=OC_SP_LEVEL_EARLY_SKIP;
1207   /*Disable VP3 compatibility by default.*/
1208   _enc->vp3_compatible=0;
1209   /*No INTER frames coded yet.*/
1210   _enc->coded_inter_frame=0;
1211   if(_enc->mb_info==NULL||_enc->frag_dc==NULL||_enc->coded_mbis==NULL
1212    ||_enc->mcu_skip_ssd==NULL||_enc->dct_tokens[0]==NULL
1213    ||_enc->dct_tokens[1]==NULL||_enc->dct_tokens[2]==NULL
1214    ||_enc->extra_bits[0]==NULL||_enc->extra_bits[1]==NULL
1215    ||_enc->extra_bits[2]==NULL
1216 #if defined(OC_COLLECT_METRICS)
1217    ||_enc->frag_sad==NULL||_enc->frag_satd==NULL||_enc->frag_ssd==NULL
1218 #endif
1219    ||oc_enc_set_quant_params(_enc,NULL)<0){
1220     oc_enc_clear(_enc);
1221     return TH_EFAULT;
1222   }
1223   oc_mode_scheme_chooser_init(&_enc->chooser);
1224   oc_enc_mb_info_init(_enc);
1225   memset(_enc->huff_idxs,0,sizeof(_enc->huff_idxs));
1226   return 0;
1227 }
1228
1229 static void oc_enc_clear(oc_enc_ctx *_enc){
1230   int pli;
1231   oc_rc_state_clear(&_enc->rc);
1232   oggpackB_writeclear(&_enc->opb);
1233   oc_quant_params_clear(&_enc->qinfo);
1234   _ogg_free(_enc->enquant_table_data);
1235 #if defined(OC_COLLECT_METRICS)
1236   /*Save the collected metrics from this run.
1237     Use tools/process_modedec_stats to actually generate modedec.h from the
1238      resulting file.*/
1239   oc_mode_metrics_dump();
1240   _ogg_free(_enc->frag_ssd);
1241   _ogg_free(_enc->frag_satd);
1242   _ogg_free(_enc->frag_sad);
1243 #endif
1244   for(pli=3;pli-->0;){
1245     oc_free_2d(_enc->extra_bits[pli]);
1246     oc_free_2d(_enc->dct_tokens[pli]);
1247   }
1248   _ogg_free(_enc->mcu_rd_iscale);
1249   _ogg_free(_enc->mcu_rd_scale);
1250   _ogg_free(_enc->mcu_skip_ssd);
1251   _ogg_free(_enc->coded_mbis);
1252   _ogg_free(_enc->frag_dc);
1253   _ogg_free(_enc->mb_info);
1254   oc_state_clear(&_enc->state);
1255 }
1256
1257 static void oc_enc_drop_frame(th_enc_ctx *_enc){
1258   /*Use the previous frame's reconstruction.*/
1259   _enc->state.ref_frame_idx[OC_FRAME_SELF]=
1260    _enc->state.ref_frame_idx[OC_FRAME_PREV];
1261   _enc->state.ref_frame_data[OC_FRAME_SELF]=
1262    _enc->state.ref_frame_data[OC_FRAME_PREV];
1263   /*Flag motion vector analysis about the frame drop.*/
1264   _enc->prevframe_dropped=1;
1265   /*Zero the packet.*/
1266   oggpackB_reset(&_enc->opb);
1267   /*Emit an inter frame with no coded blocks in VP3-compatibility mode.*/
1268   if(_enc->vp3_compatible)oc_enc_drop_frame_pack(_enc);
1269 }
1270
1271 static void oc_enc_compress_keyframe(oc_enc_ctx *_enc,int _recode){
1272   if(_enc->state.info.target_bitrate>0){
1273     _enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTRA_FRAME,
1274      _enc->state.curframe_num>0);
1275     _enc->state.nqis=1;
1276   }
1277   oc_enc_calc_lambda(_enc,OC_INTRA_FRAME);
1278   oc_enc_analyze_intra(_enc,_recode);
1279   oc_enc_frame_pack(_enc);
1280   /*On the first frame, the previous call was an initial dry-run to prime
1281      feed-forward statistics.*/
1282   if(!_recode&&_enc->state.curframe_num==0){
1283     if(_enc->state.info.target_bitrate>0){
1284       oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
1285                              OC_INTRA_FRAME,_enc->state.qis[0],1,0);
1286     }
1287     oc_enc_compress_keyframe(_enc,1);
1288   }
1289 }
1290
1291 static void oc_enc_compress_frame(oc_enc_ctx *_enc,int _recode){
1292   if(_enc->state.info.target_bitrate>0){
1293     _enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTER_FRAME,1);
1294     _enc->state.nqis=1;
1295   }
1296   oc_enc_calc_lambda(_enc,OC_INTER_FRAME);
1297   if(oc_enc_analyze_inter(_enc,_enc->rc.twopass!=2,_recode)){
1298     /*Mode analysis thinks this should have been a keyframe; start over.*/
1299     oc_enc_compress_keyframe(_enc,1);
1300   }
1301   else{
1302     oc_enc_frame_pack(_enc);
1303     if(!_enc->coded_inter_frame){
1304       /*On the first INTER frame, the previous call was an initial dry-run to
1305          prime feed-forward statistics.*/
1306       _enc->coded_inter_frame=1;
1307       if(_enc->state.info.target_bitrate>0){
1308         /*Rate control also needs to prime.*/
1309         oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
1310          OC_INTER_FRAME,_enc->state.qis[0],1,0);
1311       }
1312       oc_enc_compress_frame(_enc,1);
1313     }
1314   }
1315 }
1316
1317 /*Set the granule position for the next packet to output based on the current
1318    internal state.*/
1319 static void oc_enc_set_granpos(oc_enc_ctx *_enc){
1320   unsigned dup_offs;
1321   /*Add an offset for the number of duplicate frames we've emitted so far.*/
1322   dup_offs=_enc->prev_dup_count-_enc->nqueued_dups;
1323   /*If the current frame was a keyframe, use it for the high part.*/
1324   if(_enc->state.frame_type==OC_INTRA_FRAME){
1325     _enc->state.granpos=(_enc->state.curframe_num+_enc->state.granpos_bias<<
1326      _enc->state.info.keyframe_granule_shift)+dup_offs;
1327   }
1328   /*Otherwise use the last keyframe in the high part and put the current frame
1329      in the low part.*/
1330   else{
1331     _enc->state.granpos=
1332      (_enc->state.keyframe_num+_enc->state.granpos_bias<<
1333      _enc->state.info.keyframe_granule_shift)
1334      +_enc->state.curframe_num-_enc->state.keyframe_num+dup_offs;
1335   }
1336 }
1337
1338
1339 th_enc_ctx *th_encode_alloc(const th_info *_info){
1340   oc_enc_ctx *enc;
1341   if(_info==NULL)return NULL;
1342   enc=oc_aligned_malloc(sizeof(*enc),16);
1343   if(enc==NULL||oc_enc_init(enc,_info)<0){
1344     oc_aligned_free(enc);
1345     return NULL;
1346   }
1347   return enc;
1348 }
1349
1350 void th_encode_free(th_enc_ctx *_enc){
1351   if(_enc!=NULL){
1352     oc_enc_clear(_enc);
1353     oc_aligned_free(_enc);
1354   }
1355 }
1356
1357 int th_encode_ctl(th_enc_ctx *_enc,int _req,void *_buf,size_t _buf_sz){
1358   switch(_req){
1359     case TH_ENCCTL_SET_HUFFMAN_CODES:{
1360       if(_buf==NULL&&_buf_sz!=0||
1361        _buf!=NULL&&_buf_sz!=sizeof(th_huff_table)*TH_NHUFFMAN_TABLES){
1362         return TH_EINVAL;
1363       }
1364       return oc_enc_set_huffman_codes(_enc,(const th_huff_table *)_buf);
1365     }break;
1366     case TH_ENCCTL_SET_QUANT_PARAMS:{
1367       if(_buf==NULL&&_buf_sz!=0||
1368        _buf!=NULL&&_buf_sz!=sizeof(th_quant_info)){
1369         return TH_EINVAL;
1370       }
1371       return oc_enc_set_quant_params(_enc,(th_quant_info *)_buf);
1372     }break;
1373     case TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE:{
1374       ogg_uint32_t keyframe_frequency_force;
1375       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1376       if(_buf_sz!=sizeof(keyframe_frequency_force))return TH_EINVAL;
1377       keyframe_frequency_force=*(ogg_uint32_t *)_buf;
1378       if(keyframe_frequency_force<=0)keyframe_frequency_force=1;
1379       if(_enc->packet_state==OC_PACKET_INFO_HDR){
1380         /*It's still early enough to enlarge keyframe_granule_shift.*/
1381         _enc->state.info.keyframe_granule_shift=OC_CLAMPI(
1382          _enc->state.info.keyframe_granule_shift,
1383          OC_ILOG_32(keyframe_frequency_force-1),31);
1384       }
1385       _enc->keyframe_frequency_force=OC_MINI(keyframe_frequency_force,
1386        (ogg_uint32_t)1U<<_enc->state.info.keyframe_granule_shift);
1387       *(ogg_uint32_t *)_buf=_enc->keyframe_frequency_force;
1388       return 0;
1389     }break;
1390     case TH_ENCCTL_SET_VP3_COMPATIBLE:{
1391       int vp3_compatible;
1392       int ret;
1393       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1394       if(_buf_sz!=sizeof(vp3_compatible))return TH_EINVAL;
1395       /*Try this before we change anything else, because it can fail.*/
1396       ret=oc_enc_set_quant_params(_enc,&TH_VP31_QUANT_INFO);
1397       /*If we can't allocate enough memory, don't change any of the state.*/
1398       if(ret==TH_EFAULT)return ret;
1399       vp3_compatible=*(int *)_buf;
1400       _enc->vp3_compatible=vp3_compatible;
1401       if(oc_enc_set_huffman_codes(_enc,TH_VP31_HUFF_CODES)<0)vp3_compatible=0;
1402       if(ret<0)vp3_compatible=0;
1403       if(_enc->state.info.pixel_fmt!=TH_PF_420||
1404        _enc->state.info.pic_width<_enc->state.info.frame_width||
1405        _enc->state.info.pic_height<_enc->state.info.frame_height||
1406       /*If we have more than 4095 super blocks, VP3's RLE coding might
1407          overflow.
1408         We could overcome this by ensuring we flip the coded/not-coded flags on
1409          at least one super block in the frame, but we pick the simple solution
1410          of just telling the user the stream will be incompatible instead.
1411         It's unlikely the old VP3 codec would be able to decode streams at this
1412          resolution in real time in the first place.*/
1413        _enc->state.nsbs>4095){
1414         vp3_compatible=0;
1415       }
1416       *(int *)_buf=vp3_compatible;
1417       return 0;
1418     }break;
1419     case TH_ENCCTL_GET_SPLEVEL_MAX:{
1420       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1421       if(_buf_sz!=sizeof(int))return TH_EINVAL;
1422       *(int *)_buf=OC_SP_LEVEL_MAX;
1423       return 0;
1424     }break;
1425     case TH_ENCCTL_SET_SPLEVEL:{
1426       int speed;
1427       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1428       if(_buf_sz!=sizeof(speed))return TH_EINVAL;
1429       speed=*(int *)_buf;
1430       if(speed<0||speed>OC_SP_LEVEL_MAX)return TH_EINVAL;
1431       _enc->sp_level=speed;
1432       return 0;
1433     }break;
1434     case TH_ENCCTL_GET_SPLEVEL:{
1435       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1436       if(_buf_sz!=sizeof(int))return TH_EINVAL;
1437       *(int *)_buf=_enc->sp_level;
1438       return 0;
1439     }
1440     case TH_ENCCTL_SET_DUP_COUNT:{
1441       int dup_count;
1442       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1443       if(_buf_sz!=sizeof(dup_count))return TH_EINVAL;
1444       dup_count=*(int *)_buf;
1445       if(dup_count>=_enc->keyframe_frequency_force)return TH_EINVAL;
1446       _enc->dup_count=OC_MAXI(dup_count,0);
1447       return 0;
1448     }break;
1449     case TH_ENCCTL_SET_QUALITY:{
1450       int qi;
1451       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1452       if(_enc->state.info.target_bitrate>0)return TH_EINVAL;
1453       qi=*(int *)_buf;
1454       if(qi<0||qi>63)return TH_EINVAL;
1455       _enc->state.info.quality=qi;
1456       _enc->state.qis[0]=(unsigned char)qi;
1457       _enc->state.nqis=1;
1458       return 0;
1459     }break;
1460     case TH_ENCCTL_SET_BITRATE:{
1461       long bitrate;
1462       int  reset;
1463       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1464       bitrate=*(long *)_buf;
1465       if(bitrate<=0)return TH_EINVAL;
1466       reset=_enc->state.info.target_bitrate<=0;
1467       _enc->state.info.target_bitrate=bitrate>INT_MAX?INT_MAX:bitrate;
1468       if(reset)oc_rc_state_init(&_enc->rc,_enc);
1469       else oc_enc_rc_resize(_enc);
1470       return 0;
1471     }break;
1472     case TH_ENCCTL_SET_RATE_FLAGS:{
1473       int set;
1474       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1475       if(_buf_sz!=sizeof(set))return TH_EINVAL;
1476       if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
1477       set=*(int *)_buf;
1478       _enc->rc.drop_frames=set&TH_RATECTL_DROP_FRAMES;
1479       _enc->rc.cap_overflow=set&TH_RATECTL_CAP_OVERFLOW;
1480       _enc->rc.cap_underflow=set&TH_RATECTL_CAP_UNDERFLOW;
1481       return 0;
1482     }break;
1483     case TH_ENCCTL_SET_RATE_BUFFER:{
1484       int set;
1485       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1486       if(_buf_sz!=sizeof(set))return TH_EINVAL;
1487       if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
1488       set=*(int *)_buf;
1489       _enc->rc.buf_delay=set;
1490       oc_enc_rc_resize(_enc);
1491       *(int *)_buf=_enc->rc.buf_delay;
1492       return 0;
1493     }break;
1494     case TH_ENCCTL_2PASS_OUT:{
1495       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1496       if(_enc->state.info.target_bitrate<=0||
1497        _enc->state.curframe_num>=0&&_enc->rc.twopass!=1||
1498        _buf_sz!=sizeof(unsigned char *)){
1499         return TH_EINVAL;
1500       }
1501       return oc_enc_rc_2pass_out(_enc,(unsigned char **)_buf);
1502     }break;
1503     case TH_ENCCTL_2PASS_IN:{
1504       if(_enc==NULL)return TH_EFAULT;
1505       if(_enc->state.info.target_bitrate<=0||
1506        _enc->state.curframe_num>=0&&_enc->rc.twopass!=2){
1507         return TH_EINVAL;
1508       }
1509       return oc_enc_rc_2pass_in(_enc,_buf,_buf_sz);
1510     }break;
1511     case TH_ENCCTL_SET_COMPAT_CONFIG:{
1512       unsigned char buf[7];
1513       oc_pack_buf   opb;
1514       th_quant_info qinfo;
1515       th_huff_code  huff_codes[TH_NHUFFMAN_TABLES][TH_NDCT_TOKENS];
1516       int           ret;
1517       int           i;
1518       if(_enc==NULL||_buf==NULL)return TH_EFAULT;
1519       if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
1520       oc_pack_readinit(&opb,_buf,_buf_sz);
1521       /*Validate the setup packet header.*/
1522       for(i=0;i<7;i++)buf[i]=(unsigned char)oc_pack_read(&opb,8);
1523       if(!(buf[0]&0x80)||memcmp(buf+1,"theora",6)!=0)return TH_ENOTFORMAT;
1524       if(buf[0]!=0x82)return TH_EBADHEADER;
1525       /*Reads its contents.*/
1526       ret=oc_quant_params_unpack(&opb,&qinfo);
1527       if(ret<0){
1528         oc_quant_params_clear(&qinfo);
1529         return ret;
1530       }
1531       ret=oc_huff_codes_unpack(&opb,huff_codes);
1532       if(ret<0){
1533         oc_quant_params_clear(&qinfo);
1534         return ret;
1535       }
1536       /*Install the new state.*/
1537       oc_quant_params_clear(&_enc->qinfo);
1538       memcpy(&_enc->qinfo,&qinfo,sizeof(qinfo));
1539       oc_enc_quant_params_updated(_enc,&qinfo);
1540       memcpy(_enc->huff_codes,huff_codes,sizeof(_enc->huff_codes));
1541       return 0;
1542     }
1543 #if defined(OC_COLLECT_METRICS)
1544     case TH_ENCCTL_SET_METRICS_FILE:{
1545       OC_MODE_METRICS_FILENAME=(const char *)_buf;
1546       return 0;
1547     }
1548 #endif
1549     default:return TH_EIMPL;
1550   }
1551 }
1552
1553 int th_encode_flushheader(th_enc_ctx *_enc,th_comment *_tc,ogg_packet *_op){
1554   if(_enc==NULL)return TH_EFAULT;
1555   return oc_state_flushheader(&_enc->state,&_enc->packet_state,&_enc->opb,
1556    &_enc->qinfo,(const th_huff_table *)_enc->huff_codes,th_version_string(),
1557    _tc,_op);
1558 }
1559
1560 static void oc_img_plane_copy_pad(th_img_plane *_dst,th_img_plane *_src,
1561  ogg_int32_t _pic_x,ogg_int32_t _pic_y,
1562  ogg_int32_t _pic_width,ogg_int32_t _pic_height){
1563   unsigned char *dst;
1564   int            dstride;
1565   ogg_uint32_t   frame_width;
1566   ogg_uint32_t   frame_height;
1567   ogg_uint32_t   y;
1568   frame_width=_dst->width;
1569   frame_height=_dst->height;
1570   /*If we have _no_ data, just encode a dull green.*/
1571   if(_pic_width==0||_pic_height==0){
1572     dst=_dst->data;
1573     dstride=_dst->stride;
1574     for(y=0;y<frame_height;y++){
1575       memset(dst,0,frame_width*sizeof(*dst));
1576       dst+=dstride;
1577     }
1578   }
1579   /*Otherwise, copy what we do have, and add our own padding.*/
1580   else{
1581     unsigned char *dst_data;
1582     unsigned char *src_data;
1583     unsigned char *src;
1584     int            sstride;
1585     ogg_uint32_t   x;
1586     /*Step 1: Copy the data we do have.*/
1587     dstride=_dst->stride;
1588     sstride=_src->stride;
1589     dst_data=_dst->data;
1590     src_data=_src->data;
1591     dst=dst_data+_pic_y*(ptrdiff_t)dstride+_pic_x;
1592     src=src_data+_pic_y*(ptrdiff_t)sstride+_pic_x;
1593     for(y=0;y<_pic_height;y++){
1594       memcpy(dst,src,_pic_width);
1595       dst+=dstride;
1596       src+=sstride;
1597     }
1598     /*Step 2: Perform a low-pass extension into the padding region.*/
1599     /*Left side.*/
1600     for(x=_pic_x;x-->0;){
1601       dst=dst_data+_pic_y*(ptrdiff_t)dstride+x;
1602       for(y=0;y<_pic_height;y++){
1603         dst[0]=(dst[1]<<1)+(dst-(dstride&-(y>0)))[1]
1604          +(dst+(dstride&-(y+1<_pic_height)))[1]+2>>2;
1605         dst+=dstride;
1606       }
1607     }
1608     /*Right side.*/
1609     for(x=_pic_x+_pic_width;x<frame_width;x++){
1610       dst=dst_data+_pic_y*(ptrdiff_t)dstride+x-1;
1611       for(y=0;y<_pic_height;y++){
1612         dst[1]=(dst[0]<<1)+(dst-(dstride&-(y>0)))[0]
1613          +(dst+(dstride&-(y+1<_pic_height)))[0]+2>>2;
1614         dst+=dstride;
1615       }
1616     }
1617     /*Top.*/
1618     dst=dst_data+_pic_y*(ptrdiff_t)dstride;
1619     for(y=_pic_y;y-->0;){
1620       for(x=0;x<frame_width;x++){
1621         (dst-dstride)[x]=(dst[x]<<1)+dst[x-(x>0)]
1622          +dst[x+(x+1<frame_width)]+2>>2;
1623       }
1624       dst-=dstride;
1625     }
1626     /*Bottom.*/
1627     dst=dst_data+(_pic_y+_pic_height)*(ptrdiff_t)dstride;
1628     for(y=_pic_y+_pic_height;y<frame_height;y++){
1629       for(x=0;x<frame_width;x++){
1630         dst[x]=((dst-dstride)[x]<<1)+(dst-dstride)[x-(x>0)]
1631          +(dst-dstride)[x+(x+1<frame_width)]+2>>2;
1632       }
1633       dst+=dstride;
1634     }
1635   }
1636 }
1637
1638 int th_encode_ycbcr_in(th_enc_ctx *_enc,th_ycbcr_buffer _img){
1639   th_ycbcr_buffer img;
1640   int             frame_width;
1641   int             frame_height;
1642   int             pic_width;
1643   int             pic_height;
1644   int             pic_x;
1645   int             pic_y;
1646   int             cframe_width;
1647   int             cframe_height;
1648   int             cpic_width;
1649   int             cpic_height;
1650   int             cpic_x;
1651   int             cpic_y;
1652   int             hdec;
1653   int             vdec;
1654   int             pli;
1655   int             refi;
1656   int             drop;
1657   /*Step 1: validate parameters.*/
1658   if(_enc==NULL||_img==NULL)return TH_EFAULT;
1659   if(_enc->packet_state==OC_PACKET_DONE)return TH_EINVAL;
1660   if(_enc->rc.twopass&&_enc->rc.twopass_buffer_bytes==0)return TH_EINVAL;
1661   hdec=!(_enc->state.info.pixel_fmt&1);
1662   vdec=!(_enc->state.info.pixel_fmt&2);
1663   frame_width=_enc->state.info.frame_width;
1664   frame_height=_enc->state.info.frame_height;
1665   pic_x=_enc->state.info.pic_x;
1666   pic_y=_enc->state.info.pic_y;
1667   pic_width=_enc->state.info.pic_width;
1668   pic_height=_enc->state.info.pic_height;
1669   cframe_width=frame_width>>hdec;
1670   cframe_height=frame_height>>vdec;
1671   cpic_x=pic_x>>hdec;
1672   cpic_y=pic_y>>vdec;
1673   cpic_width=(pic_x+pic_width+hdec>>hdec)-cpic_x;
1674   cpic_height=(pic_y+pic_height+vdec>>vdec)-cpic_y;
1675   /*Flip the input buffer upside down.*/
1676   oc_ycbcr_buffer_flip(img,_img);
1677   if(img[0].width!=frame_width||img[0].height!=frame_height||
1678    img[1].width!=cframe_width||img[2].width!=cframe_width||
1679    img[1].height!=cframe_height||img[2].height!=cframe_height){
1680     /*The buffer does not match the frame size.
1681       Check to see if it matches the picture size.*/
1682     if(img[0].width!=pic_width||img[0].height!=pic_height||
1683      img[1].width!=cpic_width||img[2].width!=cpic_width||
1684      img[1].height!=cpic_height||img[2].height!=cpic_height){
1685       /*It doesn't; we don't know how to handle it.*/
1686       return TH_EINVAL;
1687     }
1688     /*Adjust the pointers to address a full frame.
1689       We still only use the picture region, however.*/
1690     img[0].data-=pic_y*(ptrdiff_t)img[0].stride+pic_x;
1691     img[1].data-=cpic_y*(ptrdiff_t)img[1].stride+cpic_x;
1692     img[2].data-=cpic_y*(ptrdiff_t)img[2].stride+cpic_x;
1693   }
1694   /*Step 2: Update the buffer state.*/
1695   if(_enc->state.ref_frame_idx[OC_FRAME_SELF]>=0){
1696     _enc->state.ref_frame_idx[OC_FRAME_PREV]=
1697      _enc->state.ref_frame_idx[OC_FRAME_SELF];
1698     _enc->state.ref_frame_data[OC_FRAME_PREV]=
1699      _enc->state.ref_frame_data[OC_FRAME_SELF];
1700     if(_enc->state.frame_type==OC_INTRA_FRAME){
1701       /*The new frame becomes both the previous and gold reference frames.*/
1702       _enc->state.keyframe_num=_enc->state.curframe_num;
1703       _enc->state.ref_frame_idx[OC_FRAME_GOLD]=
1704        _enc->state.ref_frame_idx[OC_FRAME_SELF];
1705       _enc->state.ref_frame_data[OC_FRAME_GOLD]=
1706        _enc->state.ref_frame_data[OC_FRAME_SELF];
1707     }
1708   }
1709   if(_enc->state.ref_frame_idx[OC_FRAME_IO]>=0&&_enc->prevframe_dropped==0){
1710     _enc->state.ref_frame_idx[OC_FRAME_PREV_ORIG]=
1711      _enc->state.ref_frame_idx[OC_FRAME_IO];
1712     _enc->state.ref_frame_data[OC_FRAME_PREV_ORIG]=
1713      _enc->state.ref_frame_data[OC_FRAME_IO];
1714     if(_enc->state.frame_type==OC_INTRA_FRAME){
1715       /*The new input frame becomes both the previous and gold
1716          original-reference frames.*/
1717       _enc->state.ref_frame_idx[OC_FRAME_GOLD_ORIG]=
1718        _enc->state.ref_frame_idx[OC_FRAME_IO];
1719       _enc->state.ref_frame_data[OC_FRAME_GOLD_ORIG]=
1720        _enc->state.ref_frame_data[OC_FRAME_IO];
1721     }
1722   }
1723   /*Select a free buffer to use for the incoming frame*/
1724   for(refi=3;refi==_enc->state.ref_frame_idx[OC_FRAME_GOLD_ORIG]||
1725    refi==_enc->state.ref_frame_idx[OC_FRAME_PREV_ORIG];refi++);
1726   _enc->state.ref_frame_idx[OC_FRAME_IO]=refi;
1727   _enc->state.ref_frame_data[OC_FRAME_IO]=
1728    _enc->state.ref_frame_bufs[refi][0].data;
1729   /*Step 3: Copy the input to our internal buffer.
1730     This lets us add padding, so we don't have to worry about dereferencing
1731      possibly invalid addresses, and allows us to use the same strides and
1732      fragment offsets for both the input frame and the reference frames.*/
1733   oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[refi]+0,img+0,
1734    pic_x,pic_y,pic_width,pic_height);
1735   oc_state_borders_fill_rows(&_enc->state,refi,0,0,frame_height);
1736   oc_state_borders_fill_caps(&_enc->state,refi,0);
1737   for(pli=1;pli<3;pli++){
1738     oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[refi]+pli,img+pli,
1739      cpic_x,cpic_y,cpic_width,cpic_height);
1740     oc_state_borders_fill_rows(&_enc->state,refi,pli,0,cframe_height);
1741     oc_state_borders_fill_caps(&_enc->state,refi,pli);
1742   }
1743   /*Select a free buffer to use for the reconstructed version of this frame.*/
1744   for(refi=0;refi==_enc->state.ref_frame_idx[OC_FRAME_GOLD]||
1745    refi==_enc->state.ref_frame_idx[OC_FRAME_PREV];refi++);
1746   _enc->state.ref_frame_idx[OC_FRAME_SELF]=refi;
1747   _enc->state.ref_frame_data[OC_FRAME_SELF]=
1748    _enc->state.ref_frame_bufs[refi][0].data;
1749   _enc->state.curframe_num+=_enc->prev_dup_count+1;
1750   /*Step 4: Compress the frame.*/
1751   /*Start with a keyframe, and don't allow the generation of invalid files that
1752      overflow the keyframe_granule_shift.*/
1753   if(_enc->rc.twopass_force_kf||_enc->state.curframe_num==0||
1754    _enc->state.curframe_num-_enc->state.keyframe_num+_enc->dup_count>=
1755    _enc->keyframe_frequency_force){
1756     oc_enc_compress_keyframe(_enc,0);
1757     drop=0;
1758   }
1759   else{
1760     oc_enc_compress_frame(_enc,0);
1761     drop=1;
1762   }
1763   oc_restore_fpu(&_enc->state);
1764   /*drop currently indicates if the frame is droppable.*/
1765   if(_enc->state.info.target_bitrate>0){
1766     drop=oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
1767      _enc->state.frame_type,_enc->state.qis[0],0,drop);
1768   }
1769   else drop=0;
1770   /*drop now indicates if the frame was dropped.*/
1771   if(drop)oc_enc_drop_frame(_enc);
1772   else _enc->prevframe_dropped=0;
1773   _enc->packet_state=OC_PACKET_READY;
1774   _enc->prev_dup_count=_enc->nqueued_dups=_enc->dup_count;
1775   _enc->dup_count=0;
1776 #if defined(OC_DUMP_IMAGES)
1777   oc_enc_set_granpos(_enc);
1778   oc_state_dump_frame(&_enc->state,OC_FRAME_IO,"src");
1779   oc_state_dump_frame(&_enc->state,OC_FRAME_SELF,"rec");
1780 #endif
1781   return 0;
1782 }
1783
1784 int th_encode_packetout(th_enc_ctx *_enc,int _last_p,ogg_packet *_op){
1785   unsigned char *packet;
1786   if(_enc==NULL||_op==NULL)return TH_EFAULT;
1787   if(_enc->packet_state==OC_PACKET_READY){
1788     _enc->packet_state=OC_PACKET_EMPTY;
1789     if(_enc->rc.twopass!=1){
1790       packet=oggpackB_get_buffer(&_enc->opb);
1791       /*If there's no packet, malloc failed while writing; it's lost forever.*/
1792       if(packet==NULL)return TH_EFAULT;
1793       _op->packet=packet;
1794       _op->bytes=oggpackB_bytes(&_enc->opb);
1795     }
1796     /*For the first pass in 2-pass mode, don't emit any packet data.*/
1797     else{
1798       _op->packet=NULL;
1799       _op->bytes=0;
1800     }
1801   }
1802   else if(_enc->packet_state==OC_PACKET_EMPTY){
1803     if(_enc->nqueued_dups>0){
1804       _enc->nqueued_dups--;
1805       /*Emit an inter frame with no coded blocks in VP3-compatibility mode.*/
1806       if(_enc->vp3_compatible){
1807         oggpackB_reset(&_enc->opb);
1808         oc_enc_drop_frame_pack(_enc);
1809         packet=oggpackB_get_buffer(&_enc->opb);
1810         /*If there's no packet, malloc failed while writing; it's lost
1811            forever.*/
1812         if(packet==NULL)return TH_EFAULT;
1813         _op->packet=packet;
1814         _op->bytes=oggpackB_bytes(&_enc->opb);
1815       }
1816       /*Otherwise emit a 0-byte packet.*/
1817       else{
1818         _op->packet=NULL;
1819         _op->bytes=0;
1820       }
1821     }
1822     else{
1823       if(_last_p)_enc->packet_state=OC_PACKET_DONE;
1824       return 0;
1825     }
1826   }
1827   else return 0;
1828   _last_p=_last_p&&_enc->nqueued_dups<=0;
1829   _op->b_o_s=0;
1830   _op->e_o_s=_last_p;
1831   oc_enc_set_granpos(_enc);
1832   _op->packetno=th_granule_frame(_enc,_enc->state.granpos)+3;
1833   _op->granulepos=_enc->state.granpos;
1834   if(_last_p)_enc->packet_state=OC_PACKET_DONE;
1835   return 1+_enc->nqueued_dups;
1836 }