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;
}
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];
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;
}
}
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;
}
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;
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;
}
/* 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];
}
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;
}
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");
} 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;
}
}
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;
}
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{
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 */
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;
}
}
break;
default:
- av_log_ask_for_sample(avctx, "unknown/invalid code\n");
+ avpriv_request_sample(avctx, "unknown/invalid code");
return AVERROR_INVALIDDATA;
}
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++) {
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;
}
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;
}
}
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;
}
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;
}
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;
}
}
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;
}
}
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;
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;
}
} 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;
}
} 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;
}
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;
}
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;
}
}
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:
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) {
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;
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;
}
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;
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);
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);
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;
}
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;
}
{
IcoDemuxContext *ico = s->priv_data;
AVIOContext *pb = s->pb;
- int i;
+ int i, codec;
avio_skip(pb, 4);
ico->nb_images = avio_rl16(pb);
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;
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;
}
}
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;
} 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;
}
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;
}
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;
}
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)) {
} 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")) {
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);
}
}
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;
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);
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);
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;
}
}
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);
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;
}
!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);
} 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)) {
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;
}
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;
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);