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)
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);
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
struct G722Context::TrellisNode ** nodep_buf[2]
#define AV_LOG_WARNING
Something somehow does not look correct.
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
struct G722Context::TrellisPath * paths[2]
static void filter_samples(G722Context *c, const int16_t *samples, int *xlow, int *xhigh)
static void g722_encode_no_trellis(G722Context *c, uint8_t *dst, int nb_samples, const int16_t *samples)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int encode_high(const struct G722Band *state, int xhigh)
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
#define PREV_SAMPLES_BUF_SIZE
static av_cold int g722_encode_init(AVCodecContext *avctx)
static int init(AVCodecParserContext *s)
#define CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
const int16_t ff_g722_low_inv_quant6[64]
struct G722Context::TrellisNode * node_buf[2]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]
memory of past decoded samples
AVCodec ff_adpcm_g722_encoder
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
struct G722Context::G722Band band[2]
static void g722_encode_trellis(G722Context *c, int trellis, uint8_t *dst, int nb_samples, const int16_t *samples)
static av_cold int g722_encode_close(AVCodecContext *avctx)
static int encode_low(const struct G722Band *state, int xlow)
static const float pred[4]
int frame_size
Samples per packet, initialized when calling 'init'.
static const int16_t low_quant[33]
main external API structure.
static void close(AVCodecParserContext *s)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const int16_t ff_g722_high_inv_quant[4]
AVSampleFormat
all in native-endian format
int prev_samples_pos
the number of values in prev_samples
int trellis
trellis RD quantization
void ff_g722_apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2)
#define STORE_NODE(index, UPDATE, VALUE)
int channels
number of audio channels
static av_always_inline void encode_byte(G722Context *c, uint8_t *dst, const int16_t *samples)
static int g722_encode_frame(AVCodecContext *avctx, uint8_t *dst, int buf_size, void *data)
#define FFSWAP(type, a, b)
int16_t scale_factor
delayed quantizer scale factor