* Encoders:
* The encoder needs to be fed with NULL data at the end of encoding until the
* encoder no longer returns data.
+ *
+ * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
+ * flag also means that the encoder must set the pts and duration for
+ * each output packet. If this flag is not set, the pts and duration will
+ * be determined by libavcodec from the input frame.
*/
#define CODEC_CAP_DELAY 0x0020
/**
* Codec supports avctx->thread_count == 0 (auto).
*/
#define CODEC_CAP_AUTO_THREADS 0x8000
+/**
+ * Audio encoder supports receiving a different number of samples in each call.
+ */
+#define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
//The following defines may change, don't expect compatibility if you use them.
#define MB_TYPE_INTRA4x4 0x0001
* Initialize codec static data, called from avcodec_register().
*/
void (*init_static_data)(struct AVCodec *codec);
+
+ /**
+ * Encode data to an AVPacket.
+ *
+ * @param avctx codec context
+ * @param avpkt output AVPacket (may contain a user-provided buffer)
+ * @param[in] frame AVFrame containing the raw data to be encoded
+ * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
+ * non-empty packet was returned in avpkt.
+ * @return 0 on success, negative error code on failure
+ */
+ int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
+ int *got_packet_ptr);
} AVCodec;
/**
*/
void avsubtitle_free(AVSubtitle *sub);
+#if FF_API_OLD_ENCODE_AUDIO
/**
* Encode an audio frame from samples into buf.
*
+ * @deprecated Use avcodec_encode_audio2 instead.
+ *
* @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
* However, for codecs with avctx->frame_size equal to 0 (e.g. PCM) the user
* will know how much space is needed because it depends on the value passed
* @return On error a negative value is returned, on success zero or the number
* of bytes used to encode the data read from the input buffer.
*/
-int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
- const short *samples);
+int attribute_deprecated avcodec_encode_audio(AVCodecContext *avctx,
+ uint8_t *buf, int buf_size,
+ const short *samples);
+#endif
+
+/**
+ * Encode a frame of audio.
+ *
+ * Takes input samples from frame and writes the next output packet, if
+ * available, to avpkt. The output packet does not necessarily contain data for
+ * the most recent frame, as encoders can delay, split, and combine input frames
+ * internally as needed.
+ *
+ * @param avctx codec context
+ * @param avpkt output AVPacket.
+ * The user can supply an output buffer by setting
+ * avpkt->data and avpkt->size prior to calling the
+ * function, but if the size of the user-provided data is not
+ * large enough, encoding will fail. All other AVPacket fields
+ * will be reset by the encoder using av_init_packet(). If
+ * avpkt->data is NULL, the encoder will allocate it.
+ * The encoder will set avpkt->size to the size of the
+ * output packet.
+ * @param[in] frame AVFrame containing the raw audio data to be encoded.
+ * May be NULL when flushing an encoder that has the
+ * CODEC_CAP_DELAY capability set.
+ * There are 2 codec capabilities that affect the allowed
+ * values of frame->nb_samples.
+ * If CODEC_CAP_SMALL_LAST_FRAME is set, then only the final
+ * frame may be smaller than avctx->frame_size, and all other
+ * frames must be equal to avctx->frame_size.
+ * If CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
+ * can have any number of samples.
+ * If neither is set, frame->nb_samples must be equal to
+ * avctx->frame_size for all frames.
+ * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
+ * output packet is non-empty, and to 0 if it is
+ * empty. If the function returns an error, the
+ * packet can be assumed to be invalid, and the
+ * value of got_packet_ptr is undefined and should
+ * not be used.
+ * @return 0 on success, negative error code on failure
+ */
+int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
+ const AVFrame *frame, int *got_packet_ptr);
/**
* Fill audio frame data and linesize.
* utils.
*/
+#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/crc.h"
#include "libavutil/mathematics.h"
dsputil_static_init();
}
+static av_always_inline int codec_is_encoder(AVCodec *codec)
+{
+ return codec && (codec->encode || codec->encode2);
+}
+
+static av_always_inline int codec_is_decoder(AVCodec *codec)
+{
+ return codec && codec->decode;
+}
+
void avcodec_register(AVCodec *codec)
{
AVCodec **p;
/* if the decoder init function was already called previously,
free the already allocated subtitle_header before overwriting it */
- if (codec->decode)
+ if (codec_is_decoder(codec))
av_freep(&avctx->subtitle_header);
#define SANE_NB_CHANNELS 128U
ret = AVERROR(EINVAL);
goto free_and_end;
}
- if (avctx->codec->encode) {
+ if (codec_is_encoder(avctx->codec)) {
int i;
if (avctx->codec->sample_fmts) {
for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)
goto end;
}
-int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
- const short *samples)
+int ff_alloc_packet(AVPacket *avpkt, int size)
{
- if(buf_size < FF_MIN_BUFFER_SIZE && 0){
- av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
- return -1;
+ if (size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
+ return AVERROR(EINVAL);
+
+ if (avpkt->data) {
+ uint8_t *pkt_data;
+ int pkt_size;
+
+ if (avpkt->size < size)
+ return AVERROR(EINVAL);
+
+ pkt_data = avpkt->data;
+ pkt_size = avpkt->size;
+ av_init_packet(avpkt);
+ avpkt->data = pkt_data;
+ avpkt->size = pkt_size;
+ return 0;
+ } else {
+ return av_new_packet(avpkt, size);
}
- if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
- int ret = avctx->codec->encode(avctx, buf, buf_size, samples);
- avctx->frame_number++;
- return ret;
- }else
+}
+
+int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
+ AVPacket *avpkt,
+ const AVFrame *frame,
+ int *got_packet_ptr)
+{
+ int ret;
+ int user_packet = !!avpkt->data;
+ int nb_samples;
+
+ if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
+ av_init_packet(avpkt);
+ avpkt->size = 0;
return 0;
+ }
+
+ /* check for valid frame size */
+ if (frame) {
+ nb_samples = frame->nb_samples;
+ if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
+ if (nb_samples > avctx->frame_size)
+ return AVERROR(EINVAL);
+ } else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
+ if (nb_samples != avctx->frame_size)
+ return AVERROR(EINVAL);
+ }
+ } else {
+ nb_samples = avctx->frame_size;
+ }
+
+ if (avctx->codec->encode2) {
+ *got_packet_ptr = 0;
+ ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
+ if (!ret && *got_packet_ptr &&
+ !(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
+ avpkt->pts = frame->pts;
+ avpkt->duration = av_rescale_q(frame->nb_samples,
+ (AVRational){ 1, avctx->sample_rate },
+ avctx->time_base);
+ }
+ } else {
+ /* for compatibility with encoders not supporting encode2(), we need to
+ allocate a packet buffer if the user has not provided one or check
+ the size otherwise */
+ int fs_tmp = 0;
+ int buf_size = avpkt->size;
+ if (!user_packet) {
+ if (avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) {
+ av_assert0(av_get_bits_per_sample(avctx->codec_id) != 0);
+ buf_size = nb_samples * avctx->channels *
+ av_get_bits_per_sample(avctx->codec_id) / 8;
+ } else {
+ /* this is a guess as to the required size.
+ if an encoder needs more than this, it should probably
+ implement encode2() */
+ buf_size = 2 * avctx->frame_size * avctx->channels *
+ av_get_bytes_per_sample(avctx->sample_fmt);
+ buf_size += FF_MIN_BUFFER_SIZE;
+ }
+ }
+ if ((ret = ff_alloc_packet(avpkt, buf_size)))
+ return ret;
+
+ /* Encoders using AVCodec.encode() that support
+ CODEC_CAP_SMALL_LAST_FRAME require avctx->frame_size to be set to
+ the smaller size when encoding the last frame.
+ This code can be removed once all encoders supporting
+ CODEC_CAP_SMALL_LAST_FRAME use encode2() */
+ if ((avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) &&
+ nb_samples < avctx->frame_size) {
+ fs_tmp = avctx->frame_size;
+ avctx->frame_size = nb_samples;
+ }
+
+ /* encode the frame */
+ ret = avctx->codec->encode(avctx, avpkt->data, avpkt->size,
+ frame ? frame->data[0] : NULL);
+ if (ret >= 0) {
+ if (!ret) {
+ /* no output. if the packet data was allocated by libavcodec,
+ free it */
+ if (!user_packet)
+ av_freep(&avpkt->data);
+ } else {
+ if (avctx->coded_frame)
+ avpkt->pts = avctx->coded_frame->pts;
+ /* Set duration for final small packet. This can be removed
+ once all encoders supporting CODEC_CAP_SMALL_LAST_FRAME use
+ encode2() */
+ if (fs_tmp) {
+ avpkt->duration = av_rescale_q(avctx->frame_size,
+ (AVRational){ 1, avctx->sample_rate },
+ avctx->time_base);
+ }
+ }
+ avpkt->size = ret;
+ *got_packet_ptr = (ret > 0);
+ ret = 0;
+ }
+
+ if (fs_tmp)
+ avctx->frame_size = fs_tmp;
+ }
+ if (!ret)
+ avctx->frame_number++;
+
+ /* NOTE: if we add any audio encoders which output non-keyframe packets,
+ this needs to be moved to the encoders, but for now we can do it
+ here to simplify things */
+ avpkt->flags |= AV_PKT_FLAG_KEY;
+
+ return ret;
+}
+
+#if FF_API_OLD_DECODE_AUDIO
+int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
+ uint8_t *buf, int buf_size,
+ const short *samples)
+{
+ AVPacket pkt;
+ AVFrame frame0;
+ AVFrame *frame;
+ int ret, samples_size, got_packet;
+
+ av_init_packet(&pkt);
+ pkt.data = buf;
+ pkt.size = buf_size;
+
+ if (samples) {
+ frame = &frame0;
+ avcodec_get_frame_defaults(frame);
+
+ if (avctx->frame_size) {
+ frame->nb_samples = avctx->frame_size;
+ } else {
+ /* if frame_size is not set, the number of samples must be
+ calculated from the buffer size */
+ int64_t nb_samples;
+ if (!av_get_bits_per_sample(avctx->codec_id)) {
+ av_log(avctx, AV_LOG_ERROR, "avcodec_encode_audio() does not "
+ "support this codec\n");
+ return AVERROR(EINVAL);
+ }
+ nb_samples = (int64_t)buf_size * 8 /
+ (av_get_bits_per_sample(avctx->codec_id) *
+ avctx->channels);
+ if (nb_samples >= INT_MAX)
+ return AVERROR(EINVAL);
+ frame->nb_samples = nb_samples;
+ }
+
+ /* it is assumed that the samples buffer is large enough based on the
+ relevant parameters */
+ samples_size = av_samples_get_buffer_size(NULL, avctx->channels,
+ frame->nb_samples,
+ avctx->sample_fmt, 1);
+ if ((ret = avcodec_fill_audio_frame(frame, avctx->channels,
+ avctx->sample_fmt,
+ samples, samples_size, 1)))
+ return ret;
+
+ /* fabricate frame pts from sample count.
+ this is needed because the avcodec_encode_audio() API does not have
+ a way for the user to provide pts */
+ frame->pts = av_rescale_q(avctx->internal->sample_count,
+ (AVRational){ 1, avctx->sample_rate },
+ avctx->time_base);
+ avctx->internal->sample_count += frame->nb_samples;
+ } else {
+ frame = NULL;
+ }
+
+ got_packet = 0;
+ ret = avcodec_encode_audio2(avctx, &pkt, frame, &got_packet);
+ if (!ret && got_packet && avctx->coded_frame) {
+ avctx->coded_frame->pts = pkt.pts;
+ avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
+ }
+ /* free any side data since we cannot return it */
+ if (pkt.side_data_elems > 0) {
+ int i;
+ for (i = 0; i < pkt.side_data_elems; i++)
+ av_free(pkt.side_data[i].data);
+ av_freep(&pkt.side_data);
+ pkt.side_data_elems = 0;
+ }
+
+ if (frame && frame->extended_data != frame->data)
+ av_free(frame->extended_data);
+
+ return ret ? ret : pkt.size;
}
+#endif
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
const AVFrame *pict)
av_opt_free(avctx->priv_data);
av_opt_free(avctx);
av_freep(&avctx->priv_data);
- if(avctx->codec && avctx->codec->encode)
+ if (codec_is_encoder(avctx->codec))
av_freep(&avctx->extradata);
avctx->codec = NULL;
avctx->active_thread_type = 0;
AVCodec *p, *experimental=NULL;
p = first_avcodec;
while (p) {
- if (p->encode != NULL && p->id == id) {
+ if (codec_is_encoder(p) && p->id == id) {
if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
experimental = p;
} else
return NULL;
p = first_avcodec;
while (p) {
- if (p->encode != NULL && strcmp(name,p->name) == 0)
+ if (codec_is_encoder(p) && strcmp(name,p->name) == 0)
return p;
p = p->next;
}
AVCodec *p;
p = first_avcodec;
while (p) {
- if (p->decode != NULL && p->id == id)
+ if (codec_is_decoder(p) && p->id == id)
return p;
p = p->next;
}
return NULL;
p = first_avcodec;
while (p) {
- if (p->decode != NULL && strcmp(name,p->name) == 0)
+ if (codec_is_decoder(p) && strcmp(name,p->name) == 0)
return p;
p = p->next;
}
projects / ffmpeg / commitdiff