@@ -1115,10 +1115,10 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,

                     offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;

                     clipped_offset = av_clip(offset[2], -155, 100);

                     if (offset[2] != clipped_offset) {

-                        av_log_ask_for_sample(ac->avctx, "Intensity stereo "

-                                "position clipped (%d -> %d).\nIf you heard an "

-                                "audible artifact, there may be a bug in the "

-                                "decoder. ", offset[2], clipped_offset);

+                        avpriv_request_sample(ac->avctx,

+                                              "If you heard an audible artifact, there may be a bug in the decoder. "

+                                              "Clipped intensity stereo position (%d -> %d)",

+                                              offset[2], clipped_offset);

                     }

                     sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];

                 }

@@ -1130,10 +1130,10 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,

                         offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;

                     clipped_offset = av_clip(offset[1], -100, 155);

                     if (offset[1] != clipped_offset) {

-                        av_log_ask_for_sample(ac->avctx, "Noise gain clipped "

-                                "(%d -> %d).\nIf you heard an audible "

-                                "artifact, there may be a bug in the decoder. ",

-                                offset[1], clipped_offset);

+                        avpriv_request_sample(ac->avctx,

+                                              "If you heard an audible artifact, there may be a bug in the decoder. "

+                                              "Clipped noise gain (%d -> %d)",

+                                              offset[1], clipped_offset);

                     }

                     sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];

                 }

@@ -53,7 +53,7 @@ int avpriv_adx_decode_header(AVCodecContext *avctx, const uint8_t *buf,

     /* check for encoding=3 block_size=18, sample_size=4 */

     if (buf[4] != 3 || buf[5] != 18 || buf[6] != 4) {

-        av_log_ask_for_sample(avctx, "unsupported ADX format\n");

+        avpriv_request_sample(avctx, "Support for this ADX format");

         return AVERROR_PATCHWELCOME;

     }

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

     case 24:

     case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

              break;

-    default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n",

-                                   alac->sample_size);

+    default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size);

              return AVERROR_PATCHWELCOME;

     }

     avctx->bits_per_raw_sample = alac->sample_size;

@@ -127,11 +127,11 @@ static int decode_frame(AVCodecContext *avctx,

     bytestream2_init(&s->gb, avpkt->data, buf_size);

     if (bytestream2_get_byte(&s->gb) != 0x42) {

-        av_log_ask_for_sample(avctx, "unknown record type\n");

+        avpriv_request_sample(avctx, "Unknown record type");

         return buf_size;

     }

     if (bytestream2_get_byte(&s->gb)) {

-        av_log_ask_for_sample(avctx, "padding bytes not supported\n");

+        avpriv_request_sample(avctx, "Padding bytes");

         return buf_size;

     }

     bytestream2_skip(&s->gb, 2);

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

                 if (type == 0)

                     break; // stop

                 if (type == 2) {

-                    av_log_ask_for_sample(avctx, "unknown opcode");

+                    avpriv_request_sample(avctx, "Unknown opcode");

                     return AVERROR_PATCHWELCOME;

                 }

                 continue;

@@ -222,7 +222,7 @@ static int execute_code(AVCodecContext * avctx, int c)

             height = 60<<4;

             break;

         default:

-            av_log_ask_for_sample(avctx, "unsupported screen mode\n");

+            avpriv_request_sample(avctx, "Unsupported screen mode");

         }

         if (width != avctx->width || height != avctx->height) {

             av_frame_unref(s->frame);

@@ -291,7 +291,7 @@ static int execute_code(AVCodecContext * avctx, int c)

             } else if (m == 49) {

                 s->fg = ansi_to_cga[DEFAULT_BG_COLOR];

             } else {

-                av_log_ask_for_sample(avctx, "unsupported rendition parameter\n");

+                avpriv_request_sample(avctx, "Unsupported rendition parameter");

             }

         }

         break;

@@ -308,7 +308,7 @@ static int execute_code(AVCodecContext * avctx, int c)

         s->y = av_clip(s->sy, 0, avctx->height - s->font_height);

         break;

     default:

-        av_log_ask_for_sample(avctx, "unsupported escape code\n");

+        avpriv_request_sample(avctx, "Unknown escape code");

         break;

     }

     return 0;

@@ -205,8 +205,8 @@ static av_cold int ape_decode_init(AVCodecContext *avctx)

         avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

         break;

     default:

