Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

libschroedinger: cosmetics: rename variable avccontext to avctx

Browse Source 
This is consistent with the rest of libavcodec.
pull/10/head
Justin Ruggles 12 years ago
parent 09031b4639
commit 699d02b839
4 changed files with 92 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      libavcodec/libschroedinger.c
  2. 4
      libavcodec/libschroedinger.h
  3. 60
      libavcodec/libschroedingerdec.c
  4. 102
      libavcodec/libschroedingerenc.c

22
libavcodec/libschroedinger.c
Unescape View File

@ -46,7 +46,7 @@ static const SchroVideoFormatInfo ff_schro_video_format_info[] = {
{ 4096, 2160, 24, 1 }, { 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 ret_idx = 0;
unsigned int idx; unsigned int idx;
@ -55,11 +55,11 @@ static unsigned int get_video_format_idx(AVCodecContext *avccontext)
for (idx = 1; idx < num_formats; ++idx) { for (idx = 1; idx < num_formats; ++idx) {
const SchroVideoFormatInfo *vf = &ff_schro_video_format_info[idx]; const SchroVideoFormatInfo *vf = &ff_schro_video_format_info[idx];
if (avccontext->width == vf->width && if (avctx->width == vf->width &&
avccontext->height == vf->height) { avctx->height == vf->height) {
ret_idx = idx; ret_idx = idx;
if (avccontext->time_base.den == vf->frame_rate_num && if (avctx->time_base.den == vf->frame_rate_num &&
avccontext->time_base.num == vf->frame_rate_denom) avctx->time_base.num == vf->frame_rate_denom)
return idx; return idx;
} }
} }
@ -136,12 +136,12 @@ static const SchroVideoFormatEnum ff_schro_video_formats[]={
SCHRO_VIDEO_FORMAT_DC4K_24 , 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) / unsigned int num_formats = sizeof(ff_schro_video_formats) /
sizeof(ff_schro_video_formats[0]); 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] : return (idx < num_formats) ? ff_schro_video_formats[idx] :
SCHRO_VIDEO_FORMAT_CUSTOM; SCHRO_VIDEO_FORMAT_CUSTOM;
@ -175,7 +175,7 @@ static void free_schro_frame(SchroFrame *frame, void *priv)
av_freep(&p_pic); av_freep(&p_pic);
} }
SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext, SchroFrame *ff_create_schro_frame(AVCodecContext *avctx,
SchroFrameFormat schro_frame_fmt) SchroFrameFormat schro_frame_fmt)
{ {
AVPicture *p_pic; AVPicture *p_pic;
@ -184,13 +184,13 @@ SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext,
int y_height, uv_height; int y_height, uv_height;
int i; int i;
y_width = avccontext->width; y_width = avctx->width;
y_height = avccontext->height; y_height = avctx->height;
uv_width = y_width >> (SCHRO_FRAME_FORMAT_H_SHIFT(schro_frame_fmt)); uv_width = y_width >> (SCHRO_FRAME_FORMAT_H_SHIFT(schro_frame_fmt));
uv_height = y_height >> (SCHRO_FRAME_FORMAT_V_SHIFT(schro_frame_fmt)); uv_height = y_height >> (SCHRO_FRAME_FORMAT_V_SHIFT(schro_frame_fmt));
p_pic = av_mallocz(sizeof(AVPicture)); 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 = schro_frame_new();
p_frame->format = schro_frame_fmt; p_frame->format = schro_frame_fmt;

4
libavcodec/libschroedinger.h
Unescape View File

@ -114,7 +114,7 @@ static const struct {
* Returns the video format preset matching the input video dimensions and * Returns the video format preset matching the input video dimensions and
* time base. * 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 * 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 * Create a Schro frame based on the dimensions and frame format
* passed. Returns a pointer to a frame on success, NULL on failure. * 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); SchroFrameFormat schro_frame_fmt);
#endif /* AVCODEC_LIBSCHROEDINGER_H */ #endif /* AVCODEC_LIBSCHROEDINGER_H */

60
libavcodec/libschroedingerdec.c
Unescape View File

@ -151,14 +151,14 @@ static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt)
return AV_PIX_FMT_NONE; 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. */ /* First of all, initialize our supporting libraries. */
schro_init(); schro_init();
schro_debug_set_level(avccontext->debug); schro_debug_set_level(avctx->debug);
p_schro_params->decoder = schro_decoder_new(); p_schro_params->decoder = schro_decoder_new();
schro_decoder_set_skip_ratio(p_schro_params->decoder, 1); 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); 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; SchroDecoder *decoder = p_schro_params->decoder;
p_schro_params->format = schro_decoder_get_video_format(decoder); p_schro_params->format = schro_decoder_get_video_format(decoder);
/* Tell Libav about sequence details. */ /* Tell Libav about sequence details. */
if (av_image_check_size(p_schro_params->format->width, if (av_image_check_size(p_schro_params->format->width,
p_schro_params->format->height, 0, avccontext) < 0) { p_schro_params->format->height, 0, avctx) < 0) {
av_log(avccontext, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n", av_log(avctx, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n",
p_schro_params->format->width, p_schro_params->format->height); p_schro_params->format->width, p_schro_params->format->height);
avccontext->height = avccontext->width = 0; avctx->height = avctx->width = 0;
return; return;
} }
avccontext->height = p_schro_params->format->height; avctx->height = p_schro_params->format->height;
avccontext->width = p_schro_params->format->width; avctx->width = p_schro_params->format->width;
avccontext->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format); avctx->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format);
if (ff_get_schro_frame_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) { &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 " "This codec currently only supports planar YUV 4:2:0, 4:2:2 "
"and 4:4:4 formats.\n"); "and 4:4:4 formats.\n");
return; return;
} }
avccontext->time_base.den = p_schro_params->format->frame_rate_numerator; avctx->time_base.den = p_schro_params->format->frame_rate_numerator;
avccontext->time_base.num = p_schro_params->format->frame_rate_denominator; 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, void *data, int *got_frame,
AVPacket *avpkt) AVPacket *avpkt)
{ {
@ -215,7 +215,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
int64_t pts = avpkt->pts; int64_t pts = avpkt->pts;
SchroTag *tag; SchroTag *tag;
SchroDecoderParams *p_schro_params = avccontext->priv_data; SchroDecoderParams *p_schro_params = avctx->priv_data;
SchroDecoder *decoder = p_schro_params->decoder; SchroDecoder *decoder = p_schro_params->decoder;
SchroBuffer *enc_buf; SchroBuffer *enc_buf;
SchroFrame* frame; SchroFrame* frame;
@ -241,17 +241,17 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
/* Set Schrotag with the pts to be recovered after decoding*/ /* Set Schrotag with the pts to be recovered after decoding*/
enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free); enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free);
if (!enc_buf->tag->value) { 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); return AVERROR(ENOMEM);
} }
AV_WN(64, enc_buf->tag->value, pts); AV_WN(64, enc_buf->tag->value, pts);
/* Push buffer into decoder. */ /* Push buffer into decoder. */
if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) && if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) &&
SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0) 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); state = schro_decoder_push(decoder, enc_buf);
if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT) if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT)
libschroedinger_handle_first_access_unit(avccontext); libschroedinger_handle_first_access_unit(avctx);
go = 1; go = 1;
} else } else
outer = 0; outer = 0;
@ -261,7 +261,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
state = schro_decoder_wait(decoder); state = schro_decoder_wait(decoder);
switch (state) { switch (state) {
case SCHRO_DECODER_FIRST_ACCESS_UNIT: case SCHRO_DECODER_FIRST_ACCESS_UNIT:
libschroedinger_handle_first_access_unit(avccontext); libschroedinger_handle_first_access_unit(avctx);
break; break;
case SCHRO_DECODER_NEED_BITS: case SCHRO_DECODER_NEED_BITS:
@ -271,7 +271,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
case SCHRO_DECODER_NEED_FRAME: case SCHRO_DECODER_NEED_FRAME:
/* Decoder needs a frame - create one and push it in. */ /* 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); p_schro_params->frame_format);
schro_decoder_add_output_picture(decoder, frame); schro_decoder_add_output_picture(decoder, frame);
break; break;
@ -285,7 +285,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
/* Add relation between schroframe and pts. */ /* Add relation between schroframe and pts. */
framewithpts = av_malloc(sizeof(LibSchroFrameContext)); framewithpts = av_malloc(sizeof(LibSchroFrameContext));
if (!framewithpts) { 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); return AVERROR(ENOMEM);
} }
framewithpts->frame = frame; framewithpts->frame = frame;
@ -313,9 +313,9 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext,
if (framewithpts && framewithpts->frame) { if (framewithpts && framewithpts->frame) {
if (p_schro_params->dec_frame.data[0]) 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);
if (ff_get_buffer(avccontext, &p_schro_params->dec_frame) < 0) { if (ff_get_buffer(avctx, &p_schro_params->dec_frame) < 0) {
av_log(avccontext, AV_LOG_ERROR, "Unable to allocate buffer\n"); av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
return AVERROR(ENOMEM); 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. */ /* Free the decoder. */
schro_decoder_free(p_schro_params->decoder); schro_decoder_free(p_schro_params->decoder);
av_freep(&p_schro_params->format); av_freep(&p_schro_params->format);
if (p_schro_params->dec_frame.data[0]) 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. */ /* Free data in the output frame queue. */
ff_schro_queue_free(&p_schro_params->dec_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; 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 /* Got a seek request. Free the decoded frames queue and then reset
* the decoder */ * the decoder */
SchroDecoderParams *p_schro_params = avccontext->priv_data; SchroDecoderParams *p_schro_params = avctx->priv_data;
/* Free data in the output frame queue. */ /* Free data in the output frame queue. */
ff_schro_queue_free(&p_schro_params->dec_frame_queue, ff_schro_queue_free(&p_schro_params->dec_frame_queue,

102
libavcodec/libschroedingerenc.c
Unescape View File

@ -79,33 +79,32 @@ typedef struct SchroEncoderParams {
/** /**
* Works out Schro-compatible chroma format. * 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) / int num_formats = sizeof(schro_pixel_format_map) /
sizeof(schro_pixel_format_map[0]); sizeof(schro_pixel_format_map[0]);
int idx; int idx;
SchroEncoderParams *p_schro_params = avccontext->priv_data; SchroEncoderParams *p_schro_params = avctx->priv_data;
for (idx = 0; idx < num_formats; ++idx) { for (idx = 0; idx < num_formats; ++idx) {
if (schro_pixel_format_map[idx].ff_pix_fmt == if (schro_pixel_format_map[idx].ff_pix_fmt == avctx->pix_fmt) {
avccontext->pix_fmt) {
p_schro_params->format->chroma_format = p_schro_params->format->chroma_format =
schro_pixel_format_map[idx].schro_pix_fmt; schro_pixel_format_map[idx].schro_pix_fmt;
return 0; 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" "This codec currently only supports planar YUV 4:2:0, 4:2:2"
" and 4:4:4 formats.\n"); " and 4:4:4 formats.\n");
return -1; 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; SchroVideoFormatEnum preset;
/* Initialize the libraries that libschroedinger depends on. */ /* 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(); p_schro_params->encoder = schro_encoder_new();
if (!p_schro_params->encoder) { if (!p_schro_params->encoder) {
av_log(avccontext, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"Unrecoverable Error: schro_encoder_new failed. "); "Unrecoverable Error: schro_encoder_new failed. ");
return -1; return -1;
} }
/* Initialize the format. */ /* Initialize the format. */
preset = ff_get_schro_video_format_preset(avccontext); preset = ff_get_schro_video_format_preset(avctx);
p_schro_params->format = p_schro_params->format =
schro_encoder_get_video_format(p_schro_params->encoder); schro_encoder_get_video_format(p_schro_params->encoder);
schro_video_format_set_std_video_format(p_schro_params->format, preset); schro_video_format_set_std_video_format(p_schro_params->format, preset);
p_schro_params->format->width = avccontext->width; p_schro_params->format->width = avctx->width;
p_schro_params->format->height = avccontext->height; p_schro_params->format->height = avctx->height;
if (set_chroma_format(avccontext) == -1) if (set_chroma_format(avctx) == -1)
return -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; 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; 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; 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; 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; 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; p_schro_params->format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA;
} }
if (ff_get_schro_frame_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) { &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" "This codec currently supports only planar YUV 4:2:0, 4:2:2"
" and 4:4:4 formats.\n"); " and 4:4:4 formats.\n");
return -1; return -1;
} }
p_schro_params->format->frame_rate_numerator = avccontext->time_base.den; p_schro_params->format->frame_rate_numerator = avctx->time_base.den;
p_schro_params->format->frame_rate_denominator = avccontext->time_base.num; p_schro_params->format->frame_rate_denominator = avctx->time_base.num;
p_schro_params->frame_size = avpicture_get_size(avccontext->pix_fmt, p_schro_params->frame_size = avpicture_get_size(avctx->pix_fmt,
avccontext->width, avctx->width,
avccontext->height); 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, schro_encoder_setting_set_double(p_schro_params->encoder,
"gop_structure", "gop_structure",
SCHRO_ENCODER_GOP_INTRA_ONLY); 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, schro_encoder_setting_set_double(p_schro_params->encoder,
"enable_noarith", 1); "enable_noarith", 1);
} else { } else {
schro_encoder_setting_set_double(p_schro_params->encoder, schro_encoder_setting_set_double(p_schro_params->encoder,
"au_distance", avccontext->gop_size); "au_distance", avctx->gop_size);
avccontext->has_b_frames = 1; avctx->has_b_frames = 1;
p_schro_params->dts = -1; p_schro_params->dts = -1;
} }
/* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */ /* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
if (avccontext->flags & CODEC_FLAG_QSCALE) { if (avctx->flags & CODEC_FLAG_QSCALE) {
if (!avccontext->global_quality) { if (!avctx->global_quality) {
/* lossless coding */ /* lossless coding */
schro_encoder_setting_set_double(p_schro_params->encoder, schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control", "rate_control",
@ -194,7 +193,7 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext)
"rate_control", "rate_control",
SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY); SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY);
quality = avccontext->global_quality / FF_QP2LAMBDA; quality = avctx->global_quality / FF_QP2LAMBDA;
if (quality > 10) if (quality > 10)
quality = 10; quality = 10;
schro_encoder_setting_set_double(p_schro_params->encoder, 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_RATE_CONTROL_CONSTANT_BITRATE);
schro_encoder_setting_set_double(p_schro_params->encoder, schro_encoder_setting_set_double(p_schro_params->encoder,
"bitrate", "bitrate", avctx->bit_rate);
avccontext->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 /* All material can be coded as interlaced or progressive
irrespective of the type of source material. */ irrespective of the type of source material. */
schro_encoder_setting_set_double(p_schro_params->encoder, schro_encoder_setting_set_double(p_schro_params->encoder,
"interlaced_coding", 1); "interlaced_coding", 1);
schro_encoder_setting_set_double(p_schro_params->encoder, "open_gop", 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 /* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
* and libdirac support other bit-depth data. */ * and libdirac support other bit-depth data. */
@ -230,7 +227,7 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext)
p_schro_params->format); p_schro_params->format);
/* Set the debug level. */ /* Set the debug level. */
schro_debug_set_level(avccontext->debug); schro_debug_set_level(avctx->debug);
schro_encoder_start(p_schro_params->encoder); schro_encoder_start(p_schro_params->encoder);
@ -239,19 +236,19 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext)
return 0; return 0;
} }
static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avccontext, static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avctx,
const AVFrame *frame) const AVFrame *frame)
{ {
SchroEncoderParams *p_schro_params = avccontext->priv_data; SchroEncoderParams *p_schro_params = avctx->priv_data;
SchroFrame *in_frame; SchroFrame *in_frame;
/* Input line size may differ from what the codec supports. Especially /* Input line size may differ from what the codec supports. Especially
* when transcoding from one format to another. So use avpicture_layout * when transcoding from one format to another. So use avpicture_layout
* to copy the frame. */ * 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) if (in_frame)
avpicture_layout((const AVPicture *)frame, avccontext->pix_fmt, avpicture_layout((const AVPicture *)frame, avctx->pix_fmt,
avccontext->width, avccontext->height, avctx->width, avctx->height,
in_frame->components[0].data, in_frame->components[0].data,
p_schro_params->frame_size); p_schro_params->frame_size);
@ -266,11 +263,11 @@ static void libschroedinger_free_frame(void *data)
av_free(enc_frame); 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) const AVFrame *frame, int *got_packet)
{ {
int enc_size = 0; int enc_size = 0;
SchroEncoderParams *p_schro_params = avccontext->priv_data; SchroEncoderParams *p_schro_params = avctx->priv_data;
SchroEncoder *encoder = p_schro_params->encoder; SchroEncoder *encoder = p_schro_params->encoder;
struct FFSchroEncodedFrame *p_frame_output = NULL; struct FFSchroEncodedFrame *p_frame_output = NULL;
int go = 1; int go = 1;
@ -288,8 +285,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk
} }
} else { } else {
/* Allocate frame data to schro input buffer. */ /* Allocate frame data to schro input buffer. */
SchroFrame *in_frame = libschroedinger_frame_from_data(avccontext, SchroFrame *in_frame = libschroedinger_frame_from_data(avctx, frame);
frame);
/* Load next frame. */ /* Load next frame. */
schro_encoder_push_frame(encoder, in_frame); schro_encoder_push_frame(encoder, in_frame);
} }
@ -361,7 +357,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pk
break; break;
default: 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; 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) if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0)
pkt_size += p_schro_params->enc_buf_size; pkt_size += p_schro_params->enc_buf_size;
if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) { 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; goto error;
} }
memcpy(pkt->data, p_frame_output->p_encbuf, p_frame_output->size); 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 /* 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 * do so since Dirac is a constant frame rate codec. It expects input
* to be of constant frame rate. */ * to be of constant frame rate. */
pkt->pts = 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++; pkt->dts = p_schro_params->dts++;
enc_size = p_frame_output->size; 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. */ /* Close the encoder. */
schro_encoder_free(p_schro_params->encoder); schro_encoder_free(p_schro_params->encoder);

Write Preview
Loading…
Cancel
Save