Use avpriv_report_missing_feature() where appropriate
authorDiego Biurrun <diego@biurrun.de>
Wed, 16 Dec 2015 17:01:34 +0000 (18:01 +0100)
committerDiego Biurrun <diego@biurrun.de>
Tue, 8 Nov 2016 16:54:34 +0000 (17:54 +0100)
33 files changed:
libavcodec/aacdec.c
libavcodec/alac.c
libavcodec/bmp.c
libavcodec/fraps.c
libavcodec/g2meet.c
libavcodec/g723_1enc.c
libavcodec/h264_ps.c
libavcodec/hevc_ps.c
libavcodec/hevc_ps_enc.c
libavcodec/libopenjpegdec.c
libavcodec/libopusenc.c
libavcodec/mjpegdec.c
libavcodec/opus_silk.c
libavcodec/shorten.c
libavcodec/takdec.c
libavcodec/txd.c
libavcodec/vp5.c
libavcodec/xwddec.c
libavdevice/vfwcap.c
libavdevice/xcbgrab.c
libavformat/avienc.c
libavformat/lxfdec.c
libavformat/matroskadec.c
libavformat/mpc8.c
libavformat/oggparseopus.c
libavformat/qcp.c
libavformat/rsoenc.c
libavformat/rtpdec_jpeg.c
libavformat/rtpdec_latm.c
libavformat/rtpdec_xiph.c
libavformat/rtsp.c
libavformat/spdifenc.c
libavformat/wvdec.c

index 6a06062c53448e7bb60fd07bc4168788f95a36c4..22ebcdc5705699f130edbf024763785c896cd43a 100644 (file)
@@ -1246,8 +1246,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
                 return AVERROR_INVALIDDATA;
             } else {
                 if (aot == AOT_ER_AAC_LD) {
-                    av_log(ac->avctx, AV_LOG_ERROR,
-                           "LTP in ER AAC LD not yet implemented.\n");
+                    avpriv_report_missing_feature(ac->avctx, "LTP in ER AAC LD");
                     return AVERROR_PATCHWELCOME;
                 }
                 if ((ics->ltp.present = get_bits(gb, 1)))
index 0d2a7ca01df443b593e21f1979765495d85e9b6a..83d777c760a8d6742e8b5698ae819df1e3e00ceb 100644 (file)
@@ -266,7 +266,7 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
     alac->extra_bits = get_bits(&alac->gb, 2) << 3;
     bps = alac->sample_size - alac->extra_bits + channels - 1;
     if (bps > 32) {
-        av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps);
+        avpriv_report_missing_feature(avctx, "bps %d", bps);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -424,7 +424,7 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
             break;
         }
         if (element > TYPE_CPE && element != TYPE_LFE) {
-            av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d", element);
+            avpriv_report_missing_feature(avctx, "Syntax element %d", element);
             return AVERROR_PATCHWELCOME;
         }
 
@@ -568,8 +568,8 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
             avctx->channels = alac->channels;
     }
     if (avctx->channels > ALAC_MAX_CHANNELS) {
-        av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",
-               avctx->channels);
+        avpriv_report_missing_feature(avctx, "Channel count %d",
+                                      avctx->channels);
         return AVERROR_PATCHWELCOME;
     }
     avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1];
index 648fa68e1ff7c5b551e173ff05143ea38afa3d45..5c7acb6e72d2585bc337f5ba121f42b6327f9053 100644 (file)
@@ -98,7 +98,8 @@ static int bmp_decode_frame(AVCodecContext *avctx,
         height = bytestream_get_le16(&buf);
         break;
     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;
     }
 
index c4ec23e2811ada690b78461e656f41bb9743b317..55051ffe7e1624abed58ad58cb68990747cd2ac1 100644 (file)
@@ -163,9 +163,7 @@ static int decode_frame(AVCodecContext *avctx,
     prev_pic_bit = header & (1U << 31); /* bit 31 means same as previous pic */
 
     if (version > 5) {
-        av_log(avctx, AV_LOG_ERROR,
-               "This file is encoded with Fraps version %u. "
-               "This codec can only decode versions <= 5.\n", version);
+        avpriv_report_missing_feature(avctx, "Fraps version %u", version);
         return AVERROR_PATCHWELCOME;
     }
 
index a89610d6c3a931c60215cba82da6c946c11361ba..7e90916274dd99e7f00b7d44c3bb60612fd49bd2 100644 (file)
@@ -1424,9 +1424,8 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
             }
             c->compression = bytestream2_get_be32(&bc);
             if (c->compression != 2 && c->compression != 3) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "Unknown compression method %d\n",