-        av_log_ask_for_sample(avctx, "Unsupported bits per coded sample %d\n",

-                              s->bps);

+        avpriv_request_sample(avctx,

+                              "%d bits per coded sample", s->bps);

         return AVERROR_PATCHWELCOME;

     }

     s->avctx             = avctx;

@@ -169,7 +169,7 @@ static int decode_bytes(const uint8_t *input, uint8_t *out, int bytes)

         output[i] = c ^ buf[i];

     if (off)

-        av_log_ask_for_sample(NULL, "Offset of %d not handled.\n", off);

+        avpriv_request_sample(NULL, "Offset of %d", off);

     return off;

 }

@@ -233,7 +233,7 @@ static int cdxl_decode_frame(AVCodecContext *avctx, void *data,

     if (c->bpp < 1)

         return AVERROR_INVALIDDATA;

     if (c->format != BIT_PLANAR && c->format != BIT_LINE) {

-        av_log_ask_for_sample(avctx, "unsupported pixel format: 0x%0x\n", c->format);

+        avpriv_request_sample(avctx, "Pixel format 0x%0x", c->format);

         return AVERROR_PATCHWELCOME;

     }

@@ -253,7 +253,7 @@ static int cdxl_decode_frame(AVCodecContext *avctx, void *data,

             return AVERROR_INVALIDDATA;

         avctx->pix_fmt = AV_PIX_FMT_BGR24;

     } else {

-        av_log_ask_for_sample(avctx, "unsupported encoding %d and bpp %d\n",

+        avpriv_request_sample(avctx, "Encoding %d and bpp %d",

                               encoding, c->bpp);

         return AVERROR_PATCHWELCOME;

     }

@@ -334,7 +334,7 @@ static int cinepak_decode (CinepakContext *s)

     /* if this is the first frame, check for deviant Sega FILM data */

     if (s->sega_film_skip_bytes == -1) {

         if (!encoded_buf_size) {

-            av_log_ask_for_sample(s->avctx, "encoded_buf_size is 0");

+            avpriv_request_sample(s->avctx, "encoded_buf_size 0");

             return AVERROR_PATCHWELCOME;

         }

         if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {

@@ -1100,7 +1100,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

         switch (q->subpacket[s].cookversion) {

         case MONO:

             if (avctx->channels != 1) {

-                av_log_ask_for_sample(avctx, "Container channels != 1.\n");

+                avpriv_request_sample(avctx, "Container channels != 1");

                 return AVERROR_PATCHWELCOME;

             }

             av_log(avctx, AV_LOG_DEBUG, "MONO\n");

@@ -1114,7 +1114,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

             break;

         case JOINT_STEREO:

             if (avctx->channels != 2) {

-                av_log_ask_for_sample(avctx, "Container channels != 2.\n");

+                avpriv_request_sample(avctx, "Container channels != 2");

                 return AVERROR_PATCHWELCOME;

             }

             av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");

@@ -1154,7 +1154,8 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

             break;

         default:

-            av_log_ask_for_sample(avctx, "Unknown Cook version.\n");

+            avpriv_request_sample(avctx, "Cook version %d",

+                                  q->subpacket[s].cookversion);

             return AVERROR_PATCHWELCOME;

         }

@@ -1170,7 +1171,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

         /* Try to catch some obviously faulty streams, othervise it might be exploitable */

         if (q->subpacket[s].total_subbands > 53) {

-            av_log_ask_for_sample(avctx, "total_subbands > 53\n");

+            avpriv_request_sample(avctx, "total_subbands > 53");

             return AVERROR_PATCHWELCOME;

         }

@@ -1182,7 +1183,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

         }

         if (q->subpacket[s].subbands > 50) {

-            av_log_ask_for_sample(avctx, "subbands > 50\n");

+            avpriv_request_sample(avctx, "subbands > 50");

             return AVERROR_PATCHWELCOME;

         }

         q->subpacket[s].gains1.now      = q->subpacket[s].gain_1;

@@ -1193,7 +1194,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

         q->num_subpackets++;

         s++;

         if (s > MAX_SUBPACKETS) {

-            av_log_ask_for_sample(avctx, "Too many subpackets > 5\n");

+            avpriv_request_sample(avctx, "subpackets > %d", MAX_SUBPACKETS);

             return AVERROR_PATCHWELCOME;

         }

     }

@@ -1235,8 +1236,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)

     /* Try to catch some obviously faulty streams, othervise it might be exploitable */

     if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&

         q->samples_per_channel != 1024) {

-        av_log_ask_for_sample(avctx,

-                              "unknown amount of samples_per_channel = %d\n",

+        avpriv_request_sample(avctx, "samples_per_channel = %d",

                               q->samples_per_channel);

         return AVERROR_PATCHWELCOME;

     }

@@ -1598,14 +1598,15 @@ static void dca_exss_parse_header(DCAContext *s)

         num_audiop = get_bits(&s->gb, 3) + 1;

         if (num_audiop > 1) {

-            av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");

+            avpriv_request_sample(s->avctx,

+                                  "Multiple DTS-HD audio presentations");

             /* ignore such streams for now */

             return;

         }

         num_assets = get_bits(&s->gb, 3) + 1;

         if (num_assets > 1) {

-            av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");

+            avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");

             /* ignore such streams for now */

             return;

         }

@@ -53,7 +53,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     pic->key_frame = 1;

     if (AV_RL32(src) != 0x01000002) {

-        av_log_ask_for_sample(avctx, "Unknown frame header %X\n", AV_RL32(src));

+        avpriv_request_sample(avctx, "Frame header %X", AV_RL32(src));

         return AVERROR_PATCHWELCOME;

     }

     src += 16;

@@ -3356,8 +3356,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0)

                         h->droppable         = last_pic_droppable;

                         return AVERROR_INVALIDDATA;

                     } else if (last_pic_droppable != h->droppable) {

-                        av_log_ask_for_sample(h->avctx,

-                                              "Found reference and non-reference fields in the same frame.\n");

+                        avpriv_request_sample(h->avctx,

+                                              "Found reference and non-reference fields in the same frame, which");

                         h->picture_structure = last_pic_structure;

                         h->droppable         = last_pic_droppable;

                         return AVERROR_PATCHWELCOME;

@@ -181,7 +181,7 @@ static av_cold int imc_decode_init(AVCodecContext *avctx)

         avctx->channels = 1;

     if (avctx->channels > 2) {

-        av_log_ask_for_sample(avctx, "Number of channels is not supported\n");

+        avpriv_request_sample(avctx, "Number of channels > 2");

         return AVERROR_PATCHWELCOME;

     }

@@ -778,8 +778,7 @@ static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)

     stream_format_code = get_bits(&q->gb, 3);

     if (stream_format_code & 1) {

-        av_log_ask_for_sample(avctx, "Stream format %X is not supported\n",

-                              stream_format_code);

+        avpriv_request_sample(avctx, "Stream format %X", stream_format_code);

         return AVERROR_PATCHWELCOME;

     }

