lavc & lavf: replace deprecated av_log* functions

Signed-off-by: Paul B Mahol <onemda@gmail.com>

libavcodec/012v.c

@@ -30,7 +30,7 @@ static av_cold int zero12v_decode_init(AVCodecContext *avctx)
     avctx->bits_per_raw_sample = 10;
 
     if (avctx->codec_tag == MKTAG('a', '1', '2', 'v'))
-        av_log_ask_for_sample(avctx, "Samples with actual transparency needed\n");
+        avpriv_request_sample(avctx, "transparency");
 
     return 0;
 }

libavcodec/adpcm.c

@@ -323,7 +323,7 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
         shift  = 12 - (in[4+i*2] & 15);
         filter = in[4+i*2] >> 4;
         if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
-            av_log_ask_for_sample(avctx, "unknown XA-ADPCM filter %d\n", filter);
+            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
             filter=0;
         }
         f0 = xa_adpcm_table[filter][0];
@@ -352,7 +352,7 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
         shift  = 12 - (in[5+i*2] & 15);
         filter = in[5+i*2] >> 4;
         if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
-            av_log_ask_for_sample(avctx, "unknown XA-ADPCM filter %d\n", filter);
+            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
             filter=0;
         }
 

libavcodec/atrac1.c

@@ -342,7 +342,7 @@ static av_cold int atrac1_decode_init(AVCodecContext *avctx)
     }
 
     if (avctx->block_align <= 0) {
-        av_log_ask_for_sample(avctx, "unsupported block align\n");
+        av_log(avctx, AV_LOG_ERROR, "Unsupported block align.");
         return AVERROR_PATCHWELCOME;
     }
 

libavcodec/cook.c

@@ -1202,7 +1202,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
             return AVERROR_PATCHWELCOME;
         }
         if (q->subpacket[s].subbands == 0) {
-            av_log_ask_for_sample(avctx, "subbands is 0\n");
+            avpriv_request_sample(avctx, "subbands = 0");
             return AVERROR_PATCHWELCOME;
         }
         q->subpacket[s].gains1.now      = q->subpacket[s].gain_1;

libavcodec/dcadec.c

@@ -739,7 +739,7 @@ static int dca_parse_frame_header(DCAContext *s)
 
     if (s->lfe == 3) {
         s->lfe = 0;
-        av_log_ask_for_sample(s->avctx, "LFE is 3\n");
+        avpriv_request_sample(s->avctx, "LFE = 3");
         return AVERROR_PATCHWELCOME;
     }
 
@@ -1012,7 +1012,7 @@ static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
         /* Scale factor index */
         quant7 = get_bits(&s->gb, 8);
         if (quant7 > 127) {
-            av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
+            avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");
             return AVERROR_INVALIDDATA;
         }
         s->lfe_scale_factor = scale_factor_quant7[quant7];
@@ -2167,7 +2167,7 @@ static int dca_decode_frame(AVCodecContext *avctx, void *data,
                 }
 
                 if (s->xch_base_channel < 2) {
-                    av_log_ask_for_sample(avctx, "XCh with fewer than 2 base channels is not supported\n");
+                    avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");
                     continue;
                 }
 

libavcodec/exr.c

@@ -697,7 +697,7 @@ static int decode_frame(AVCodecContext *avctx,
             avctx->pix_fmt = AV_PIX_FMT_RGB48;
         break;
     case EXR_UINT:
-        av_log_missing_feature(avctx, "32-bit unsigned int", 1);
+        avpriv_request_sample(avctx, "32-bit unsigned int");
         return AVERROR_PATCHWELCOME;
     default:
         av_log(avctx, AV_LOG_ERROR, "Missing channel list\n");

libavcodec/iff.c

@@ -345,7 +345,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
             } else if (avctx->bits_per_coded_sample == 32) {
                 avctx->pix_fmt = AV_PIX_FMT_BGR32;
             } else {
-                av_log_ask_for_sample(avctx, "unknown bits_per_coded_sample\n");
+                avpriv_request_sample(avctx, "unknown bits_per_coded_sample");
                 return AVERROR_PATCHWELCOME;
             }
         }
