Traneptora/FFmpeg
1
Fork 0
forked from FFmpeg/FFmpeg
Code Pull requests Activity

Merge commit '67deba8a416d818f3d95aef0aa916589090396e2'

Browse source 
* commit '67deba8a416d818f3d95aef0aa916589090396e2':
  Use avpriv_report_missing_feature() where appropriate

Merged-by: Clément Bœsch <cboesch@gopro.com>
This commit is contained in:
Clément Bœsch 2017-03-31 10:40:34 +02:00
commit e3287077ec
27 changed files with 61 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
libavcodec/alac.c
View file

@ -251,7 +251,7 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
alac->extra_bits = get_bits(&alac->gb, 2) << 3; alac->extra_bits = get_bits(&alac->gb, 2) << 3;
bps = alac->sample_size - alac->extra_bits + channels - 1; bps = alac->sample_size - alac->extra_bits + channels - 1;
if (bps > 32U) { if (bps > 32U) {
av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps); avpriv_report_missing_feature(avctx, "bps %d", bps);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -431,7 +431,7 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
break; break;
} }
if (element > TYPE_CPE && element != TYPE_LFE) { if (element > TYPE_CPE && element != TYPE_LFE) {
av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d\n", element); avpriv_report_missing_feature(avctx, "Syntax element %d", element);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -583,8 +583,8 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
avctx->channels = alac->channels; avctx->channels = alac->channels;
} }
if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) { if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) {
av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n", avpriv_report_missing_feature(avctx, "Channel count %d",
avctx->channels); avctx->channels);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1]; avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1];

3
libavcodec/bmp.c
View file

@ -100,7 +100,8 @@ static int bmp_decode_frame(AVCodecContext *avctx,
height = bytestream_get_le16(&buf); height = bytestream_get_le16(&buf);
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "unsupported BMP file, patch welcome\n"); avpriv_report_missing_feature(avctx, "Information header size %u",
ihsize);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

4
libavcodec/fraps.c
View file

@ -160,9 +160,7 @@ static int decode_frame(AVCodecContext *avctx,
header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */ header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */
if (version > 5) { if (version > 5) {
av_log(avctx, AV_LOG_ERROR, avpriv_report_missing_feature(avctx, "Fraps version %u", version);
"This file is encoded with Fraps version %u. "
"This codec can only decode versions <= 5.\n", version);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

11
libavcodec/g2meet.c
View file

@ -1442,9 +1442,8 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
} }
c->compression = bytestream2_get_be32(&bc); c->compression = bytestream2_get_be32(&bc);
if (c->compression != 2 && c->compression != 3) { if (c->compression != 2 && c->compression != 3) {
av_log(avctx, AV_LOG_ERROR, avpriv_report_missing_feature(avctx, "Compression method %d",
"Unknown compression method %d\n", c->compression);
c->compression);
ret = AVERROR_PATCHWELCOME; ret = AVERROR_PATCHWELCOME;
goto header_fail; goto header_fail;
} }
@ -1475,9 +1474,9 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
g_mask = bytestream2_get_be32(&bc); g_mask = bytestream2_get_be32(&bc);
b_mask = bytestream2_get_be32(&bc); b_mask = bytestream2_get_be32(&bc);
if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) { if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) {
av_log(avctx, AV_LOG_ERROR, avpriv_report_missing_feature(avctx,
"Invalid or unsupported bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32"\n", "Bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32,
r_mask, g_mask, b_mask); r_mask, g_mask, b_mask);
ret = AVERROR_PATCHWELCOME; ret = AVERROR_PATCHWELCOME;
goto header_fail; goto header_fail;
} }

3
libavcodec/g723_1enc.c
View file