@@ -960,12 +960,12 @@ static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx,

     }

     if (ctx->frame_flags & BS_8BIT_PEL) {

-        av_log_ask_for_sample(avctx, "8-bit pixel format\n");

+        avpriv_request_sample(avctx, "8-bit pixel format");

         return AVERROR_PATCHWELCOME;

     }

     if (ctx->frame_flags & BS_MV_X_HALF || ctx->frame_flags & BS_MV_Y_HALF) {

-        av_log_ask_for_sample(avctx, "halfpel motion vectors\n");

+        avpriv_request_sample(avctx, "Halfpel motion vectors");

         return AVERROR_PATCHWELCOME;

     }

@@ -329,12 +329,12 @@ static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,

             transform_id = get_bits(&ctx->gb, 5);

             if (transform_id >= FF_ARRAY_ELEMS(transforms) ||

                 !transforms[transform_id].inv_trans) {

-                av_log_ask_for_sample(avctx, "Unimplemented transform: %d!\n", transform_id);

+                avpriv_request_sample(avctx, "Transform %d", transform_id);

                 return AVERROR_PATCHWELCOME;

             }

             if ((transform_id >= 7 && transform_id <= 9) ||

                  transform_id == 17) {

-                av_log_ask_for_sample(avctx, "DCT transform not supported yet!\n");

+                avpriv_request_sample(avctx, "DCT transform");

                 return AVERROR_PATCHWELCOME;

             }

@@ -283,7 +283,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

         break;

     default:

         l->lossy = AV_RL32(avctx->extradata + 8);

-        av_log_ask_for_sample(avctx, "This is LOCO codec version %i.\n", version);