@@ -646,7 +646,7 @@ static void decode_deep_tvdc32(uint8_t *dst, const uint8_t *src, int src_size, i
 static int unsupported(AVCodecContext *avctx)
 {
     IffContext *s = avctx->priv_data;
-    av_log_ask_for_sample(avctx, "unsupported bitmap (compression %i, bpp %i, ham %i)\n", s->compression, s->bpp, s->ham);
+    avpriv_request_sample(avctx, "bitmap (compression %i, bpp %i, ham %i)", s->compression, s->bpp, s->ham);
     return AVERROR_INVALIDDATA;
 }
 

libavcodec/mjpegdec.c

@@ -330,7 +330,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
 
     if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
         if (s->progressive) {
-            av_log_ask_for_sample(s->avctx, "progressively coded interlaced pictures not supported\n");
+            avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
             return AVERROR_INVALIDDATA;
         }
     } else{

libavcodec/mpegaudiodec.c

@@ -209,7 +209,7 @@ static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
     if (g->block_type == 2) {
         if (g->switch_point) {
             if(s->sample_rate_index == 8)
-                av_log_ask_for_sample(s->avctx, "switch point in 8khz\n");
+                avpriv_request_sample(s->avctx, "switch point in 8khz");
             /* if switched mode, we handle the 36 first samples as
                 long blocks.  For 8000Hz, we handle the 72 first
                 exponents as long blocks */

libavcodec/mvcdec.c

@@ -150,7 +150,7 @@ static int decode_mvc2(AVCodecContext *avctx, GetByteContext *gb, uint8_t *dst_s
         av_log(avctx, AV_LOG_WARNING, "dimension mismatch\n");
 
     if (bytestream2_get_byteu(gb)) {
-        av_log_ask_for_sample(avctx, "bitmap feature\n");
+        avpriv_request_sample(avctx, "bitmap feature");
         return AVERROR_PATCHWELCOME;
     }
 

libavcodec/paf.c

@@ -342,7 +342,7 @@ static int paf_vid_decode(AVCodecContext *avctx, void *data,
         }
         break;
     default:
-        av_log_ask_for_sample(avctx, "unknown/invalid code\n");
+        avpriv_request_sample(avctx, "unknown/invalid code");
         return AVERROR_INVALIDDATA;
     }
 

libavcodec/qdm2.c

@@ -646,7 +646,7 @@ static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_arra
 
     if (!superblocktype_2_3) {
         /* This case is untested, no samples available */
-        av_log_ask_for_sample(NULL, "!superblocktype_2_3");
+        avpriv_request_sample(NULL, "!superblocktype_2_3");
         return;
         for (ch = 0; ch < nb_channels; ch++)
             for (sb = 0; sb < 30; sb++) {

libavcodec/ra288.c

@@ -68,7 +68,7 @@ static av_cold int ra288_decode_init(AVCodecContext *avctx)
     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
 
     if (avctx->block_align <= 0) {
-        av_log_ask_for_sample(avctx, "unsupported block align\n");
+        av_log(avctx, AV_LOG_ERROR, "unsupported block align\n");
         return AVERROR_PATCHWELCOME;
     }
 

libavcodec/sanm.c

@@ -760,7 +760,7 @@ static int process_frame_obj(SANMVideoContext *ctx)
         return old_codec47(ctx, top, left, w, h);
         break;
     default:
-        av_log_ask_for_sample(ctx->avctx, "unknown subcodec %d\n", codec);
+        avpriv_request_sample(ctx->avctx, "unknown subcodec %d", codec);
         return AVERROR_PATCHWELCOME;
     }
 }
@@ -784,7 +784,7 @@ static int decode_0(SANMVideoContext *ctx)
 
 static int decode_nop(SANMVideoContext *ctx)
 {
-    av_log_ask_for_sample(ctx->avctx, "unknown/unsupported compression type\n");
+    avpriv_request_sample(ctx->avctx, "unknown/unsupported compression type");
     return AVERROR_PATCHWELCOME;
 }
 
@@ -1271,7 +1271,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
                 return ret;
             }
         } else {
-            av_log_ask_for_sample(avctx, "subcodec %d is not implemented\n",
+            avpriv_request_sample(avctx, "subcodec %d",
                    header.codec);
             return AVERROR_PATCHWELCOME;
         }

libavcodec/sgirledec.c

@@ -101,7 +101,7 @@ static int decode_sgirle8(AVCodecContext *avctx, uint8_t *dst, const uint8_t *sr
                 v   -= length;
             } while (v > 0);
         } else {
-            av_log_ask_for_sample(avctx, "unknown opcode\n");
+            avpriv_request_sample(avctx, "opcode %d", v);
             return AVERROR_PATCHWELCOME;
         }
     }

