From d94c577d3c61e428cfcbcd3dc3a80bd848077eae Mon Sep 17 00:00:00 2001 From: Janne Grunau Date: Sun, 30 Oct 2011 15:34:32 +0100 Subject: [PATCH 1/2] cmdutils: check fread() return value --- cmdutils.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/cmdutils.c b/cmdutils.c index ade3f10ce2..c158de36e8 100644 --- a/cmdutils.c +++ b/cmdutils.c @@ -787,6 +787,7 @@ int read_yesno(void) int read_file(const char *filename, char **bufptr, size_t *size) { + int ret; FILE *f = fopen(filename, "rb"); if (!f) { @@ -802,11 +803,22 @@ int read_file(const char *filename, char **bufptr, size_t *size) fclose(f); return AVERROR(ENOMEM); } - fread(*bufptr, 1, *size, f); - (*bufptr)[*size++] = '\0'; + ret = fread(*bufptr, 1, *size, f); + if (ret < *size) { + av_free(*bufptr); + if (ferror(f)) { + av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n", + filename, strerror(errno)); + ret = AVERROR(errno); + } else + ret = AVERROR_EOF; + } else { + ret = 0; + (*bufptr)[*size++] = '\0'; + } fclose(f); - return 0; + return ret; } void init_pts_correction(PtsCorrectionContext *ctx) From 45235d69c271966409cdd3eaa022258c22e04fdb Mon Sep 17 00:00:00 2001 From: Diego Biurrun Date: Sun, 30 Oct 2011 13:19:50 +0100 Subject: [PATCH 2/2] libdirac/libschroedinger: Drop unnecessary symbol prefixes. The names used in the libdirac/libschroedinger wrappers are long enough as-is. Bloating them with unnecessary prefixes makes them even more unwieldy. --- libavcodec/libdirac.h | 2 +- libavcodec/libdirac_libschro.c | 16 ++++++------ libavcodec/libdirac_libschro.h | 28 ++++++++++---------- libavcodec/libdiracdec.c | 24 ++++++++--------- libavcodec/libdiracenc.c | 30 ++++++++++----------- libavcodec/libschroedinger.c | 8 +++--- libavcodec/libschroedinger.h | 2 +- libavcodec/libschroedingerdec.c | 46 ++++++++++++++++----------------- libavcodec/libschroedingerenc.c | 33 ++++++++++++----------- 9 files changed, 94 insertions(+), 95 deletions(-) diff --git a/libavcodec/libdirac.h b/libavcodec/libdirac.h index 7f7912238d..e054f61a78 100644 --- a/libavcodec/libdirac.h +++ b/libavcodec/libdirac.h @@ -35,7 +35,7 @@ static const struct { enum PixelFormat ff_pix_fmt; dirac_chroma_t dirac_pix_fmt; -} ffmpeg_dirac_pixel_format_map[] = { +} dirac_pixel_format_map[] = { { PIX_FMT_YUV420P, format420 }, { PIX_FMT_YUV422P, format422 }, { PIX_FMT_YUV444P, format444 }, diff --git a/libavcodec/libdirac_libschro.c b/libavcodec/libdirac_libschro.c index 525d8663bc..45b5b83264 100644 --- a/libavcodec/libdirac_libschro.c +++ b/libavcodec/libdirac_libschro.c @@ -25,7 +25,7 @@ #include "libdirac_libschro.h" -static const FfmpegDiracSchroVideoFormatInfo ff_dirac_schro_video_format_info[] = { +static const DiracSchroVideoFormatInfo ff_dirac_schro_video_format_info[] = { { 640, 480, 24000, 1001}, { 176, 120, 15000, 1001}, { 176, 144, 25, 2 }, @@ -53,7 +53,7 @@ unsigned int ff_dirac_schro_get_video_format_idx(AVCodecContext *avccontext) sizeof(ff_dirac_schro_video_format_info[0]); for (idx = 1; idx < num_formats; ++idx) { - const FfmpegDiracSchroVideoFormatInfo *vf = &ff_dirac_schro_video_format_info[idx]; + const DiracSchroVideoFormatInfo *vf = &ff_dirac_schro_video_format_info[idx]; if (avccontext->width == vf->width && avccontext->height == vf->height) { ret_idx = idx; @@ -65,22 +65,22 @@ unsigned int ff_dirac_schro_get_video_format_idx(AVCodecContext *avccontext) return ret_idx; } -void ff_dirac_schro_queue_init(FfmpegDiracSchroQueue *queue) +void ff_dirac_schro_queue_init(DiracSchroQueue *queue) { queue->p_head = queue->p_tail = NULL; queue->size = 0; } -void ff_dirac_schro_queue_free(FfmpegDiracSchroQueue *queue, +void ff_dirac_schro_queue_free(DiracSchroQueue *queue, void (*free_func)(void *)) { while (queue->p_head) free_func(ff_dirac_schro_queue_pop(queue)); } -int ff_dirac_schro_queue_push_back(FfmpegDiracSchroQueue *queue, void *p_data) +int ff_dirac_schro_queue_push_back(DiracSchroQueue *queue, void *p_data) { - FfmpegDiracSchroQueueElement *p_new = av_mallocz(sizeof(FfmpegDiracSchroQueueElement)); + DiracSchroQueueElement *p_new = av_mallocz(sizeof(DiracSchroQueueElement)); if (!p_new) return -1; @@ -97,9 +97,9 @@ int ff_dirac_schro_queue_push_back(FfmpegDiracSchroQueue *queue, void *p_data) return 0; } -void *ff_dirac_schro_queue_pop(FfmpegDiracSchroQueue *queue) +void *ff_dirac_schro_queue_pop(DiracSchroQueue *queue) { - FfmpegDiracSchroQueueElement *top = queue->p_head; + DiracSchroQueueElement *top = queue->p_head; if (top) { void *data = top->data; diff --git a/libavcodec/libdirac_libschro.h b/libavcodec/libdirac_libschro.h index 9c2e9e7bb7..a80558f820 100644 --- a/libavcodec/libdirac_libschro.h +++ b/libavcodec/libdirac_libschro.h @@ -33,7 +33,7 @@ typedef struct { uint16_t height; uint16_t frame_rate_num; uint16_t frame_rate_denom; -} FfmpegDiracSchroVideoFormatInfo; +} DiracSchroVideoFormatInfo; /** * Returns the index into the Dirac Schro common video format info table @@ -43,7 +43,7 @@ unsigned int ff_dirac_schro_get_video_format_idx(AVCodecContext *avccontext); /** * contains a single encoded frame returned from Dirac or Schroedinger */ -typedef struct FfmpegDiracSchroEncodedFrame { +typedef struct DiracSchroEncodedFrame { /** encoded frame data */ uint8_t *p_encbuf; @@ -55,51 +55,51 @@ typedef struct FfmpegDiracSchroEncodedFrame { /** key frame flag. 1 : is key frame , 0 : in not key frame */ uint16_t key_frame; -} FfmpegDiracSchroEncodedFrame; +} DiracSchroEncodedFrame; /** * queue element */ -typedef struct FfmpegDiracSchroQueueElement { +typedef struct DiracSchroQueueElement { /** Data to be stored in queue*/ void *data; /** Pointer to next element queue */ - struct FfmpegDiracSchroQueueElement *next; -} FfmpegDiracSchroQueueElement; + struct DiracSchroQueueElement *next; +} DiracSchroQueueElement; /** * A simple queue implementation used in libdirac and libschroedinger */ -typedef struct FfmpegDiracSchroQueue { +typedef struct DiracSchroQueue { /** Pointer to head of queue */ - FfmpegDiracSchroQueueElement *p_head; + DiracSchroQueueElement *p_head; /** Pointer to tail of queue */ - FfmpegDiracSchroQueueElement *p_tail; + DiracSchroQueueElement *p_tail; /** Queue size*/ int size; -} FfmpegDiracSchroQueue; +} DiracSchroQueue; /** * Initialise the queue */ -void ff_dirac_schro_queue_init(FfmpegDiracSchroQueue *queue); +void ff_dirac_schro_queue_init(DiracSchroQueue *queue); /** * Add an element to the end of the queue */ -int ff_dirac_schro_queue_push_back(FfmpegDiracSchroQueue *queue, void *p_data); +int ff_dirac_schro_queue_push_back(DiracSchroQueue *queue, void *p_data); /** * Return the first element in the queue */ -void *ff_dirac_schro_queue_pop(FfmpegDiracSchroQueue *queue); +void *ff_dirac_schro_queue_pop(DiracSchroQueue *queue); /** * Free the queue resources. free_func is a function supplied by the caller to * free any resources allocated by the caller. The data field of the queue * element is passed to it. */ -void ff_dirac_schro_queue_free(FfmpegDiracSchroQueue *queue, +void ff_dirac_schro_queue_free(DiracSchroQueue *queue, void (*free_func)(void *)); #endif /* AVCODEC_LIBDIRAC_LIBSCHRO_H */ diff --git a/libavcodec/libdiracdec.c b/libavcodec/libdiracdec.c index 5b3ad23c63..65651711b1 100644 --- a/libavcodec/libdiracdec.c +++ b/libavcodec/libdiracdec.c @@ -37,34 +37,34 @@ #include /** contains a single frame returned from Dirac */ -typedef struct FfmpegDiracDecoderParams { +typedef struct DiracDecoderParams { /** decoder handle */ dirac_decoder_t* p_decoder; /** buffer to hold decoded frame */ unsigned char* p_out_frame_buf; -} FfmpegDiracDecoderParams; +} DiracDecoderParams; /** * returns Libav chroma format */ -static enum PixelFormat GetFfmpegChromaFormat(dirac_chroma_t dirac_pix_fmt) +static enum PixelFormat get_chroma_format(dirac_chroma_t dirac_pix_fmt) { - int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) / - sizeof(ffmpeg_dirac_pixel_format_map[0]); + int num_formats = sizeof(dirac_pixel_format_map) / + sizeof(dirac_pixel_format_map[0]); int idx; for (idx = 0; idx < num_formats; ++idx) - if (ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt == dirac_pix_fmt) - return ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt; + if (dirac_pixel_format_map[idx].dirac_pix_fmt == dirac_pix_fmt) + return dirac_pixel_format_map[idx].ff_pix_fmt; return PIX_FMT_NONE; } static av_cold int libdirac_decode_init(AVCodecContext *avccontext) { - FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data; + DiracDecoderParams *p_dirac_params = avccontext->priv_data; p_dirac_params->p_decoder = dirac_decoder_init(avccontext->debug); if (!p_dirac_params->p_decoder) @@ -80,7 +80,7 @@ static int libdirac_decode_frame(AVCodecContext *avccontext, const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; - FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data; + DiracDecoderParams *p_dirac_params = avccontext->priv_data; AVPicture *picture = data; AVPicture pic; int pict_size; @@ -117,7 +117,7 @@ static int libdirac_decode_frame(AVCodecContext *avccontext, avccontext->height = src_params->height; avccontext->width = src_params->width; - avccontext->pix_fmt = GetFfmpegChromaFormat(src_params->chroma); + avccontext->pix_fmt = get_chroma_format(src_params->chroma); if (avccontext->pix_fmt == PIX_FMT_NONE) { av_log(avccontext, AV_LOG_ERROR, "Dirac chroma format %d not supported currently\n", @@ -174,7 +174,7 @@ static int libdirac_decode_frame(AVCodecContext *avccontext, static av_cold int libdirac_decode_close(AVCodecContext *avccontext) { - FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data; + DiracDecoderParams *p_dirac_params = avccontext->priv_data; dirac_decoder_close(p_dirac_params->p_decoder); av_freep(&p_dirac_params->p_out_frame_buf); @@ -198,7 +198,7 @@ AVCodec ff_libdirac_decoder = { .name = "libdirac", .type = AVMEDIA_TYPE_VIDEO, .id = CODEC_ID_DIRAC, - .priv_data_size = sizeof(FfmpegDiracDecoderParams), + .priv_data_size = sizeof(DiracDecoderParams), .init = libdirac_decode_init, .close = libdirac_decode_close, .decode = libdirac_decode_frame, diff --git a/libavcodec/libdiracenc.c b/libavcodec/libdiracenc.c index 9d02db9e4b..33dba2236a 100644 --- a/libavcodec/libdiracenc.c +++ b/libavcodec/libdiracenc.c @@ -38,7 +38,7 @@ #include /** Dirac encoder private data */ -typedef struct FfmpegDiracEncoderParams { +typedef struct DiracEncoderParams { /** Dirac encoder context */ dirac_encoder_context_t enc_ctx; @@ -61,27 +61,27 @@ typedef struct FfmpegDiracEncoderParams { int enc_buf_size; /** queue storing encoded frames */ - FfmpegDiracSchroQueue enc_frame_queue; + DiracSchroQueue enc_frame_queue; /** end of sequence signalled by user, 0 - false, 1 - true */ int eos_signalled; /** end of sequence returned by encoder, 0 - false, 1 - true */ int eos_pulled; -} FfmpegDiracEncoderParams; +} DiracEncoderParams; /** * Works out Dirac-compatible chroma format. */ static dirac_chroma_t GetDiracChromaFormat(enum PixelFormat ff_pix_fmt) { - int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) / - sizeof(ffmpeg_dirac_pixel_format_map[0]); + int num_formats = sizeof(dirac_pixel_format_map) / + sizeof(dirac_pixel_format_map[0]); int idx; for (idx = 0; idx < num_formats; ++idx) - if (ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt) - return ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt; + if (dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt) + return dirac_pixel_format_map[idx].dirac_pix_fmt; return formatNK; } @@ -127,7 +127,7 @@ static VideoFormat GetDiracVideoFormatPreset(AVCodecContext *avccontext) static av_cold int libdirac_encode_init(AVCodecContext *avccontext) { - FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; + DiracEncoderParams* p_dirac_params = avccontext->priv_data; int no_local = 1; int verbose = avccontext->debug; VideoFormat preset; @@ -219,7 +219,7 @@ static av_cold int libdirac_encode_init(AVCodecContext *avccontext) static void DiracFreeFrame(void *data) { - FfmpegDiracSchroEncodedFrame *enc_frame = data; + DiracSchroEncodedFrame *enc_frame = data; av_freep(&(enc_frame->p_encbuf)); av_free(enc_frame); @@ -231,9 +231,9 @@ static int libdirac_encode_frame(AVCodecContext *avccontext, { int enc_size = 0; dirac_encoder_state_t state; - FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; - FfmpegDiracSchroEncodedFrame* p_frame_output = NULL; - FfmpegDiracSchroEncodedFrame* p_next_output_frame = NULL; + DiracEncoderParams *p_dirac_params = avccontext->priv_data; + DiracSchroEncodedFrame *p_frame_output = NULL; + DiracSchroEncodedFrame *p_next_output_frame = NULL; int go = 1; int last_frame_in_sequence = 0; @@ -303,7 +303,7 @@ static int libdirac_encode_frame(AVCodecContext *avccontext, break; /* create output frame */ - p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame)); + p_frame_output = av_mallocz(sizeof(DiracSchroEncodedFrame)); /* set output data */ p_frame_output->size = p_dirac_params->enc_buf_size; p_frame_output->p_encbuf = p_dirac_params->enc_buf; @@ -371,7 +371,7 @@ static int libdirac_encode_frame(AVCodecContext *avccontext, static av_cold int libdirac_encode_close(AVCodecContext *avccontext) { - FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; + DiracEncoderParams *p_dirac_params = avccontext->priv_data; /* close the encoder */ dirac_encoder_close(p_dirac_params->p_encoder); @@ -395,7 +395,7 @@ AVCodec ff_libdirac_encoder = { .name = "libdirac", .type = AVMEDIA_TYPE_VIDEO, .id = CODEC_ID_DIRAC, - .priv_data_size = sizeof(FfmpegDiracEncoderParams), + .priv_data_size = sizeof(DiracEncoderParams), .init = libdirac_encode_init, .encode = libdirac_encode_frame, .close = libdirac_encode_close, diff --git a/libavcodec/libschroedinger.c b/libavcodec/libschroedinger.c index 804d652ff7..1d31712d44 100644 --- a/libavcodec/libschroedinger.c +++ b/libavcodec/libschroedinger.c @@ -64,14 +64,14 @@ SchroVideoFormatEnum ff_get_schro_video_format_preset(AVCodecContext *avccontext int ff_get_schro_frame_format (SchroChromaFormat schro_pix_fmt, SchroFrameFormat *schro_frame_fmt) { - unsigned int num_formats = sizeof(ffmpeg_schro_pixel_format_map) / - sizeof(ffmpeg_schro_pixel_format_map[0]); + unsigned int num_formats = sizeof(schro_pixel_format_map) / + sizeof(schro_pixel_format_map[0]); int idx; for (idx = 0; idx < num_formats; ++idx) { - if (ffmpeg_schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) { - *schro_frame_fmt = ffmpeg_schro_pixel_format_map[idx].schro_frame_fmt; + if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) { + *schro_frame_fmt = schro_pixel_format_map[idx].schro_frame_fmt; return 0; } } diff --git a/libavcodec/libschroedinger.h b/libavcodec/libschroedinger.h index c9e2a5ecb0..c6ae5ea642 100644 --- a/libavcodec/libschroedinger.h +++ b/libavcodec/libschroedinger.h @@ -34,7 +34,7 @@ static const struct { enum PixelFormat ff_pix_fmt; SchroChromaFormat schro_pix_fmt; SchroFrameFormat schro_frame_fmt; -} ffmpeg_schro_pixel_format_map[] = { +} schro_pixel_format_map[] = { { PIX_FMT_YUV420P, SCHRO_CHROMA_420, SCHRO_FRAME_FORMAT_U8_420 }, { PIX_FMT_YUV422P, SCHRO_CHROMA_422, SCHRO_FRAME_FORMAT_U8_422 }, { PIX_FMT_YUV444P, SCHRO_CHROMA_444, SCHRO_FRAME_FORMAT_U8_444 }, diff --git a/libavcodec/libschroedingerdec.c b/libavcodec/libschroedingerdec.c index a9c1ca40f5..184e8cb42b 100644 --- a/libavcodec/libschroedingerdec.c +++ b/libavcodec/libschroedingerdec.c @@ -41,7 +41,7 @@ #include /** libschroedinger decoder private data */ -typedef struct FfmpegSchroDecoderParams { +typedef struct SchroDecoderParams { /** Schroedinger video format */ SchroVideoFormat *format; @@ -52,7 +52,7 @@ typedef struct FfmpegSchroDecoderParams { SchroDecoder* decoder; /** queue storing decoded frames */ - FfmpegDiracSchroQueue dec_frame_queue; + DiracSchroQueue dec_frame_queue; /** end of sequence signalled */ int eos_signalled; @@ -62,25 +62,25 @@ typedef struct FfmpegSchroDecoderParams { /** decoded picture */ AVPicture dec_pic; -} FfmpegSchroDecoderParams; +} SchroDecoderParams; -typedef struct FfmpegSchroParseUnitContext { +typedef struct SchroParseUnitContext { const uint8_t *buf; int buf_size; -} FfmpegSchroParseUnitContext; +} SchroParseUnitContext; static void libschroedinger_decode_buffer_free(SchroBuffer *schro_buf, void *priv); -static void FfmpegSchroParseContextInit(FfmpegSchroParseUnitContext *parse_ctx, - const uint8_t *buf, int buf_size) +static void SchroParseContextInit(SchroParseUnitContext *parse_ctx, + const uint8_t *buf, int buf_size) { parse_ctx->buf = buf; parse_ctx->buf_size = buf_size; } -static SchroBuffer* FfmpegFindNextSchroParseUnit(FfmpegSchroParseUnitContext *parse_ctx) +static SchroBuffer *FindNextSchroParseUnit(SchroParseUnitContext *parse_ctx) { SchroBuffer *enc_buf = NULL; int next_pu_offset = 0; @@ -120,22 +120,22 @@ static SchroBuffer* FfmpegFindNextSchroParseUnit(FfmpegSchroParseUnitContext *pa /** * Returns Libav chroma format. */ -static enum PixelFormat GetFfmpegChromaFormat(SchroChromaFormat schro_pix_fmt) +static enum PixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt) { - int num_formats = sizeof(ffmpeg_schro_pixel_format_map) / - sizeof(ffmpeg_schro_pixel_format_map[0]); + int num_formats = sizeof(schro_pixel_format_map) / + sizeof(schro_pixel_format_map[0]); int idx; for (idx = 0; idx < num_formats; ++idx) - if (ffmpeg_schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) - return ffmpeg_schro_pixel_format_map[idx].ff_pix_fmt; + if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) + return schro_pixel_format_map[idx].ff_pix_fmt; return PIX_FMT_NONE; } static av_cold int libschroedinger_decode_init(AVCodecContext *avccontext) { - FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avccontext->priv_data; /* First of all, initialize our supporting libraries. */ schro_init(); @@ -164,7 +164,7 @@ static void libschroedinger_decode_frame_free(void *frame) static void libschroedinger_handle_first_access_unit(AVCodecContext *avccontext) { - FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avccontext->priv_data; SchroDecoder *decoder = p_schro_params->decoder; p_schro_params->format = schro_decoder_get_video_format(decoder); @@ -179,7 +179,7 @@ static void libschroedinger_handle_first_access_unit(AVCodecContext *avccontext) } avccontext->height = p_schro_params->format->height; avccontext->width = p_schro_params->format->width; - avccontext->pix_fmt = GetFfmpegChromaFormat(p_schro_params->format->chroma_format); + avccontext->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) { @@ -206,7 +206,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; - FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avccontext->priv_data; SchroDecoder *decoder = p_schro_params->decoder; AVPicture *picture = data; SchroBuffer *enc_buf; @@ -214,11 +214,11 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, int state; int go = 1; int outer = 1; - FfmpegSchroParseUnitContext parse_ctx; + SchroParseUnitContext parse_ctx; *data_size = 0; - FfmpegSchroParseContextInit(&parse_ctx, buf, buf_size); + SchroParseContextInit(&parse_ctx, buf, buf_size); if (!buf_size) { if (!p_schro_params->eos_signalled) { state = schro_decoder_push_end_of_stream(decoder); @@ -228,7 +228,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, /* Loop through all the individual parse units in the input buffer */ do { - if ((enc_buf = FfmpegFindNextSchroParseUnit(&parse_ctx))) { + if ((enc_buf = FindNextSchroParseUnit(&parse_ctx))) { /* Push buffer into decoder. */ if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) && SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0) @@ -314,7 +314,7 @@ static int libschroedinger_decode_frame(AVCodecContext *avccontext, static av_cold int libschroedinger_decode_close(AVCodecContext *avccontext) { - FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avccontext->priv_data; /* Free the decoder. */ schro_decoder_free(p_schro_params->decoder); av_freep(&p_schro_params->format); @@ -332,7 +332,7 @@ static void libschroedinger_flush(AVCodecContext *avccontext) { /* Got a seek request. Free the decoded frames queue and then reset * the decoder */ - FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data; + SchroDecoderParams *p_schro_params = avccontext->priv_data; /* Free data in the output frame queue. */ ff_dirac_schro_queue_free(&p_schro_params->dec_frame_queue, @@ -348,7 +348,7 @@ AVCodec ff_libschroedinger_decoder = { .name = "libschroedinger", .type = AVMEDIA_TYPE_VIDEO, .id = CODEC_ID_DIRAC, - .priv_data_size = sizeof(FfmpegSchroDecoderParams), + .priv_data_size = sizeof(SchroDecoderParams), .init = libschroedinger_decode_init, .close = libschroedinger_decode_close, .decode = libschroedinger_decode_frame, diff --git a/libavcodec/libschroedingerenc.c b/libavcodec/libschroedingerenc.c index 43494a17cb..dec9c2a37e 100644 --- a/libavcodec/libschroedingerenc.c +++ b/libavcodec/libschroedingerenc.c @@ -41,7 +41,7 @@ /** libschroedinger encoder private data */ -typedef struct FfmpegSchroEncoderParams { +typedef struct SchroEncoderParams { /** Schroedinger video format */ SchroVideoFormat *format; @@ -64,31 +64,31 @@ typedef struct FfmpegSchroEncoderParams { int enc_buf_size; /** queue storing encoded frames */ - FfmpegDiracSchroQueue enc_frame_queue; + DiracSchroQueue enc_frame_queue; /** end of sequence signalled */ int eos_signalled; /** end of sequence pulled */ int eos_pulled; -} FfmpegSchroEncoderParams; +} SchroEncoderParams; /** * Works out Schro-compatible chroma format. */ static int SetSchroChromaFormat(AVCodecContext *avccontext) { - int num_formats = sizeof(ffmpeg_schro_pixel_format_map) / - sizeof(ffmpeg_schro_pixel_format_map[0]); + int num_formats = sizeof(schro_pixel_format_map) / + sizeof(schro_pixel_format_map[0]); int idx; - FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avccontext->priv_data; for (idx = 0; idx < num_formats; ++idx) { - if (ffmpeg_schro_pixel_format_map[idx].ff_pix_fmt == + if (schro_pixel_format_map[idx].ff_pix_fmt == avccontext->pix_fmt) { p_schro_params->format->chroma_format = - ffmpeg_schro_pixel_format_map[idx].schro_pix_fmt; + schro_pixel_format_map[idx].schro_pix_fmt; return 0; } } @@ -102,7 +102,7 @@ static int SetSchroChromaFormat(AVCodecContext *avccontext) static int libschroedinger_encode_init(AVCodecContext *avccontext) { - FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avccontext->priv_data; SchroVideoFormatEnum preset; /* Initialize the libraries that libschroedinger depends on. */ @@ -238,7 +238,7 @@ static int libschroedinger_encode_init(AVCodecContext *avccontext) static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avccontext, void *in_data) { - FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avccontext->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 @@ -256,7 +256,7 @@ static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avccontext, static void SchroedingerFreeFrame(void *data) { - FfmpegDiracSchroEncodedFrame *enc_frame = data; + DiracSchroEncodedFrame *enc_frame = data; av_freep(&(enc_frame->p_encbuf)); av_free(enc_frame); @@ -267,9 +267,9 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, int buf_size, void *data) { int enc_size = 0; - FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avccontext->priv_data; SchroEncoder *encoder = p_schro_params->encoder; - struct FfmpegDiracSchroEncodedFrame* p_frame_output = NULL; + struct DiracSchroEncodedFrame *p_frame_output = NULL; int go = 1; SchroBuffer *enc_buf; int presentation_frame; @@ -328,7 +328,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, } /* Create output frame. */ - p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame)); + p_frame_output = av_mallocz(sizeof(DiracSchroEncodedFrame)); /* Set output data. */ p_frame_output->size = p_schro_params->enc_buf_size; p_frame_output->p_encbuf = p_schro_params->enc_buf; @@ -400,8 +400,7 @@ static int libschroedinger_encode_frame(AVCodecContext *avccontext, static int libschroedinger_encode_close(AVCodecContext *avccontext) { - - FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data; + SchroEncoderParams *p_schro_params = avccontext->priv_data; /* Close the encoder. */ schro_encoder_free(p_schro_params->encoder); @@ -426,7 +425,7 @@ AVCodec ff_libschroedinger_encoder = { .name = "libschroedinger", .type = AVMEDIA_TYPE_VIDEO, .id = CODEC_ID_DIRAC, - .priv_data_size = sizeof(FfmpegSchroEncoderParams), + .priv_data_size = sizeof(SchroEncoderParams), .init = libschroedinger_encode_init, .encode = libschroedinger_encode_frame, .close = libschroedinger_encode_close,