+        avpriv_request_sample(avctx, "LOCO codec version %i", version);

     }

     l->mode = AV_RL32(avctx->extradata + 4);

@@ -329,9 +329,10 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)

         return AVERROR_INVALIDDATA;

     }

     if (mh.num_substreams > MAX_SUBSTREAMS) {

-        av_log_ask_for_sample(m->avctx,

-               "Number of substreams %d is larger than the maximum supported "

-               "by the decoder.\n", mh.num_substreams);

+        avpriv_request_sample(m->avctx,

+                              "%d substreams (more than the "

+                              "maximum supported by the decoder)",

+                              mh.num_substreams);

         return AVERROR_PATCHWELCOME;

     }

@@ -429,9 +430,10 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,

     /* This should happen for TrueHD streams with >6 channels and MLP's noise

      * type. It is not yet known if this is allowed. */

     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {

-        av_log_ask_for_sample(m->avctx,

-               "Number of channels %d is larger than the maximum supported "

-               "by the decoder.\n", s->max_channel + 2);

+        avpriv_request_sample(m->avctx,

+                              "%d channels (more than the "

+                              "maximum supported by the decoder)",

+                              s->max_channel + 2);

         return AVERROR_PATCHWELCOME;

     }

@@ -490,9 +492,9 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,

                                                             channel);

         }

         if (ch_assign > s->max_matrix_channel) {

-            av_log_ask_for_sample(m->avctx,

-                   "Assignment of matrix channel %d to invalid output channel %d.\n",

-                   ch, ch_assign);

+            avpriv_request_sample(m->avctx,

+                                  "Assignment of matrix channel %d to invalid output channel %d",

+                                  ch, ch_assign);

             return AVERROR_PATCHWELCOME;

         }

         s->ch_assign[ch_assign] = ch;

@@ -823,8 +825,8 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,

     if (s->data_check_present) {

         expected_stream_pos  = get_bits_count(gbp);

         expected_stream_pos += get_bits(gbp, 16);

-        av_log_ask_for_sample(m->avctx, "This file contains some features "

-                              "we have not tested yet.\n");

+        avpriv_request_sample(m->avctx,

+                              "Substreams with VLC block size check info");

     }

     if (s->blockpos + s->blocksize > m->access_unit_size) {

@@ -65,8 +65,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)

     /* Musepack SV7 is always stereo */

     if (avctx->channels != 2) {

-        av_log_ask_for_sample(avctx, "Unsupported number of channels: %d\n",

-                              avctx->channels);

+        avpriv_request_sample(avctx, "%d channels", avctx->channels);

         return AVERROR_PATCHWELCOME;

     }

@@ -430,8 +430,8 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,

         ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w >> 1, h >> 1);

         ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w >> 1, h >> 1);

     } else if (v->respic)

-        av_log_ask_for_sample(v->s.avctx,

-                              "Asymmetric WMV9 rectangle subsampling\n");

+        avpriv_request_sample(v->s.avctx,

+                              "Asymmetric WMV9 rectangle subsampling");

     av_assert0(f->linesize[1] == f->linesize[2]);

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

     s->nb_planes   = (tmp >> 4) + 1;

     bpp            = bits_per_plane * s->nb_planes;

     if (bits_per_plane > 8 || bpp < 1 || bpp > 32) {

-        av_log_ask_for_sample(s, "unsupported bit depth\n");

+        avpriv_request_sample(s, "Unsupported bit depth");

         return AVERROR_PATCHWELCOME;

     }

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

             }

         }

     } else {

-        av_log_ask_for_sample(s, "uncompressed image\n");

+        avpriv_request_sample(s, "Uncompressed image");

         return avpkt->size;

     }

@@ -42,7 +42,7 @@ static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     bytes_per_pixel = AV_RL16(buf+12) >> 3;

     if (bytes_per_pixel != 2) {

-        av_log_ask_for_sample(avctx, "Image format is not RGB15.\n");

+        avpriv_request_sample(avctx, "Image format not RGB15");

         return AVERROR_PATCHWELCOME;

     }

@@ -51,7 +51,7 @@ static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     if (buf_end - buf < offset)

         return AVERROR_INVALIDDATA;

     if (offset != 0x2c)

-        av_log_ask_for_sample(avctx, "offset != 0x2c\n");

+        avpriv_request_sample(avctx, "offset != 0x2c");

     buf += offset;