libavcodec/vc1dec.c

@@ -5287,7 +5287,7 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
             v->output_height > 1 << 14) return -1;
 
         if ((v->sprite_width&1) || (v->sprite_height&1)) {
-            av_log_ask_for_sample(avctx, "odd sprites are not supported\n");
+            avpriv_request_sample(avctx, "odd sprites support");
             return AVERROR_PATCHWELCOME;
         }
     }

libavcodec/vcr1.c

@@ -38,7 +38,7 @@ static av_cold int vcr1_decode_init(AVCodecContext *avctx)
     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 
     if (avctx->width % 8 || avctx->height%4) {
-        av_log_ask_for_sample(avctx, "odd dimensions are not supported\n");
+        avpriv_request_sample(avctx, "odd dimensions support");
         return AVERROR_PATCHWELCOME;
     }
     return 0;

libavformat/astdec.c

@@ -50,7 +50,7 @@ static int ast_read_header(AVFormatContext *s)
 
     depth = avio_rb16(s->pb);
     if (depth != 16) {
-        av_log_ask_for_sample(s, "unsupported depth %d\n", depth);
+        avpriv_request_sample(s, "depth %d", depth);
         return AVERROR_INVALIDDATA;
     }
 

libavformat/avr.c

@@ -51,7 +51,7 @@ static int avr_read_header(AVFormatContext *s)
     } else if (chan == 0xFFFFu) {
         st->codec->channels = 2;
     } else {
-        av_log_ask_for_sample(s, "unknown number of channels\n");
+        avpriv_request_sample(s, "chan %d", chan);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -78,7 +78,7 @@ static int avr_read_header(AVFormatContext *s)
     } else if (sign == 0xFFFFu && bps == 16) {
         st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
     } else {
-        av_log_ask_for_sample(s, "unknown bits per sample\n");
+        avpriv_request_sample(s, "bits per sample %d", bps);
         return AVERROR_PATCHWELCOME;
     }
 

libavformat/brstm.c

@@ -75,7 +75,7 @@ static int read_header(AVFormatContext *s)
         return AVERROR_INVALIDDATA;
     }
     if (bom == 0xFFFE) {
-        av_log_ask_for_sample(s, "unsupported byte order\n");
+        avpriv_request_sample(s, "little endian byte order");
         return AVERROR_PATCHWELCOME;
     }
 
@@ -110,7 +110,7 @@ static int read_header(AVFormatContext *s)
     case 1: codec = AV_CODEC_ID_PCM_S16BE_PLANAR; break;
     case 2: codec = AV_CODEC_ID_ADPCM_THP;        break;
     default:
-        av_log_ask_for_sample(s, "unsupported codec: %d\n", codec);
+        avpriv_request_sample(s, "codec %d", codec);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -220,8 +220,8 @@ static int read_header(AVFormatContext *s)
             }
             avio_skip(s->pb, start - avio_tell(s->pb));
 
-            if (major!=1 || minor)
-                av_log_ask_for_sample(s, "Version %d.%d\n", major, minor);
+            if (major != 1 || minor)
+                avpriv_request_sample(s, "Version %d.%d", major, minor);
 
             return 0;
         default:

libavformat/electronicarts.c

@@ -184,7 +184,7 @@ static int process_audio_header_elements(AVFormatContext *s)
         case  3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3; break;
         case -1: break;
         default:
-            av_log_ask_for_sample(s, "unsupported stream type; revision=%i\n", revision);
+            avpriv_request_sample(s, "stream type; revision=%i", revision);
             return 0;
         }
         switch (revision2) {
@@ -195,7 +195,7 @@ static int process_audio_header_elements(AVFormatContext *s)
             case  2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;
             case  3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
             default:
-                av_log_ask_for_sample(s, "unsupported stream type; revision=%i, revision2=%i\n", revision, revision2);
+                avpriv_request_sample(s, "stream type; revision=%i, revision2=%i", revision, revision2);
                 return 0;
             }
             break;
