static int generate_codebook(RoqContext *enc, RoqTempdata *tempdata,
int *points, int inputCount, roq_cell *results,
int size, int cbsize)
{
int i, j, k, ret = 0;
int c_size = size*size/4;
int *buf;
int *codebook = av_malloc_array(6*c_size, cbsize*sizeof(int));
int *closest_cb;
if (!codebook)
return AVERROR(ENOMEM);
if (size == 4) {
closest_cb = av_malloc_array(6*c_size, inputCount*sizeof(int));
if (!closest_cb) {
ret = AVERROR(ENOMEM);
goto out;
}
} else
closest_cb = tempdata->closest_cb2;
ret = avpriv_init_elbg(points, 6 * c_size, inputCount, codebook,
cbsize, 1, closest_cb, &enc->randctx);
if (ret < 0)
goto out;
ret = avpriv_do_elbg(points, 6 * c_size, inputCount, codebook,
cbsize, 1, closest_cb, &enc->randctx);
if (ret < 0)
goto out;
buf = codebook;
for (i=0; i<cbsize; i++)
for (k=0; k<c_size; k++) {
for(j=0; j<4; j++)
results->y[j] = *buf++;
results->u = (*buf++ + CHROMA_BIAS/2)/CHROMA_BIAS;
results->v = (*buf++ + CHROMA_BIAS/2)/CHROMA_BIAS;
results++;
}
out:
if (size == 4)
av_free(closest_cb);
av_free(codebook);
return ret;
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
ConvolutionContext *s = ctx->priv;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
int p;
s->depth = desc->comp[0].depth;
s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
s->planewidth[0] = s->planewidth[3] = inlink->w;
s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
s->planeheight[0] = s->planeheight[3] = inlink->h;
s->nb_planes = av_pix_fmt_count_planes(inlink->format);
s->nb_threads = ff_filter_get_nb_threads(ctx);
s->bptrs = av_calloc(s->nb_threads, sizeof(*s->bptrs));
if (!s->bptrs)
return AVERROR(ENOMEM);
s->bstride = s->planewidth[0] + 64;
s->bpc = (s->depth + 7) / 8;
s->buffer = av_malloc_array(7 * s->bstride * s->nb_threads, s->bpc);
if (!s->buffer)
return AVERROR(ENOMEM);
for (p = 0; p < s->nb_threads; p++) {
s->bptrs[p] = s->buffer + 7 * s->bstride * s->bpc * p;
}
if (!strcmp(ctx->filter->name, "convolution")) {
if (s->depth > 8) {
for (p = 0; p < s->nb_planes; p++) {
if (s->size[p] == 3)
s->filter[p] = filter16_3x3;
else if (s->size[p] == 5)
s->filter[p] = filter16_5x5;
else if (s->size[p] == 7)
s->filter[p] = filter16_7x7;
}
}
} else if (!strcmp(ctx->filter->name, "prewitt")) {
if (s->depth > 8)
for (p = 0; p < s->nb_planes; p++)
s->filter[p] = filter16_prewitt;
} else if (!strcmp(ctx->filter->name, "roberts")) {
if (s->depth > 8)
for (p = 0; p < s->nb_planes; p++)
s->filter[p] = filter16_roberts;
} else if (!strcmp(ctx->filter->name, "sobel")) {
if (s->depth > 8)
for (p = 0; p < s->nb_planes; p++)
s->filter[p] = filter16_sobel;
}
return 0;
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
SilenceRemoveContext *s = ctx->priv;
s->window_size = (inlink->sample_rate / 50) * inlink->channels;
s->window = av_malloc_array(s->window_size, sizeof(*s->window));
if (!s->window)
return AVERROR(ENOMEM);
clear_rms(s);
s->start_duration = av_rescale(s->start_duration, inlink->sample_rate,
AV_TIME_BASE);
s->stop_duration = av_rescale(s->stop_duration, inlink->sample_rate,
AV_TIME_BASE);
s->start_holdoff = av_malloc_array(FFMAX(s->start_duration, 1),
sizeof(*s->start_holdoff) *
inlink->channels);
if (!s->start_holdoff)
return AVERROR(ENOMEM);
s->start_holdoff_offset = 0;
s->start_holdoff_end = 0;
s->start_found_periods = 0;
s->stop_holdoff = av_malloc_array(FFMAX(s->stop_duration, 1),
sizeof(*s->stop_holdoff) *
inlink->channels);
if (!s->stop_holdoff)
return AVERROR(ENOMEM);
s->stop_holdoff_offset = 0;
s->stop_holdoff_end = 0;
s->stop_found_periods = 0;
if (s->start_periods)
s->mode = SILENCE_TRIM;
else
s->mode = SILENCE_COPY;
return 0;
}
STDMETHODIMP CDecD3D11::FindVideoServiceConversion(AVCodecID codec, int profile, DXGI_FORMAT surface_format, GUID *input )
{
AVD3D11VADeviceContext *pDeviceContext = (AVD3D11VADeviceContext *)((AVHWDeviceContext *)m_pDevCtx->data)->hwctx;
HRESULT hr = S_OK;
UINT nProfiles = pDeviceContext->video_device->GetVideoDecoderProfileCount();
GUID *guid_list = (GUID *)av_malloc_array(nProfiles, sizeof(*guid_list));
DbgLog((LOG_TRACE, 10, L"-> Enumerating supported D3D11 modes (count: %d)", nProfiles));
for (UINT i = 0; i < nProfiles; i++)
{
hr = pDeviceContext->video_device->GetVideoDecoderProfile(i, &guid_list[i]);
if (FAILED(hr)) {
DbgLog((LOG_ERROR, 10, L"Error retrieving decoder profile"));
av_free(guid_list);
return hr;
}
#ifdef DEBUG
const dxva_mode_t *mode = get_dxva_mode_from_guid(&guid_list[i]);
if (mode) {
DbgLog((LOG_TRACE, 10, L" -> %S", mode->name));
}
else {
DbgLog((LOG_TRACE, 10, L" -> Unknown GUID (%s)", WStringFromGUID(guid_list[i]).c_str()));
}
#endif
}
/* Iterate over our priority list */
for (unsigned i = 0; dxva_modes[i].name; i++) {
const dxva_mode_t *mode = &dxva_modes[i];
if (!check_dxva_mode_compatibility(mode, codec, profile))
continue;
BOOL supported = FALSE;
for (UINT g = 0; !supported && g < nProfiles; g++) {
supported = IsEqualGUID(*mode->guid, guid_list[g]);
}
if (!supported)
continue;
DbgLog((LOG_TRACE, 10, L"-> Trying to use '%S'", mode->name));
hr = pDeviceContext->video_device->CheckVideoDecoderFormat(mode->guid, surface_format, &supported);
if (SUCCEEDED(hr) && supported) {
*input = *mode->guid;
av_free(guid_list);
return S_OK;
}
}
av_free(guid_list);
return E_FAIL;
}
av_cold int ff_psy_init(FFPsyContext *ctx, AVCodecContext *avctx, int num_lens,
const uint8_t **bands, const int* num_bands,
int num_groups, const uint8_t *group_map)
{
int i, j, k = 0;
ctx->avctx = avctx;
ctx->ch = av_mallocz_array(sizeof(ctx->ch[0]), avctx->channels * 2);
ctx->group = av_mallocz_array(sizeof(ctx->group[0]), num_groups);
ctx->bands = av_malloc_array (sizeof(ctx->bands[0]), num_lens);
ctx->num_bands = av_malloc_array (sizeof(ctx->num_bands[0]), num_lens);
ctx->cutoff = avctx->cutoff;
if (!ctx->ch || !ctx->group || !ctx->bands || !ctx->num_bands) {
ff_psy_end(ctx);
return AVERROR(ENOMEM);
}
memcpy(ctx->bands, bands, sizeof(ctx->bands[0]) * num_lens);
memcpy(ctx->num_bands, num_bands, sizeof(ctx->num_bands[0]) * num_lens);
/* assign channels to groups (with virtual channels for coupling) */
for (i = 0; i < num_groups; i++) {
/* NOTE: Add 1 to handle the AAC chan_config without modification.
* This has the side effect of allowing an array of 0s to map
* to one channel per group.
*/
ctx->group[i].num_ch = group_map[i] + 1;
for (j = 0; j < ctx->group[i].num_ch * 2; j++)
ctx->group[i].ch[j] = &ctx->ch[k++];
}
switch (ctx->avctx->codec_id) {
case AV_CODEC_ID_AAC:
ctx->model = &ff_aac_psy_model;
break;
}
if (ctx->model->init)
return ctx->model->init(ctx);
return 0;
}
static int filter_units_make_type_list(const char *list_string,
CodedBitstreamUnitType **type_list,
int *nb_types)
{
CodedBitstreamUnitType *list = NULL;
int pass, count;
for (pass = 1; pass <= 2; pass++) {
long value, range_start, range_end;
const char *str;
char *value_end;
count = 0;
for (str = list_string; *str;) {
value = strtol(str, &value_end, 0);
if (str == value_end)
goto invalid;
str = (const char *)value_end;
if (*str == '-') {
++str;
range_start = value;
range_end = strtol(str, &value_end, 0);
if (str == value_end)
goto invalid;
for (value = range_start; value < range_end; value++) {
if (pass == 2)
list[count] = value;
++count;
}
} else {
if (pass == 2)
list[count] = value;
++count;
}
if (*str == '|')
++str;
}
if (pass == 1) {
list = av_malloc_array(count, sizeof(*list));
if (!list)
return AVERROR(ENOMEM);
}
}
*type_list = list;
*nb_types = count;
return 0;
invalid:
av_freep(&list);
return AVERROR(EINVAL);
}
static int config_props(AVFilterLink *inlink)
{
PixdescTestContext *priv = inlink->dst->priv;
priv->pix_desc = av_pix_fmt_desc_get(inlink->format);
av_freep(&priv->line);
if (!(priv->line = av_malloc_array(sizeof(*priv->line), inlink->w)))
return AVERROR(ENOMEM);
return 0;
}
int swri_get_dither(SwrContext *s, void *dst, int len, unsigned seed, enum AVSampleFormat noise_fmt) {
double scale = s->dither.noise_scale;
#define TMP_EXTRA 2
double *tmp = av_malloc_array(len + TMP_EXTRA, sizeof(double));
int i;
if (!tmp)
return AVERROR(ENOMEM);
for(i=0; i<len + TMP_EXTRA; i++){
double v;
seed = seed* 1664525 + 1013904223;
switch(s->dither.method){
case SWR_DITHER_RECTANGULAR: v= ((double)seed) / UINT_MAX - 0.5; break;
default:
av_assert0(s->dither.method < SWR_DITHER_NB);
v = ((double)seed) / UINT_MAX;
seed = seed*1664525 + 1013904223;
v-= ((double)seed) / UINT_MAX;
break;
}
tmp[i] = v;
}
for(i=0; i<len; i++){
double v;
switch(s->dither.method){
default:
av_assert0(s->dither.method < SWR_DITHER_NB);
v = tmp[i];
break;
case SWR_DITHER_TRIANGULAR_HIGHPASS :
v = (- tmp[i] + 2*tmp[i+1] - tmp[i+2]) / sqrt(6);
break;
}
v*= scale;
switch(noise_fmt){
case AV_SAMPLE_FMT_S16P: ((int16_t*)dst)[i] = v; break;
case AV_SAMPLE_FMT_S32P: ((int32_t*)dst)[i] = v; break;
case AV_SAMPLE_FMT_FLTP: ((float *)dst)[i] = v; break;
case AV_SAMPLE_FMT_DBLP: ((double *)dst)[i] = v; break;
default: av_assert0(0);
}
}
av_free(tmp);
return 0;
}
int ff_ffv1_allocate_initial_states(FFV1Context *f)
{
int i;
for (i = 0; i < f->quant_table_count; i++) {
f->initial_states[i] = av_malloc_array(f->context_count[i],
sizeof(*f->initial_states[i]));
if (!f->initial_states[i])
return AVERROR(ENOMEM);
memset(f->initial_states[i], 128,
f->context_count[i] * sizeof(*f->initial_states[i]));
}
return 0;
}
PCA *ff_pca_init(int n){
PCA *pca;
if(n<=0)
return NULL;
pca= av_mallocz(sizeof(*pca));
pca->n= n;
pca->z = av_malloc_array(n, sizeof(*pca->z));
pca->count=0;
pca->covariance= av_calloc(n*n, sizeof(double));
pca->mean= av_calloc(n, sizeof(double));
return pca;
}
/**
* init MDCT or IMDCT computation.
*/
av_cold int ff_mdct_init(FFTContext *s, int nbits, int inverse, double scale)
{
int n, n4, i;
double alpha, theta;
int tstep;
memset(s, 0, sizeof(*s));
n = 1 << nbits;
s->mdct_bits = nbits;
s->mdct_size = n;
n4 = n >> 2;
s->mdct_permutation = FF_MDCT_PERM_NONE;
if (ff_fft_init(s, s->mdct_bits - 2, inverse) < 0)
goto fail;
s->tcos = av_malloc_array(n/2, sizeof(FFTSample));
if (!s->tcos)
goto fail;
switch (s->mdct_permutation) {
case FF_MDCT_PERM_NONE:
s->tsin = s->tcos + n4;
tstep = 1;
break;
case FF_MDCT_PERM_INTERLEAVE:
s->tsin = s->tcos + 1;
tstep = 2;
break;
default:
goto fail;
}
theta = 1.0 / 8.0 + (scale < 0 ? n4 : 0);
scale = sqrt(fabs(scale));
for(i=0;i<n4;i++) {
alpha = 2 * M_PI * (i + theta) / n;
#if FFT_FIXED_32
s->tcos[i*tstep] = lrint(-cos(alpha) * 2147483648.0);
s->tsin[i*tstep] = lrint(-sin(alpha) * 2147483648.0);
#else
s->tcos[i*tstep] = FIX15(-cos(alpha) * scale);
s->tsin[i*tstep] = FIX15(-sin(alpha) * scale);
#endif
}
return 0;
fail:
ff_mdct_end(s);
return -1;
}
/**
* Initialize cel evaluators and set their source coordinates
*/
static void create_cel_evals(RoqContext *enc, RoqTempdata *tempData)
{
int n=0, x, y, i;
tempData->cel_evals = av_malloc_array(enc->width*enc->height/64, sizeof(CelEvaluation));
/* Map to the ROQ quadtree order */
for (y=0; y<enc->height; y+=16)
for (x=0; x<enc->width; x+=16)
for(i=0; i<4; i++) {
tempData->cel_evals[n ].sourceX = x + (i&1)*8;
tempData->cel_evals[n++].sourceY = y + (i&2)*4;
}
}
static av_cold int cng_encode_init(AVCodecContext *avctx)
{
CNGContext *p = avctx->priv_data;
int ret;
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
return AVERROR(EINVAL);
}
avctx->frame_size = 640;
p->order = 10;
if ((ret = ff_lpc_init(&p->lpc, avctx->frame_size, p->order, FF_LPC_TYPE_LEVINSON)) < 0)
return ret;
p->samples32 = av_malloc_array(avctx->frame_size, sizeof(*p->samples32));
p->ref_coef = av_malloc_array(p->order, sizeof(*p->ref_coef));
if (!p->samples32 || !p->ref_coef) {
cng_encode_close(avctx);
return AVERROR(ENOMEM);
}
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AudioPhaserContext *p = outlink->src->priv;
AVFilterLink *inlink = outlink->src->inputs[0];
p->delay_buffer_length = p->delay * 0.001 * inlink->sample_rate + 0.5;
p->delay_buffer = av_calloc(p->delay_buffer_length, sizeof(*p->delay_buffer) * inlink->channels);
p->modulation_buffer_length = inlink->sample_rate / p->speed + 0.5;
p->modulation_buffer = av_malloc_array(p->modulation_buffer_length, sizeof(*p->modulation_buffer));
if (!p->modulation_buffer || !p->delay_buffer)
return AVERROR(ENOMEM);
ff_generate_wave_table(p->type, AV_SAMPLE_FMT_S32,
p->modulation_buffer, p->modulation_buffer_length,
1., p->delay_buffer_length, M_PI / 2.0);
p->delay_pos = p->modulation_pos = 0;
switch (inlink->format) {
case AV_SAMPLE_FMT_DBL:
p->phaser = phaser_dbl;
break;
case AV_SAMPLE_FMT_DBLP:
p->phaser = phaser_dblp;
break;
case AV_SAMPLE_FMT_FLT:
p->phaser = phaser_flt;
break;
case AV_SAMPLE_FMT_FLTP:
p->phaser = phaser_fltp;
break;
case AV_SAMPLE_FMT_S16:
p->phaser = phaser_s16;
break;
case AV_SAMPLE_FMT_S16P:
p->phaser = phaser_s16p;
break;
case AV_SAMPLE_FMT_S32:
p->phaser = phaser_s32;
break;
case AV_SAMPLE_FMT_S32P:
p->phaser = phaser_s32p;
break;
default:
av_assert0(0);
}
return 0;
}
static int config_input(AVFilterLink *inlink)
{
VagueDenoiserContext *s = inlink->dst->priv;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
int nsteps_width, nsteps_height, nsteps_max;
s->depth = desc->comp[0].depth;
s->nb_planes = desc->nb_components;
s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
s->planeheight[0] = s->planeheight[3] = inlink->h;
s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
s->planewidth[0] = s->planewidth[3] = inlink->w;
s->block = av_malloc_array(inlink->w * inlink->h, sizeof(*s->block));
s->in = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->in));
s->out = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->out));
s->tmp = av_malloc_array(32 + FFMAX(inlink->w, inlink->h), sizeof(*s->tmp));
if (!s->block || !s->in || !s->out || !s->tmp)
return AVERROR(ENOMEM);
s->threshold *= 1 << (s->depth - 8);
s->peak = (1 << s->depth) - 1;
nsteps_width = ((s->planes & 2 || s->planes & 4) && s->nb_planes > 1) ? s->planewidth[1] : s->planewidth[0];
nsteps_height = ((s->planes & 2 || s->planes & 4) && s->nb_planes > 1) ? s->planeheight[1] : s->planeheight[0];
for (nsteps_max = 1; nsteps_max < 15; nsteps_max++) {
if (pow(2, nsteps_max) >= nsteps_width || pow(2, nsteps_max) >= nsteps_height)
break;
}
s->nsteps = FFMIN(s->nsteps, nsteps_max - 2);
return 0;
}
int ff_alloc_entries(AVCodecContext *avctx, int count)
{
int i;
if (avctx->active_thread_type & FF_THREAD_SLICE) {
SliceThreadContext *p = avctx->internal->thread_ctx;
if (p->entries) {
av_assert0(p->thread_count == avctx->thread_count);
av_freep(&p->entries);
}
p->thread_count = avctx->thread_count;
p->entries = av_mallocz_array(count, sizeof(int));
if (!p->progress_mutex) {
p->progress_mutex = av_malloc_array(p->thread_count, sizeof(pthread_mutex_t));
p->progress_cond = av_malloc_array(p->thread_count, sizeof(pthread_cond_t));
}
if (!p->entries || !p->progress_mutex || !p->progress_cond) {
av_freep(&p->entries);
av_freep(&p->progress_mutex);
av_freep(&p->progress_cond);
return AVERROR(ENOMEM);
}
p->entries_count = count;
for (i = 0; i < p->thread_count; i++) {
pthread_mutex_init(&p->progress_mutex[i], NULL);
pthread_cond_init(&p->progress_cond[i], NULL);
}
}
return 0;
}
static int cuda_frames_get_constraints(AVHWDeviceContext *ctx,
const void *hwconfig,
AVHWFramesConstraints *constraints)
{
int i;
constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,
sizeof(*constraints->valid_sw_formats));
if (!constraints->valid_sw_formats)
return AVERROR(ENOMEM);
for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
constraints->valid_sw_formats[i] = supported_formats[i];
constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_formats)] = AV_PIX_FMT_NONE;
constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
if (!constraints->valid_hw_formats)
return AVERROR(ENOMEM);
constraints->valid_hw_formats[0] = AV_PIX_FMT_CUDA;
constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
return 0;
}
AVParserState *ff_store_parser_state(AVFormatContext *s)
{
int i;
AVStream *st;
AVParserStreamState *ss;
AVParserState *state = av_malloc(sizeof(AVParserState));
if (!state)
return NULL;
state->stream_states = av_malloc_array(s->nb_streams, sizeof(AVParserStreamState));
if (!state->stream_states) {
av_free(state);
return NULL;
}
state->fpos = avio_tell(s->pb);
// copy context structures
state->packet_buffer = s->packet_buffer;
state->parse_queue = s->parse_queue;
state->raw_packet_buffer = s->raw_packet_buffer;
state->raw_packet_buffer_remaining_size = s->raw_packet_buffer_remaining_size;
s->packet_buffer = NULL;
s->parse_queue = NULL;
s->raw_packet_buffer = NULL;
s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
// copy stream structures
state->nb_streams = s->nb_streams;
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
ss = &state->stream_states[i];
ss->parser = st->parser;
ss->last_IP_pts = st->last_IP_pts;
ss->cur_dts = st->cur_dts;
ss->probe_packets = st->probe_packets;
st->parser = NULL;
st->last_IP_pts = AV_NOPTS_VALUE;
st->cur_dts = AV_NOPTS_VALUE;
st->probe_packets = MAX_PROBE_PACKETS;
}
return state;
}
static int dxva2_transfer_get_formats(AVHWFramesContext *ctx,
enum AVHWFrameTransferDirection dir,
enum AVPixelFormat **formats)
{
enum AVPixelFormat *fmts;
fmts = av_malloc_array(2, sizeof(*fmts));
if (!fmts)
return AVERROR(ENOMEM);
fmts[0] = ctx->sw_format;
fmts[1] = AV_PIX_FMT_NONE;
*formats = fmts;
return 0;
}
int av_packet_split_side_data(AVPacket *pkt){
if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
int i;
unsigned int size;
uint8_t *p;
p = pkt->data + pkt->size - 8 - 5;
for (i=1; ; i++){
size = AV_RB32(p);
if (size>INT_MAX - 5 || p - pkt->data < size)
return 0;
if (p[4]&128)
break;
if (p - pkt->data < size + 5)
return 0;
p-= size+5;
}
if (i > AV_PKT_DATA_NB)
return AVERROR(ERANGE);
pkt->side_data = av_malloc_array(i, sizeof(*pkt->side_data));
if (!pkt->side_data)
return AVERROR(ENOMEM);
p= pkt->data + pkt->size - 8 - 5;
for (i=0; ; i++){
size= AV_RB32(p);
av_assert0(size<=INT_MAX - 5 && p - pkt->data >= size);
pkt->side_data[i].data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
pkt->side_data[i].size = size;
pkt->side_data[i].type = p[4]&127;
if (!pkt->side_data[i].data)
return AVERROR(ENOMEM);
memcpy(pkt->side_data[i].data, p-size, size);
pkt->size -= size + 5;
if(p[4]&128)
break;
p-= size+5;
}
pkt->size -= 8;
pkt->side_data_elems = i+1;
return 1;
}
return 0;
}
static void fft_ref_init(int nbits, int inverse)
{
int n, i;
double c1, s1, alpha;
n = 1 << nbits;
exptab = av_malloc_array((n / 2), sizeof(*exptab));
for (i = 0; i < (n/2); i++) {
alpha = 2 * M_PI * (float)i / (float)n;
c1 = cos(alpha);
s1 = sin(alpha);
if (!inverse)
s1 = -s1;
exptab[i].re = c1;
exptab[i].im = s1;
}
}
static int fft_ref_init(int nbits, int inverse)
{
int i, n = 1 << nbits;
exptab = av_malloc_array((n / 2), sizeof(*exptab));
if (!exptab)
return AVERROR(ENOMEM);
for (i = 0; i < (n / 2); i++) {
double alpha = 2 * M_PI * (float) i / (float) n;
double c1 = cos(alpha), s1 = sin(alpha);
if (!inverse)
s1 = -s1;
exptab[i].re = c1;
exptab[i].im = s1;
}
return 0;
}
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
{
int i;
f->slice_count = f->num_h_slices * f->num_v_slices;
av_assert0(f->slice_count > 0);
for (i = 0; i < f->slice_count; i++) {
int sx = i % f->num_h_slices;
int sy = i / f->num_h_slices;
int sxs = f->avctx->width * sx / f->num_h_slices;
int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
int sys = f->avctx->height * sy / f->num_v_slices;
int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
FFV1Context *fs = av_mallocz(sizeof(*fs));
if (!fs)
goto memfail;
f->slice_context[i] = fs;
memcpy(fs, f, sizeof(*fs));
memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
fs->slice_width = sxe - sxs;
fs->slice_height = sye - sys;
fs->slice_x = sxs;
fs->slice_y = sys;
fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
sizeof(*fs->sample_buffer));
if (!fs->sample_buffer) {
av_freep(&f->slice_context[i]);
goto memfail;
}
}
return 0;
memfail:
while(--i >= 0) {
av_freep(&f->slice_context[i]->sample_buffer);
av_freep(&f->slice_context[i]);
}
return AVERROR(ENOMEM);
}
/**
* Initialize MDCT tables.
*
* @param s AC-3 encoder private context
* @return 0 on success, negative error code on failure
*/
av_cold int ff_ac3_float_mdct_init(AC3EncodeContext *s)
{
float *window;
int i, n, n2;
n = 1 << 9;
n2 = n >> 1;
window = av_malloc_array(n, sizeof(*window));
if (!window) {
av_log(s->avctx, AV_LOG_ERROR, "Cannot allocate memory.\n");
return AVERROR(ENOMEM);
}
ff_kbd_window_init(window, 5.0, n2);
for (i = 0; i < n2; i++)
window[n-1-i] = window[i];
s->mdct_window = window;
return ff_mdct_init(&s->mdct, 9, 0, -2.0 / n);
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
SwapRectContext *s = ctx->priv;
if (!s->w || !s->h ||
!s->x1 || !s->y1 ||
!s->x2 || !s->y2)
return AVERROR(EINVAL);
s->desc = av_pix_fmt_desc_get(inlink->format);
av_image_fill_max_pixsteps(s->pixsteps, NULL, s->desc);
s->nb_planes = av_pix_fmt_count_planes(inlink->format);
s->temp = av_malloc_array(inlink->w, s->pixsteps[0]);
if (!s->temp)
return AVERROR(ENOMEM);
return 0;
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
AudioSurroundContext *s = ctx->priv;
int ch;
s->rdft = av_calloc(inlink->channels, sizeof(*s->rdft));
if (!s->rdft)
return AVERROR(ENOMEM);
for (ch = 0; ch < inlink->channels; ch++) {
s->rdft[ch] = av_rdft_init(ff_log2(s->buf_size), DFT_R2C);
if (!s->rdft[ch])
return AVERROR(ENOMEM);
}
s->nb_in_channels = inlink->channels;
s->input_levels = av_malloc_array(s->nb_in_channels, sizeof(*s->input_levels));
if (!s->input_levels)
return AVERROR(ENOMEM);
for (ch = 0; ch < s->nb_in_channels; ch++)
s->input_levels[ch] = s->level_in;
ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_FRONT_CENTER);
if (ch >= 0)
s->input_levels[ch] *= s->fc_in;
ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_LOW_FREQUENCY);
if (ch >= 0)
s->input_levels[ch] *= s->lfe_in;
s->input = ff_get_audio_buffer(inlink, s->buf_size * 2);
if (!s->input)
return AVERROR(ENOMEM);
s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->buf_size);
if (!s->fifo)
return AVERROR(ENOMEM);
s->lowcut = 1.f * s->lowcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
s->highcut = 1.f * s->highcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
return 0;
}
static av_cold int init_cook_mlt(COOKContext *q)
{
int j, ret;
int mlt_size = q->samples_per_channel;
if ((q->mlt_window = av_malloc_array(mlt_size, sizeof(*q->mlt_window))) == 0)
return AVERROR(ENOMEM);
/* Initialize the MLT window: simple sine window. */
ff_sine_window_init(q->mlt_window, mlt_size);
for (j = 0; j < mlt_size; j++)
q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
/* Initialize the MDCT. */
if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0))) {
av_freep(&q->mlt_window);
return ret;
}
av_log(q->avctx, AV_LOG_DEBUG, "MDCT initialized, order = %d.\n",
av_log2(mlt_size) + 1);
return 0;
}
static int vdpau_transfer_get_formats(AVHWFramesContext *ctx,
enum AVHWFrameTransferDirection dir,
enum AVPixelFormat **formats)
{
VDPAUFramesContext *priv = ctx->internal->priv;
enum AVPixelFormat *fmts;
if (priv->nb_pix_fmts == 1) {
av_log(ctx, AV_LOG_ERROR,
"No target formats are supported for this chroma type\n");
return AVERROR(ENOSYS);
}
fmts = av_malloc_array(priv->nb_pix_fmts, sizeof(*fmts));
if (!fmts)
return AVERROR(ENOMEM);
memcpy(fmts, priv->pix_fmts, sizeof(*fmts) * (priv->nb_pix_fmts));
*formats = fmts;
return 0;
}
static int config_input(AVFilterLink *inlink)
{
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
GBlurContext *s = inlink->dst->priv;
s->depth = desc->comp[0].depth;
s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
s->planewidth[0] = s->planewidth[3] = inlink->w;
s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
s->planeheight[0] = s->planeheight[3] = inlink->h;
s->nb_planes = av_pix_fmt_count_planes(inlink->format);
s->buffer = av_malloc_array(inlink->w, inlink->h * sizeof(*s->buffer));
if (!s->buffer)
return AVERROR(ENOMEM);
if (s->sigmaV < 0) {
s->sigmaV = s->sigma;
}
return 0;
}
static int init_pass2(MpegEncContext *s)
{
RateControlContext *rcc = &s->rc_context;
AVCodecContext *a = s->avctx;
int i, toobig;
double fps = get_fps(s->avctx);
double complexity[5] = { 0 }; // approximate bits at quant=1
uint64_t const_bits[5] = { 0 }; // quantizer independent bits
uint64_t all_const_bits;
uint64_t all_available_bits = (uint64_t)(s->bit_rate *
(double)rcc->num_entries / fps);
double rate_factor = 0;
double step;
const int filter_size = (int)(a->qblur * 4) | 1;
double expected_bits = 0; // init to silence gcc warning
double *qscale, *blurred_qscale, qscale_sum;
/* find complexity & const_bits & decide the pict_types */
for (i = 0; i < rcc->num_entries; i++) {
RateControlEntry *rce = &rcc->entry[i];
rce->new_pict_type = rce->pict_type;
rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
rcc->frame_count[rce->pict_type]++;
complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
(double)rce->qscale;
const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
}
all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
const_bits[AV_PICTURE_TYPE_P] +
const_bits[AV_PICTURE_TYPE_B];
if (all_available_bits < all_const_bits) {
av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
return -1;
}
qscale = av_malloc_array(rcc->num_entries, sizeof(double));
blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
toobig = 0;
for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
expected_bits = 0;
rate_factor += step;
rcc->buffer_index = s->avctx->rc_buffer_size / 2;
/* find qscale */
for (i = 0; i < rcc->num_entries; i++) {
RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
rcc->last_qscale_for[rce->pict_type] = qscale[i];
}
assert(filter_size % 2 == 1);
/* fixed I/B QP relative to P mode */
for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
}
for (i = rcc->num_entries - 1; i >= 0; i--) {
RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
}
/* smooth curve */
for (i = 0; i < rcc->num_entries; i++) {
RateControlEntry *rce = &rcc->entry[i];
const int pict_type = rce->new_pict_type;
int j;
double q = 0.0, sum = 0.0;
for (j = 0; j < filter_size; j++) {
int index = i + j - filter_size / 2;
double d = index - i;
double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
if (index < 0 || index >= rcc->num_entries)
continue;
if (pict_type != rcc->entry[index].new_pict_type)
continue;
q += qscale[index] * coeff;
sum += coeff;
}
blurred_qscale[i] = q / sum;
}
/* find expected bits */
for (i = 0; i < rcc->num_entries; i++) {
RateControlEntry *rce = &rcc->entry[i];
double bits;
rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
bits += 8 * ff_vbv_update(s, bits);
rce->expected_bits = expected_bits;
expected_bits += bits;
}
av_dlog(s->avctx,
"expected_bits: %f all_available_bits: %d rate_factor: %f\n",
expected_bits, (int)all_available_bits, rate_factor);
if (expected_bits > all_available_bits) {
rate_factor -= step;
++toobig;
}
}
av_free(qscale);
av_free(blurred_qscale);
/* check bitrate calculations and print info */
qscale_sum = 0.0;
for (i = 0; i < rcc->num_entries; i++) {
av_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
i,
rcc->entry[i].new_qscale,
rcc->entry[i].new_qscale / FF_QP2LAMBDA);
qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
s->avctx->qmin, s->avctx->qmax);
}
assert(toobig <= 40);
av_log(s->avctx, AV_LOG_DEBUG,
"[lavc rc] requested bitrate: %d bps expected bitrate: %d bps\n",
s->bit_rate,
(int)(expected_bits / ((double)all_available_bits / s->bit_rate)));
av_log(s->avctx, AV_LOG_DEBUG,
"[lavc rc] estimated target average qp: %.3f\n",
(float)qscale_sum / rcc->num_entries);
if (toobig == 0) {
av_log(s->avctx, AV_LOG_INFO,
"[lavc rc] Using all of requested bitrate is not "
"necessary for this video with these parameters.\n");
} else if (toobig == 40) {
av_log(s->avctx, AV_LOG_ERROR,
"[lavc rc] Error: bitrate too low for this video "
"with these parameters.\n");
return -1;
} else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
av_log(s->avctx, AV_LOG_ERROR,
"[lavc rc] Error: 2pass curve failed to converge\n");
return -1;
}
return 0;
}