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

avformat/mux: Add flag for "only default codecs allowed"

Browse Source 
AVOutputFormat has default codecs for audio, video and subtitle
and often these are the only codecs of this type allowed.
So add a flag to AVOutputFormat so that this can be checked generically.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
release/7.0
Andreas Rheinhardt 11 months ago
parent 03b04eef72
commit a24bccc238
27 changed files with 72 additions and 169 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. 17
      libavformat/ac4enc.c
  2. 7
      libavformat/adtsenc.c
  3. 8
      libavformat/aeaenc.c
  4. 9
      libavformat/alp.c
  5. 9
      libavformat/amvenc.c
  6. 9
      libavformat/apm.c
  7. 9
      libavformat/apngenc.c
  8. 9
      libavformat/argo_asf.c
  9. 9
      libavformat/argo_cvg.c
  10. 7
      libavformat/assenc.c
  11. 5
      libavformat/bit.c
  12. 12
      libavformat/codec2.c
  13. 9
      libavformat/gif.c
  14. 8
      libavformat/ilbc.c
  15. 9
      libavformat/kvag.c
  16. 8
      libavformat/microdvdenc.c
  17. 11
      libavformat/mux.c
  18. 9
      libavformat/mux.h
  19. 2
      libavformat/mux_utils.c
  20. 8
      libavformat/rcwtenc.c
  21. 9
      libavformat/sccenc.c
  22. 8
      libavformat/ttmlenc.c
  23. 7
      libavformat/vc1testenc.c
  24. 10
      libavformat/webpenc.c
  25. 9
      libavformat/webvttenc.c
  26. 10
      libavformat/westwood_audenc.c
  27. 14
      libavformat/wvenc.c

17
libavformat/ac4enc.c
Unescape View File