@@ -635,8 +635,8 @@ static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx,

         return I_F_Q;

     if (bitrate == SILENCE) {

-        //FIXME: Remove experimental warning when tested with samples.

-        av_log_ask_for_sample(avctx, "'Blank frame handling is experimental.");

+        // FIXME: Remove this warning when tested with samples.

+        avpriv_request_sample(avctx, "Blank frame handling");

     }

     return bitrate;

 }

@@ -136,7 +136,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

     ctx->version = AV_RB16(avctx->extradata + 4);

     if (ctx->version != 0x103) {

-        av_log_ask_for_sample(avctx, "unknown version %X\n", ctx->version);

+        avpriv_request_sample(avctx, "Unknown version %X", ctx->version);

         return AVERROR_PATCHWELCOME;

     }

@@ -54,7 +54,7 @@ static int sunrast_decode_frame(AVCodecContext *avctx, void *data,

     buf      += 32;

     if (type == RT_FORMAT_TIFF || type == RT_FORMAT_IFF || type == RT_EXPERIMENTAL) {

-        av_log_ask_for_sample(avctx, "unsupported (compression) type\n");

+        avpriv_request_sample(avctx, "TIFF/IFF/EXPERIMENTAL (compression) type");

         return AVERROR_PATCHWELCOME;

     }

     if (type > RT_FORMAT_IFF) {

@@ -66,7 +66,7 @@ static int sunrast_decode_frame(AVCodecContext *avctx, void *data,

         return AVERROR_INVALIDDATA;

     }

     if (maptype == RMT_RAW) {

-        av_log_ask_for_sample(avctx, "unsupported colormap type\n");

+        avpriv_request_sample(avctx, "Unknown colormap type");

         return AVERROR_PATCHWELCOME;

     }

     if (maptype > RMT_RAW) {

@@ -355,7 +355,7 @@ static int truemotion1_decode_header(TrueMotion1Context *s)

         s->flags = FLAG_KEYFRAME;

     if (s->flags & FLAG_SPRITE) {

-        av_log_ask_for_sample(s->avctx, "SPRITE frame found.\n");

+        avpriv_request_sample(s->avctx, "Frame with sprite");

         /* FIXME header.width, height, xoffset and yoffset aren't initialized */

         return AVERROR_PATCHWELCOME;

     } else {

@@ -365,7 +365,7 @@ static int truemotion1_decode_header(TrueMotion1Context *s)

             if ((s->w < 213) && (s->h >= 176))

             {

                 s->flags |= FLAG_INTERPOLATED;

-                av_log_ask_for_sample(s->avctx, "INTERPOLATION selected.\n");

+                avpriv_request_sample(s->avctx, "Interpolated frame");

             }

         }

     }

@@ -63,7 +63,7 @@ static av_cold int truespeech_decode_init(AVCodecContext * avctx)

     TSContext *c = avctx->priv_data;

     if (avctx->channels != 1) {

-        av_log_ask_for_sample(avctx, "Unsupported channel count: %d\n", avctx->channels);

+        avpriv_request_sample(avctx, "Channel count %d", avctx->channels);

         return AVERROR_PATCHWELCOME;

     }

@@ -376,7 +376,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     c->frame_pred = (c->frame_info >> 8) & 3;

     if (c->frame_pred == PRED_GRADIENT) {

-        av_log_ask_for_sample(avctx, "Frame uses gradient prediction\n");

+        avpriv_request_sample(avctx, "Frame with gradient prediction");

         return AVERROR_PATCHWELCOME;

     }

@@ -491,7 +491,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

     c->flags           = AV_RL32(avctx->extradata + 12);

     if (c->frame_info_size != 4)

-        av_log_ask_for_sample(avctx, "Frame info is not 4 bytes\n");

+        avpriv_request_sample(avctx, "Frame info not 4 bytes");

     av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08X\n", c->flags);

     c->slices      = (c->flags >> 24) + 1;

     c->compression = c->flags & 1;

@@ -52,7 +52,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     }

     if (avpkt->size > avctx->width * avctx->height * 8 / 3) {

-        av_log_ask_for_sample(avctx, "Probably padded data\n");

+        avpriv_request_sample(avctx, "(Probably) padded data");

     }

     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

@@ -4850,7 +4850,7 @@ static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)

     for (sprite = 0; sprite <= v->two_sprites; sprite++) {

         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);

         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])