-                       c->compression);
+                avpriv_report_missing_feature(avctx, "Compression method %d",
+                                              c->compression);
                 return AVERROR_PATCHWELCOME;
             }
             c->tile_width  = bytestream2_get_be32(&bc);
@@ -1453,9 +1452,9 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
                 g_mask = bytestream2_get_be32(&bc);
                 b_mask = bytestream2_get_be32(&bc);
                 if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Invalid or unsupported bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32"\n",
-                           r_mask, g_mask, b_mask);
+                    avpriv_report_missing_feature(avctx,
+                                                  "Bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32,
+                                                  r_mask, g_mask, b_mask);
                     return AVERROR_PATCHWELCOME;
                 }
             } else {
index 1ebd46541662144dacfc995e8249c541e7ef6e02..82f5cecfa248c2cadec033af59e2cad6e0411efd 100644 (file)
@@ -57,7 +57,8 @@ static av_cold int g723_1_encode_init(AVCodecContext *avctx)
     if (avctx->bit_rate == 6300) {
         p->cur_rate = RATE_6300;
     } 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;
     } else {
         av_log(avctx, AV_LOG_ERROR, "Bitrate not supported, use 6300\n");
index 36902e8e7704fe2c35b34e19d8946407153ab8b2..37c3be1cb99afef712f87baf9a28e3a068be130f 100644 (file)
@@ -700,9 +700,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
     sps = (SPS*)ps->sps_list[pps->sps_id]->data;
 
     if (sps->bit_depth_luma > 10) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Unimplemented luma bit depth=%d (max=10)\n",
-               sps->bit_depth_luma);
+        avpriv_report_missing_feature(avctx, "Luma bit depth=%d (max=10)",
+                                      sps->bit_depth_luma);
         ret = AVERROR_PATCHWELCOME;
         goto fail;
     }
index 6a8cfebaf76d368244bc534ead2cd200513cf8ae..c28e86b34a100804991f1c927f526e71cc28c857 100644 (file)
@@ -657,13 +657,12 @@ static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
         case 9:  sps->pix_fmt = AV_PIX_FMT_YUV420P9;  break;
         case 10: sps->pix_fmt = AV_PIX_FMT_YUV420P10; break;
         default:
-            av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n",
-                   sps->bit_depth);
+            avpriv_report_missing_feature(avctx, "Bit depth %d",
+                                          sps->bit_depth);
             return AVERROR_PATCHWELCOME;
         }
     } else {
-        av_log(avctx, AV_LOG_ERROR,
-               "non-4:2:0 support is currently unspecified.\n");
+        avpriv_report_missing_feature(avctx, "Non-4:2:0 support");
         return AVERROR_PATCHWELCOME;
     }
 
index 1e86757d7c3da2bccb55e54d41a04ad5703c41f3..4864e6ebfc6fa7be152413398ad8e760028cc668 100644 (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);
     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;
+    }
 
     put_bits(&pb, 1, 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)
             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;
+        }
     }
 
     put_bits(&pb, 1, 0);    // extension flag
index 401ea9b801ed51668bdff51477af7860d1ce2526..6b8e210ac69e534f4cf836000d74f8a1493854bc 100644 (file)
@@ -396,7 +396,7 @@ static int libopenjpeg_decode_frame(AVCodecContext *avctx,
         }
         break;
     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;
         goto done;
     }
index 1fb597bd3385f8cda79e7f59a1467053a45bce8f..500e58c85e3de55bf1454ac214d803396aaa58d8 100644 (file)
@@ -164,8 +164,9 @@ static int av_cold libopus_encode_init(AVCodecContext *avctx)
     /* FIXME: Opus can handle up to 255 channels. However, the mapping for
      * anything greater than 8 is undefined. */
     if (avctx->channels > 8) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Channel layout undefined for %d channels.\n", avctx->channels);
