diff --git a/cmdutils.c b/cmdutils.c index 1634947b20..36a80c6740 100644 --- a/cmdutils.c +++ b/cmdutils.c @@ -474,7 +474,9 @@ int opt_default(void *optctx, const char *opt, const char *arg) char opt_stripped[128]; const char *p; const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(); - const av_unused AVClass *rc_class; +#if CONFIG_AVRESAMPLE + const AVClass *rc = avresample_get_class(); +#endif const AVClass *sc, *swr_class; if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug")) @@ -527,8 +529,7 @@ int opt_default(void *optctx, const char *opt, const char *arg) } #endif #if CONFIG_AVRESAMPLE - rc_class = avresample_get_class(); - if ((o=av_opt_find(&rc_class, opt, NULL, 0, + if ((o=av_opt_find(&rc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) { av_dict_set(&resample_opts, opt, arg, FLAGS); consumed = 1; diff --git a/libavcodec/libschroedinger.c b/libavcodec/libschroedinger.c index c4963e19b7..f452d70a68 100644 --- a/libavcodec/libschroedinger.c +++ b/libavcodec/libschroedinger.c @@ -46,7 +46,7 @@ static const SchroVideoFormatInfo ff_schro_video_format_info[] = { { 4096, 2160, 24, 1 }, }; -static unsigned int get_video_format_idx(AVCodecContext *avccontext) +static unsigned int get_video_format_idx(AVCodecContext *avctx) { unsigned int ret_idx = 0; unsigned int idx; @@ -55,11 +55,11 @@ static unsigned int get_video_format_idx(AVCodecContext *avccontext) for (idx = 1; idx < num_formats; ++idx) { const SchroVideoFormatInfo *vf = &ff_schro_video_format_info[idx]; - if (avccontext->width == vf->width && - avccontext->height == vf->height) { + if (avctx->width == vf->width && + avctx->height == vf->height) { ret_idx = idx; - if (avccontext->time_base.den == vf->frame_rate_num && - avccontext->time_base.num == vf->frame_rate_denom) + if (avctx->time_base.den == vf->frame_rate_num && + avctx->time_base.num == vf->frame_rate_denom) return idx; } } @@ -136,12 +136,12 @@ static const SchroVideoFormatEnum ff_schro_video_formats[]={ SCHRO_VIDEO_FORMAT_DC4K_24 , }; -SchroVideoFormatEnum ff_get_schro_video_format_preset(AVCodecContext *avccontext) +SchroVideoFormatEnum ff_get_schro_video_format_preset(AVCodecContext *avctx) { unsigned int num_formats = sizeof(ff_schro_video_formats) / sizeof(ff_schro_video_formats[0]); - unsigned int idx = get_video_format_idx(avccontext); + unsigned int idx = get_video_format_idx(avctx); return (idx < num_formats) ? ff_schro_video_formats[idx] : SCHRO_VIDEO_FORMAT_CUSTOM; @@ -175,7 +175,7 @@ static void free_schro_frame(SchroFrame *frame, void *priv) av_freep(&p_pic); } -SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext, +SchroFrame *ff_create_schro_frame(AVCodecContext *avctx, SchroFrameFormat schro_frame_fmt) { AVPicture *p_pic; @@ -184,13 +184,13 @@ SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext, int y_height, uv_height; int i; - y_width = avccontext->width; - y_height = avccontext->height; + y_width = avctx->width; + y_height = avctx->height; uv_width = y_width >> (SCHRO_FRAME_FORMAT_H_SHIFT(schro_frame_fmt)); uv_height = y_height >> (SCHRO_FRAME_FORMAT_V_SHIFT(schro_frame_fmt)); p_pic = av_mallocz(sizeof(AVPicture)); - if (!p_pic || avpicture_alloc(p_pic, avccontext->pix_fmt, y_width, y_height) < 0) { + if (!p_pic || avpicture_alloc(p_pic, avctx->pix_fmt, y_width, y_height) < 0) { av_free(p_pic); return NULL; } diff --git a/libavcodec/libschroedinger.h b/libavcodec/libschroedinger.h index f2e513b551..12fe57c7f1 100644 --- a/libavcodec/libschroedinger.h +++ b/libavcodec/libschroedinger.h @@ -114,7 +114,7 @@ static const struct { * Returns the video format preset matching the input video dimensions and * time base. */ -SchroVideoFormatEnum ff_get_schro_video_format_preset (AVCodecContext *avccontext); +SchroVideoFormatEnum ff_get_schro_video_format_preset (AVCodecContext *avctx); /** * Sets the Schroedinger frame format corresponding to the Schro chroma format @@ -127,7 +127,7 @@ int ff_get_schro_frame_format(SchroChromaFormat schro_chroma_fmt, * Create a Schro frame based on the dimensions and frame format * passed. Returns a pointer to a frame on success, NULL on failure. */ -SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext, +SchroFrame *ff_create_schro_frame(AVCodecContext *avctx, SchroFrameFormat schro_frame_fmt); #endif /* AVCODEC_LIBSCHROEDINGER_H */ diff --git a/libavcodec/libschroedingerdec.c b/libavcodec/libschroedingerdec.c index bce0271850..985ae60835 100644 --- a/libavcodec/libschroedingerdec.c +++ b/libavcodec/libschroedingerdec.c @@ -147,14 +147,14 @@ static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt) return AV_PIX_FMT_NONE; } -static av_cold int libschroedinger_decode_init(AVCodecContext *avccontext) +static av_cold int libschroedinger_decode_init(AVCodecContext *avctx) { - SchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avctx->priv_data; /* First of all, initialize our supporting libraries. */ schro_init(); - schro_debug_set_level(avccontext->debug); + schro_debug_set_level(avctx->debug); p_schro_params->decoder = schro_decoder_new(); schro_decoder_set_skip_ratio(p_schro_params->decoder, 1); @@ -171,38 +171,38 @@ static void libschroedinger_decode_frame_free(void *frame) schro_frame_unref(frame); } -static void libschroedinger_handle_first_access_unit(AVCodecContext *avccontext) +static void libschroedinger_handle_first_access_unit(AVCodecContext *avctx) { - SchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avctx->priv_data; SchroDecoder *decoder = p_schro_params->decoder; p_schro_params->format = schro_decoder_get_video_format(decoder); /* Tell FFmpeg about sequence details. */ if (av_image_check_size(p_schro_params->format->width, - p_schro_params->format->height, 0, avccontext) < 0) { - av_log(avccontext, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n", + p_schro_params->format->height, 0, avctx) < 0) { + av_log(avctx, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n", p_schro_params->format->width, p_schro_params->format->height); - avccontext->height = avccontext->width = 0; + avctx->height = avctx->width = 0; return; } - avccontext->height = p_schro_params->format->height; - avccontext->width = p_schro_params->format->width; - avccontext->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format); + avctx->height = p_schro_params->format->height; + avctx->width = p_schro_params->format->width; + avctx->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format); if (ff_get_schro_frame_format(p_schro_params->format->chroma_format, &p_schro_params->frame_format) == -1) { - av_log(avccontext, AV_LOG_ERROR, + av_log(avctx, AV_LOG_ERROR, "This codec currently only supports planar YUV 4:2:0, 4:2:2 " "and 4:4:4 formats.\n"); return; } - avccontext->time_base.den = p_schro_params->format->frame_rate_numerator; - avccontext->time_base.num = p_schro_params->format->frame_rate_denominator; + avctx->time_base.den = p_schro_params->format->frame_rate_numerator; + avctx->time_base.num = p_schro_params->format->frame_rate_denominator; } -static int libschroedinger_decode_frame(AVCodecContext *avccontext, +static int libschroedinger_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { @@ -211,7 +211,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, int64_t pts = avpkt->pts; SchroTag *tag; - SchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avctx->priv_data; SchroDecoder *decoder = p_schro_params->decoder; SchroBuffer *enc_buf; SchroFrame* frame; @@ -237,17 +237,17 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, /* Set Schrotag with the pts to be recovered after decoding*/ enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free); if (!enc_buf->tag->value) { - av_log(avccontext, AV_LOG_ERROR, "Unable to allocate SchroTag\n"); + av_log(avctx, AV_LOG_ERROR, "Unable to allocate SchroTag\n"); return AVERROR(ENOMEM); } AV_WN(64, enc_buf->tag->value, pts); /* Push buffer into decoder. */ if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) && SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0) - avccontext->has_b_frames = 1; + avctx->has_b_frames = 1; state = schro_decoder_push(decoder, enc_buf); if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT) - libschroedinger_handle_first_access_unit(avccontext); + libschroedinger_handle_first_access_unit(avctx); go = 1; } else outer = 0; @@ -257,7 +257,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, state = schro_decoder_wait(decoder); switch (state) { case SCHRO_DECODER_FIRST_ACCESS_UNIT: - libschroedinger_handle_first_access_unit(avccontext); + libschroedinger_handle_first_access_unit(avctx); break; case SCHRO_DECODER_NEED_BITS: @@ -267,7 +267,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, case SCHRO_DECODER_NEED_FRAME: /* Decoder needs a frame - create one and push it in. */ - frame = ff_create_schro_frame(avccontext, + frame = ff_create_schro_frame(avctx, p_schro_params->frame_format); schro_decoder_add_output_picture(decoder, frame); break; @@ -281,7 +281,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, /* Add relation between schroframe and pts. */ framewithpts = av_malloc(sizeof(LibSchroFrameContext)); if (!framewithpts) { - av_log(avccontext, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n"); + av_log(avctx, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n"); return AVERROR(ENOMEM); } framewithpts->frame = frame; @@ -309,9 +309,9 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, if (framewithpts && framewithpts->frame) { if (p_schro_params->dec_frame.data[0]) - avccontext->release_buffer(avccontext, &p_schro_params->dec_frame); - if (ff_get_buffer(avccontext, &p_schro_params->dec_frame) < 0) { - av_log(avccontext, AV_LOG_ERROR, "Unable to allocate buffer\n"); + avctx->release_buffer(avctx, &p_schro_params->dec_frame); + if (ff_get_buffer(avctx, &p_schro_params->dec_frame) < 0) { + av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n"); return AVERROR(ENOMEM); } @@ -350,15 +350,15 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, } -static av_cold int libschroedinger_decode_close(AVCodecContext *avccontext) +static av_cold int libschroedinger_decode_close(AVCodecContext *avctx) { - SchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avctx->priv_data; /* Free the decoder. */ schro_decoder_free(p_schro_params->decoder); av_freep(&p_schro_params->format); if (p_schro_params->dec_frame.data[0]) - avccontext->release_buffer(avccontext, &p_schro_params->dec_frame); + avctx->release_buffer(avctx, &p_schro_params->dec_frame); /* Free data in the output frame queue. */ ff_schro_queue_free(&p_schro_params->dec_frame_queue, @@ -367,11 +367,11 @@ static av_cold int libschroedinger_decode_close(AVCodecContext *avccontext) return 0; } -static void libschroedinger_flush(AVCodecContext *avccontext) +static void libschroedinger_flush(AVCodecContext *avctx) { /* Got a seek request. Free the decoded frames queue and then reset * the decoder */ - SchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avctx->priv_data; /* Free data in the output frame queue. */ ff_schro_queue_free(&p_schro_params->dec_frame_queue, diff --git a/libavcodec/libschroedingerenc.c b/libavcodec/libschroedingerenc.c index aed7818567..297c6c50c8 100644 --- a/libavcodec/libschroedingerenc.c +++ b/libavcodec/libschroedingerenc.c @@ -77,33 +77,32 @@ typedef struct SchroEncoderParams { /** * Works out Schro-compatible chroma format. */ -static int set_chroma_format(AVCodecContext *avccontext) +static int set_chroma_format(AVCodecContext *avctx) { int num_formats = sizeof(schro_pixel_format_map) / sizeof(schro_pixel_format_map[0]); int idx; - SchroEncoderParams *p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avctx->priv_data; for (idx = 0; idx < num_formats; ++idx) { - if (schro_pixel_format_map[idx].ff_pix_fmt == - avccontext->pix_fmt) { + if (schro_pixel_format_map[idx].ff_pix_fmt == avctx->pix_fmt) { p_schro_params->format->chroma_format = schro_pixel_format_map[idx].schro_pix_fmt; return 0; } } - av_log(avccontext, AV_LOG_ERROR, + av_log(avctx, AV_LOG_ERROR, "This codec currently only supports planar YUV 4:2:0, 4:2:2" " and 4:4:4 formats.\n"); return -1; } -static int libschroedinger_encode_init(AVCodecContext *avccontext) +static int libschroedinger_encode_init(AVCodecContext *avctx) { - SchroEncoderParams *p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avctx->priv_data; SchroVideoFormatEnum preset; /* Initialize the libraries that libschroedinger depends on. */ @@ -113,75 +112,75 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) p_schro_params->encoder = schro_encoder_new(); if (!p_schro_params->encoder) { - av_log(avccontext, AV_LOG_ERROR, + av_log(avctx, AV_LOG_ERROR, "Unrecoverable Error: schro_encoder_new failed. "); return -1; } /* Initialize the format. */ - preset = ff_get_schro_video_format_preset(avccontext); + preset = ff_get_schro_video_format_preset(avctx); p_schro_params->format = schro_encoder_get_video_format(p_schro_params->encoder); schro_video_format_set_std_video_format(p_schro_params->format, preset); - p_schro_params->format->width = avccontext->width; - p_schro_params->format->height = avccontext->height; + p_schro_params->format->width = avctx->width; + p_schro_params->format->height = avctx->height; - if (set_chroma_format(avccontext) == -1) + if (set_chroma_format(avctx) == -1) return -1; - if (avccontext->color_primaries == AVCOL_PRI_BT709) { + if (avctx->color_primaries == AVCOL_PRI_BT709) { p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_HDTV; - } else if (avccontext->color_primaries == AVCOL_PRI_BT470BG) { + } else if (avctx->color_primaries == AVCOL_PRI_BT470BG) { p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_625; - } else if (avccontext->color_primaries == AVCOL_PRI_SMPTE170M) { + } else if (avctx->color_primaries == AVCOL_PRI_SMPTE170M) { p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_525; } - if (avccontext->colorspace == AVCOL_SPC_BT709) { + if (avctx->colorspace == AVCOL_SPC_BT709) { p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_HDTV; - } else if (avccontext->colorspace == AVCOL_SPC_BT470BG) { + } else if (avctx->colorspace == AVCOL_SPC_BT470BG) { p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_SDTV; } - if (avccontext->color_trc == AVCOL_TRC_BT709) { + if (avctx->color_trc == AVCOL_TRC_BT709) { p_schro_params->format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA; } if (ff_get_schro_frame_format(p_schro_params->format->chroma_format, &p_schro_params->frame_format) == -1) { - av_log(avccontext, AV_LOG_ERROR, + av_log(avctx, AV_LOG_ERROR, "This codec currently supports only planar YUV 4:2:0, 4:2:2" " and 4:4:4 formats.\n"); return -1; } - p_schro_params->format->frame_rate_numerator = avccontext->time_base.den; - p_schro_params->format->frame_rate_denominator = avccontext->time_base.num; + p_schro_params->format->frame_rate_numerator = avctx->time_base.den; + p_schro_params->format->frame_rate_denominator = avctx->time_base.num; - p_schro_params->frame_size = avpicture_get_size(avccontext->pix_fmt, - avccontext->width, - avccontext->height); + p_schro_params->frame_size = avpicture_get_size(avctx->pix_fmt, + avctx->width, + avctx->height); - avccontext->coded_frame = &p_schro_params->picture; + avctx->coded_frame = &p_schro_params->picture; - if (!avccontext->gop_size) { + if (!avctx->gop_size) { schro_encoder_setting_set_double(p_schro_params->encoder, "gop_structure", SCHRO_ENCODER_GOP_INTRA_ONLY); - if (avccontext->coder_type == FF_CODER_TYPE_VLC) + if (avctx->coder_type == FF_CODER_TYPE_VLC) schro_encoder_setting_set_double(p_schro_params->encoder, "enable_noarith", 1); } else { schro_encoder_setting_set_double(p_schro_params->encoder, - "au_distance", avccontext->gop_size); - avccontext->has_b_frames = 1; + "au_distance", avctx->gop_size); + avctx->has_b_frames = 1; p_schro_params->dts = -1; } /* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */ - if (avccontext->flags & CODEC_FLAG_QSCALE) { - if (!avccontext->global_quality) { + if (avctx->flags & CODEC_FLAG_QSCALE) { + if (!avctx->global_quality) { /* lossless coding */ schro_encoder_setting_set_double(p_schro_params->encoder, "rate_control", @@ -192,7 +191,7 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) "rate_control", SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY); - quality = avccontext->global_quality / FF_QP2LAMBDA; + quality = avctx->global_quality / FF_QP2LAMBDA; if (quality > 10) quality = 10; schro_encoder_setting_set_double(p_schro_params->encoder, @@ -204,19 +203,17 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE); schro_encoder_setting_set_double(p_schro_params->encoder, - "bitrate", - avccontext->bit_rate); - + "bitrate", avctx->bit_rate); } - if (avccontext->flags & CODEC_FLAG_INTERLACED_ME) + if (avctx->flags & CODEC_FLAG_INTERLACED_ME) /* All material can be coded as interlaced or progressive irrespective of the type of source material. */ schro_encoder_setting_set_double(p_schro_params->encoder, "interlaced_coding", 1); schro_encoder_setting_set_double(p_schro_params->encoder, "open_gop", - !(avccontext->flags & CODEC_FLAG_CLOSED_GOP)); + !(avctx->flags & CODEC_FLAG_CLOSED_GOP)); /* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger * and libdirac support other bit-depth data. */ @@ -228,7 +225,7 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) p_schro_params->format); /* Set the debug level. */ - schro_debug_set_level(avccontext->debug); + schro_debug_set_level(avctx->debug); schro_encoder_start(p_schro_params->encoder); @@ -237,19 +234,19 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) return 0; } -static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avccontext, +static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avctx, const AVFrame *frame) { - SchroEncoderParams *p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avctx->priv_data; SchroFrame *in_frame; /* Input line size may differ from what the codec supports. Especially * when transcoding from one format to another. So use avpicture_layout * to copy the frame. */ - in_frame = ff_create_schro_frame(avccontext, p_schro_params->frame_format); + in_frame = ff_create_schro_frame(avctx, p_schro_params->frame_format); if (in_frame) - avpicture_layout((const AVPicture *)frame, avccontext->pix_fmt, - avccontext->width, avccontext->height, + avpicture_layout((const AVPicture *)frame, avctx->pix_fmt, + avctx->width, avctx->height, in_frame->components[0].data, p_schro_params->frame_size); @@ -264,11 +261,11 @@ static void libschroedinger_free_frame(void *data) av_free(enc_frame); } -static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pkt, +static int libschroedinger_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet) { int enc_size = 0; - SchroEncoderParams *p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avctx->priv_data; SchroEncoder *encoder = p_schro_params->encoder; struct FFSchroEncodedFrame *p_frame_output = NULL; int go = 1; @@ -286,8 +283,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk } } else { /* Allocate frame data to schro input buffer. */ - SchroFrame *in_frame = libschroedinger_frame_from_data(avccontext, - frame); + SchroFrame *in_frame = libschroedinger_frame_from_data(avctx, frame); /* Load next frame. */ schro_encoder_push_frame(encoder, in_frame); } @@ -358,7 +354,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk break; default: - av_log(avccontext, AV_LOG_ERROR, "Unknown Schro Encoder state\n"); + av_log(avctx, AV_LOG_ERROR, "Unknown Schro Encoder state\n"); return -1; } } @@ -377,16 +373,16 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk pkt_size = p_frame_output->size; if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0) pkt_size += p_schro_params->enc_buf_size; - if ((ret = ff_alloc_packet2(avccontext, pkt, pkt_size)) < 0) + if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size)) < 0) goto error; memcpy(pkt->data, p_frame_output->p_encbuf, p_frame_output->size); - avccontext->coded_frame->key_frame = p_frame_output->key_frame; + avctx->coded_frame->key_frame = p_frame_output->key_frame; /* Use the frame number of the encoded frame as the pts. It is OK to * do so since Dirac is a constant frame rate codec. It expects input * to be of constant frame rate. */ pkt->pts = - avccontext->coded_frame->pts = p_frame_output->frame_num; + avctx->coded_frame->pts = p_frame_output->frame_num; pkt->dts = p_schro_params->dts++; enc_size = p_frame_output->size; @@ -411,9 +407,9 @@ error: } -static int libschroedinger_encode_close(AVCodecContext *avccontext) +static int libschroedinger_encode_close(AVCodecContext *avctx) { - SchroEncoderParams *p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avctx->priv_data; /* Close the encoder. */ schro_encoder_free(p_schro_params->encoder); diff --git a/libavcodec/vorbisenc.c b/libavcodec/vorbisenc.c index 33b2577d96..50780dd717 100644 --- a/libavcodec/vorbisenc.c +++ b/libavcodec/vorbisenc.c @@ -236,15 +236,15 @@ static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc) } static int create_vorbis_context(vorbis_enc_context *venc, - AVCodecContext *avccontext) + AVCodecContext *avctx) { vorbis_enc_floor *fc; vorbis_enc_residue *rc; vorbis_enc_mapping *mc; int i, book, ret; - venc->channels = avccontext->channels; - venc->sample_rate = avccontext->sample_rate; + venc->channels = avctx->channels; + venc->sample_rate = avctx->sample_rate; venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11; venc->ncodebooks = FF_ARRAY_ELEMS(cvectors); @@ -340,7 +340,7 @@ static int create_vorbis_context(vorbis_enc_context *venc, }; fc->list[i].x = a[i - 2]; } - if (ff_vorbis_ready_floor1_list(avccontext, fc->list, fc->values)) + if (ff_vorbis_ready_floor1_list(avctx, fc->list, fc->values)) return AVERROR_BUG; venc->nresidues = 1; @@ -1014,10 +1014,10 @@ static int apply_window_and_mdct(vorbis_enc_context *venc, return 1; } -static int vorbis_encode_frame(AVCodecContext *avccontext, AVPacket *avpkt, +static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { - vorbis_enc_context *venc = avccontext->priv_data; + vorbis_enc_context *venc = avctx->priv_data; float **audio = frame ? (float **)frame->extended_data : NULL; int samples = frame ? frame->nb_samples : 0; vorbis_enc_mode *mode; @@ -1029,13 +1029,13 @@ static int vorbis_encode_frame(AVCodecContext *avccontext, AVPacket *avpkt, return 0; samples = 1 << (venc->log2_blocksize[0] - 1); - if ((ret = ff_alloc_packet2(avccontext, avpkt, 8192))) + if ((ret = ff_alloc_packet2(avctx, avpkt, 8192))) return ret; init_put_bits(&pb, avpkt->data, avpkt->size); if (pb.size_in_bits - put_bits_count(&pb) < 1 + ilog(venc->nmodes - 1)) { - av_log(avccontext, AV_LOG_ERROR, "output buffer is too small\n"); + av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); return AVERROR(EINVAL); } @@ -1055,7 +1055,7 @@ static int vorbis_encode_frame(AVCodecContext *avccontext, AVPacket *avpkt, uint16_t posts[MAX_FLOOR_VALUES]; floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples); if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples)) { - av_log(avccontext, AV_LOG_ERROR, "output buffer is too small\n"); + av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); return AVERROR(EINVAL); } } @@ -1079,17 +1079,17 @@ static int vorbis_encode_frame(AVCodecContext *avccontext, AVPacket *avpkt, if (residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], &pb, venc->coeffs, samples, venc->channels)) { - av_log(avccontext, AV_LOG_ERROR, "output buffer is too small\n"); + av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); return AVERROR(EINVAL); } flush_put_bits(&pb); avpkt->size = put_bits_count(&pb) >> 3; - avpkt->duration = ff_samples_to_time_base(avccontext, avccontext->frame_size); + avpkt->duration = ff_samples_to_time_base(avctx, avctx->frame_size); if (frame) { if (frame->pts != AV_NOPTS_VALUE) - avpkt->pts = ff_samples_to_time_base(avccontext, frame->pts); + avpkt->pts = ff_samples_to_time_base(avctx, frame->pts); } else avpkt->pts = venc->next_pts; if (avpkt->pts != AV_NOPTS_VALUE) @@ -1100,9 +1100,9 @@ static int vorbis_encode_frame(AVCodecContext *avccontext, AVPacket *avpkt, } -static av_cold int vorbis_encode_close(AVCodecContext *avccontext) +static av_cold int vorbis_encode_close(AVCodecContext *avctx) { - vorbis_enc_context *venc = avccontext->priv_data; + vorbis_enc_context *venc = avctx->priv_data; int i; if (venc->codebooks) @@ -1155,42 +1155,42 @@ static av_cold int vorbis_encode_close(AVCodecContext *avccontext) ff_mdct_end(&venc->mdct[1]); #if FF_API_OLD_ENCODE_AUDIO - av_freep(&avccontext->coded_frame); + av_freep(&avctx->coded_frame); #endif - av_freep(&avccontext->extradata); + av_freep(&avctx->extradata); return 0 ; } -static av_cold int vorbis_encode_init(AVCodecContext *avccontext) +static av_cold int vorbis_encode_init(AVCodecContext *avctx) { - vorbis_enc_context *venc = avccontext->priv_data; + vorbis_enc_context *venc = avctx->priv_data; int ret; - if (avccontext->channels != 2) { - av_log(avccontext, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n"); + if (avctx->channels != 2) { + av_log(avctx, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n"); return -1; } - if ((ret = create_vorbis_context(venc, avccontext)) < 0) + if ((ret = create_vorbis_context(venc, avctx)) < 0) goto error; - avccontext->bit_rate = 0; - if (avccontext->flags & CODEC_FLAG_QSCALE) - venc->quality = avccontext->global_quality / (float)FF_QP2LAMBDA; + avctx->bit_rate = 0; + if (avctx->flags & CODEC_FLAG_QSCALE) + venc->quality = avctx->global_quality / (float)FF_QP2LAMBDA; else venc->quality = 8; venc->quality *= venc->quality; - if ((ret = put_main_header(venc, (uint8_t**)&avccontext->extradata)) < 0) + if ((ret = put_main_header(venc, (uint8_t**)&avctx->extradata)) < 0) goto error; - avccontext->extradata_size = ret; + avctx->extradata_size = ret; - avccontext->frame_size = 1 << (venc->log2_blocksize[0] - 1); + avctx->frame_size = 1 << (venc->log2_blocksize[0] - 1); #if FF_API_OLD_ENCODE_AUDIO - avccontext->coded_frame = avcodec_alloc_frame(); - if (!avccontext->coded_frame) { + avctx->coded_frame = avcodec_alloc_frame(); + if (!avctx->coded_frame) { ret = AVERROR(ENOMEM); goto error; } @@ -1198,7 +1198,7 @@ static av_cold int vorbis_encode_init(AVCodecContext *avccontext) return 0; error: - vorbis_encode_close(avccontext); + vorbis_encode_close(avctx); return ret; }