33 #define FREEZE_INTERVAL 128
37 #define MAX_FRAME_SIZE 32768
42 #define MAX_TRELLIS 16
58 int frontier = 1 << avctx->
trellis;
61 for (i = 0; i < 2; i++) {
81 "allowed. Using %d instead of %d\n", new_frame_size,
96 "allowed. Using %d instead of %d\n", new_trellis,
109 for (i = 0; i < 2; i++) {
118 35, 72, 110, 150, 190, 233, 276, 323,
119 370, 422, 473, 530, 587, 650, 714, 786,
120 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
121 1765, 1980, 2195, 2557, 2919
125 int *xlow,
int *xhigh)
131 *xlow = xout1 + xout2 >> 14;
132 *xhigh = xout1 - xout2 >> 14;
143 int diff = av_clip_int16(xhigh - state->s_predictor);
144 int pred = 141 * state->scale_factor >> 8;
146 return ((diff ^ (diff >> (
sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
151 int diff = av_clip_int16(xlow - state->s_predictor);
153 int limit = diff ^ (diff >> (
sizeof(diff)*8-1));
155 limit = limit + 1 << 10;
156 if (limit >
low_quant[8] * state->scale_factor)
158 while (i < 29 && limit >
low_quant[i] * state->scale_factor)
160 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
164 uint8_t *dst,
int nb_samples,
168 int frontier = 1 << trellis;
171 int pathn[2] = {0, 0}, froze = -1;
174 for (i = 0; i < 2; i++) {
176 nodes_next[i] = c->
nodep_buf[i] + frontier;
178 nodes[i][0] = c->
node_buf[i] + frontier;
179 nodes[i][0]->
ssd = 0;
180 nodes[i][0]->
path = 0;
181 nodes[i][0]->state = c->
band[i];
184 for (i = 0; i < nb_samples >> 1; i++) {
187 int heap_pos[2] = {0, 0};
189 for (j = 0; j < 2; j++) {
190 next[j] = c->
node_buf[j] + frontier*(i & 1);
191 memset(nodes_next[j], 0, frontier *
sizeof(**nodes_next));
196 for (j = 0; j < frontier && nodes[0][j]; j++) {
202 int range = j < frontier/2 ? 4 : 0;
205 int ilow =
encode_low(&cur_node->state, xlow);
207 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
208 int decoded, dec_diff, pos;
215 decoded = av_clip((cur_node->state.scale_factor *
217 + cur_node->state.s_predictor, -16384, 16383);
218 dec_diff = xlow - decoded;
220 #define STORE_NODE(index, UPDATE, VALUE)\
221 ssd = cur_node->ssd + dec_diff*dec_diff;\
224 if (ssd < cur_node->ssd)\
226 if (heap_pos[index] < frontier) {\
227 pos = heap_pos[index]++;\
228 assert(pathn[index] < FREEZE_INTERVAL * frontier);\
229 node = nodes_next[index][pos] = next[index]++;\
230 node->path = pathn[index]++;\
234 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
235 if (ssd >= nodes_next[index][pos]->ssd)\
238 node = nodes_next[index][pos];\
241 node->state = cur_node->state;\
243 c->paths[index][node->path].value = VALUE;\
244 c->paths[index][node->path].prev = cur_node->path;\
248 int parent = (pos - 1) >> 1;\
249 if (nodes_next[index][parent]->ssd <= ssd)\
251 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
252 nodes_next[index][pos]);\
259 for (j = 0; j < frontier && nodes[1][j]; j++) {
267 for (ihigh = 0; ihigh < 4; ihigh++) {
268 int dhigh, decoded, dec_diff, pos;
272 dhigh = cur_node->state.scale_factor *
274 decoded = av_clip(dhigh + cur_node->state.s_predictor,
276 dec_diff = xhigh - decoded;
282 for (j = 0; j < 2; j++) {
285 if (nodes[j][0]->
ssd > (1 << 16)) {
286 for (k = 1; k < frontier && nodes[j][k]; k++)
287 nodes[j][k]->
ssd -= nodes[j][0]->
ssd;
288 nodes[j][0]->ssd = 0;
293 p[0] = &c->
paths[0][nodes[0][0]->path];
294 p[1] = &c->
paths[1][nodes[1][0]->path];
295 for (j = i; j > froze; j--) {
296 dst[j] = p[1]->value << 6 | p[0]->value;
301 pathn[0] = pathn[1] = 0;
302 memset(nodes[0] + 1, 0, (frontier - 1)*
sizeof(**nodes));
303 memset(nodes[1] + 1, 0, (frontier - 1)*
sizeof(**nodes));
309 for (j = i; j > froze; j--) {
310 dst[j] = p[1]->value << 6 | p[0]->value;
314 c->
band[0] = nodes[0][0]->state;
315 c->
band[1] = nodes[1][0]->state;
321 int xlow, xhigh, ilow, ihigh;
328 *dst = ihigh << 6 | ilow;
332 uint8_t *dst,
int nb_samples,
336 for (i = 0; i < nb_samples; i += 2)
341 uint8_t *dst,
int buf_size,
void *
data)
344 const int16_t *samples =
data;
355 if (nb_samples < avctx->frame_size) {
356 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
357 encode_byte(c, &dst[nb_samples >> 1], last_samples);