+        avpriv_report_missing_feature(avctx,
+                                      "Undefined channel layout for %d channels",
+                                      avctx->channels);
         return AVERROR_PATCHWELCOME;
     }
     if (!avctx->bit_rate) {
index c670f357c9e0d3efd225b6cbf7312c596cae6b48..a4a6c63411d82305c6e0a1c163be28eb98121e92 100644 (file)
@@ -373,7 +373,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
         break;
     default:
-        av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
+        avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x", pix_fmt_id);
         return AVERROR_PATCHWELCOME;
     }
     if (s->ls) {
@@ -1035,8 +1035,9 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
     len = get_bits(&s->gb, 16);
     nb_components = get_bits(&s->gb, 8);
     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
-        av_log(s->avctx, AV_LOG_ERROR,
-               "decode_sos: nb_components (%d) unsupported\n", nb_components);
+        avpriv_report_missing_feature(s->avctx,
+                                      "decode_sos: nb_components (%d)",
+                                      nb_components);
         return AVERROR_PATCHWELCOME;
     }
     if (len != 6 + 2 * nb_components) {
index d83fb373c6de65f96f6042955efefff675088518..5db1b26c6f8074eb12711b3664e0e9feb9e472dc 100644 (file)
@@ -1530,7 +1530,7 @@ int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
 
         redundancy[i] = opus_rc_p2model(rc, 1);
         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;
         }
     }
index ee6dc70942d670c3ccb7a29c1bc5dd6b477b1969..00d166177996c9ec8c48758fa011d952024369e2 100644 (file)
@@ -515,8 +515,8 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
             case FN_BLOCKSIZE: {
                 unsigned blocksize = get_uint(s, av_log2(s->blocksize));
                 if (blocksize > s->blocksize) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Increasing block size is not supported\n");
+                    avpriv_report_missing_feature(avctx,
+                                                  "Increasing block size");
                     return AVERROR_PATCHWELCOME;
                 }
                 if (!blocksize || blocksize > MAX_BLOCKSIZE) {
index c9db928c5c0a0f462376b34db2e71b9176c4c666..394567bbba6f7d2b7f78fbcf6f76f72996cfa1d1 100644 (file)
@@ -702,7 +702,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
 
     if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
         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;
     }
     if (s->ti.data_type) {
index ac46608f6163392d1d1aeb4f45a1cdd534ad358f..db1d9540322381c6eaf1bd272f50d7f699b8e655 100644 (file)
@@ -56,8 +56,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     flags           = bytestream2_get_byte(&gb);
 
     if (version < 8 || version > 9) {
-        av_log(avctx, AV_LOG_ERROR, "texture data version %u is unsupported\n",
-                                                                    version);
+        avpriv_report_missing_feature(avctx, "Texture data version %u", version);
         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) {
         avctx->pix_fmt = AV_PIX_FMT_RGBA;
     } 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;
     }
 
@@ -143,7 +142,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 
 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;
 }
 
index 2d8ba1a0f79c21b4ffec32ea793eff3b5e8ef821..e5036e62a9ba9577081e71d781fdc594f6610261 100644 (file)
@@ -51,7 +51,7 @@ static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size,
             return AVERROR_INVALIDDATA;
         vp56_rac_gets(c, 2);
         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;
         }
         rows = vp56_rac_gets(c, 8);  /* number of stored macroblock rows */
index 1c9874aa3276abc481171ae5fdd0ed2678c57dd0..387b697491ed8d75f45c70d0b2a814b247761b0e 100644 (file)
@@ -147,7 +147,7 @@ static int xwd_decode_frame(AVCodecContext *avctx, void *data,
     }
 
     if (pixformat != XWD_Z_PIXMAP) {
-        av_log(avctx, AV_LOG_ERROR, "pixmap format %"PRIu32" unsupported\n", pixformat);
+        avpriv_report_missing_feature(avctx, "Pixmap format %"PRIu32, pixformat);
         return AVERROR_PATCHWELCOME;
     }
 
index 9edd2c5f302f285f20a426518ad2b22272614d44..3523fde6e17683df3b27aac29eca7805168d5342 100644 (file)
@@ -383,8 +383,7 @@ static int vfw_read_header(AVFormatContext *s)
     if (par->format == AV_PIX_FMT_NONE) {
         par->codec_id = vfw_codecid(biCompression);
         if (par->codec_id == AV_CODEC_ID_NONE) {
-            av_log(s, AV_LOG_ERROR, "Unknown compression type. "
-                             "Please report verbose (-v 9) debug information.\n");
+            avpriv_report_missing_feature(s, "This compression type");
             vfw_read_close(s);
             return AVERROR_PATCHWELCOME;
         }
index 0fd99ebc9f4c8eebbff7b8d60499cd23f97df813..2913df5e9423cc2d6e9db59aa49c836f31713900 100644 (file)
@@ -500,7 +500,7 @@ static int pixfmt_from_pixmap_format(AVFormatContext *s, int depth,
 
         fmt++;
     }
-    av_log(s, AV_LOG_ERROR, "Pixmap format not mappable.\n");
+    avpriv_report_missing_feature(s, "Mapping this pixmap format");
 
     return AVERROR_PATCHWELCOME;
 }