@ -19,7 +19,6 @@
*/ */
#include "libavcodec/codec_id.h" #include "libavcodec/codec_id.h"
#include "libavcodec/codec_par.h"
#include "libavcodec/packet.h" #include "libavcodec/packet.h"
#include "libavutil/crc.h" #include "libavutil/crc.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
@ -31,18 +30,6 @@ typedef struct AC4Context {
int write_crc; int write_crc;
} AC4Context; } AC4Context;
static int ac4_init(AVFormatContext *s)
{
AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_AC4) {
av_log(s, AV_LOG_ERROR, "Only one AC-4 stream can be muxed by the AC-4 muxer\n");
return AVERROR(EINVAL);
}
return 0;
}
static int ac4_write_packet(AVFormatContext *s, AVPacket *pkt) static int ac4_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AC4Context *ac4 = s->priv_data; AC4Context *ac4 = s->priv_data;
@ -96,8 +83,8 @@ const FFOutputFormat ff_ac4_muxer = {
.p.audio_codec = AV_CODEC_ID_AC4, .p.audio_codec = AV_CODEC_ID_AC4,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
.init = ac4_init, FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_packet = ac4_write_packet, .write_packet = ac4_write_packet,
.p.priv_class = &ac4_muxer_class, .p.priv_class = &ac4_muxer_class,
.p.flags = AVFMT_NOTIMESTAMPS, .p.flags = AVFMT_NOTIMESTAMPS,

7
libavformat/adtsenc.c
Unescape View File

@ -106,10 +106,6 @@ static int adts_init(AVFormatContext *s)
ADTSContext *adts = s->priv_data; ADTSContext *adts = s->priv_data;
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_AAC) {
av_log(s, AV_LOG_ERROR, "Only AAC streams can be muxed by the ADTS muxer\n");
return AVERROR(EINVAL);
}
if (par->extradata_size > 0) if (par->extradata_size > 0)
return adts_decode_extradata(s, adts, par->extradata, return adts_decode_extradata(s, adts, par->extradata,
par->extradata_size); par->extradata_size);
@ -242,7 +238,8 @@ const FFOutputFormat ff_adts_muxer = {
.p.audio_codec = AV_CODEC_ID_AAC, .p.audio_codec = AV_CODEC_ID_AAC,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = adts_init, .init = adts_init,
.write_header = adts_write_header, .write_header = adts_write_header,
.write_packet = adts_write_packet, .write_packet = adts_write_packet,

8
libavformat/aeaenc.c
Unescape View File

@ -37,11 +37,6 @@ static int aea_write_header(AVFormatContext *s)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (st->codecpar->codec_id != AV_CODEC_ID_ATRAC1) {
av_log(s, AV_LOG_ERROR, "AEA can only store ATRAC1 streams, %s was found.\n", avcodec_get_name(st->codecpar->codec_id));
return AVERROR(EINVAL);
}
if (st->codecpar->sample_rate != 44100) { if (st->codecpar->sample_rate != 44100) {
av_log(s, AV_LOG_ERROR, "Invalid sample rate (%d) AEA only supports 44.1kHz.\n", st->codecpar->sample_rate); av_log(s, AV_LOG_ERROR, "Invalid sample rate (%d) AEA only supports 44.1kHz.\n", st->codecpar->sample_rate);
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -105,7 +100,8 @@ const FFOutputFormat ff_aea_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = aea_write_header, .write_header = aea_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,
.write_trailer = aea_write_trailer, .write_trailer = aea_write_trailer,

9
libavformat/alp.c
Unescape View File

@ -191,12 +191,6 @@ static int alp_write_init(AVFormatContext *s)
par = s->streams[0]->codecpar; par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ADPCM_IMA_ALP) {
av_log(s, AV_LOG_ERROR, "%s codec not supported\n",
avcodec_get_name(par->codec_id));
return AVERROR(EINVAL);
}
if (par->ch_layout.nb_channels > 2) { if (par->ch_layout.nb_channels > 2) {
av_log(s, AV_LOG_ERROR, "A maximum of 2 channels are supported\n"); av_log(s, AV_LOG_ERROR, "A maximum of 2 channels are supported\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -295,7 +289,8 @@ const FFOutputFormat ff_alp_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.p.priv_class = &alp_muxer_class, .p.priv_class = &alp_muxer_class,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = alp_write_init, .init = alp_write_init,
.write_header = alp_write_header, .write_header = alp_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,

9
libavformat/amvenc.c
Unescape View File

@ -113,11 +113,7 @@ static av_cold int amv_init(AVFormatContext *s)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (ast->codecpar->codec_id != AV_CODEC_ID_ADPCM_IMA_AMV) { av_assert1(ast->codecpar->codec_id == AV_CODEC_ID_ADPCM_IMA_AMV);
av_log(s, AV_LOG_ERROR, "Second AMV stream must be %s\n",
avcodec_get_name(AV_CODEC_ID_ADPCM_IMA_AMV));
return AVERROR(EINVAL);
}
/* These files are broken-enough as they are. They shouldn't be streamed. */ /* These files are broken-enough as they are. They shouldn't be streamed. */
if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) { if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
@ -411,7 +407,8 @@ const FFOutputFormat ff_amv_muxer = {
.p.audio_codec = AV_CODEC_ID_ADPCM_IMA_AMV, .p.audio_codec = AV_CODEC_ID_ADPCM_IMA_AMV,
.p.video_codec = AV_CODEC_ID_AMV, .p.video_codec = AV_CODEC_ID_AMV,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = amv_init, .init = amv_init,
.deinit = amv_deinit, .deinit = amv_deinit,
.write_header = amv_write_header, .write_header = amv_write_header,

9
libavformat/apm.c
Unescape View File

@ -217,12 +217,6 @@ static int apm_write_init(AVFormatContext *s)
{ {
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ADPCM_IMA_APM) {
av_log(s, AV_LOG_ERROR, "%s codec not supported\n",
avcodec_get_name(par->codec_id));
return AVERROR(EINVAL);
}
if (par->ch_layout.nb_channels > 2) { if (par->ch_layout.nb_channels > 2) {
av_log(s, AV_LOG_ERROR, "APM files only support up to 2 channels\n"); av_log(s, AV_LOG_ERROR, "APM files only support up to 2 channels\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -305,7 +299,8 @@ const FFOutputFormat ff_apm_muxer = {
.p.audio_codec = AV_CODEC_ID_ADPCM_IMA_APM, .p.audio_codec = AV_CODEC_ID_ADPCM_IMA_APM,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = apm_write_init, .init = apm_write_init,
.write_header = apm_write_header, .write_header = apm_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,

9
libavformat/apngenc.c
Unescape View File

@ -84,12 +84,6 @@ static int apng_write_header(AVFormatContext *format_context)
APNGMuxContext *apng = format_context->priv_data; APNGMuxContext *apng = format_context->priv_data;
AVCodecParameters *par = format_context->streams[0]->codecpar; AVCodecParameters *par = format_context->streams[0]->codecpar;
if (format_context->streams[0]->codecpar->codec_id != AV_CODEC_ID_APNG) {
av_log(format_context, AV_LOG_ERROR,
"APNG muxer supports only a single video APNG stream.\n");
return AVERROR(EINVAL);
}
if (apng->last_delay.num > UINT16_MAX || apng->last_delay.den > UINT16_MAX) { if (apng->last_delay.num > UINT16_MAX || apng->last_delay.den > UINT16_MAX) {
av_reduce(&apng->last_delay.num, &apng->last_delay.den, av_reduce(&apng->last_delay.num, &apng->last_delay.den,
apng->last_delay.num, apng->last_delay.den, UINT16_MAX); apng->last_delay.num, apng->last_delay.den, UINT16_MAX);
@ -314,7 +308,8 @@ const FFOutputFormat ff_apng_muxer = {
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.video_codec = AV_CODEC_ID_APNG, .p.video_codec = AV_CODEC_ID_APNG,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = apng_write_header, .write_header = apng_write_header,
.write_packet = apng_write_packet, .write_packet = apng_write_packet,
.write_trailer = apng_write_trailer, .write_trailer = apng_write_trailer,

9
libavformat/argo_asf.c
Unescape View File

@ -290,12 +290,6 @@ static int argo_asf_write_init(AVFormatContext *s)
ArgoASFMuxContext *ctx = s->priv_data; ArgoASFMuxContext *ctx = s->priv_data;
const AVCodecParameters *par = s->streams[0]->codecpar; const AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ADPCM_ARGO) {
av_log(s, AV_LOG_ERROR, "%s codec not supported\n",
avcodec_get_name(par->codec_id));
return AVERROR(EINVAL);
}
if (ctx->version_major == 1 && ctx->version_minor == 1 && par->sample_rate != 22050) { if (ctx->version_major == 1 && ctx->version_minor == 1 && par->sample_rate != 22050) {
av_log(s, AV_LOG_ERROR, "ASF v1.1 files only support a sample rate of 22050\n"); av_log(s, AV_LOG_ERROR, "ASF v1.1 files only support a sample rate of 22050\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -476,7 +470,8 @@ const FFOutputFormat ff_argo_asf_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.p.priv_class = &argo_asf_muxer_class, .p.priv_class = &argo_asf_muxer_class,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = argo_asf_write_init, .init = argo_asf_write_init,
.write_header = argo_asf_write_header, .write_header = argo_asf_write_header,
.write_packet = argo_asf_write_packet, .write_packet = argo_asf_write_packet,

9
libavformat/argo_cvg.c
Unescape View File

@ -271,12 +271,6 @@ static int argo_cvg_write_init(AVFormatContext *s)
ArgoCVGMuxContext *ctx = s->priv_data; ArgoCVGMuxContext *ctx = s->priv_data;
const AVCodecParameters *par = s->streams[0]->codecpar; const AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ADPCM_PSX) {
av_log(s, AV_LOG_ERROR, "%s codec not supported\n",
avcodec_get_name(par->codec_id));
return AVERROR(EINVAL);
}
if (par->ch_layout.nb_channels != 1) { if (par->ch_layout.nb_channels != 1) {
av_log(s, AV_LOG_ERROR, "CVG files only support 1 channel\n"); av_log(s, AV_LOG_ERROR, "CVG files only support 1 channel\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -403,7 +397,8 @@ const FFOutputFormat ff_argo_cvg_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.p.priv_class = &argo_cvg_muxer_class, .p.priv_class = &argo_cvg_muxer_class,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = argo_cvg_write_init, .init = argo_cvg_write_init,
.write_header = argo_cvg_write_header, .write_header = argo_cvg_write_header,
.write_packet = argo_cvg_write_packet, .write_packet = argo_cvg_write_packet,

7
libavformat/assenc.c
Unescape View File

@ -50,10 +50,6 @@ static int write_header(AVFormatContext *s)
ASSContext *ass = s->priv_data; ASSContext *ass = s->priv_data;
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ASS) {
av_log(s, AV_LOG_ERROR, "Exactly one ASS/SSA stream is needed.\n");
return AVERROR(EINVAL);
}
avpriv_set_pts_info(s->streams[0], 64, 1, 100); avpriv_set_pts_info(s->streams[0], 64, 1, 100);
if (par->extradata_size > 0) { if (par->extradata_size > 0) {
size_t header_size = par->extradata_size; size_t header_size = par->extradata_size;
@ -241,7 +237,8 @@ const FFOutputFormat ff_ass_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_ASS, .p.subtitle_codec = AV_CODEC_ID_ASS,
.p.flags = AVFMT_GLOBALHEADER | AVFMT_NOTIMESTAMPS | AVFMT_TS_NONSTRICT, .p.flags = AVFMT_GLOBALHEADER | AVFMT_NOTIMESTAMPS | AVFMT_TS_NONSTRICT,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.p.priv_class = &ass_class, .p.priv_class = &ass_class,
.priv_data_size = sizeof(ASSContext), .priv_data_size = sizeof(ASSContext),
.write_header = write_header, .write_header = write_header,

5
libavformat/bit.c
Unescape View File

@ -129,7 +129,7 @@ static int write_header(AVFormatContext *s)
{ {
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if ((par->codec_id != AV_CODEC_ID_G729) || par->ch_layout.nb_channels != 1) { if (par->ch_layout.nb_channels != 1) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"only codec g729 with 1 channel is supported by this format\n"); "only codec g729 with 1 channel is supported by this format\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -168,7 +168,8 @@ const FFOutputFormat ff_bit_muxer = {
.p.audio_codec = AV_CODEC_ID_G729, .p.audio_codec = AV_CODEC_ID_G729,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = write_header, .write_header = write_header,
.write_packet = write_packet, .write_packet = write_packet,
}; };

12
libavformat/codec2.c
Unescape View File

@ -214,14 +214,7 @@ static int codec2_read_packet(AVFormatContext *s, AVPacket *pkt)
static int codec2_write_header(AVFormatContext *s) static int codec2_write_header(AVFormatContext *s)
{ {
AVStream *st; AVStream *st = s->streams[0];
if (s->streams[0]->codecpar->codec_id != AV_CODEC_ID_CODEC2) {
av_log(s, AV_LOG_ERROR, ".c2 files must have exactly one codec2 stream\n");
return AVERROR(EINVAL);
}
st = s->streams[0];
if (st->codecpar->extradata_size != CODEC2_EXTRADATA_SIZE) { if (st->codecpar->extradata_size != CODEC2_EXTRADATA_SIZE) {
av_log(s, AV_LOG_ERROR, ".c2 files require exactly %i bytes of extradata (got %i)\n", av_log(s, AV_LOG_ERROR, ".c2 files require exactly %i bytes of extradata (got %i)\n",
@ -319,7 +312,8 @@ const FFOutputFormat ff_codec2_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.p.flags = AVFMT_NOTIMESTAMPS, .p.flags = AVFMT_NOTIMESTAMPS,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = codec2_write_header, .write_header = codec2_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,
}; };

9
libavformat/gif.c
Unescape View File

@ -42,12 +42,6 @@ typedef struct GIFContext {
static int gif_write_header(AVFormatContext *s) static int gif_write_header(AVFormatContext *s)
{ {
if (s->streams[0]->codecpar->codec_id != AV_CODEC_ID_GIF) {
av_log(s, AV_LOG_ERROR,
"GIF muxer supports only a single video GIF stream.\n");
return AVERROR(EINVAL);
}
avpriv_set_pts_info(s->streams[0], 64, 1, 100); avpriv_set_pts_info(s->streams[0], 64, 1, 100);
return 0; return 0;
@ -212,7 +206,8 @@ const FFOutputFormat ff_gif_muxer = {
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.video_codec = AV_CODEC_ID_GIF, .p.video_codec = AV_CODEC_ID_GIF,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = gif_write_header, .write_header = gif_write_header,
.write_packet = gif_write_packet, .write_packet = gif_write_packet,
.write_trailer = gif_write_trailer, .write_trailer = gif_write_trailer,

8
libavformat/ilbc.c
Unescape View File

@ -35,11 +35,6 @@ static int ilbc_write_header(AVFormatContext *s)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ILBC) {
av_log(s, AV_LOG_ERROR, "Unsupported codec\n");
return AVERROR(EINVAL);
}
if (par->block_align == 50) { if (par->block_align == 50) {
avio_write(pb, mode30_header, sizeof(mode30_header) - 1); avio_write(pb, mode30_header, sizeof(mode30_header) - 1);
} else if (par->block_align == 38) { } else if (par->block_align == 38) {
@ -125,7 +120,8 @@ const FFOutputFormat ff_ilbc_muxer = {
.p.audio_codec = AV_CODEC_ID_ILBC, .p.audio_codec = AV_CODEC_ID_ILBC,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.p.flags = AVFMT_NOTIMESTAMPS, .p.flags = AVFMT_NOTIMESTAMPS,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = ilbc_write_header, .write_header = ilbc_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,
}; };

9
libavformat/kvag.c
Unescape View File

@ -131,12 +131,6 @@ static int kvag_write_init(AVFormatContext *s)
{ {
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
if (par->codec_id != AV_CODEC_ID_ADPCM_IMA_SSI) {
av_log(s, AV_LOG_ERROR, "%s codec not supported\n",
avcodec_get_name(par->codec_id));
return AVERROR(EINVAL);
}
if (par->ch_layout.nb_channels > 2) { if (par->ch_layout.nb_channels > 2) {
av_log(s, AV_LOG_ERROR, "KVAG files only support up to 2 channels\n"); av_log(s, AV_LOG_ERROR, "KVAG files only support up to 2 channels\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -190,7 +184,8 @@ const FFOutputFormat ff_kvag_muxer = {
.p.audio_codec = AV_CODEC_ID_ADPCM_IMA_SSI, .p.audio_codec = AV_CODEC_ID_ADPCM_IMA_SSI,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.init = kvag_write_init, .init = kvag_write_init,
.write_header = kvag_write_header, .write_header = kvag_write_header,
.write_packet = ff_raw_write_packet, .write_packet = ff_raw_write_packet,

8
libavformat/microdvdenc.c
Unescape View File

@ -29,11 +29,6 @@ static int microdvd_write_header(struct AVFormatContext *s)
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
AVRational framerate = s->streams[0]->avg_frame_rate; AVRational framerate = s->streams[0]->avg_frame_rate;
if (par->codec_id != AV_CODEC_ID_MICRODVD) {
av_log(s, AV_LOG_ERROR, "Exactly one MicroDVD stream is needed.\n");
return -1;
}
if (par->extradata && par->extradata_size > 0) { if (par->extradata && par->extradata_size > 0) {
avio_write(s->pb, "{DEFAULT}{}", 11); avio_write(s->pb, "{DEFAULT}{}", 11);
avio_write(s->pb, par->extradata, par->extradata_size); avio_write(s->pb, par->extradata, par->extradata_size);
@ -65,7 +60,8 @@ const FFOutputFormat ff_microdvd_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_MICRODVD, .p.subtitle_codec = AV_CODEC_ID_MICRODVD,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = microdvd_write_header, .write_header = microdvd_write_header,
.write_packet = microdvd_write_packet, .write_packet = microdvd_write_packet,
}; };

11
libavformat/mux.c
Unescape View File

@ -268,7 +268,7 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options)
} }
break; break;
} }
if (of->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH) { if (of->flags_internal & (FF_OFMT_FLAG_MAX_ONE_OF_EACH | FF_OFMT_FLAG_ONLY_DEFAULT_CODECS)) {
enum AVCodecID default_codec_id = AV_CODEC_ID_NONE; enum AVCodecID default_codec_id = AV_CODEC_ID_NONE;
unsigned nb; unsigned nb;
if ((unsigned)par->codec_type < FF_ARRAY_ELEMS(default_codec_offsets)) { if ((unsigned)par->codec_type < FF_ARRAY_ELEMS(default_codec_offsets)) {
@ -276,7 +276,14 @@ static int init_muxer(AVFormatContext *s, AVDictionary **options)
if (default_codec_offsets[par->codec_type]) if (default_codec_offsets[par->codec_type])
default_codec_id = *(const enum AVCodecID*)((const char*)of + default_codec_offsets[par->codec_type]); default_codec_id = *(const enum AVCodecID*)((const char*)of + default_codec_offsets[par->codec_type]);
} }
if (default_codec_id == AV_CODEC_ID_NONE || nb > 1) { if (of->flags_internal & FF_OFMT_FLAG_ONLY_DEFAULT_CODECS &&
default_codec_id != AV_CODEC_ID_NONE && par->codec_id != default_codec_id) {
av_log(s, AV_LOG_ERROR, "%s muxer supports only codec %s for type %s\n",
of->p.name, avcodec_get_name(default_codec_id), av_get_media_type_string(par->codec_type));
ret = AVERROR(EINVAL);
goto fail;
} else if (default_codec_id == AV_CODEC_ID_NONE ||
(of->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH && nb > 1)) {
const char *type = av_get_media_type_string(par->codec_type); const char *type = av_get_media_type_string(par->codec_type);
av_log(s, AV_LOG_ERROR, "%s muxer does not support %s stream of type %s\n", av_log(s, AV_LOG_ERROR, "%s muxer does not support %s stream of type %s\n",
of->p.name, default_codec_id == AV_CODEC_ID_NONE ? "any" : "more than one", of->p.name, default_codec_id == AV_CODEC_ID_NONE ? "any" : "more than one",

9
libavformat/mux.h
Unescape View File

@ -48,6 +48,15 @@ struct AVDeviceInfoList;
* the actual muxer's init/write_header callbacks. * the actual muxer's init/write_header callbacks.
*/ */
#define FF_OFMT_FLAG_MAX_ONE_OF_EACH (1 << 2) #define FF_OFMT_FLAG_MAX_ONE_OF_EACH (1 << 2)
/**
* If this flag is set, then the only permitted audio/video/subtitle
* codec ids are AVOutputFormat.audio/video/subtitle_codec;
* if any of the latter is unset (i.e. equal to AV_CODEC_ID_NONE),
* then no stream of the corresponding type is supported.
* In addition, codec types without default codec field
* are disallowed.
*/
#define FF_OFMT_FLAG_ONLY_DEFAULT_CODECS (1 << 3)
typedef struct FFOutputFormat { typedef struct FFOutputFormat {
/** /**

2
libavformat/mux_utils.c
Unescape View File

@ -44,6 +44,8 @@ int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
codec_id == ofmt->audio_codec || codec_id == ofmt->audio_codec ||
codec_id == ofmt->subtitle_codec)) codec_id == ofmt->subtitle_codec))
return 1; return 1;
else if (ffofmt(ofmt)->flags_internal & FF_OFMT_FLAG_ONLY_DEFAULT_CODECS)
return 0;
else if (ffofmt(ofmt)->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH) { else if (ffofmt(ofmt)->flags_internal & FF_OFMT_FLAG_MAX_ONE_OF_EACH) {
enum AVMediaType type = avcodec_get_type(codec_id); enum AVMediaType type = avcodec_get_type(codec_id);
switch (type) { switch (type) {

8
libavformat/rcwtenc.c
Unescape View File

@ -84,11 +84,6 @@ static void rcwt_flush_cluster(AVFormatContext *avf)
static int rcwt_write_header(AVFormatContext *avf) static int rcwt_write_header(AVFormatContext *avf)
{ {
if (avf->streams[0]->codecpar->codec_id != AV_CODEC_ID_EIA_608) {
av_log(avf, AV_LOG_ERROR, "RCWT supports only CC (608/708)\n");
return AVERROR(EINVAL);
}
avpriv_set_pts_info(avf->streams[0], 64, 1, 1000); avpriv_set_pts_info(avf->streams[0], 64, 1, 1000);
/* magic number */ /* magic number */
@ -169,7 +164,8 @@ const FFOutputFormat ff_rcwt_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_EIA_608, .p.subtitle_codec = AV_CODEC_ID_EIA_608,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.priv_data_size = sizeof(RCWTContext), .priv_data_size = sizeof(RCWTContext),
.write_header = rcwt_write_header, .write_header = rcwt_write_header,
.write_packet = rcwt_write_packet, .write_packet = rcwt_write_packet,

9
libavformat/sccenc.c
Unescape View File

@ -35,12 +35,6 @@ static int scc_write_header(AVFormatContext *avf)
{ {
SCCContext *scc = avf->priv_data; SCCContext *scc = avf->priv_data;
if (avf->streams[0]->codecpar->codec_id != AV_CODEC_ID_EIA_608) {
av_log(avf, AV_LOG_ERROR,
"Unsupported subtitles codec: %s\n",
avcodec_get_name(avf->streams[0]->codecpar->codec_id));
return AVERROR(EINVAL);
}
avpriv_set_pts_info(avf->streams[0], 64, 1, 1000); avpriv_set_pts_info(avf->streams[0], 64, 1, 1000);
avio_printf(avf->pb, "Scenarist_SCC V1.0\n"); avio_printf(avf->pb, "Scenarist_SCC V1.0\n");
@ -114,7 +108,8 @@ const FFOutputFormat ff_scc_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_EIA_608, .p.subtitle_codec = AV_CODEC_ID_EIA_608,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.priv_data_size = sizeof(SCCContext), .priv_data_size = sizeof(SCCContext),
.write_header = scc_write_header, .write_header = scc_write_header,
.write_packet = scc_write_packet, .write_packet = scc_write_packet,

8
libavformat/ttmlenc.c
Unescape View File

@ -126,11 +126,6 @@ static int ttml_write_header(AVFormatContext *ctx)
TTMLMuxContext *ttml_ctx = ctx->priv_data; TTMLMuxContext *ttml_ctx = ctx->priv_data;
ttml_ctx->document_written = 0; ttml_ctx->document_written = 0;
if (ctx->streams[0]->codecpar->codec_id != AV_CODEC_ID_TTML) {
av_log(ctx, AV_LOG_ERROR, "Exactly one TTML stream is required!\n");
return AVERROR(EINVAL);
}
{ {
AVStream *st = ctx->streams[0]; AVStream *st = ctx->streams[0];
AVIOContext *pb = ctx->pb; AVIOContext *pb = ctx->pb;
@ -226,7 +221,8 @@ const FFOutputFormat ff_ttml_muxer = {
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.audio_codec = AV_CODEC_ID_NONE, .p.audio_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_TTML, .p.subtitle_codec = AV_CODEC_ID_TTML,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
.write_header = ttml_write_header, .write_header = ttml_write_header,
.write_packet = ttml_write_packet, .write_packet = ttml_write_packet,
.write_trailer = ttml_write_trailer, .write_trailer = ttml_write_trailer,

7
libavformat/vc1testenc.c
Unescape View File

@ -31,10 +31,6 @@ static int vc1test_write_header(AVFormatContext *s)
AVCodecParameters *par = s->streams[0]->codecpar; AVCodecParameters *par = s->streams[0]->codecpar;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
if (par->codec_id != AV_CODEC_ID_WMV3) {
av_log(s, AV_LOG_ERROR, "Only WMV3 is accepted!\n");
return -1;
}
avio_wl24(pb, 0); //frames count will be here avio_wl24(pb, 0); //frames count will be here
avio_w8(pb, 0xC5); avio_w8(pb, 0xC5);
avio_wl32(pb, 4); avio_wl32(pb, 4);
@ -92,5 +88,6 @@ const FFOutputFormat ff_vc1t_muxer = {
.write_header = vc1test_write_header, .write_header = vc1test_write_header,
.write_packet = vc1test_write_packet, .write_packet = vc1test_write_packet,
.write_trailer = vc1test_write_trailer, .write_trailer = vc1test_write_trailer,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
}; };

10
libavformat/webpenc.c
Unescape View File

@ -38,15 +38,10 @@ typedef struct WebpContext{
static int webp_init(AVFormatContext *s) static int webp_init(AVFormatContext *s)
{ {
WebpContext *const w = s->priv_data; WebpContext *const w = s->priv_data;
AVStream *st; AVStream *st = s->streams[0];
w->last_pkt = ffformatcontext(s)->pkt; w->last_pkt = ffformatcontext(s)->pkt;
st = s->streams[0];
if (st->codecpar->codec_id != AV_CODEC_ID_WEBP) {
av_log(s, AV_LOG_ERROR, "Only WebP is supported\n");
return AVERROR(EINVAL);
}
avpriv_set_pts_info(st, 24, 1, 1000); avpriv_set_pts_info(st, 24, 1, 1000);
return 0; return 0;
@ -233,5 +228,6 @@ const FFOutputFormat ff_webp_muxer = {
.write_trailer = webp_write_trailer, .write_trailer = webp_write_trailer,
.p.priv_class = &webp_muxer_class, .p.priv_class = &webp_muxer_class,
.p.flags = AVFMT_VARIABLE_FPS, .p.flags = AVFMT_VARIABLE_FPS,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
}; };

9
libavformat/webvttenc.c
Unescape View File

@ -47,14 +47,8 @@ static void webvtt_write_time(AVIOContext *pb, int64_t millisec)
static int webvtt_write_header(AVFormatContext *ctx) static int webvtt_write_header(AVFormatContext *ctx)
{ {
AVStream *s = ctx->streams[0]; AVStream *s = ctx->streams[0];
AVCodecParameters *par = ctx->streams[0]->codecpar;
AVIOContext *pb = ctx->pb; AVIOContext *pb = ctx->pb;
if (par->codec_id != AV_CODEC_ID_WEBVTT) {
av_log(ctx, AV_LOG_ERROR, "Exactly one WebVTT stream is needed.\n");
return AVERROR(EINVAL);
}
avpriv_set_pts_info(s, 64, 1, 1000); avpriv_set_pts_info(s, 64, 1, 1000);
avio_printf(pb, "WEBVTT\n"); avio_printf(pb, "WEBVTT\n");
@ -114,5 +108,6 @@ const FFOutputFormat ff_webvtt_muxer = {
.p.subtitle_codec = AV_CODEC_ID_WEBVTT, .p.subtitle_codec = AV_CODEC_ID_WEBVTT,
.write_header = webvtt_write_header, .write_header = webvtt_write_header,
.write_packet = webvtt_write_packet, .write_packet = webvtt_write_packet,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
}; };

10
libavformat/westwood_audenc.c
Unescape View File

@ -43,7 +43,6 @@ typedef struct AUDMuxContext {
static int wsaud_write_init(AVFormatContext *ctx) static int wsaud_write_init(AVFormatContext *ctx)
{ {
AVStream *st = ctx->streams[0];
AVIOContext *pb = ctx->pb; AVIOContext *pb = ctx->pb;
/* Stream must be seekable to correctly write the file. */ /* Stream must be seekable to correctly write the file. */
@ -53,12 +52,6 @@ static int wsaud_write_init(AVFormatContext *ctx)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (st->codecpar->codec_id != AV_CODEC_ID_ADPCM_IMA_WS) {
av_log(ctx, AV_LOG_ERROR, "%s codec not supported for Westwood AUD.\n",
avcodec_get_name(st->codecpar->codec_id));
return AVERROR(EINVAL);
}
return 0; return 0;
} }
@ -133,5 +126,6 @@ const FFOutputFormat ff_wsaud_muxer = {
.write_header = wsaud_write_header, .write_header = wsaud_write_header,
.write_packet = wsaud_write_packet, .write_packet = wsaud_write_packet,
.write_trailer = wsaud_write_trailer, .write_trailer = wsaud_write_trailer,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
}; };

14
libavformat/wvenc.c
Unescape View File

@ -31,16 +31,6 @@ typedef struct WvMuxContext {
int64_t samples; int64_t samples;
} WvMuxContext; } WvMuxContext;
static av_cold int wv_init(AVFormatContext *ctx)
{
if (ctx->streams[0]->codecpar->codec_id != AV_CODEC_ID_WAVPACK) {
av_log(ctx, AV_LOG_ERROR, "This muxer only supports a single WavPack stream.\n");
return AVERROR(EINVAL);
}
return 0;
}
static int wv_write_packet(AVFormatContext *ctx, AVPacket *pkt) static int wv_write_packet(AVFormatContext *ctx, AVPacket *pkt)
{ {
WvMuxContext *s = ctx->priv_data; WvMuxContext *s = ctx->priv_data;
@ -85,9 +75,9 @@ const FFOutputFormat ff_wv_muxer = {
.p.audio_codec = AV_CODEC_ID_WAVPACK, .p.audio_codec = AV_CODEC_ID_WAVPACK,
.p.video_codec = AV_CODEC_ID_NONE, .p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE, .p.subtitle_codec = AV_CODEC_ID_NONE,
.init = wv_init,
.write_packet = wv_write_packet, .write_packet = wv_write_packet,
.write_trailer = wv_write_trailer, .write_trailer = wv_write_trailer,
.p.flags = AVFMT_NOTIMESTAMPS, .p.flags = AVFMT_NOTIMESTAMPS,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
}; };

Write Preview
Loading…
Cancel
Save