/********************************************************************
* *
* THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009 *
* by the Xiph.Org Foundation http://www.xiph.org/ *
* *
********************************************************************
function:
last mod: $Id: encode.c 16503 2009-08-22 18:14:02Z giles $
********************************************************************/
#include <stdlib.h>
#include <string.h>
#include "encint.h"
#if defined(OC_X86_ASM)
# include "x86/x86enc.h"
#endif
/*The default quantization parameters used by VP3.1.*/
static const int OC_VP31_RANGE_SIZES[1]={63};
static const th_quant_base OC_VP31_BASES_INTRA_Y[2]={
{
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 58, 68,109,103, 77,
24, 35, 55, 64, 81,104,113, 92,
49, 64, 78, 87,103,121,120,101,
72, 92, 95, 98,112,100,103, 99
},
{
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 58, 68,109,103, 77,
24, 35, 55, 64, 81,104,113, 92,
49, 64, 78, 87,103,121,120,101,
72, 92, 95, 98,112,100,103, 99
}
};
static const th_quant_base OC_VP31_BASES_INTRA_C[2]={
{
17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99
},
{
17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99
}
};
static const th_quant_base OC_VP31_BASES_INTER[2]={
{
16, 16, 16, 20, 24, 28, 32, 40,
16, 16, 20, 24, 28, 32, 40, 48,
16, 20, 24, 28, 32, 40, 48, 64,
20, 24, 28, 32, 40, 48, 64, 64,
24, 28, 32, 40, 48, 64, 64, 64,
28, 32, 40, 48, 64, 64, 64, 96,
32, 40, 48, 64, 64, 64, 96,128,
40, 48, 64, 64, 64, 96,128,128
},
{
16, 16, 16, 20, 24, 28, 32, 40,
16, 16, 20, 24, 28, 32, 40, 48,
16, 20, 24, 28, 32, 40, 48, 64,
20, 24, 28, 32, 40, 48, 64, 64,
24, 28, 32, 40, 48, 64, 64, 64,
28, 32, 40, 48, 64, 64, 64, 96,
32, 40, 48, 64, 64, 64, 96,128,
40, 48, 64, 64, 64, 96,128,128
}
};
const th_quant_info TH_VP31_QUANT_INFO={
{
220,200,190,180,170,170,160,160,
150,150,140,140,130,130,120,120,
110,110,100,100, 90, 90, 90, 80,
80, 80, 70, 70, 70, 60, 60, 60,
60, 50, 50, 50, 50, 40, 40, 40,
40, 40, 30, 30, 30, 30, 30, 30,
30, 20, 20, 20, 20, 20, 20, 20,
20, 10, 10, 10, 10, 10, 10, 10
},
{
500,450,400,370,340,310,285,265,
245,225,210,195,185,180,170,160,
150,145,135,130,125,115,110,107,
100, 96, 93, 89, 85, 82, 75, 74,
70, 68, 64, 60, 57, 56, 52, 50,
49, 45, 44, 43, 40, 38, 37, 35,
33, 32, 30, 29, 28, 25, 24, 22,
21, 19, 18, 17, 15, 13, 12, 10
},
{
30,25,20,20,15,15,14,14,
13,13,12,12,11,11,10,10,
9, 9, 8, 8, 7, 7, 7, 7,
6, 6, 6, 6, 5, 5, 5, 5,
4, 4, 4, 4, 3, 3, 3, 3,
2, 2, 2, 2, 2, 2, 2, 2,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
},
{
{
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_Y},
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C},
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C}
},
{
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
{1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER}
}
}
};
/*The current default quantization parameters.*/
static const int OC_DEF_QRANGE_SIZES[3]={32,16,15};
static const th_quant_base OC_DEF_BASES_INTRA_Y[4]={
{
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15,
},
{
15, 12, 12, 15, 18, 20, 20, 21,
13, 13, 14, 17, 18, 21, 21, 20,
14, 14, 15, 18, 20, 21, 21, 21,
14, 16, 17, 19, 20, 21, 21, 21,
16, 17, 20, 21, 21, 21, 21, 21,
18, 19, 20, 21, 21, 21, 21, 21,
20, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21
},
{
16, 12, 11, 16, 20, 25, 27, 28,
13, 13, 14, 18, 21, 28, 28, 27,
14, 13, 16, 20, 25, 28, 28, 28,
14, 16, 19, 22, 27, 29, 29, 28,
17, 19, 25, 28, 28, 30, 30, 29,
20, 24, 27, 28, 29, 30, 30, 29,
27, 28, 29, 29, 30, 30, 30, 30,
29, 29, 29, 29, 30, 30, 30, 29
},
{
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 58, 68,109,103, 77,
24, 35, 55, 64, 81,104,113, 92,
49, 64, 78, 87,103,121,120,101,
72, 92, 95, 98,112,100,103, 99
}
};
static const th_quant_base OC_DEF_BASES_INTRA_C[4]={
{
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19
},
{
18, 18, 21, 25, 26, 26, 26, 26,
18, 20, 22, 26, 26, 26, 26, 26,
21, 22, 25, 26, 26, 26, 26, 26,
25, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26
},
{
17, 18, 22, 31, 36, 36, 36, 36,
18, 20, 24, 34, 36, 36, 36, 36,
22, 24, 33, 36, 36, 36, 36, 36,
31, 34, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 36, 36, 36
},
{
17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99
}
};
static const th_quant_base OC_DEF_BASES_INTER[4]={
{
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21
},
{
18, 18, 18, 21, 23, 24, 25, 27,
18, 18, 21, 23, 24, 25, 27, 28,
18, 21, 23, 24, 25, 27, 28, 29,
21, 23, 24, 25, 27, 28, 29, 29,
23, 24, 25, 27, 28, 29, 29, 29,
24, 25, 27, 28, 29, 29, 29, 30,
25, 27, 28, 29, 29, 29, 30, 30,
27, 28, 29, 29, 29, 30, 30, 30
},
{
17, 17, 17, 20, 23, 26, 28, 32,
17, 17, 20, 23, 26, 28, 32, 34,
17, 20, 23, 26, 28, 32, 34, 37,
20, 23, 26, 28, 32, 34, 37, 37,
23, 26, 28, 32, 34, 37, 37, 37,
26, 28, 32, 34, 37, 37, 37, 41,
28, 32, 34, 37, 37, 37, 41, 42,
32, 34, 37, 37, 37, 41, 42, 42
},
{
16, 16, 16, 20, 24, 28, 32, 40,
16, 16, 20, 24, 28, 32, 40, 48,
16, 20, 24, 28, 32, 40, 48, 64,
20, 24, 28, 32, 40, 48, 64, 64,
24, 28, 32, 40, 48, 64, 64, 64,
28, 32, 40, 48, 64, 64, 64, 96,
32, 40, 48, 64, 64, 64, 96,128,
40, 48, 64, 64, 64, 96,128,128
}
};
const th_quant_info TH_DEF_QUANT_INFO={
{
365,348,333,316,300,287,277,265,
252,240,229,219,206,197,189,180,
171,168,160,153,146,139,132,127,
121,115,110,107,101, 97, 94, 89,
85, 83, 78, 73, 72, 67, 66, 62,
60, 59, 56, 53, 52, 48, 47, 43,
42, 40, 36, 35, 34, 33, 31, 30,
28, 25, 24, 22, 20, 17, 14, 10
},
{
365,348,333,316,300,287,277,265,
252,240,229,219,206,197,189,180,
171,168,160,153,146,139,132,127,
121,115,110,107,101, 97, 94, 89,
85, 83, 78, 73, 72, 67, 66, 62,
60, 59, 56, 53, 52, 48, 47, 43,
42, 40, 36, 35, 34, 33, 31, 30,
28, 25, 24, 22, 20, 17, 14, 10
},
{
30,25,20,20,15,15,14,14,
13,13,12,12,11,11,10,10,
9, 9, 8, 8, 7, 7, 7, 7,
6, 6, 6, 6, 5, 5, 5, 5,
4, 4, 4, 4, 3, 3, 3, 3,
2, 2, 2, 2, 2, 2, 2, 2,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
},
{
{
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_Y},
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C},
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C}
},
{
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
{3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER}
}
}
};
/*The Huffman codes used for macro block modes.*/
const unsigned char OC_MODE_BITS[2][OC_NMODES]={
/*Codebook 0: a maximally skewed prefix code.*/
{1,2,3,4,5,6,7,7},
/*Codebook 1: a fixed-length code.*/
{3,3,3,3,3,3,3,3}
};
static const unsigned char OC_MODE_CODES[2][OC_NMODES]={
/*Codebook 0: a maximally skewed prefix code.*/
{0x00,0x02,0x06,0x0E,0x1E,0x3E,0x7E,0x7F},
/*Codebook 1: a fixed-length code.*/
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07}
};
/*The Huffman codes used for motion vectors.*/
const unsigned char OC_MV_BITS[2][64]={
/*Codebook 0: VLC code.*/
{
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,7,7,7,7,7,7,7,7,6,6,6,6,4,4,3,
3,
3,4,4,6,6,6,6,7,7,7,7,7,7,7,7,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
},
/*Codebook 1: (5 bit magnitude, 1 bit sign).
This wastes a code word (0x01, negative zero), or a bit (0x00, positive
zero, requires only 5 bits to uniquely decode), but is hopefully not used
very often.*/
{
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
}
};
static const unsigned char OC_MV_CODES[2][64]={
/*Codebook 0: VLC code.*/
{
0xFF,0xFD,0xFB,0xF9,0xF7,0xF5,0xF3,
0xF1,0xEF,0xED,0xEB,0xE9,0xE7,0xE5,0xE3,
0xE1,0x6F,0x6D,0x6B,0x69,0x67,0x65,0x63,
0x61,0x2F,0x2D,0x2B,0x29,0x09,0x07,0x02,
0x00,
0x01,0x06,0x08,0x28,0x2A,0x2C,0x2E,0x60,
0x62,0x64,0x66,0x68,0x6A,0x6C,0x6E,0xE0,
0xE2,0xE4,0xE6,0xE8,0xEA,0xEC,0xEE,0xF0,
0xF2,0xF4,0xF6,0xF8,0xFA,0xFC,0xFE
},
/*Codebook 1: (5 bit magnitude, 1 bit sign).*/
{
0x3F,0x3D,0x3B,0x39,0x37,0x35,0x33,
0x31,0x2F,0x2D,0x2B,0x29,0x27,0x25,0x23,
0x21,0x1F,0x1D,0x1B,0x19,0x17,0x15,0x13,
0x11,0x0F,0x0D,0x0B,0x09,0x07,0x05,0x03,
0x00,
0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,
0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
0x32,0x34,0x36,0x38,0x3A,0x3C,0x3E
}
};
/*Super block run coding scheme:
Codeword Run Length
0 1
10x 2-3
110x 4-5
1110xx 6-9
11110xxx 10-17
111110xxxx 18-33
111111xxxxxxxxxxxx 34-4129*/
const ogg_uint16_t OC_SB_RUN_VAL_MIN[8]={1,2,4,6,10,18,34,4130};
static const unsigned OC_SB_RUN_CODE_PREFIX[7]={
0,4,0xC,0x38,0xF0,0x3E0,0x3F000
};
const unsigned char OC_SB_RUN_CODE_NBITS[7]={1,3,4,6,8,10,18};
/*Writes the bit pattern for the run length of a super block run to the given
oggpack_buffer.
_opb: The buffer to write to.
_run_count: The length of the run, which must be positive.
_flag: The current flag.
_done: Whether or not more flags are to be encoded.*/
static void oc_sb_run_pack(oggpack_buffer *_opb,ptrdiff_t _run_count,
int _flag,int _done){
int i;
if(_run_count>=4129){
do{
oggpackB_write(_opb,0x3FFFF,18);
_run_count-=4129;
if(_run_count>0)oggpackB_write(_opb,_flag,1);
else if(!_done)oggpackB_write(_opb,!_flag,1);
}
while(_run_count>=4129);
if(_run_count<=0)return;
}
for(i=0;_run_count>=OC_SB_RUN_VAL_MIN[i+1];i++);
oggpackB_write(_opb,OC_SB_RUN_CODE_PREFIX[i]+_run_count-OC_SB_RUN_VAL_MIN[i],
OC_SB_RUN_CODE_NBITS[i]);
}
/*Block run coding scheme:
Codeword Run Length
0x 1-2
10x 3-4
110x 5-6
1110xx 7-10
11110xx 11-14
11111xxxx 15-30*/
const unsigned char OC_BLOCK_RUN_CODE_NBITS[30]={
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
};
static const ogg_uint16_t OC_BLOCK_RUN_CODE_PATTERN[30]={
0x000,0x001,0x004,0x005,0x00C,0x00D,0x038,
0x039,0x03A,0x03B,0x078,0x079,0x07A,0x07B,0x1F0,
0x1F1,0x1F2,0x1F3,0x1F4,0x1F5,0x1F6,0x1F7,0x1F8,
0x1F9,0x1FA,0x1FB,0x1FC,0x1FD,0x1FE,0x1FF
};
/*Writes the bit pattern for the run length of a block run to the given
oggpack_buffer.
_opb: The buffer to write to.
_run_count: The length of the run.
This must be positive, and no more than 30.*/
static void oc_block_run_pack(oggpack_buffer *_opb,int _run_count){
oggpackB_write(_opb,OC_BLOCK_RUN_CODE_PATTERN[_run_count-1],
OC_BLOCK_RUN_CODE_NBITS[_run_count-1]);
}
static void oc_enc_frame_header_pack(oc_enc_ctx *_enc){
/*Mark this as a data packet.*/
oggpackB_write(&_enc->opb,0,1);
/*Output the frame type (key frame or delta frame).*/
oggpackB_write(&_enc->opb,_enc->state.frame_type,1);
/*Write out the current qi list.*/
oggpackB_write(&_enc->opb,_enc->state.qis[0],6);
if(_enc->state.nqis>1){
oggpackB_write(&_enc->opb,1,1);
oggpackB_write(&_enc->opb,_enc->state.qis[1],6);
if(_enc->state.nqis>2){
oggpackB_write(&_enc->opb,1,1);
oggpackB_write(&_enc->opb,_enc->state.qis[2],6);
}
else oggpackB_write(&_enc->opb,0,1);
}
else oggpackB_write(&_enc->opb,0,1);
if(_enc->state.frame_type==OC_INTRA_FRAME){
/*Key frames have 3 unused configuration bits, holdovers from the VP3 days.
Most of the other unused bits in the VP3 headers were eliminated.
Monty kept these to leave us some wiggle room for future expansion,
though a single bit in all frames would have been far more useful.*/
oggpackB_write(&_enc->opb,0,3);
}
}
/*Writes the bit flags for whether or not each super block is partially coded
or not.
These flags are run-length encoded, with the flag value alternating between
each run.
Return: The number partially coded SBs.*/
static unsigned oc_enc_partial_sb_flags_pack(oc_enc_ctx *_enc){
const oc_sb_flags *sb_flags;
unsigned nsbs;
unsigned sbi;
unsigned npartial;
int flag;
sb_flags=_enc->state.sb_flags;
nsbs=_enc->state.nsbs;
flag=sb_flags[0].coded_partially;
oggpackB_write(&_enc->opb,flag,1);
sbi=npartial=0;
do{
unsigned run_count;
for(run_count=0;sbi<nsbs;sbi++){
if(sb_flags[sbi].coded_partially!=flag)break;
run_count++;
npartial+=flag;
}
oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
flag=!flag;
}
while(sbi<nsbs);
return npartial;
}
/*Writes the coded/not coded flags for each super block that is not partially
coded.
These flags are run-length encoded, with the flag value altenating between
each run.*/
static void oc_enc_coded_sb_flags_pack(oc_enc_ctx *_enc){
const oc_sb_flags *sb_flags;
unsigned nsbs;
unsigned sbi;
int flag;
sb_flags=_enc->state.sb_flags;
nsbs=_enc->state.nsbs;
/*Skip partially coded super blocks; their flags have already been coded.*/
for(sbi=0;sb_flags[sbi].coded_partially;sbi++);
flag=sb_flags[sbi].coded_fully;
oggpackB_write(&_enc->opb,flag,1);
do{
unsigned run_count;
for(run_count=0;sbi<nsbs;sbi++){
if(sb_flags[sbi].coded_partially)continue;
if(sb_flags[sbi].coded_fully!=flag)break;
run_count++;
}
oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
flag=!flag;
}
while(sbi<nsbs);
}
static void oc_enc_coded_flags_pack(oc_enc_ctx *_enc){
const oc_sb_map *sb_maps;
const oc_sb_flags *sb_flags;
unsigned nsbs;
const oc_fragment *frags;
unsigned npartial;
int run_count;
int flag;
int pli;
unsigned sbi;
npartial=oc_enc_partial_sb_flags_pack(_enc);
if(npartial<_enc->state.nsbs)oc_enc_coded_sb_flags_pack(_enc);
sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
sb_flags=_enc->state.sb_flags;
nsbs=_enc->state.nsbs;
frags=_enc->state.frags;
for(sbi=0;sbi<nsbs&&!sb_flags[sbi].coded_partially;sbi++);
/*If there's at least one partial SB, store individual coded block flags.*/
if(sbi<nsbs){
flag=frags[sb_maps[sbi][0][0]].coded;
oggpackB_write(&_enc->opb,flag,1);
run_count=0;
nsbs=sbi=0;
for(pli=0;pli<3;pli++){
nsbs+=_enc->state.fplanes[pli].nsbs;
for(;sbi<nsbs;sbi++){
int quadi;
int bi;
ptrdiff_t fragi;
if(sb_flags[sbi].coded_partially){
for(quadi=0;quadi<4;quadi++){
for(bi=0;bi<4;bi++){
fragi=sb_maps[sbi][quadi][bi];
if(fragi>=0){
if(frags[fragi].coded!=flag){
oc_block_run_pack(&_enc->opb,run_count);
flag=!flag;
run_count=1;
}
else run_count++;
}
}
}
}
}
}
/*Flush any trailing block coded run.*/
if(run_count>0)oc_block_run_pack(&_enc->opb,run_count);
}
}
static void oc_enc_mb_modes_pack(oc_enc_ctx *_enc){
const unsigned char *mode_codes;
const unsigned char *mode_bits;
const unsigned char *mode_ranks;
unsigned *coded_mbis;
size_t ncoded_mbis;
const signed char *mb_modes;
unsigned mbii;
int scheme;
int mb_mode;
scheme=_enc->chooser.scheme_list[0];
/*Encode the best scheme.*/
oggpackB_write(&_enc->opb,scheme,3);
/*If the chosen scheme is scheme 0, send the mode frequency ordering.*/
if(scheme==0){
for(mb_mode=0;mb_mode<OC_NMODES;mb_mode++){
oggpackB_write(&_enc->opb,_enc->chooser.scheme0_ranks[mb_mode],3);
}
}
mode_ranks=_enc->chooser.mode_ranks[scheme];
mode_bits=OC_MODE_BITS[scheme+1>>3];
mode_codes=OC_MODE_CODES[scheme+1>>3];
coded_mbis=_enc->coded_mbis;
ncoded_mbis=_enc->ncoded_mbis;
mb_modes=_enc->state.mb_modes;
for(mbii=0;mbii<ncoded_mbis;mbii++){
int rank;
rank=mode_ranks[mb_modes[coded_mbis[mbii]]];
oggpackB_write(&_enc->opb,mode_codes[rank],mode_bits[rank]);
}
}
static void oc_enc_mv_pack(oc_enc_ctx *_enc,int _mv_scheme,int _dx,int _dy){
oggpackB_write(&_enc->opb,
OC_MV_CODES[_mv_scheme][_dx+31],OC_MV_BITS[_mv_scheme][_dx+31]);
oggpackB_write(&_enc->opb,
OC_MV_CODES[_mv_scheme][_dy+31],OC_MV_BITS[_mv_scheme][_dy+31]);
}
static void oc_enc_mvs_pack(oc_enc_ctx *_enc){
const unsigned *coded_mbis;
size_t ncoded_mbis;
const oc_mb_map *mb_maps;
const signed char *mb_modes;
const oc_fragment *frags;
const oc_mv *frag_mvs;
unsigned mbii;
int mv_scheme;
/*Choose the coding scheme.*/
mv_scheme=_enc->mv_bits[1]<_enc->mv_bits[0];
oggpackB_write(&_enc->opb,mv_scheme,1);
/*Encode the motion vectors.
Macro blocks are iterated in Hilbert scan order, but the MVs within the
macro block are coded in raster order.*/
coded_mbis=_enc->coded_mbis;
ncoded_mbis=_enc->ncoded_mbis;
mb_modes=_enc->state.mb_modes;
mb_maps=(const oc_mb_map *)_enc->state.mb_maps;
frags=_enc->state.frags;
frag_mvs=(const oc_mv *)_enc->state.frag_mvs;
for(mbii=0;mbii<ncoded_mbis;mbii++){
ptrdiff_t fragi;
unsigned mbi;
int bi;
mbi=coded_mbis[mbii];
switch(mb_modes[mbi]){
case OC_MODE_INTER_MV:
case OC_MODE_GOLDEN_MV:{
for(bi=0;;bi++){
fragi=mb_maps[mbi][0][bi];
if(frags[fragi].coded){
oc_enc_mv_pack(_enc,mv_scheme,
frag_mvs[fragi][0],frag_mvs[fragi][1]);
/*Only code a single MV for this macro block.*/
break;
}
}
}break;
case OC_MODE_INTER_MV_FOUR:{
for(bi=0;bi<4;bi++){
fragi=mb_maps[mbi][0][bi];
if(frags[fragi].coded){
oc_enc_mv_pack(_enc,mv_scheme,
frag_mvs[fragi][0],frag_mvs[fragi][1]);
/*Keep coding all the MVs for this macro block.*/
}
}
}break;
}
}
}
static void oc_enc_block_qis_pack(oc_enc_ctx *_enc){
const oc_fragment *frags;
ptrdiff_t *coded_fragis;
ptrdiff_t ncoded_fragis;
ptrdiff_t fragii;
ptrdiff_t run_count;
ptrdiff_t nqi0;
int flag;
if(_enc->state.nqis<=1)return;
ncoded_fragis=_enc->state.ntotal_coded_fragis;
if(ncoded_fragis<=0)return;
coded_fragis=_enc->state.coded_fragis;
frags=_enc->state.frags;
flag=!!frags[coded_fragis[0]].qii;
oggpackB_write(&_enc->opb,flag,1);
nqi0=0;
for(fragii=0;fragii<ncoded_fragis;){
for(run_count=0;fragii<ncoded_fragis;fragii++){
if(!!frags[coded_fragis[fragii]].qii!=flag)break;
run_count++;
nqi0+=!flag;
}
oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
flag=!flag;
}
if(_enc->state.nqis<3||nqi0>=ncoded_fragis)return;
for(fragii=0;!frags[coded_fragis[fragii]].qii;fragii++);
flag=frags[coded_fragis[fragii]].qii-1;
oggpackB_write(&_enc->opb,flag,1);
while(fragii<ncoded_fragis){
for(run_count=0;fragii<ncoded_fragis;fragii++){
int qii;
qii=frags[coded_fragis[fragii]].qii;
if(!qii)continue;
if(qii-1!=flag)break;
run_count++;
}
oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
flag=!flag;
}
}
/*Counts the tokens of each type used for the given range of coefficient
indices in zig-zag order.
_zzi_start: The first zig-zag index to include.
_zzi_end: The first zig-zag index to not include.
_token_counts_y: Returns the token counts for the Y' plane.
_token_counts_c: Returns the token counts for the Cb and Cr planes.*/
static void oc_enc_count_tokens(oc_enc_ctx *_enc,int _zzi_start,int _zzi_end,
ptrdiff_t _token_counts_y[32],ptrdiff_t _token_counts_c[32]){
const unsigned char *dct_tokens;
ptrdiff_t ndct_tokens;
int pli;
int zzi;
ptrdiff_t ti;
memset(_token_counts_y,0,32*sizeof(*_token_counts_y));
memset(_token_counts_c,0,32*sizeof(*_token_counts_c));
for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
dct_tokens=_enc->dct_tokens[0][zzi];
ndct_tokens=_enc->ndct_tokens[0][zzi];
for(ti=_enc->dct_token_offs[0][zzi];ti<ndct_tokens;ti++){
_token_counts_y[dct_tokens[ti]]++;
}
}
for(pli=1;pli<3;pli++){
for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
dct_tokens=_enc->dct_tokens[pli][zzi];
ndct_tokens=_enc->ndct_tokens[pli][zzi];
for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
_token_counts_c[dct_tokens[ti]]++;
}
}
}
}
/*Computes the number of bits used for each of the potential Huffman code for
the given list of token counts.
The bits are added to whatever the current bit counts are.*/
static void oc_enc_count_bits(oc_enc_ctx *_enc,int _hgi,
const ptrdiff_t _token_counts[32],size_t _bit_counts[16]){
int huffi;
int huff_offs;
int token;
huff_offs=_hgi<<4;
for(huffi=0;huffi<16;huffi++){
for(token=0;token<32;token++){
_bit_counts[huffi]+=
_token_counts[token]*_enc->huff_codes[huffi+huff_offs][token].nbits;
}
}
}
/*Returns the Huffman index using the fewest number of bits.*/
static int oc_select_huff_idx(size_t _bit_counts[16]){
int best_huffi;
int huffi;
best_huffi=0;
for(huffi=1;huffi<16;huffi++)if(_bit_counts[huffi]<_bit_counts[best_huffi]){
best_huffi=huffi;
}
return best_huffi;
}
static void oc_enc_huff_group_pack(oc_enc_ctx *_enc,
int _zzi_start,int _zzi_end,const int _huff_idxs[2]){
int zzi;
for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
int pli;
for(pli=0;pli<3;pli++){
const unsigned char *dct_tokens;
const ogg_uint16_t *extra_bits;
ptrdiff_t ndct_tokens;
const th_huff_code *huff_codes;
ptrdiff_t ti;
dct_tokens=_enc->dct_tokens[pli][zzi];
extra_bits=_enc->extra_bits[pli][zzi];
ndct_tokens=_enc->ndct_tokens[pli][zzi];
huff_codes=_enc->huff_codes[_huff_idxs[pli+1>>1]];
for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
int token;
int neb;
token=dct_tokens[ti];
oggpackB_write(&_enc->opb,huff_codes[token].pattern,
huff_codes[token].nbits);
neb=OC_DCT_TOKEN_EXTRA_BITS[token];
if(neb)oggpackB_write(&_enc->opb,extra_bits[ti],neb);
}
}
}
}
static void oc_enc_residual_tokens_pack(oc_enc_ctx *_enc){
static const unsigned char OC_HUFF_GROUP_MIN[6]={0,1,6,15,28,64};
static const unsigned char *OC_HUFF_GROUP_MAX=OC_HUFF_GROUP_MIN+1;
ptrdiff_t token_counts_y[32];
ptrdiff_t token_counts_c[32];
size_t bits_y[16];
size_t bits_c[16];
int huff_idxs[2];
int frame_type;
int hgi;
frame_type=_enc->state.frame_type;
/*Choose which Huffman tables to use for the DC token list.*/
oc_enc_count_tokens(_enc,0,1,token_counts_y,token_counts_c);
memset(bits_y,0,sizeof(bits_y));
memset(bits_c,0,sizeof(bits_c));
oc_enc_count_bits(_enc,0,token_counts_y,bits_y);
oc_enc_count_bits(_enc,0,token_counts_c,bits_c);
huff_idxs[0]=oc_select_huff_idx(bits_y);
huff_idxs[1]=oc_select_huff_idx(bits_c);
/*Write the DC token list with the chosen tables.*/
oggpackB_write(&_enc->opb,huff_idxs[0],4);
oggpackB_write(&_enc->opb,huff_idxs[1],4);
_enc->huff_idxs[frame_type][0][0]=(unsigned char)huff_idxs[0];
_enc->huff_idxs[frame_type][0][1]=(unsigned char)huff_idxs[1];
oc_enc_huff_group_pack(_enc,0,1,huff_idxs);
/*Choose which Huffman tables to use for the AC token lists.*/
memset(bits_y,0,sizeof(bits_y));
memset(bits_c,0,sizeof(bits_c));
for(hgi=1;hgi<5;hgi++){
oc_enc_count_tokens(_enc,OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],
token_counts_y,token_counts_c);
oc_enc_count_bits(_enc,hgi,token_counts_y,bits_y);
oc_enc_count_bits(_enc,hgi,token_counts_c,bits_c);
}
huff_idxs[0]=oc_select_huff_idx(bits_y);
huff_idxs[1]=oc_select_huff_idx(bits_c);
/*Write the AC token lists using the chosen tables.*/
oggpackB_write(&_enc->opb,huff_idxs[0],4);
oggpackB_write(&_enc->opb,huff_idxs[1],4);
_enc->huff_idxs[frame_type][1][0]=(unsigned char)huff_idxs[0];
_enc->huff_idxs[frame_type][1][1]=(unsigned char)huff_idxs[1];
for(hgi=1;hgi<5;hgi++){
huff_idxs[0]+=16;
huff_idxs[1]+=16;
oc_enc_huff_group_pack(_enc,
OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],huff_idxs);
}
}
static void oc_enc_frame_pack(oc_enc_ctx *_enc){
oggpackB_reset(&_enc->opb);
/*Only proceed if we have some coded blocks.
If there are no coded blocks, we can drop this frame simply by emitting a
0 byte packet.*/
if(_enc->state.ntotal_coded_fragis>0){
oc_enc_frame_header_pack(_enc);
if(_enc->state.frame_type==OC_INTER_FRAME){
/*Coded block flags, MB modes, and MVs are only needed for delta frames.*/
oc_enc_coded_flags_pack(_enc);
oc_enc_mb_modes_pack(_enc);
oc_enc_mvs_pack(_enc);
}
oc_enc_block_qis_pack(_enc);
oc_enc_tokenize_finish(_enc);
oc_enc_residual_tokens_pack(_enc);
}
/*Success: Mark the packet as ready to be flushed.*/
_enc->packet_state=OC_PACKET_READY;
#if defined(OC_COLLECT_METRICS)
oc_enc_mode_metrics_collect(_enc);
#endif
}
void oc_enc_vtable_init_c(oc_enc_ctx *_enc){
/*The implementations prefixed with oc_enc_ are encoder-specific.
The rest we re-use from the decoder.*/
_enc->opt_vtable.frag_sad=oc_enc_frag_sad_c;
_enc->opt_vtable.frag_sad_thresh=oc_enc_frag_sad_thresh_c;
_enc->opt_vtable.frag_sad2_thresh=oc_enc_frag_sad2_thresh_c;
_enc->opt_vtable.frag_satd_thresh=oc_enc_frag_satd_thresh_c;
_enc->opt_vtable.frag_satd2_thresh=oc_enc_frag_satd2_thresh_c;
_enc->opt_vtable.frag_intra_satd=oc_enc_frag_intra_satd_c;
_enc->opt_vtable.frag_sub=oc_enc_frag_sub_c;
_enc->opt_vtable.frag_sub_128=oc_enc_frag_sub_128_c;
_enc->opt_vtable.frag_copy2=oc_enc_frag_copy2_c;
_enc->opt_vtable.frag_recon_intra=oc_frag_recon_intra_c;
_enc->opt_vtable.frag_recon_inter=oc_frag_recon_inter_c;
_enc->opt_vtable.fdct8x8=oc_enc_fdct8x8_c;
}
/*Initialize the macro block neighbor lists for MC analysis.
This assumes that the entire mb_info memory region has been initialized with
zeros.*/
static void oc_enc_mb_info_init(oc_enc_ctx *_enc){
oc_mb_enc_info *embs;
const signed char *mb_modes;
unsigned nhsbs;
unsigned nvsbs;
unsigned nhmbs;
unsigned nvmbs;
unsigned sby;
mb_modes=_enc->state.mb_modes;
embs=_enc->mb_info;
nhsbs=_enc->state.fplanes[0].nhsbs;
nvsbs=_enc->state.fplanes[0].nvsbs;
nhmbs=_enc->state.nhmbs;
nvmbs=_enc->state.nvmbs;
for(sby=0;sby<nvsbs;sby++){
unsigned sbx;
for(sbx=0;sbx<nhsbs;sbx++){
int quadi;
for(quadi=0;quadi<4;quadi++){
/*Because of the Hilbert curve ordering the macro blocks are
visited in, the available neighbors change depending on where in
a super block the macro block is located.
Only the first three vectors are used in the median calculation
for the optimal predictor, and so the most important should be
listed first.
Additional vectors are used, so there will always be at least 3,
except for in the upper-left most macro block.*/
/*The number of current neighbors for each macro block position.*/
static const unsigned char NCNEIGHBORS[4]={4,3,2,4};
/*The offset of each current neighbor in the X direction.*/
static const signed char CDX[4][4]={
{-1,0,1,-1},
{-1,0,-1,},
{-1,-1},
{-1,0,0,1}
};
/*The offset of each current neighbor in the Y direction.*/
static const signed char CDY[4][4]={
{0,-1,-1,-1},
{0,-1,-1},
{0,-1},
{0,-1,1,-1}
};
/*The offset of each previous neighbor in the X direction.*/
static const signed char PDX[4]={-1,0,1,0};
/*The offset of each previous neighbor in the Y direction.*/
static const signed char PDY[4]={0,-1,0,1};
unsigned mbi;
int mbx;
int mby;
unsigned nmbi;
int nmbx;
int nmby;
int ni;
mbi=(sby*nhsbs+sbx<<2)+quadi;
if(mb_modes[mbi]==OC_MODE_INVALID)continue;
mbx=2*sbx+(quadi>>1);
mby=2*sby+(quadi+1>>1&1);
/*Fill in the neighbors with current motion vectors available.*/
for(ni=0;ni<NCNEIGHBORS[quadi];ni++){
nmbx=mbx+CDX[quadi][ni];
nmby=mby+CDY[quadi][ni];
if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
embs[mbi].cneighbors[embs[mbi].ncneighbors++]=nmbi;
}
/*Fill in the neighbors with previous motion vectors available.*/
for(ni=0;ni<4;ni++){
nmbx=mbx+PDX[ni];
nmby=mby+PDY[ni];
if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
embs[mbi].pneighbors[embs[mbi].npneighbors++]=nmbi;
}
}
}
}
}
static int oc_enc_set_huffman_codes(oc_enc_ctx *_enc,
const th_huff_code _codes[TH_NHUFFMAN_TABLES][TH_NDCT_TOKENS]){
int ret;
if(_enc==NULL)return TH_EFAULT;
if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
if(_codes==NULL)_codes=TH_VP31_HUFF_CODES;
/*Validate the codes.*/
oggpackB_reset(&_enc->opb);
ret=oc_huff_codes_pack(&_enc->opb,_codes);
if(ret<0)return ret;
memcpy(_enc->huff_codes,_codes,sizeof(_enc->huff_codes));
return 0;
}
/*Sets the quantization parameters to use.
This may only be called before the setup header is written.
If it is called multiple times, only the last call has any effect.
_qinfo: The quantization parameters.
These are described in more detail in theoraenc.h.
This can be NULL, in which case the default quantization parameters
will be used.*/
static int oc_enc_set_quant_params(oc_enc_ctx *_enc,
const th_quant_info *_qinfo){
int qi;
int pli;
int qti;
if(_enc==NULL)return TH_EFAULT;
if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
if(_qinfo==NULL)_qinfo=&TH_DEF_QUANT_INFO;
/*TODO: Analyze for packing purposes instead of just doing a shallow copy.*/
memcpy(&_enc->qinfo,_qinfo,sizeof(_enc->qinfo));
for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
_enc->state.dequant_tables[qi][pli][qti]=
_enc->state.dequant_table_data[qi][pli][qti];
_enc->enquant_tables[qi][pli][qti]=_enc->enquant_table_data[qi][pli][qti];
}
oc_enquant_tables_init(_enc->state.dequant_tables,
_enc->enquant_tables,_qinfo);
memcpy(_enc->state.loop_filter_limits,_qinfo->loop_filter_limits,
sizeof(_enc->state.loop_filter_limits));
oc_enquant_qavg_init(_enc->log_qavg,_enc->state.dequant_tables,
_enc->state.info.pixel_fmt);
return 0;
}
static void oc_enc_clear(oc_enc_ctx *_enc);
static int oc_enc_init(oc_enc_ctx *_enc,const th_info *_info){
th_info info;
size_t mcu_nmbs;
ptrdiff_t mcu_nfrags;
int hdec;
int vdec;
int ret;
int pli;
/*Clean up the requested settings.*/
memcpy(&info,_info,sizeof(info));
info.version_major=TH_VERSION_MAJOR;
info.version_minor=TH_VERSION_MINOR;
info.version_subminor=TH_VERSION_SUB;
if(info.quality>63)info.quality=63;
if(info.quality<0)info.quality=32;
if(info.target_bitrate<0)info.target_bitrate=0;
/*Initialize the shared encoder/decoder state.*/
ret=oc_state_init(&_enc->state,&info,4);
if(ret<0)return ret;
_enc->mb_info=_ogg_calloc(_enc->state.nmbs,sizeof(*_enc->mb_info));
_enc->frag_dc=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_dc));
_enc->coded_mbis=
(unsigned *)_ogg_malloc(_enc->state.nmbs*sizeof(*_enc->coded_mbis));
hdec=!(_enc->state.info.pixel_fmt&1);
vdec=!(_enc->state.info.pixel_fmt&2);
/*If chroma is sub-sampled in the vertical direction, we have to encode two
super block rows of Y' for each super block row of Cb and Cr.*/
_enc->mcu_nvsbs=1<<vdec;
mcu_nmbs=_enc->mcu_nvsbs*_enc->state.fplanes[0].nhsbs*(size_t)4;
mcu_nfrags=4*mcu_nmbs+(8*mcu_nmbs>>hdec+vdec);
_enc->mcu_skip_ssd=(unsigned *)_ogg_malloc(
mcu_nfrags*sizeof(*_enc->mcu_skip_ssd));
for(pli=0;pli<3;pli++){
_enc->dct_tokens[pli]=(unsigned char **)oc_malloc_2d(64,
_enc->state.fplanes[pli].nfrags,sizeof(**_enc->dct_tokens));
_enc->extra_bits[pli]=(ogg_uint16_t **)oc_malloc_2d(64,
_enc->state.fplanes[pli].nfrags,sizeof(**_enc->extra_bits));
}
#if defined(OC_COLLECT_METRICS)
_enc->frag_satd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_satd));
_enc->frag_ssd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_ssd));
#endif
#if defined(OC_X86_ASM)
oc_enc_vtable_init_x86(_enc);
#else
oc_enc_vtable_init_c(_enc);
#endif
_enc->keyframe_frequency_force=1<<_enc->state.info.keyframe_granule_shift;
_enc->state.qis[0]=_enc->state.info.quality;
_enc->state.nqis=1;
oc_rc_state_init(&_enc->rc,_enc);
oggpackB_writeinit(&_enc->opb);
if(_enc->mb_info==NULL||_enc->frag_dc==NULL||_enc->coded_mbis==NULL||
_enc->mcu_skip_ssd==NULL||_enc->dct_tokens[0]==NULL||
_enc->dct_tokens[1]==NULL||_enc->dct_tokens[2]==NULL||
_enc->extra_bits[0]==NULL||_enc->extra_bits[1]==NULL||
_enc->extra_bits[2]==NULL
#if defined(OC_COLLECT_METRICS)
||_enc->frag_satd==NULL||_enc->frag_ssd==NULL
#endif
){
oc_enc_clear(_enc);
return TH_EFAULT;
}
oc_mode_scheme_chooser_init(&_enc->chooser);
oc_enc_mb_info_init(_enc);
memset(_enc->huff_idxs,0,sizeof(_enc->huff_idxs));
/*Reset the packet-out state machine.*/
_enc->packet_state=OC_PACKET_INFO_HDR;
_enc->dup_count=0;
_enc->nqueued_dups=0;
_enc->prev_dup_count=0;
/*Enable speed optimizations up through early skip by default.*/
_enc->sp_level=OC_SP_LEVEL_EARLY_SKIP;
/*Disable VP3 compatibility by default.*/
_enc->vp3_compatible=0;
/*No INTER frames coded yet.*/
_enc->coded_inter_frame=0;
memcpy(_enc->huff_codes,TH_VP31_HUFF_CODES,sizeof(_enc->huff_codes));
oc_enc_set_quant_params(_enc,NULL);
return 0;
}
static void oc_enc_clear(oc_enc_ctx *_enc){
int pli;
oc_rc_state_clear(&_enc->rc);
#if defined(OC_COLLECT_METRICS)
oc_enc_mode_metrics_dump(_enc);
#endif
oggpackB_writeclear(&_enc->opb);
#if defined(OC_COLLECT_METRICS)
_ogg_free(_enc->frag_ssd);
_ogg_free(_enc->frag_satd);
#endif
for(pli=3;pli-->0;){
oc_free_2d(_enc->extra_bits[pli]);
oc_free_2d(_enc->dct_tokens[pli]);
}
_ogg_free(_enc->mcu_skip_ssd);
_ogg_free(_enc->coded_mbis);
_ogg_free(_enc->frag_dc);
_ogg_free(_enc->mb_info);
oc_state_clear(&_enc->state);
}
static void oc_enc_drop_frame(th_enc_ctx *_enc){
/*Use the previous frame's reconstruction.*/
_enc->state.ref_frame_idx[OC_FRAME_SELF]=
_enc->state.ref_frame_idx[OC_FRAME_PREV];
/*Flag motion vector analysis about the frame drop.*/
_enc->prevframe_dropped=1;
/*Zero the packet.*/
oggpackB_reset(&_enc->opb);
}
static void oc_enc_compress_keyframe(oc_enc_ctx *_enc,int _recode){
if(_enc->state.info.target_bitrate>0){
_enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTRA_FRAME,
_enc->state.curframe_num>0);
_enc->state.nqis=1;
}
oc_enc_calc_lambda(_enc,OC_INTRA_FRAME);
oc_enc_analyze_intra(_enc,_recode);
oc_enc_frame_pack(_enc);
/*On the first frame, the previous call was an initial dry-run to prime
feed-forward statistics.*/
if(!_recode&&_enc->state.curframe_num==0){
if(_enc->state.info.target_bitrate>0){
oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
OC_INTRA_FRAME,_enc->state.qis[0],1,0);
}
oc_enc_compress_keyframe(_enc,1);
}
}
static void oc_enc_compress_frame(oc_enc_ctx *_enc,int _recode){
if(_enc->state.info.target_bitrate>0){
_enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTER_FRAME,1);
_enc->state.nqis=1;
}
oc_enc_calc_lambda(_enc,OC_INTER_FRAME);
if(oc_enc_analyze_inter(_enc,_enc->rc.twopass!=2,_recode)){
/*Mode analysis thinks this should have been a keyframe; start over.*/
oc_enc_compress_keyframe(_enc,1);
}
else{
oc_enc_frame_pack(_enc);
if(!_enc->coded_inter_frame){
/*On the first INTER frame, the previous call was an initial dry-run to
prime feed-forward statistics.*/
_enc->coded_inter_frame=1;
if(_enc->state.info.target_bitrate>0){
/*Rate control also needs to prime.*/
oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
OC_INTER_FRAME,_enc->state.qis[0],1,0);
}
oc_enc_compress_frame(_enc,1);
}
}
}
/*Set the granule position for the next packet to output based on the current
internal state.*/
static void oc_enc_set_granpos(oc_enc_ctx *_enc){
unsigned dup_offs;
/*Add an offset for the number of duplicate frames we've emitted so far.*/
dup_offs=_enc->prev_dup_count-_enc->nqueued_dups;
/*If the current frame was a keyframe, use it for the high part.*/
if(_enc->state.frame_type==OC_INTRA_FRAME){
_enc->state.granpos=(_enc->state.curframe_num+_enc->state.granpos_bias<<
_enc->state.info.keyframe_granule_shift)+dup_offs;
}
/*Otherwise use the last keyframe in the high part and put the current frame
in the low part.*/
else{
_enc->state.granpos=
(_enc->state.keyframe_num+_enc->state.granpos_bias<<
_enc->state.info.keyframe_granule_shift)
+_enc->state.curframe_num-_enc->state.keyframe_num+dup_offs;
}
}
th_enc_ctx *th_encode_alloc(const th_info *_info){
oc_enc_ctx *enc;
if(_info==NULL)return NULL;
enc=_ogg_malloc(sizeof(*enc));
if(enc==NULL||oc_enc_init(enc,_info)<0){
_ogg_free(enc);
return NULL;
}
return enc;
}
void th_encode_free(th_enc_ctx *_enc){
if(_enc!=NULL){
oc_enc_clear(_enc);
_ogg_free(_enc);
}
}
int th_encode_ctl(th_enc_ctx *_enc,int _req,void *_buf,size_t _buf_sz){
switch(_req){
case TH_ENCCTL_SET_HUFFMAN_CODES:{
if(_buf==NULL&&_buf_sz!=0||
_buf!=NULL&&_buf_sz!=sizeof(th_huff_table)*TH_NHUFFMAN_TABLES){
return TH_EINVAL;
}
return oc_enc_set_huffman_codes(_enc,(const th_huff_table *)_buf);
}break;
case TH_ENCCTL_SET_QUANT_PARAMS:{
if(_buf==NULL&&_buf_sz!=0||
_buf!=NULL&&_buf_sz!=sizeof(th_quant_info)){
return TH_EINVAL;
}
return oc_enc_set_quant_params(_enc,(th_quant_info *)_buf);
}break;
case TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE:{
ogg_uint32_t keyframe_frequency_force;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(keyframe_frequency_force))return TH_EINVAL;
keyframe_frequency_force=*(ogg_uint32_t *)_buf;
if(keyframe_frequency_force<=0)keyframe_frequency_force=1;
if(_enc->packet_state==OC_PACKET_INFO_HDR){
/*It's still early enough to enlarge keyframe_granule_shift.*/
_enc->state.info.keyframe_granule_shift=OC_CLAMPI(
_enc->state.info.keyframe_granule_shift,
OC_ILOG_32(keyframe_frequency_force-1),31);
}
_enc->keyframe_frequency_force=OC_MINI(keyframe_frequency_force,
(ogg_uint32_t)1U<<_enc->state.info.keyframe_granule_shift);
*(ogg_uint32_t *)_buf=_enc->keyframe_frequency_force;
return 0;
}break;
case TH_ENCCTL_SET_VP3_COMPATIBLE:{
int vp3_compatible;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(vp3_compatible))return TH_EINVAL;
vp3_compatible=*(int *)_buf;
_enc->vp3_compatible=vp3_compatible;
if(oc_enc_set_huffman_codes(_enc,TH_VP31_HUFF_CODES)<0)vp3_compatible=0;
if(oc_enc_set_quant_params(_enc,&TH_VP31_QUANT_INFO)<0)vp3_compatible=0;
if(_enc->state.info.pixel_fmt!=TH_PF_420||
_enc->state.info.pic_width<_enc->state.info.frame_width||
_enc->state.info.pic_height<_enc->state.info.frame_height||
/*If we have more than 4095 super blocks, VP3's RLE coding might
overflow.
We could overcome this by ensuring we flip the coded/not-coded flags on
at least one super block in the frame, but we pick the simple solution
of just telling the user the stream will be incompatible instead.
It's unlikely the old VP3 codec would be able to decode streams at this
resolution in real time in the first place.*/
_enc->state.nsbs>4095){
vp3_compatible=0;
}
*(int *)_buf=vp3_compatible;
return 0;
}break;
case TH_ENCCTL_GET_SPLEVEL_MAX:{
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(int))return TH_EINVAL;
*(int *)_buf=OC_SP_LEVEL_MAX;
return 0;
}break;
case TH_ENCCTL_SET_SPLEVEL:{
int speed;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(speed))return TH_EINVAL;
speed=*(int *)_buf;
if(speed<0||speed>OC_SP_LEVEL_MAX)return TH_EINVAL;
_enc->sp_level=speed;
return 0;
}break;
case TH_ENCCTL_GET_SPLEVEL:{
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(int))return TH_EINVAL;
*(int *)_buf=_enc->sp_level;
return 0;
}
case TH_ENCCTL_SET_DUP_COUNT:{
int dup_count;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(dup_count))return TH_EINVAL;
dup_count=*(int *)_buf;
if(dup_count>=_enc->keyframe_frequency_force)return TH_EINVAL;
_enc->dup_count=OC_MAXI(dup_count,0);
return 0;
}break;
case TH_ENCCTL_SET_QUALITY:{
int qi;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_enc->state.info.target_bitrate>0)return TH_EINVAL;
qi=*(int *)_buf;
if(qi<0||qi>63)return TH_EINVAL;
_enc->state.info.quality=qi;
_enc->state.qis[0]=(unsigned char)qi;
_enc->state.nqis=1;
return 0;
}break;
case TH_ENCCTL_SET_BITRATE:{
long bitrate;
int reset;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
bitrate=*(long *)_buf;
if(bitrate<=0)return TH_EINVAL;
reset=_enc->state.info.target_bitrate<=0;
_enc->state.info.target_bitrate=bitrate>INT_MAX?INT_MAX:bitrate;
if(reset)oc_rc_state_init(&_enc->rc,_enc);
else oc_enc_rc_resize(_enc);
return 0;
}break;
case TH_ENCCTL_SET_RATE_FLAGS:{
int set;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(set))return TH_EINVAL;
if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
set=*(int *)_buf;
_enc->rc.drop_frames=set&TH_RATECTL_DROP_FRAMES;
_enc->rc.cap_overflow=set&TH_RATECTL_CAP_OVERFLOW;
_enc->rc.cap_underflow=set&TH_RATECTL_CAP_UNDERFLOW;
return 0;
}break;
case TH_ENCCTL_SET_RATE_BUFFER:{
int set;
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_buf_sz!=sizeof(set))return TH_EINVAL;
if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
set=*(int *)_buf;
_enc->rc.buf_delay=set;
oc_enc_rc_resize(_enc);
*(int *)_buf=_enc->rc.buf_delay;
return 0;
}break;
case TH_ENCCTL_2PASS_OUT:{
if(_enc==NULL||_buf==NULL)return TH_EFAULT;
if(_enc->state.info.target_bitrate<=0||
_enc->state.curframe_num>=0&&_enc->rc.twopass!=1||
_buf_sz!=sizeof(unsigned char *)){
return TH_EINVAL;
}
return oc_enc_rc_2pass_out(_enc,(unsigned char **)_buf);
}break;
case TH_ENCCTL_2PASS_IN:{
if(_enc==NULL)return TH_EFAULT;
if(_enc->state.info.target_bitrate<=0||
_enc->state.curframe_num>=0&&_enc->rc.twopass!=2){
return TH_EINVAL;
}
return oc_enc_rc_2pass_in(_enc,_buf,_buf_sz);
}break;
default:return TH_EIMPL;
}
}
int th_encode_flushheader(th_enc_ctx *_enc,th_comment *_tc,ogg_packet *_op){
if(_enc==NULL)return TH_EFAULT;
return oc_state_flushheader(&_enc->state,&_enc->packet_state,&_enc->opb,
&_enc->qinfo,(const th_huff_table *)_enc->huff_codes,th_version_string(),
_tc,_op);
}
static void oc_img_plane_copy_pad(th_img_plane *_dst,th_img_plane *_src,
ogg_int32_t _pic_x,ogg_int32_t _pic_y,
ogg_int32_t _pic_width,ogg_int32_t _pic_height){
unsigned char *dst;
int dstride;
ogg_uint32_t frame_width;
ogg_uint32_t frame_height;
ogg_uint32_t y;
frame_width=_dst->width;
frame_height=_dst->height;
/*If we have _no_ data, just encode a dull green.*/
if(_pic_width==0||_pic_height==0){
dst=_dst->data;
dstride=_dst->stride;
for(y=0;y<frame_height;y++){
memset(dst,0,frame_width*sizeof(*dst));
dst+=dstride;
}
}
/*Otherwise, copy what we do have, and add our own padding.*/
else{
unsigned char *dst_data;
unsigned char *src_data;
unsigned char *src;
int sstride;
ogg_uint32_t x;
/*Step 1: Copy the data we do have.*/
dstride=_dst->stride;
sstride=_src->stride;
dst_data=_dst->data;
src_data=_src->data;
dst=dst_data+_pic_y*(ptrdiff_t)dstride+_pic_x;
src=src_data+_pic_y*(ptrdiff_t)sstride+_pic_x;
for(y=0;y<_pic_height;y++){
memcpy(dst,src,_pic_width);
dst+=dstride;
src+=sstride;
}
/*Step 2: Perform a low-pass extension into the padding region.*/
/*Left side.*/
for(x=_pic_x;x-->0;){
dst=dst_data+_pic_y*(ptrdiff_t)dstride+x;
for(y=0;y<_pic_height;y++){
dst[0]=(dst[1]<<1)+(dst-(dstride&-(y>0)))[1]
+(dst+(dstride&-(y+1<_pic_height)))[1]+2>>2;
dst+=dstride;
}
}
/*Right side.*/
for(x=_pic_x+_pic_width;x<frame_width;x++){
dst=dst_data+_pic_y*(ptrdiff_t)dstride+x-1;
for(y=0;y<_pic_height;y++){
dst[1]=(dst[0]<<1)+(dst-(dstride&-(y>0)))[0]
+(dst+(dstride&-(y+1<_pic_height)))[0]+2>>2;
dst+=dstride;
}
}
/*Top.*/
dst=dst_data+_pic_y*(ptrdiff_t)dstride;
for(y=_pic_y;y-->0;){
for(x=0;x<frame_width;x++){
(dst-dstride)[x]=(dst[x]<<1)+dst[x-(x>0)]
+dst[x+(x+1<frame_width)]+2>>2;
}
dst-=dstride;
}
/*Bottom.*/
dst=dst_data+(_pic_y+_pic_height)*(ptrdiff_t)dstride;
for(y=_pic_y+_pic_height;y<frame_height;y++){
for(x=0;x<frame_width;x++){
dst[x]=((dst-dstride)[x]<<1)+(dst-dstride)[x-(x>0)]
+(dst-dstride)[x+(x+1<frame_width)]+2>>2;
}
dst+=dstride;
}
}
}
int th_encode_ycbcr_in(th_enc_ctx *_enc,th_ycbcr_buffer _img){
th_ycbcr_buffer img;
int cframe_width;
int cframe_height;
int cpic_width;
int cpic_height;
int cpic_x;
int cpic_y;
int hdec;
int vdec;
int pli;
int refi;
int drop;
/*Step 1: validate parameters.*/
if(_enc==NULL||_img==NULL)return TH_EFAULT;
if(_enc->packet_state==OC_PACKET_DONE)return TH_EINVAL;
if(_enc->rc.twopass&&_enc->rc.twopass_buffer_bytes==0)return TH_EINVAL;
if((ogg_uint32_t)_img[0].width!=_enc->state.info.frame_width||
(ogg_uint32_t)_img[0].height!=_enc->state.info.frame_height){
return TH_EINVAL;
}
hdec=!(_enc->state.info.pixel_fmt&1);
vdec=!(_enc->state.info.pixel_fmt&2);
cframe_width=_enc->state.info.frame_width>>hdec;
cframe_height=_enc->state.info.frame_height>>vdec;
if(_img[1].width!=cframe_width||_img[2].width!=cframe_width||
_img[1].height!=cframe_height||_img[2].height!=cframe_height){
return TH_EINVAL;
}
/*Step 2: Copy the input to our internal buffer.
This lets us add padding, if necessary, so we don't have to worry about
dereferencing possibly invalid addresses, and allows us to use the same
strides and fragment offsets for both the input frame and the reference
frames.*/
/*Flip the input buffer upside down.*/
oc_ycbcr_buffer_flip(img,_img);
oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[OC_FRAME_IO]+0,img+0,
_enc->state.info.pic_x,_enc->state.info.pic_y,
_enc->state.info.pic_width,_enc->state.info.pic_height);
cpic_x=_enc->state.info.pic_x>>hdec;
cpic_y=_enc->state.info.pic_y>>vdec;
cpic_width=(_enc->state.info.pic_x+_enc->state.info.pic_width+hdec>>hdec)
-cpic_x;
cpic_height=(_enc->state.info.pic_y+_enc->state.info.pic_height+vdec>>vdec)
-cpic_y;
for(pli=1;pli<3;pli++){
oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[OC_FRAME_IO]+pli,img+pli,
cpic_x,cpic_y,cpic_width,cpic_height);
}
/*Step 3: Update the buffer state.*/
if(_enc->state.ref_frame_idx[OC_FRAME_SELF]>=0){
_enc->state.ref_frame_idx[OC_FRAME_PREV]=
_enc->state.ref_frame_idx[OC_FRAME_SELF];
if(_enc->state.frame_type==OC_INTRA_FRAME){
/*The new frame becomes both the previous and gold reference frames.*/
_enc->state.keyframe_num=_enc->state.curframe_num;
_enc->state.ref_frame_idx[OC_FRAME_GOLD]=
_enc->state.ref_frame_idx[OC_FRAME_SELF];
}
}
/*Select a free buffer to use for the reconstructed version of this frame.*/
for(refi=0;refi==_enc->state.ref_frame_idx[OC_FRAME_GOLD]||
refi==_enc->state.ref_frame_idx[OC_FRAME_PREV];refi++);
_enc->state.ref_frame_idx[OC_FRAME_SELF]=refi;
_enc->state.curframe_num+=_enc->prev_dup_count+1;
/*Step 4: Compress the frame.*/
/*Start with a keyframe, and don't allow the generation of invalid files that
overflow the keyframe_granule_shift.*/
if(_enc->rc.twopass_force_kf||_enc->state.curframe_num==0||
_enc->state.curframe_num-_enc->state.keyframe_num+_enc->dup_count>=
_enc->keyframe_frequency_force){
oc_enc_compress_keyframe(_enc,0);
drop=0;
}
else{
oc_enc_compress_frame(_enc,0);
drop=1;
}
oc_restore_fpu(&_enc->state);
/*drop currently indicates if the frame is droppable.*/
if(_enc->state.info.target_bitrate>0){
drop=oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
_enc->state.frame_type,_enc->state.qis[0],0,drop);
}
else drop=0;
/*drop now indicates if the frame was dropped.*/
if(drop)oc_enc_drop_frame(_enc);
else _enc->prevframe_dropped=0;
_enc->packet_state=OC_PACKET_READY;
_enc->prev_dup_count=_enc->nqueued_dups=_enc->dup_count;
_enc->dup_count=0;
#if defined(OC_DUMP_IMAGES)
oc_enc_set_granpos(_enc);
oc_state_dump_frame(&_enc->state,OC_FRAME_IO,"src");
oc_state_dump_frame(&_enc->state,OC_FRAME_SELF,"rec");
#endif
return 0;
}
int th_encode_packetout(th_enc_ctx *_enc,int _last_p,ogg_packet *_op){
if(_enc==NULL||_op==NULL)return TH_EFAULT;
if(_enc->packet_state==OC_PACKET_READY){
_enc->packet_state=OC_PACKET_EMPTY;
if(_enc->rc.twopass!=1){
unsigned char *packet;
packet=oggpackB_get_buffer(&_enc->opb);
/*If there's no packet, malloc failed while writing; it's lost forever.*/
if(packet==NULL)return TH_EFAULT;
_op->packet=packet;
_op->bytes=oggpackB_bytes(&_enc->opb);
}
/*For the first pass in 2-pass mode, don't emit any packet data.*/
else{
_op->packet=NULL;
_op->bytes=0;
}
}
else if(_enc->packet_state==OC_PACKET_EMPTY){
if(_enc->nqueued_dups>0){
_enc->nqueued_dups--;
_op->packet=NULL;
_op->bytes=0;
}
else{
if(_last_p)_enc->packet_state=OC_PACKET_DONE;
return 0;
}
}
else return 0;
_last_p=_last_p&&_enc->nqueued_dups<=0;
_op->b_o_s=0;
_op->e_o_s=_last_p;
oc_enc_set_granpos(_enc);
_op->packetno=th_granule_frame(_enc,_enc->state.granpos)+3;
_op->granulepos=_enc->state.granpos;
if(_last_p)_enc->packet_state=OC_PACKET_DONE;
return 1+_enc->nqueued_dups;
}