36 #define FREEZE_INTERVAL 128
40 #define MAX_FRAME_SIZE 32768
45 #define MAX_TRELLIS 16
51 for (i = 0; i < 2; i++) {
74 int frontier = 1 << avctx->
trellis;
77 for (i = 0; i < 2; i++) {
101 "allowed. Using %d instead of %d\n", new_frame_size,
117 "allowed. Using %d instead of %d\n", new_trellis,
132 35, 72, 110, 150, 190, 233, 276, 323,
133 370, 422, 473, 530, 587, 650, 714, 786,
134 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
135 1765, 1980, 2195, 2557, 2919
139 int *xlow,
int *xhigh)
145 *xlow = xout[0] + xout[1] >> 14;
146 *xhigh = xout[0] - xout[1] >> 14;
157 int diff = av_clip_int16(xhigh - state->s_predictor);
158 int pred = 141 * state->scale_factor >> 8;
160 return ((diff ^ (diff >> (
sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
165 int diff = av_clip_int16(xlow - state->s_predictor);
167 int limit = diff ^ (diff >> (
sizeof(
diff)*8-1));
169 limit = limit + 1 << 10;
170 if (limit >
low_quant[8] * state->scale_factor)
172 while (i < 29 && limit >
low_quant[i] * state->scale_factor)
174 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
179 const int16_t *samples)
182 int frontier = 1 << trellis;
185 int pathn[2] = {0, 0}, froze = -1;
188 for (i = 0; i < 2; i++) {
190 nodes_next[i] = c->
nodep_buf[i] + frontier;
192 nodes[i][0] = c->
node_buf[i] + frontier;
193 nodes[i][0]->
ssd = 0;
194 nodes[i][0]->
path = 0;
195 nodes[i][0]->state = c->
band[i];
198 for (i = 0; i < nb_samples >> 1; i++) {
201 int heap_pos[2] = {0, 0};
203 for (j = 0; j < 2; j++) {
204 next[j] = c->
node_buf[j] + frontier*(i & 1);
205 memset(nodes_next[j], 0, frontier *
sizeof(**nodes_next));
210 for (j = 0; j < frontier && nodes[0][j]; j++) {
216 int range = j < frontier/2 ? 4 : 0;
219 int ilow =
encode_low(&cur_node->state, xlow);
221 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
222 int decoded, dec_diff, pos;
229 decoded = av_clip_intp2((cur_node->state.scale_factor *
231 + cur_node->state.s_predictor, 14);
232 dec_diff = xlow - decoded;
234 #define STORE_NODE(index, UPDATE, VALUE)\
235 ssd = cur_node->ssd + dec_diff*dec_diff;\
238 if (ssd < cur_node->ssd)\
240 if (heap_pos[index] < frontier) {\
241 pos = heap_pos[index]++;\
242 av_assert2(pathn[index] < FREEZE_INTERVAL * frontier);\
243 node = nodes_next[index][pos] = next[index]++;\
244 node->path = pathn[index]++;\
248 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
249 if (ssd >= nodes_next[index][pos]->ssd)\
252 node = nodes_next[index][pos];\
255 node->state = cur_node->state;\
257 c->paths[index][node->path].value = VALUE;\
258 c->paths[index][node->path].prev = cur_node->path;\
262 int parent = (pos - 1) >> 1;\
263 if (nodes_next[index][parent]->ssd <= ssd)\
265 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
266 nodes_next[index][pos]);\
273 for (j = 0; j < frontier && nodes[1][j]; j++) {
281 for (ihigh = 0; ihigh < 4; ihigh++) {
282 int dhigh, decoded, dec_diff, pos;
286 dhigh = cur_node->state.scale_factor *
288 decoded = av_clip_intp2(dhigh + cur_node->state.s_predictor, 14);
289 dec_diff = xhigh - decoded;
295 for (j = 0; j < 2; j++) {
298 if (nodes[j][0]->
ssd > (1 << 16)) {
299 for (k = 1; k < frontier && nodes[j][k]; k++)
300 nodes[j][k]->
ssd -= nodes[j][0]->
ssd;
301 nodes[j][0]->ssd = 0;
306 p[0] = &c->
paths[0][nodes[0][0]->path];
307 p[1] = &c->
paths[1][nodes[1][0]->path];
308 for (j = i; j > froze; j--) {
309 dst[j] = p[1]->value << 6 | p[0]->value;
314 pathn[0] = pathn[1] = 0;
315 memset(nodes[0] + 1, 0, (frontier - 1)*
sizeof(**nodes));
316 memset(nodes[1] + 1, 0, (frontier - 1)*
sizeof(**nodes));
322 for (j = i; j > froze; j--) {
323 dst[j] = p[1]->value << 6 | p[0]->value;
327 c->
band[0] = nodes[0][0]->state;
328 c->
band[1] = nodes[1][0]->state;
332 const int16_t *samples)
334 int xlow, xhigh, ilow, ihigh;
341 *dst = ihigh << 6 | ilow;
346 const int16_t *samples)
349 for (i = 0; i < nb_samples; i += 2)
357 const int16_t *samples = (
const int16_t *)frame->
data[0];
358 int nb_samples, out_size,
ret;
372 if (nb_samples < frame->nb_samples) {
373 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
struct G722Context::TrellisNode ** nodep_buf[2]
This structure describes decoded (raw) audio or video data.
void(* apply_qmf)(const int16_t *prev_samples, int xout[2])
#define AV_LOG_WARNING
Something somehow does not look correct.
static av_cold int init(AVCodecContext *avctx)
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)
static int encode_high(const struct G722Band *state, int xhigh)
#define PREV_SAMPLES_BUF_SIZE
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static av_cold int g722_encode_init(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
struct G722Context::TrellisNode * node_buf[2]
#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]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int initial_padding
Audio only.
int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]
memory of past decoded samples
simple assert() macros that are a bit more flexible than ISO C assert().
AVCodec ff_adpcm_g722_encoder
const char * name
Name of the codec implementation.
av_cold void ff_g722dsp_init(G722DSPContext *c)
Libavcodec external API header.
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)
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
static const float pred[4]
int frame_size
Number of samples per channel in an audio frame.
static const int16_t low_quant[33]
AVSampleFormat
Audio sample formats.
main external API structure.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
common internal api header.
common internal and external API header
int prev_samples_pos
the number of values in prev_samples
int trellis
trellis RD quantization
#define STORE_NODE(index, UPDATE, VALUE)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
const int16_t ff_g722_high_inv_quant[4]
int channels
number of audio channels
static av_always_inline void encode_byte(G722Context *c, uint8_t *dst, const int16_t *samples)
static void * av_mallocz_array(size_t nmemb, size_t size)
static enum AVSampleFormat sample_fmts[]
static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
#define FFSWAP(type, a, b)
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
This structure stores compressed data.
int16_t scale_factor
delayed quantizer scale factor
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.