@@ -251,7 +251,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 > 32U) {

-        av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps);

+        avpriv_report_missing_feature(avctx, "bps %d", bps);

         return AVERROR_PATCHWELCOME;

     }

@@ -431,7 +431,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\n", element);

+            avpriv_report_missing_feature(avctx, "Syntax element %d", element);

             return AVERROR_PATCHWELCOME;

         }

@@ -583,8 +583,8 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)

             avctx->channels = alac->channels;

     }

     if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) {

-        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];

@@ -100,7 +100,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;

     }

@@ -160,9 +160,7 @@ static int decode_frame(AVCodecContext *avctx,

     header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */

     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;

     }

@@ -1442,9 +1442,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);

                 ret = AVERROR_PATCHWELCOME;

                 goto header_fail;

             }

@@ -1475,9 +1474,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);

                     ret = AVERROR_PATCHWELCOME;

                     goto header_fail;

                 }

@@ -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");

@@ -774,8 +774,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct

         ret = AVERROR_INVALIDDATA;

         goto fail;

     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {

-        av_log(avctx, AV_LOG_ERROR,

-               "Unimplemented luma bit depth=%d\n",

+        avpriv_report_missing_feature(avctx,

+               "Unimplemented luma bit depth=%d",

                sps->bit_depth_luma);

         ret = AVERROR_PATCHWELCOME;

         goto fail;

@@ -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

@@ -540,7 +540,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;

     }

@@ -586,13 +586,13 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)

         break;

     default:

 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_v, 0, sizeof(s->upscale_v));

         return AVERROR_PATCHWELCOME;

     }

     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;

     }

     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);

     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) {

@@ -807,7 +807,7 @@ int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,

         redundancy[i] = ff_opus_rc_dec_log(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;

         }

     }

@@ -627,8 +627,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) {

@@ -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) {

@@ -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;

     }

@@ -149,7 +148,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;

 }

@@ -53,7 +53,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 */

@@ -387,8 +387,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;

         }

@@ -509,7 +509,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;

 }

@@ -368,8 +368,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:

@@ -181,7 +181,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;

         }

@@ -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 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;

         }

@@ -2548,10 +2548,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;

     } else if (ebml.doctype_version == 3) {

@@ -239,7 +239,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);

@@ -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;

     }

@@ -247,7 +247,7 @@ static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,

         type &= ~0x40;

     }

     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;

     }

@@ -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;

     }

@@ -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;

     }

@@ -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));

     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);

@@ -470,7 +470,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;

@@ -98,7 +98,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;

     }