-            av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");

+            avpriv_request_sample(avctx, "Non-zero rotation coefficients");

         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");

         for (i = 0; i < 7; i++)

             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",

@@ -141,8 +141,9 @@ static int parse_setup_header(AVCodecContext *avctx, VorbisParseContext *s,

      * we may need to approach this the long way and parse the whole Setup

      * header, but I hope very much that it never comes to that. */

     if (last_mode_count > 2) {

-        av_log_ask_for_sample(avctx, "%d modes found. This is either a false "

-                              "positive or a sample from an unknown encoder.\n",

+        avpriv_request_sample(avctx,

+                              "%d modes (either a false positive or a "

+                              "sample from an unknown encoder)",

                               last_mode_count);

     }

     /* We're limiting the mode count to 63 so that we know that the previous

@@ -202,7 +202,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

         av_dlog(avctx, "\n");

     } else {

-        av_log_ask_for_sample(avctx, "Unsupported extradata size\n");

+        avpriv_request_sample(avctx, "Unsupported extradata size");

         return AVERROR_PATCHWELCOME;

     }

@@ -256,7 +256,8 @@ static av_cold int decode_init(AVCodecContext *avctx)

                s->num_channels);

         return AVERROR_INVALIDDATA;

     } else if (s->num_channels > WMALL_MAX_CHANNELS) {

-        av_log_ask_for_sample(avctx, "unsupported number of channels\n");

+        avpriv_request_sample(avctx,

+                              "More than %d channels", WMALL_MAX_CHANNELS);

         return AVERROR_PATCHWELCOME;

     }

@@ -925,8 +926,8 @@ static int decode_subframe(WmallDecodeCtx *s)

             s->do_lpc = get_bits1(&s->gb);

             if (s->do_lpc) {

                 decode_lpc(s);

-                av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "

-                                      "implemented. Expect wrong output.\n");

+                avpriv_request_sample(s->avctx, "Expect wrong output since "

+                                      "inverse LPC filter");

             }

         } else

             s->do_lpc = 0;

@@ -1137,7 +1138,7 @@ static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,

     buflen = (s->num_saved_bits + len + 8) >> 3;

     if (len <= 0 || buflen > MAX_FRAMESIZE) {

-        av_log_ask_for_sample(s->avctx, "input buffer too small\n");

+        avpriv_request_sample(s->avctx, "Too small input buffer");

         s->packet_loss = 1;

         return;

     }

@@ -299,7 +299,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

         av_dlog(avctx, "\n");

     } else {

-        av_log_ask_for_sample(avctx, "Unknown extradata size\n");

+        avpriv_request_sample(avctx, "Unknown extradata size");

         return AVERROR_PATCHWELCOME;

     }

@@ -346,7 +346,8 @@ static av_cold int decode_init(AVCodecContext *avctx)

                avctx->channels);

         return AVERROR_INVALIDDATA;

     } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {

-        av_log_ask_for_sample(avctx, "unsupported number of channels\n");

+        avpriv_request_sample(avctx,

+                              "More than %d channels", WMAPRO_MAX_CHANNELS);

         return AVERROR_PATCHWELCOME;

     }

@@ -676,8 +677,8 @@ static int decode_channel_transform(WMAProDecodeCtx* s)

         int remaining_channels = s->channels_for_cur_subframe;

         if (get_bits1(&s->gb)) {

-            av_log_ask_for_sample(s->avctx,

-                                  "unsupported channel transform bit\n");

+            avpriv_request_sample(s->avctx,

+                                  "Channel transform bit");

             return AVERROR_PATCHWELCOME;

         }

@@ -713,8 +714,8 @@ static int decode_channel_transform(WMAProDecodeCtx* s)

             if (chgroup->num_channels == 2) {

                 if (get_bits1(&s->gb)) {

                     if (get_bits1(&s->gb)) {

-                        av_log_ask_for_sample(s->avctx,

-                                              "unsupported channel transform type\n");

+                        avpriv_request_sample(s->avctx,

+                                              "Unknown channel transform type");

                     }

                 } else {

                     chgroup->transform = 1;

@@ -739,8 +740,8 @@ static int decode_channel_transform(WMAProDecodeCtx* s)

                     } else {

                         /** FIXME: more than 6 coupled channels not supported */

                         if (chgroup->num_channels > 6) {

-                            av_log_ask_for_sample(s->avctx,

-                                                  "coupled channels > 6\n");

+                            avpriv_request_sample(s->avctx,

+                                                  "Coupled channels > 6");

                         } else {

                             memcpy(chgroup->decorrelation_matrix,

                                    default_decorrelation[chgroup->num_channels],

@@ -1147,7 +1148,7 @@ static int decode_subframe(WMAProDecodeCtx *s)

     /** no idea for what the following bit is used */

     if (get_bits1(&s->gb)) {

-        av_log_ask_for_sample(s->avctx, "reserved bit set\n");

+        avpriv_request_sample(s->avctx, "Reserved bit");

         return AVERROR_PATCHWELCOME;

     }

@@ -1453,7 +1454,7 @@ static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,

     buflen = (s->num_saved_bits + len + 8) >> 3;

     if (len <= 0 || buflen > MAX_FRAMESIZE) {

-        av_log_ask_for_sample(s->avctx, "input buffer too small\n");

+        avpriv_request_sample(s->avctx, "Too small input buffer");

         s->packet_loss = 1;

         return;

     }

@@ -92,12 +92,14 @@ static int decode_frame(AVCodecContext *avctx,

     else {

         l->shift = 8 - (buf[2] >> 4);

         if (l->shift > 4) {

-            av_log_ask_for_sample(avctx, "Unknown WNV1 frame header value %i\n",

+            avpriv_request_sample(avctx,

+                                  "Unknown WNV1 frame header value %i",

                                   buf[2] >> 4);

             l->shift = 4;

         }

         if (l->shift < 1) {

-            av_log_ask_for_sample(avctx, "Unknown WNV1 frame header value %i\n",

+            avpriv_request_sample(avctx,

+                                  "Unknown WNV1 frame header value %i",

                                   buf[2] >> 4);

             l->shift = 1;

         }

@@ -92,7 +92,7 @@ static int xwd_decode_frame(AVCodecContext *avctx, void *data,

     }

     if (xoffset) {

-        av_log_ask_for_sample(avctx, "unsupported xoffset %d\n", xoffset);

+        avpriv_request_sample(avctx, "xoffset %d", xoffset);

         return AVERROR_PATCHWELCOME;

     }

@@ -192,7 +192,9 @@ static int xwd_decode_frame(AVCodecContext *avctx, void *data,

     }

     if (avctx->pix_fmt == AV_PIX_FMT_NONE) {

-        av_log_ask_for_sample(avctx, "unknown file: bpp %d, pixdepth %d, vclass %d\n", bpp, pixdepth, vclass);

+        avpriv_request_sample(avctx,

+                              "Unknown file: bpp %d, pixdepth %d, vclass %d",

+                              bpp, pixdepth, vclass);

         return AVERROR_PATCHWELCOME;

     }

@@ -432,18 +432,15 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac

                "Flags=%X ver=%i.%i comp=%i fmt=%i blk=%ix%i\n",

                c->flags,hi_ver,lo_ver,c->comp,c->fmt,c->bw,c->bh);

         if (hi_ver != 0 || lo_ver != 1) {

-            av_log_ask_for_sample(avctx, "Unsupported version %i.%i\n",

-                                  hi_ver, lo_ver);

+            avpriv_request_sample(avctx, "Version %i.%i", hi_ver, lo_ver);

             return AVERROR_PATCHWELCOME;

         }

         if (c->bw == 0 || c->bh == 0) {

-            av_log_ask_for_sample(avctx, "Unsupported block size %ix%i\n",

-                                  c->bw, c->bh);

+            avpriv_request_sample(avctx, "Block size %ix%i", c->bw, c->bh);

             return AVERROR_PATCHWELCOME;

         }

         if (c->comp != 0 && c->comp != 1) {

-            av_log_ask_for_sample(avctx, "Unsupported compression type %i\n",

-                                  c->comp);

+            avpriv_request_sample(avctx, "Compression type %i", c->comp);

             return AVERROR_PATCHWELCOME;

         }

@@ -474,8 +471,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac

         default:

             c->decode_intra = NULL;

             c->decode_xor = NULL;

-            av_log_ask_for_sample(avctx, "Unsupported (for now) format %i\n",

-                                  c->fmt);

+            avpriv_request_sample(avctx, "Format %i", c->fmt);

             return AVERROR_PATCHWELCOME;

         }