#include "avformat.h"
#include "internal.h"
#include "libavcodec/internal.h"
+#include "libavcodec/packet_internal.h"
#include "libavutil/opt.h"
#include "libavutil/dict.h"
#include "libavutil/pixdesc.h"
}
-int avformat_alloc_output_context2(AVFormatContext **avctx, ff_const59 AVOutputFormat *oformat,
+int avformat_alloc_output_context2(AVFormatContext **avctx, const AVOutputFormat *oformat,
const char *format, const char *filename)
{
AVFormatContext *s = avformat_alloc_context();
s->priv_data = NULL;
if (filename) {
-#if FF_API_FORMAT_FILENAME
-FF_DISABLE_DEPRECATION_WARNINGS
- av_strlcpy(s->filename, filename, sizeof(s->filename));
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
if (!(s->url = av_strdup(filename)))
goto nomem;
(ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
goto fail;
-#if FF_API_FORMAT_FILENAME
-FF_DISABLE_DEPRECATION_WARNINGS
- if (!s->url && !(s->url = av_strdup(s->filename))) {
-FF_ENABLE_DEPRECATION_WARNINGS
-#else
if (!s->url && !(s->url = av_strdup(""))) {
-#endif
ret = AVERROR(ENOMEM);
goto fail;
}
-#if FF_API_LAVF_AVCTX
-FF_DISABLE_DEPRECATION_WARNINGS
- if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
- if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
- av_log(s, AV_LOG_WARNING,
- "The AVFormatContext is not in set to bitexact mode, only "
- "the AVCodecContext. If this is not intended, set "
- "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
- }
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
// some sanity checks
if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
st = s->streams[i];
par = st->codecpar;
-#if FF_API_LAVF_AVCTX
-FF_DISABLE_DEPRECATION_WARNINGS
- if (st->codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN &&
- st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
- av_log(s, AV_LOG_WARNING, "Using AVStream.codec to pass codec "
- "parameters to muxers is deprecated, use AVStream.codecpar "
- "instead.\n");
- ret = avcodec_parameters_from_context(st->codecpar, st->codec);
- if (ret < 0)
- goto fail;
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
if (!st->time_base.num) {
/* fall back on the default timebase values */
if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
#define AV_PKT_FLAG_UNCODED_FRAME 0x2000
-#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
+#if FF_API_COMPUTE_PKT_FIELDS2
FF_DISABLE_DEPRECATION_WARNINGS
//FIXME merge with compute_pkt_fields
static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
case AVMEDIA_TYPE_AUDIO:
frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
(*(AVFrame **)pkt->data)->nb_samples :
- av_get_audio_frame_duration(st->codec, pkt->size);
+ av_get_audio_frame_duration2(st->codecpar, pkt->size);
/* HACK/FIXME, we skip the initial 0 size packets as they are most
* likely equal to the encoder delay, but it would be better if we
static int prepare_input_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
{
-#if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
+#if !FF_API_COMPUTE_PKT_FIELDS2
/* sanitize the timestamps */
if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
{
int ret;
- AVPacketList **next_point, *this_pktl;
+ PacketList **next_point, *this_pktl;
AVStream *st = s->streams[pkt->stream_index];
int chunked = s->max_chunk_size || s->max_chunk_duration;
- this_pktl = av_malloc(sizeof(AVPacketList));
+ this_pktl = av_malloc(sizeof(PacketList));
if (!this_pktl) {
av_packet_unref(pkt);
return AVERROR(ENOMEM);
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
AVPacket *pkt, int flush)
{
- AVPacketList *pktl;
+ PacketList *pktl;
int stream_count = 0;
int noninterleaved_count = 0;
int i, ret;
for (i = 0; i < s->nb_streams; i++) {
int64_t last_dts;
- const AVPacketList *last = s->streams[i]->internal->last_in_packet_buffer;
+ const PacketList *last = s->streams[i]->internal->last_in_packet_buffer;
if (!last)
continue;
return 0;
}
-int ff_interleaved_peek(AVFormatContext *s, int stream,
- AVPacket *pkt, int add_offset)
+const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream)
{
- AVPacketList *pktl = s->internal->packet_buffer;
+ PacketList *pktl = s->internal->packet_buffer;
while (pktl) {
if (pktl->pkt.stream_index == stream) {
- *pkt = pktl->pkt;
- if (add_offset) {
- AVStream *st = s->streams[pkt->stream_index];
- int64_t offset = st->internal->mux_ts_offset;
-
- if (s->output_ts_offset)
- offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
-
- if (pkt->dts != AV_NOPTS_VALUE)
- pkt->dts += offset;
- if (pkt->pts != AV_NOPTS_VALUE)
- pkt->pts += offset;
- }
- return 0;
+ return &pktl->pkt;
}
pktl = pktl->next;
}
- return AVERROR(ENOENT);
+ return NULL;
}
/**
guess_pkt_duration(s, st, pkt);
-#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
+#if FF_API_COMPUTE_PKT_FIELDS2
if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
return ret;
#endif
int av_write_frame(AVFormatContext *s, AVPacket *in)
{
- AVPacket local_pkt, *pkt = &local_pkt;
+ AVPacket *pkt = s->internal->pkt;
int ret;
if (!in) {
* The following avoids copying in's data unnecessarily.
* Copying side data is unavoidable as a bitstream filter
* may change it, e.g. free it on errors. */
+ av_packet_unref(pkt);
pkt->buf = NULL;
pkt->data = in->data;
pkt->size = in->size;
int av_write_trailer(AVFormatContext *s)
{
int i, ret1, ret = 0;
- AVPacket pkt = {0};
- av_init_packet(&pkt);
+ AVPacket *pkt = s->internal->pkt;
+ av_packet_unref(pkt);
for (i = 0; i < s->nb_streams; i++) {
if (s->streams[i]->internal->bsfc) {
- ret1 = write_packets_from_bsfs(s, s->streams[i], &pkt, 1/*interleaved*/);
+ ret1 = write_packets_from_bsfs(s, s->streams[i], pkt, 1/*interleaved*/);
if (ret1 < 0)
- av_packet_unref(&pkt);
+ av_packet_unref(pkt);
if (ret >= 0)
ret = ret1;
}
static int write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
AVFrame *frame, int interleaved)
{
- AVPacket pkt, *pktp;
+ AVPacket *pkt = s->internal->pkt;
av_assert0(s->oformat);
if (!s->oformat->write_uncoded_frame) {
}
if (!frame) {
- pktp = NULL;
+ pkt = NULL;
} else {
size_t bufsize = sizeof(frame) + AV_INPUT_BUFFER_PADDING_SIZE;
AVFrame **framep = av_mallocz(bufsize);
if (!framep)
goto fail;
- pktp = &pkt;
- av_init_packet(&pkt);
- pkt.buf = av_buffer_create((void *)framep, bufsize,
+ av_packet_unref(pkt);
+ pkt->buf = av_buffer_create((void *)framep, bufsize,
uncoded_frame_free, NULL, 0);
- if (!pkt.buf) {
+ if (!pkt->buf) {
av_free(framep);
fail:
av_frame_free(&frame);
}
*framep = frame;
- pkt.data = (void *)framep;
- pkt.size = sizeof(frame);
- pkt.pts =
- pkt.dts = frame->pts;
- pkt.duration = frame->pkt_duration;
- pkt.stream_index = stream_index;
- pkt.flags |= AV_PKT_FLAG_UNCODED_FRAME;
+ pkt->data = (void *)framep;
+ pkt->size = sizeof(frame);
+ pkt->pts =
+ pkt->dts = frame->pts;
+ pkt->duration = frame->pkt_duration;
+ pkt->stream_index = stream_index;
+ pkt->flags |= AV_PKT_FLAG_UNCODED_FRAME;
}
- return interleaved ? av_interleaved_write_frame(s, pktp) :
- av_write_frame(s, pktp);
+ return interleaved ? av_interleaved_write_frame(s, pkt) :
+ av_write_frame(s, pkt);
}
int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
projects / ffmpeg / blobdiff