index e4743981b8e69d6aa25fedf88dd7d79ff131df76..84a316f78721e6cded4bf2be0067115ec9f6149a 100644 (file)
@@ -225,8 +225,7 @@ static int avi_write_header(AVFormatContext *s)
             // XSUB subtitles behave like video tracks, other subtitles
             // are not (yet) supported.
             if (par->codec_id != AV_CODEC_ID_XSUB) {
-                av_log(s, AV_LOG_ERROR,
-                       "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
+                avpriv_report_missing_feature(s, "Subtitle streams other than DivX XSUB");
                 return AVERROR_PATCHWELCOME;
             }
         case AVMEDIA_TYPE_VIDEO:
index 9c884ba9b59a42f3dd0435130b68f247634229d8..285539c22af701940fe22a0d110ff300d9613405 100644 (file)
@@ -180,7 +180,7 @@ static int get_packet_header(AVFormatContext *s)
         st->codecpar->bits_per_coded_sample = (audio_format >> 6) & 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;
         }
 
@@ -190,8 +190,7 @@ static int get_packet_header(AVFormatContext *s)
         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;
         default:
-            av_log(s, AV_LOG_WARNING,
-                   "only 16-, 20-, 24- and 32-bit PCM currently supported\n");
+            avpriv_report_missing_feature(s, "PCM not 16-, 20-, 24- or 32-bits");
             return AVERROR_PATCHWELCOME;
         }
 
index 991f86b8d561af17356571c5c31fd047937dd6aa..80167309650c9c8df499b49ea784b0c2aaa2f09a 100644 (file)
@@ -1947,10 +1947,9 @@ static int matroska_read_header(AVFormatContext *s)
         ebml.max_size        > sizeof(uint64_t)  ||
         ebml.id_length       > sizeof(uint32_t)  ||
         ebml.doctype_version > 3) {
-        av_log(matroska->ctx, AV_LOG_ERROR,
-               "EBML header using unsupported features\n"
-               "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
-               ebml.version, ebml.doctype, ebml.doctype_version);
+        avpriv_report_missing_feature(matroska->ctx,
+                                      "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
+                                      ebml.version, ebml.doctype, ebml.doctype_version);
         ebml_free(ebml_syntax, &ebml);
         return AVERROR_PATCHWELCOME;
     }
index bd17c19838ebb41a2dcd315d30ea3191f1840258..d4005fa499949090d5d462486016073b58ba8d69 100644 (file)
@@ -228,7 +228,7 @@ static int mpc8_read_header(AVFormatContext *s)
     avio_skip(pb, 4); //CRC
     c->ver = avio_r8(pb);
     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;
     }
     c->samples = ffio_read_varlen(pb);
index 915ef42babb817b2bcdc3d1704f1b202347e934b..f523143cabe73ccd8aca073312391c5246404c0f 100644 (file)
@@ -123,9 +123,9 @@ static int opus_packet(AVFormatContext *avf, int idx)
         skip = FFMIN(skip, os->pduration);
         if (skip > 0) {
             os->pduration = skip < os->pduration ? os->pduration - skip : 1;
-            av_log(avf, AV_LOG_WARNING,
-                   "Last packet is truncated to %d (because of unimplemented end trim support).\n",
-                   os->pduration);
+            avpriv_report_missing_feature(avf,
+                                          "Last packet truncated to %u since end trim support",
+                                          os->pduration);
             return AVERROR_PATCHWELCOME;
         }
     }
