From 699d02b839ff8001bb68d975a15e9622cd64574b Mon Sep 17 00:00:00 2001 From: Justin Ruggles Date: Sun, 24 Feb 2013 13:15:12 -0500 Subject: [PATCH] libschroedinger: cosmetics: rename variable avccontext to avctx This is consistent with the rest of libavcodec. --- libavcodec/libschroedinger.c | 22 +++---- libavcodec/libschroedinger.h | 4 +- libavcodec/libschroedingerdec.c | 60 +++++++++---------- libavcodec/libschroedingerenc.c | 102 +++++++++++++++----------------- 4 files changed, 92 insertions(+), 96 deletions(-) diff --git a/libavcodec/libschroedinger.c b/libavcodec/libschroedinger.c index 68e925cabc..2aa5eb9fa1 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)); - avpicture_alloc(p_pic, avccontext->pix_fmt, y_width, y_height); + avpicture_alloc(p_pic, avctx->pix_fmt, y_width, y_height); p_frame = schro_frame_new(); p_frame->format = schro_frame_fmt; diff --git a/libavcodec/libschroedinger.h b/libavcodec/libschroedinger.h index bf179d2778..5481f92ce0 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 2411fe63dd..d0077d8a01 100644 --- a/libavcodec/libschroedingerdec.c +++ b/libavcodec/libschroedingerdec.c @@ -151,14 +151,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); @@ -175,38 +175,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 Libav 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) { @@ -215,7 +215,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; @@ -241,17 +241,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; @@ -261,7 +261,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: @@ -271,7 +271,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; @@ -285,7 +285,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; @@ -313,9 +313,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); } @@ -354,15 +354,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, @@ -371,11 +371,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 40022861be..596a8bda64 100644 --- a/libavcodec/libschroedingerenc.c +++ b/libavcodec/libschroedingerenc.c @@ -79,33 +79,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. */ @@ -115,75 +114,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", @@ -194,7 +193,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, @@ -206,19 +205,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. */ @@ -230,7 +227,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); @@ -239,19 +236,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); @@ -266,11 +263,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; @@ -288,8 +285,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); } @@ -361,7 +357,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; } } @@ -381,17 +377,17 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0) pkt_size += p_schro_params->enc_buf_size; if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) { - av_log(avccontext, AV_LOG_ERROR, "Error getting output packet of size %d.\n", pkt_size); + av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", pkt_size); 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; @@ -416,9 +412,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);