@@ -203,12 +203,12 @@ static int process_audio_header_elements(AVFormatContext *s)
         case -1: break;
         default:
             ea->audio_codec = AV_CODEC_ID_NONE;
-            av_log_ask_for_sample(s, "unsupported stream type; revision2=%i\n", revision2);
+            avpriv_request_sample(s, "stream type; revision2=%i", revision2);
             return 0;
         }
         break;
     default:
-        av_log_ask_for_sample(s, "unsupported stream type; compression_type=%i\n", compression_type);
+        avpriv_request_sample(s, "stream type; compression_type=%i", compression_type);
         return 0;
     }
 
@@ -244,7 +244,7 @@ static int process_audio_header_eacs(AVFormatContext *s)
     case 1: ea->audio_codec = AV_CODEC_ID_PCM_MULAW; ea->bytes = 1; break;
     case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS; break;
     default:
-        av_log_ask_for_sample(s, "unsupported stream type; audio compression_type=%i\n", compression_type);
+        avpriv_request_sample(s, "stream type; audio compression_type=%i", compression_type);
     }
 
     return 1;
@@ -332,7 +332,7 @@ static int process_ea_header(AVFormatContext *s) {
         switch (blockid) {
             case ISNh_TAG:
                 if (avio_rl32(pb) != EACS_TAG) {
-                    av_log_ask_for_sample(s, "unknown 1SNh headerid\n");
+                    avpriv_request_sample(s, "unknown 1SNh headerid");
                     return 0;
                 }
                 err = process_audio_header_eacs(s);
@@ -344,7 +344,7 @@ static int process_ea_header(AVFormatContext *s) {
                 if (blockid == GSTR_TAG) {
                     avio_skip(pb, 4);
                 } else if ((blockid & 0xFFFF)!=PT00_TAG) {
-                    av_log_ask_for_sample(s, "unknown SCHl headerid\n");
+                    avpriv_request_sample(s, "unknown SCHl headerid");
                     return 0;
                 }
                 err = process_audio_header_elements(s);
@@ -531,7 +531,7 @@ static int ea_read_packet(AVFormatContext *s,
                 chunk_size -= 12;
             }
             if (partial_packet) {
-                av_log_ask_for_sample(s, "video header followed by audio packet not supported.\n");
+                avpriv_request_sample(s, "video header followed by audio packet");
                 av_free_packet(pkt);
                 partial_packet = 0;
             }

libavformat/epafdec.c

@@ -77,7 +77,7 @@ static int epaf_read_header(AVFormatContext *s)
         st->codec->codec_id = AV_CODEC_ID_PCM_S8;
         break;
     case 1:
-        av_log_missing_feature(s, "24-bit Paris PCM format", 1);
+        avpriv_request_sample(s, "24-bit Paris PCM format");
     default:
         return AVERROR_INVALIDDATA;
     }

libavformat/icodec.c

@@ -53,7 +53,7 @@ static int read_header(AVFormatContext *s)
 {
     IcoDemuxContext *ico = s->priv_data;
     AVIOContext *pb = s->pb;
-    int i;
+    int i, codec;
 
     avio_skip(pb, 4);
     ico->nb_images = avio_rl16(pb);
@@ -88,7 +88,8 @@ static int read_header(AVFormatContext *s)
         if (avio_seek(pb, ico->images[i].offset, SEEK_SET) < 0)
             break;
 
-        switch(avio_rl32(pb)) {
+        codec = avio_rl32(pb);
+        switch (codec) {
         case MKTAG(0x89, 'P', 'N', 'G'):
             st->codec->codec_id = AV_CODEC_ID_PNG;
             st->codec->width    = 0;
@@ -106,7 +107,7 @@ static int read_header(AVFormatContext *s)
                 st->codec->height = tmp / 2;
             break;
         default:
-            av_log_ask_for_sample(s, "unsupported codec\n");
+            avpriv_request_sample(s, "codec %d", codec);
             return AVERROR_INVALIDDATA;
         }
     }

libavformat/iff.c

@@ -298,7 +298,7 @@ static int iff_read_header(AVFormatContext *s)
             else if (fmt_size == sizeof(deep_abgr) && !memcmp(fmt, deep_abgr, sizeof(deep_abgr)))
                 st->codec->pix_fmt = AV_PIX_FMT_ABGR;
             else {
-                av_log_ask_for_sample(s, "unsupported color format\n");
+                avpriv_request_sample(s, "color format %.16s", fmt);
                 return AVERROR_PATCHWELCOME;
             }
             break;
@@ -364,7 +364,7 @@ static int iff_read_header(AVFormatContext *s)
             } else if (iff->maud_bits ==  8 && iff->maud_compression == 3) {
                 st->codec->codec_id = AV_CODEC_ID_PCM_MULAW;
             } else {
-                av_log_ask_for_sample(s, "unsupported compression %d and bit depth %d\n", iff->maud_compression, iff->maud_bits);
+                avpriv_request_sample(s, "compression %d and bit depth %d", iff->maud_compression, iff->maud_bits);
                 return AVERROR_PATCHWELCOME;
             }
 

libavformat/lvfdec.c

@@ -41,7 +41,7 @@ static int lvf_read_header(AVFormatContext *s)
     if (!nb_streams)
         return AVERROR_INVALIDDATA;
     if (nb_streams > 2) {
-        av_log_ask_for_sample(s, "too many streams\n");
+        avpriv_request_sample(s, "%d streams", nb_streams);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -87,7 +87,7 @@ static int lvf_read_header(AVFormatContext *s)
             avio_seek(s->pb, 2048 + 8, SEEK_SET);
             return 0;
         default:
-            av_log_ask_for_sample(s, "unknown id\n");
+            avpriv_request_sample(s, "id %d", id);
             return AVERROR_PATCHWELCOME;
         }
 

libavformat/lxfdec.c

@@ -130,7 +130,7 @@ static int get_packet_header(AVFormatContext *s)
     version     = bytestream_get_le32(&p);
     header_size = bytestream_get_le32(&p);
     if (version > 1)
-        av_log_ask_for_sample(s, "Unknown format version %i\n", version);
+        avpriv_request_sample(s, "format version %i", version);
     if (header_size < (version ? 72 : 60) ||
         header_size > LXF_MAX_PACKET_HEADER_SIZE ||
         (header_size & 3)) {

libavformat/mvdec.c

@@ -172,7 +172,7 @@ static int parse_video_var(AVFormatContext *avctx, AVStream *st, const char *nam
         } else if (!strcmp(str, "MVC2")) {
             st->codec->codec_id = AV_CODEC_ID_MVC2;
         } else {
-            av_log_ask_for_sample(avctx, "unknown video compression %s\n", str);
+            avpriv_request_sample(avctx, "video compression %s", str);
         }
         av_free(str);
     } else if (!strcmp(name, "FPS")) {
@@ -214,7 +214,7 @@ static void read_table(AVFormatContext *avctx, AVStream *st, int (*parse)(AVForm
         name[sizeof(name) - 1] = 0;
         size = avio_rb32(pb);
         if (parse(avctx, st, name, size) < 0) {
-            av_log_ask_for_sample(avctx, "unknown variable %s\n", name);
+            avpriv_request_sample(avctx, "variable %s", name);
             avio_skip(pb, size);
         }
     }
@@ -274,7 +274,7 @@ static int mv_read_header(AVFormatContext *avctx)
             vst->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
             break;
         default:
-            av_log_ask_for_sample(avctx, "unknown video compression %i\n", v);
+            avpriv_request_sample(avctx, "video compression %i", v);
             break;
         }
         vst->codec->codec_tag = 0;
@@ -293,7 +293,7 @@ static int mv_read_header(AVFormatContext *avctx)
         if (v == AUDIO_FORMAT_SIGNED) {
             ast->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
         } else {
-            av_log_ask_for_sample(avctx, "unknown audio compression (format %i)\n", v);
+            avpriv_request_sample(avctx, "audio compression (format %i)", v);
         }
 
         avio_skip(pb, 12);
@@ -317,7 +317,7 @@ static int mv_read_header(AVFormatContext *avctx)
         read_table(avctx, NULL, parse_global_var);
 
         if (mv->nb_audio_tracks > 1) {
-            av_log_ask_for_sample(avctx, "multiple audio streams\n");
+            avpriv_request_sample(avctx, "multiple audio streams support");
             return AVERROR_PATCHWELCOME;
         } else if (mv->nb_audio_tracks) {
             ast = avformat_new_stream(avctx, NULL);
@@ -329,7 +329,7 @@ static int mv_read_header(AVFormatContext *avctx)
             if (ast->codec->codec_tag == 100 && ast->codec->codec_id == AUDIO_FORMAT_SIGNED && ast->codec->bits_per_coded_sample == 16) {
                 ast->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
             } else {
-                av_log_ask_for_sample(avctx, "unknown audio compression %i (format %i, width %i)\n",
+                avpriv_request_sample(avctx, "audio compression %i (format %i, width %i)",
                     ast->codec->codec_tag, ast->codec->codec_id, ast->codec->bits_per_coded_sample);
                 ast->codec->codec_id = AV_CODEC_ID_NONE;
             }
@@ -341,7 +341,7 @@ static int mv_read_header(AVFormatContext *avctx)
         }
 
         if (mv->nb_video_tracks > 1) {
-            av_log_ask_for_sample(avctx, "multiple video streams\n");
+            avpriv_request_sample(avctx, "multiple video streams support");
             return AVERROR_PATCHWELCOME;
         } else if (mv->nb_video_tracks) {
             vst = avformat_new_stream(avctx, NULL);
@@ -357,7 +357,7 @@ static int mv_read_header(AVFormatContext *avctx)
         if (mv->nb_video_tracks)
             read_index(pb, vst);
     } else {
-        av_log_ask_for_sample(avctx, "unknown version %i\n", version);
+        avpriv_request_sample(avctx, "version %i", version);
         return AVERROR_PATCHWELCOME;
     }
 

libavformat/nistspheredec.c

@@ -70,7 +70,7 @@ static int nist_read_header(AVFormatContext *s)
                        !av_strcasecmp(coding, "mu-law")) {
                 st->codec->codec_id = AV_CODEC_ID_PCM_MULAW;
             } else {
-                av_log_ask_for_sample(s, "unsupported coding: %s\n", coding);
+                avpriv_request_sample(s, "coding %s", coding);
             }
 
             avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
@@ -93,7 +93,7 @@ static int nist_read_header(AVFormatContext *s)
             } else if (!av_strcasecmp(format, "10")) {
                 be = 1;
             } else if (av_strcasecmp(format, "1")) {
-                av_log_ask_for_sample(s, "unsupported sample byte format: %s\n", format);
+                avpriv_request_sample(s, "sample byte format %s", format);
                 return AVERROR_PATCHWELCOME;
             }
         } else if (!memcmp(buffer, "sample_coding", 13)) {

libavformat/oggdec.c

@@ -195,7 +195,7 @@ static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, int nsegs)
         if (i >= ogg->nstreams)
             return ogg_new_stream(s, serial);
     } else if (ogg->nstreams != 1) {
-        av_log_missing_feature(s, "Changing stream parameters in multistream ogg", 0);
+        avpriv_report_missing_feature(s, "Changing stream parameters in multistream ogg");
         return AVERROR_PATCHWELCOME;
     }
 

libavformat/pmpdec.c

@@ -139,7 +139,7 @@ static int pmp_packet(AVFormatContext *s, AVPacket *pkt)
         int num_packets;
         pmp->audio_packets = avio_r8(pb);
         if (!pmp->audio_packets) {
-            av_log_ask_for_sample(s, "0 audio packets\n");
+            avpriv_request_sample(s, "0 audio packets");
             return AVERROR_PATCHWELCOME;
         }
         num_packets = (pmp->num_streams - 1) * pmp->audio_packets + 1;

libavformat/wvenc.c

@@ -45,7 +45,7 @@ static int write_header(AVFormatContext *s)
         return AVERROR(EINVAL);
     }
     if (codec->extradata_size > 0) {
-        av_log_missing_feature(s, "remuxing from matroska container", 0);
+        avpriv_report_missing_feature(s, "remuxing from matroska container");
         return AVERROR_PATCHWELCOME;
     }
     avpriv_set_pts_info(s->streams[0], 64, 1, codec->sample_rate);