index 4069dbe8c08e5436a28c8cb176df365ea251c1c3..b262d609df84206537032306310df7fc76c3fd5a 100644 (file)
@@ -102,10 +102,10 @@ static int qcp_read_header(AVFormatContext *s)
     if (is_qcelp_13k_guid(buf)) {
         st->codecpar->codec_id = AV_CODEC_ID_QCELP;
     } else if (!memcmp(buf, guid_evrc, 16)) {
-        av_log(s, AV_LOG_ERROR, "EVRC codec is not supported.\n");
+        avpriv_report_missing_feature(s, "EVRC codec");
         return AVERROR_PATCHWELCOME;
     } else if (!memcmp(buf, guid_smv, 16)) {
-        av_log(s, AV_LOG_ERROR, "SMV codec is not supported.\n");
+        avpriv_report_missing_feature(s, "SMV codec");
         return AVERROR_PATCHWELCOME;
     } else {
         av_log(s, AV_LOG_ERROR, "Unknown codec GUID.\n");
index 4f8278c4ab5470072bbde6fa4ae1792e8491a4f8..f9dd419c4ceccfab968150df491af566e2fd8ba5 100644 (file)
@@ -50,7 +50,7 @@ static int rso_write_header(AVFormatContext *s)
     }
 
     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;
     }
 
index 2cf41139c3794bc62b6bd2c6da184529bb4fcce5..c3e5c8dc9ff4d0a9386de151089cfe7e28bc6554 100644 (file)
@@ -230,7 +230,7 @@ static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,
     len -= 8;
 
     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;
     }
 
index 6be0a25d2bf2b69c60e7a49cb5fd99897c7de1af..df85ed3615a89cb7a8c83d3897d645d903392251 100644 (file)
@@ -109,9 +109,9 @@ static int parse_fmtp_config(AVStream *st, const char *value)
     num_layers        = get_bits(&gb, 3);
     if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 ||
         num_layers != 0) {
-        av_log(NULL, AV_LOG_WARNING, "Unsupported LATM config (%d,%d,%d,%d)\n",
-                                     audio_mux_version, same_time_framing,
-                                     num_programs, num_layers);
+        avpriv_report_missing_feature(NULL, "LATM config (%d,%d,%d,%d)",
+                                      audio_mux_version, same_time_framing,
+                                      num_programs, num_layers);
         ret = AVERROR_PATCHWELCOME;
         goto end;
     }
index 7821686983e1a95d2cf0b57a427d7f989e585aea..920a8a75bffa94c6fb02668e673e0f53a365e109 100644 (file)
@@ -108,15 +108,14 @@ static int xiph_handle_packet(AVFormatContext *ctx, PayloadContext *data,
     }
 
     if (ident != data->ident) {
-        av_log(ctx, AV_LOG_ERROR,
-               "Unimplemented Xiph SDP configuration change detected\n");
+        avpriv_report_missing_feature(ctx, "Xiph SDP configuration change");
         return AVERROR_PATCHWELCOME;
     }
 
     if (tdt) {
-        av_log(ctx, AV_LOG_ERROR,
-               "Unimplemented RTP Xiph packet settings (%d,%d,%d)\n",
-               fragmented, tdt, num_pkts);
+        avpriv_report_missing_feature(ctx,
+                                      "RTP Xiph packet settings (%d,%d,%d)",
+                                      fragmented, tdt, num_pkts);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -246,9 +245,8 @@ parse_packed_headers(AVFormatContext *s,
     length2            = get_base128(&packed_headers, packed_headers_end);
 
     if (num_packed != 1 || num_headers > 3) {
-        av_log(s, AV_LOG_ERROR,
-               "Unimplemented number of headers: %u packed headers, %u headers\n",
-               num_packed, num_headers);
+        avpriv_report_missing_feature(s, "%u packed headers, %u headers",
+                                      num_packed, num_headers);
         return AVERROR_PATCHWELCOME;
     }
 
index 84b912f7f2d8e41b3897ec5aec71735ccf21de2c..7e5985719e90021a89fa1c2193661a64092186e9 100644 (file)
@@ -1333,8 +1333,7 @@ static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
     ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
     if (send_content_length > 0 && send_content) {
         if (rt->control_transport == RTSP_MODE_TUNNEL) {
-            av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
-                                    "with content data not supported\n");
+            avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
             return AVERROR_PATCHWELCOME;
         }
         ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
index a19bcab4c938ebcccfdbeda2f602f4e5885a92b0..a9b3b522b3bb0b254dc2d4f1c9997526ac73321a 100644 (file)
@@ -469,7 +469,8 @@ static int spdif_write_header(AVFormatContext *s)
             return AVERROR(ENOMEM);
         break;
     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 0;
index 717275c6a0c0338efc4a169598e7795c29592101..51aae084ea65fde40c504ae060ef760900498e9e 100644 (file)
@@ -95,7 +95,8 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
     }
 
     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;
     }