@ -57,7 +57,8 @@ static av_cold int g723_1_encode_init(AVCodecContext *avctx)
if (avctx->bit_rate == 6300) { if (avctx->bit_rate == 6300) {
p->cur_rate = RATE_6300; p->cur_rate = RATE_6300;
} else if (avctx->bit_rate == 5300) { } else if (avctx->bit_rate == 5300) {
av_log(avctx, AV_LOG_ERROR, "Bitrate not supported yet, use 6300\n"); av_log(avctx, AV_LOG_ERROR, "Use bitrate 6300 instead of 5300.\n");
avpriv_report_missing_feature(avctx, "Bitrate 5300");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} else { } else {
av_log(avctx, AV_LOG_ERROR, "Bitrate not supported, use 6300\n"); av_log(avctx, AV_LOG_ERROR, "Bitrate not supported, use 6300\n");

4
libavcodec/h264_ps.c
View file

@ -774,8 +774,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto fail; goto fail;
} else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) { } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
av_log(avctx, AV_LOG_ERROR, avpriv_report_missing_feature(avctx,
"Unimplemented luma bit depth=%d\n", "Unimplemented luma bit depth=%d",
sps->bit_depth_luma); sps->bit_depth_luma);
ret = AVERROR_PATCHWELCOME; ret = AVERROR_PATCHWELCOME;
goto fail; goto fail;

10
libavcodec/hevc_ps_enc.c
View file

@ -90,9 +90,10 @@ int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
put_bits(&pb, 6, vps->vps_max_layer_id); put_bits(&pb, 6, vps->vps_max_layer_id);
set_ue_golomb(&pb, vps->vps_num_layer_sets - 1); set_ue_golomb(&pb, vps->vps_num_layer_sets - 1);
// writing layer_id_included_flag not supported if (vps->vps_num_layer_sets > 1) {
if (vps->vps_num_layer_sets > 1) avpriv_report_missing_feature(NULL, "Writing layer_id_included_flag");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
}
put_bits(&pb, 1, vps->vps_timing_info_present_flag); put_bits(&pb, 1, vps->vps_timing_info_present_flag);
if (vps->vps_timing_info_present_flag) { if (vps->vps_timing_info_present_flag) {
@ -102,9 +103,10 @@ int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
if (vps->vps_poc_proportional_to_timing_flag) if (vps->vps_poc_proportional_to_timing_flag)
set_ue_golomb(&pb, vps->vps_num_ticks_poc_diff_one - 1); set_ue_golomb(&pb, vps->vps_num_ticks_poc_diff_one - 1);
// writing HRD parameters not supported if (vps->vps_num_hrd_parameters) {
if (vps->vps_num_hrd_parameters) avpriv_report_missing_feature(NULL, "Writing HRD parameters");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
}
} }
put_bits(&pb, 1, 0); // extension flag put_bits(&pb, 1, 0); // extension flag

2
libavcodec/libopenjpegdec.c
View file

@ -540,7 +540,7 @@ static int libopenjpeg_decode_frame(AVCodecContext *avctx,
} }
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "unsupported pixel size %d\n", pixel_size); avpriv_report_missing_feature(avctx, "Pixel size %d", pixel_size);
ret = AVERROR_PATCHWELCOME; ret = AVERROR_PATCHWELCOME;
goto done; goto done;
} }

9
libavcodec/mjpegdec.c
View file

