RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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.
This commit is contained in:
Diego Biurrun 2011-10-30 13:19:50 +01:00
parent d94c577d3c
commit 45235d69c2
9 changed files with 94 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libavcodec/libdirac.h
View File

@ -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 },

16
libavcodec/libdirac_libschro.c
View File

@ -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;

28
libavcodec/libdirac_libschro.h
View File

@ -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 */

24
libavcodec/libdiracdec.c
View File

@ -37,34 +37,34 @@
#include <libdirac_decoder/dirac_parser.h>
/** 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,

30
libavcodec/libdiracenc.c
View File

@ -38,7 +38,7 @@
#include <libdirac_encoder/dirac_encoder.h>
/** 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,

8
libavcodec/libschroedinger.c
View File

@ -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;
}
}

2
libavcodec/libschroedinger.h
View File

@ -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 },

46
libavcodec/libschroedingerdec.c
View File

@ -41,7 +41,7 @@
#include <schroedinger/schrovideoformat.h>
/** 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,

33
libavcodec/libschroedingerenc.c
View File

@ -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,