@ -586,13 +586,13 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
break; break;
default: default:
unk_pixfmt: unk_pixfmt:
av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x bits:%d\n", pix_fmt_id, s->bits); avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
memset(s->upscale_h, 0, sizeof(s->upscale_h)); memset(s->upscale_h, 0, sizeof(s->upscale_h));
memset(s->upscale_v, 0, sizeof(s->upscale_v)); memset(s->upscale_v, 0, sizeof(s->upscale_v));
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) { if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n"); avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (s->ls) { if (s->ls) {
@ -1483,8 +1483,9 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
len = get_bits(&s->gb, 16); len = get_bits(&s->gb, 16);
nb_components = get_bits(&s->gb, 8); nb_components = get_bits(&s->gb, 8);
if (nb_components == 0 || nb_components > MAX_COMPONENTS) { if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
av_log(s->avctx, AV_LOG_ERROR, avpriv_report_missing_feature(s->avctx,
"decode_sos: nb_components (%d) unsupported\n", nb_components); "decode_sos: nb_components (%d)",
nb_components);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (len != 6 + 2 * nb_components) { if (len != 6 + 2 * nb_components) {

2
libavcodec/opus_silk.c
View file

@ -807,7 +807,7 @@ int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
redundancy[i] = ff_opus_rc_dec_log(rc, 1); redundancy[i] = ff_opus_rc_dec_log(rc, 1);
if (redundancy[i]) { if (redundancy[i]) {
av_log(s->avctx, AV_LOG_ERROR, "LBRR frames present; this is unsupported\n"); avpriv_report_missing_feature(s->avctx, "LBRR frames");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
} }

4
libavcodec/shorten.c
View file

@ -627,8 +627,8 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
case FN_BLOCKSIZE: { case FN_BLOCKSIZE: {
unsigned blocksize = get_uint(s, av_log2(s->blocksize)); unsigned blocksize = get_uint(s, av_log2(s->blocksize));
if (blocksize > s->blocksize) { if (blocksize > s->blocksize) {
av_log(avctx, AV_LOG_ERROR, avpriv_report_missing_feature(avctx,
"Increasing block size is not supported\n"); "Increasing block size");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (!blocksize || blocksize > MAX_BLOCKSIZE) { if (!blocksize || blocksize > MAX_BLOCKSIZE) {

2
libavcodec/takdec.c
View file

@ -702,7 +702,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
if (s->ti.codec != TAK_CODEC_MONO_STEREO && if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
s->ti.codec != TAK_CODEC_MULTICHANNEL) { s->ti.codec != TAK_CODEC_MULTICHANNEL) {
av_log(avctx, AV_LOG_ERROR, "unsupported codec: %d\n", s->ti.codec); avpriv_report_missing_feature(avctx, "TAK codec type %d", s->ti.codec);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (s->ti.data_type) { if (s->ti.data_type) {

7
libavcodec/txd.c
View file

@ -56,8 +56,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
flags = bytestream2_get_byte(&gb); flags = bytestream2_get_byte(&gb);
if (version < 8 || version > 9) { if (version < 8 || version > 9) {
av_log(avctx, AV_LOG_ERROR, "texture data version %u is unsupported\n", avpriv_report_missing_feature(avctx, "Texture data version %u", version);
version);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -66,7 +65,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
} else if (depth == 16 || depth == 32) { } else if (depth == 16 || depth == 32) {
avctx->pix_fmt = AV_PIX_FMT_RGBA; avctx->pix_fmt = AV_PIX_FMT_RGBA;
} else { } else {
av_log(avctx, AV_LOG_ERROR, "depth of %u is unsupported\n", depth); avpriv_report_missing_feature(avctx, "Color depth of %u", depth);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -149,7 +148,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
return avpkt->size; return avpkt->size;
unsupported: unsupported:
av_log(avctx, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", d3d_format); avpriv_report_missing_feature(avctx, "d3d format (%08x)", d3d_format);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

2
libavcodec/vp5.c
View file

@ -53,7 +53,7 @@ static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
vp56_rac_gets(c, 2); vp56_rac_gets(c, 2);
if (vp56_rac_get(c)) { if (vp56_rac_get(c)) {
av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n"); avpriv_report_missing_feature(s->avctx, "Interlacing");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */ rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */

3
libavdevice/vfwcap.c
View file

@ -387,8 +387,7 @@ static int vfw_read_header(AVFormatContext *s)
if (par->format == AV_PIX_FMT_NONE) { if (par->format == AV_PIX_FMT_NONE) {
par->codec_id = vfw_codecid(biCompression); par->codec_id = vfw_codecid(biCompression);
if (par->codec_id == AV_CODEC_ID_NONE) { if (par->codec_id == AV_CODEC_ID_NONE) {
av_log(s, AV_LOG_ERROR, "Unknown compression type. " avpriv_report_missing_feature(s, "This compression type");
"Please report verbose (-v 9) debug information.\n");
vfw_read_close(s); vfw_read_close(s);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

2
libavdevice/xcbgrab.c
View file

@ -509,7 +509,7 @@ static int pixfmt_from_pixmap_format(AVFormatContext *s, int depth,
fmt++; fmt++;
} }
av_log(s, AV_LOG_ERROR, "Pixmap format not mappable.\n"); avpriv_report_missing_feature(s, "Mapping this pixmap format");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

3
libavformat/avienc.c
View file

@ -368,8 +368,7 @@ static int avi_write_header(AVFormatContext *s)
// XSUB subtitles behave like video tracks, other subtitles // XSUB subtitles behave like video tracks, other subtitles
// are not (yet) supported. // are not (yet) supported.
if (par->codec_id != AV_CODEC_ID_XSUB) { if (par->codec_id != AV_CODEC_ID_XSUB) {
av_log(s, AV_LOG_ERROR, avpriv_report_missing_feature(s, "Subtitle streams other than DivX XSUB");
"Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:

5
libavformat/lxfdec.c
View file

@ -181,7 +181,7 @@ static int get_packet_header(AVFormatContext *s)
st->codecpar->bits_per_coded_sample = (audio_format >> 6) & 0x3F; st->codecpar->bits_per_coded_sample = (audio_format >> 6) & 0x3F;
if (st->codecpar->bits_per_coded_sample != (audio_format & 0x3F)) { if (st->codecpar->bits_per_coded_sample != (audio_format & 0x3F)) {
av_log(s, AV_LOG_WARNING, "only tightly packed PCM currently supported\n"); avpriv_report_missing_feature(s, "Not tightly packed PCM");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -191,8 +191,7 @@ static int get_packet_header(AVFormatContext *s)
case 24: st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE_PLANAR; break; case 24: st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE_PLANAR; break;
case 32: st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE_PLANAR; break; case 32: st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE_PLANAR; break;
default: default:
av_log(s, AV_LOG_WARNING, avpriv_report_missing_feature(s, "PCM not 16-, 20-, 24- or 32-bits");
"only 16-, 20-, 24- and 32-bit PCM currently supported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

7
libavformat/matroskadec.c
View file

@ -2548,10 +2548,9 @@ static int matroska_read_header(AVFormatContext *s)
ebml.max_size > sizeof(uint64_t) || ebml.max_size > sizeof(uint64_t) ||
ebml.id_length > sizeof(uint32_t) || ebml.id_length > sizeof(uint32_t) ||
ebml.doctype_version > 3) { ebml.doctype_version > 3) {
av_log(matroska->ctx, AV_LOG_ERROR, avpriv_report_missing_feature(matroska->ctx,
"EBML header using unsupported features\n" "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
"(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n", ebml.version, ebml.doctype, ebml.doctype_version);
ebml.version, ebml.doctype, ebml.doctype_version);
ebml_free(ebml_syntax, &ebml); ebml_free(ebml_syntax, &ebml);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} else if (ebml.doctype_version == 3) { } else if (ebml.doctype_version == 3) {

2
libavformat/mpc8.c
View file

@ -239,7 +239,7 @@ static int mpc8_read_header(AVFormatContext *s)
avio_skip(pb, 4); //CRC avio_skip(pb, 4); //CRC
c->ver = avio_r8(pb); c->ver = avio_r8(pb);
if(c->ver != 8){ if(c->ver != 8){
av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver); avpriv_report_missing_feature(s, "Stream version %d", c->ver);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
c->samples = ffio_read_varlen(pb); c->samples = ffio_read_varlen(pb);

2
libavformat/rsoenc.c
View file

@ -50,7 +50,7 @@ static int rso_write_header(AVFormatContext *s)
} }
if (par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) { if (par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
av_log(s, AV_LOG_ERROR, "ADPCM in RSO not implemented\n"); avpriv_report_missing_feature(s, "ADPCM in RSO");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

2
libavformat/rtpdec_jpeg.c
View file

@ -247,7 +247,7 @@ static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,
type &= ~0x40; type &= ~0x40;
} }
if (type > 1) { if (type > 1) {
av_log(ctx, AV_LOG_ERROR, "Unimplemented RTP/JPEG type %"PRIu8"\n", type); avpriv_report_missing_feature(ctx, "RTP/JPEG type %"PRIu8, type);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

6
libavformat/rtpdec_latm.c
View file

@ -109,9 +109,9 @@ static int parse_fmtp_config(AVStream *st, const char *value)
num_layers = get_bits(&gb, 3); num_layers = get_bits(&gb, 3);
if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 || if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 ||
num_layers != 0) { num_layers != 0) {
av_log(NULL, AV_LOG_WARNING, "Unsupported LATM config (%d,%d,%d,%d)\n", avpriv_report_missing_feature(NULL, "LATM config (%d,%d,%d,%d)",
audio_mux_version, same_time_framing, audio_mux_version, same_time_framing,
num_programs, num_layers); num_programs, num_layers);
ret = AVERROR_PATCHWELCOME; ret = AVERROR_PATCHWELCOME;
goto end; goto end;
} }

14
libavformat/rtpdec_xiph.c
View file

@ -108,15 +108,14 @@ static int xiph_handle_packet(AVFormatContext *ctx, PayloadContext *data,
} }
if (ident != data->ident) { if (ident != data->ident) {
av_log(ctx, AV_LOG_ERROR, avpriv_report_missing_feature(ctx, "Xiph SDP configuration change");
"Unimplemented Xiph SDP configuration change detected\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
if (tdt) { if (tdt) {
av_log(ctx, AV_LOG_ERROR, avpriv_report_missing_feature(ctx,
"Unimplemented RTP Xiph packet settings (%d,%d,%d)\n", "RTP Xiph packet settings (%d,%d,%d)",
fragmented, tdt, num_pkts); fragmented, tdt, num_pkts);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
@ -246,9 +245,8 @@ parse_packed_headers(AVFormatContext *s,
length2 = get_base128(&packed_headers, packed_headers_end); length2 = get_base128(&packed_headers, packed_headers_end);
if (num_packed != 1 || num_headers > 3) { if (num_packed != 1 || num_headers > 3) {
av_log(s, AV_LOG_ERROR, avpriv_report_missing_feature(s, "%u packed headers, %u headers",
"Unimplemented number of headers: %u packed headers, %u headers\n", num_packed, num_headers);
num_packed, num_headers);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }

3
libavformat/rtsp.c
View file

@ -1340,8 +1340,7 @@ static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf)); ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
if (send_content_length > 0 && send_content) { if (send_content_length > 0 && send_content) {
if (rt->control_transport == RTSP_MODE_TUNNEL) { if (rt->control_transport == RTSP_MODE_TUNNEL) {
av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests " avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
"with content data not supported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
ffurl_write(rt->rtsp_hd_out, send_content, send_content_length); ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);

3
libavformat/spdifenc.c
View file

@ -470,7 +470,8 @@ static int spdif_write_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
break; break;
default: default:
av_log(s, AV_LOG_ERROR, "codec not supported\n"); avpriv_report_missing_feature(s, "Codec %d",
s->streams[0]->codecpar->codec_id);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
return 0; return 0;

3
libavformat/wvdec.c
View file

@ -98,7 +98,8 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
} }
if (wc->header.version < 0x402 || wc->header.version > 0x410) { if (wc->header.version < 0x402 || wc->header.version > 0x410) {
av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", wc->header.version); avpriv_report_missing_feature(ctx, "WV version 0x%03X",
wc->header.version);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }