Entries are sorted chronologically from oldest to youngest within each release,
releases are sorted from youngest to oldest.
-
version next:
- v410 Quicktime Uncompressed 4:4:4 10-bit encoder and decoder
- SBaGen (SBG) binaural beats script demuxer
static enum AVDiscard skip_frame = AVDISCARD_DEFAULT;
static enum AVDiscard skip_idct = AVDISCARD_DEFAULT;
static enum AVDiscard skip_loop_filter = AVDISCARD_DEFAULT;
-static int error_recognition = FF_ER_CAREFUL;
static int error_concealment = 3;
static int decoder_reorder_pts = -1;
static int autoexit;
avctx->skip_frame = skip_frame;
avctx->skip_idct = skip_idct;
avctx->skip_loop_filter = skip_loop_filter;
- avctx->error_recognition = error_recognition;
avctx->error_concealment = error_concealment;
if(avctx->lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
{ "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, { (void*)&skip_frame }, "", "" },
{ "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, { (void*)&skip_idct }, "", "" },
{ "idct", OPT_INT | HAS_ARG | OPT_EXPERT, { (void*)&idct }, "set idct algo", "algo" },
- { "er", OPT_INT | HAS_ARG | OPT_EXPERT, { (void*)&error_recognition }, "set error detection threshold (0-4)", "threshold" },
{ "ec", OPT_INT | HAS_ARG | OPT_EXPERT, { (void*)&error_concealment }, "set error concealment options", "bit_mask" },
{ "sync", HAS_ARG | OPT_EXPERT, { (void*)opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
{ "autoexit", OPT_BOOL | OPT_EXPERT, { (void*)&autoexit }, "exit at the end", "" },
OBJS-$(CONFIG_ADPCM_G726_DECODER) += g726.o
OBJS-$(CONFIG_ADPCM_G726_ENCODER) += g726.o
OBJS-$(CONFIG_ADPCM_IMA_AMV_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_APC_DECODER) += adpcm.o adpcm_data.o
OBJS-$(CONFIG_ADPCM_IMA_DK3_DECODER) += adpcm.o adpcm_data.o
OBJS-$(CONFIG_ADPCM_IMA_DK4_DECODER) += adpcm.o adpcm_data.o
OBJS-$(CONFIG_ADPCM_IMA_EA_EACS_DECODER) += adpcm.o adpcm_data.o
if (namelen >= 15)
put_bits(&s->pb, 8, namelen - 14);
put_bits(&s->pb, 4, 0); //extension type - filler
- padbits = 8 - (put_bits_count(&s->pb) & 7);
+ padbits = -put_bits_count(&s->pb) & 7;
avpriv_align_put_bits(&s->pb);
for (i = 0; i < namelen - 2; i++)
put_bits(&s->pb, 8, name[i]);
typedef struct ADPCMDecodeContext {
AVFrame frame;
ADPCMChannelStatus status[6];
+ int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */
} ADPCMDecodeContext;
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
return -1;
}
break;
- case CODEC_ID_ADPCM_IMA_WS:
- if (avctx->extradata && avctx->extradata_size == 2 * 4) {
+ case CODEC_ID_ADPCM_IMA_APC:
+ if (avctx->extradata && avctx->extradata_size >= 8) {
c->status[0].predictor = AV_RL32(avctx->extradata);
c->status[1].predictor = AV_RL32(avctx->extradata + 4);
}
break;
+ case CODEC_ID_ADPCM_IMA_WS:
+ if (avctx->extradata && avctx->extradata_size >= 42)
+ c->vqa_version = AV_RL16(avctx->extradata);
+ break;
default:
break;
}
break;
/* simple 4-bit adpcm */
case CODEC_ID_ADPCM_CT:
+ case CODEC_ID_ADPCM_IMA_APC:
case CODEC_ID_ADPCM_IMA_EA_SEAD:
case CODEC_ID_ADPCM_IMA_WS:
case CODEC_ID_ADPCM_YAMAHA:
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
}
break;
- case CODEC_ID_ADPCM_IMA_WS:
+ case CODEC_ID_ADPCM_IMA_APC:
while (src < buf + buf_size) {
uint8_t v = *src++;
*samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
}
break;
+ case CODEC_ID_ADPCM_IMA_WS:
+ for (channel = 0; channel < avctx->channels; channel++) {
+ const uint8_t *src0;
+ int src_stride;
+ int16_t *smp = samples + channel;
+
+ if (c->vqa_version == 3) {
+ src0 = src + channel * buf_size / 2;
+ src_stride = 1;
+ } else {
+ src0 = src + channel;
+ src_stride = avctx->channels;
+ }
+ for (n = nb_samples / 2; n > 0; n--) {
+ uint8_t v = *src0;
+ src0 += src_stride;
+ *smp = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
+ smp += avctx->channels;
+ *smp = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
+ smp += avctx->channels;
+ }
+ }
+ src = buf + buf_size;
+ break;
case CODEC_ID_ADPCM_XA:
while (buf_size >= 128) {
xa_decode(samples, src, &c->status[0], &c->status[1],
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
REGISTER_ENCDEC (ADPCM_G722, adpcm_g722);
REGISTER_ENCDEC (ADPCM_G726, adpcm_g726);
REGISTER_DECODER (ADPCM_IMA_AMV, adpcm_ima_amv);
+ REGISTER_DECODER (ADPCM_IMA_APC, adpcm_ima_apc);
REGISTER_DECODER (ADPCM_IMA_DK3, adpcm_ima_dk3);
REGISTER_DECODER (ADPCM_IMA_DK4, adpcm_ima_dk4);
REGISTER_DECODER (ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
CODEC_ID_ADPCM_EA_MAXIS_XA,
CODEC_ID_ADPCM_IMA_ISS,
CODEC_ID_ADPCM_G722,
+ CODEC_ID_ADPCM_IMA_APC,
/* AMR */
CODEC_ID_AMR_NB = 0x12000,
slice_count = avctx->slice_count;
for(i=0; i<slice_count; i++){
- int offset= get_slice_offset(avctx, slices_hdr, i);
+ unsigned offset = get_slice_offset(avctx, slices_hdr, i);
int size, size2;
+ if (offset >= buf_size)
+ return AVERROR_INVALIDDATA;
+
if(i+1 == slice_count)
size= buf_size - offset;
else
else
size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
+ if (size <= 0 || size2 <= 0 ||
+ offset + FFMAX(size, size2) > buf_size)
+ return AVERROR_INVALIDDATA;
+
if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
i++;
}
return 3;
case CODEC_ID_ADPCM_SBPRO_4:
case CODEC_ID_ADPCM_CT:
+ case CODEC_ID_ADPCM_IMA_APC:
case CODEC_ID_ADPCM_IMA_WAV:
case CODEC_ID_ADPCM_IMA_QT:
case CODEC_ID_ADPCM_SWF:
#define AVCODEC_VERSION_H
#define LIBAVCODEC_VERSION_MAJOR 53
-#define LIBAVCODEC_VERSION_MINOR 58
+#define LIBAVCODEC_VERSION_MINOR 59
#define LIBAVCODEC_VERSION_MICRO 100
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
#define FF_API_ANTIALIAS_ALGO (LIBAVCODEC_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_REQUEST_CHANNELS
-#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 54)
+#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_OPT_H
#define FF_API_OPT_H (LIBAVCODEC_VERSION_MAJOR < 54)
#define FF_API_DATA_POINTERS (LIBAVCODEC_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_OLD_DECODE_AUDIO
-#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 54)
+#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_OLD_TIMECODE
#define FF_API_OLD_TIMECODE (LIBAVCODEC_VERSION_MAJOR < 54)
#define FF_API_AVFRAME_AGE (LIBAVCODEC_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_OLD_ENCODE_AUDIO
-#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 54)
+#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
#endif
#endif /* AVCODEC_VERSION_H */
OBJS-$(CONFIG_SNDIO_INDEV) += sndio_common.o sndio_dec.o
OBJS-$(CONFIG_SNDIO_OUTDEV) += sndio_common.o sndio_enc.o
OBJS-$(CONFIG_V4L2_INDEV) += v4l2.o
-OBJS-$(CONFIG_V4L_INDEV) += v4l.o
OBJS-$(CONFIG_VFWCAP_INDEV) += vfwcap.o
OBJS-$(CONFIG_X11_GRAB_DEVICE_INDEV) += x11grab.o
REGISTER_OUTDEV (SDL, sdl);
REGISTER_INOUTDEV (SNDIO, sndio);
REGISTER_INDEV (V4L2, v4l2);
-#if FF_API_V4L
REGISTER_INDEV (V4L, v4l);
-#endif
REGISTER_INDEV (VFWCAP, vfwcap);
REGISTER_INDEV (X11_GRAB_DEVICE, x11_grab_device);
LIBAVDEVICE_VERSION_MICRO)
#define LIBAVDEVICE_BUILD LIBAVDEVICE_VERSION_INT
-#ifndef FF_API_V4L
-#define FF_API_V4L (LIBAVDEVICE_VERSION_MAJOR < 54)
-#endif
-
/**
* Return the LIBAVDEVICE_VERSION_INT constant.
*/
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
+ st->codec->codec_id = CODEC_ID_ADPCM_IMA_APC;
avio_rl32(pb); /* number of samples */
st->codec->sample_rate = avio_rl32(pb);
#define FF_API_SET_PTS_INFO (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_CLOSE_INPUT_FILE
-#define FF_API_CLOSE_INPUT_FILE (LIBAVFORMAT_VERSION_MAJOR < 54)
+#define FF_API_CLOSE_INPUT_FILE (LIBAVFORMAT_VERSION_MAJOR < 55)
#endif
#endif /* AVFORMAT_VERSION_H */
#define AUD_CHUNK_PREAMBLE_SIZE 8
#define AUD_CHUNK_SIGNATURE 0x0000DEAF
-typedef struct WsAudDemuxContext {
- int audio_samplerate;
- int audio_channels;
- int audio_bits;
- enum CodecID audio_type;
- int audio_stream_index;
- int64_t audio_frame_counter;
-} WsAudDemuxContext;
-
static int wsaud_probe(AVProbeData *p)
{
int field;
/* note: only check for WS IMA (type 99) right now since there is no
* support for type 1 */
- if (p->buf[11] != 99)
+ if (p->buf[11] != 99 && p->buf[11] != 1)
return 0;
/* read ahead to the first audio chunk and validate the first header signature */
static int wsaud_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
- WsAudDemuxContext *wsaud = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st;
unsigned char header[AUD_HEADER_SIZE];
+ int sample_rate, channels, codec;
if (avio_read(pb, header, AUD_HEADER_SIZE) != AUD_HEADER_SIZE)
return AVERROR(EIO);
- wsaud->audio_samplerate = AV_RL16(&header[0]);
- if (header[11] == 99)
- wsaud->audio_type = CODEC_ID_ADPCM_IMA_WS;
- else
- return AVERROR_INVALIDDATA;
- /* flag 0 indicates stereo */
- wsaud->audio_channels = (header[10] & 0x1) + 1;
- /* flag 1 indicates 16 bit audio */
- wsaud->audio_bits = (((header[10] & 0x2) >> 1) + 1) * 8;
+ sample_rate = AV_RL16(&header[0]);
+ channels = (header[10] & 0x1) + 1;
+ codec = header[11];
/* initialize the audio decoder stream */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- avpriv_set_pts_info(st, 33, 1, wsaud->audio_samplerate);
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- st->codec->codec_id = wsaud->audio_type;
- st->codec->codec_tag = 0; /* no tag */
- st->codec->channels = wsaud->audio_channels;
- st->codec->sample_rate = wsaud->audio_samplerate;
- st->codec->bits_per_coded_sample = wsaud->audio_bits;
- st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
- st->codec->bits_per_coded_sample / 4;
- st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
-
- wsaud->audio_stream_index = st->index;
- wsaud->audio_frame_counter = 0;
+
+ switch (codec) {
+ case 1:
+ if (channels != 1) {
+ av_log_ask_for_sample(s, "Stereo WS-SND1 is not supported.\n");
+ return AVERROR_PATCHWELCOME;
+ }
+ st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
+ break;
+ case 99:
+ st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
+ st->codec->bits_per_coded_sample = 4;
+ st->codec->bit_rate = channels * sample_rate * 4;
+ break;
+ default:
+ av_log_ask_for_sample(s, "Unknown codec: %d\n", codec);
+ return AVERROR_PATCHWELCOME;
+ }
+ avpriv_set_pts_info(st, 64, 1, sample_rate);
+ st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+ st->codec->channels = channels;
+ st->codec->sample_rate = sample_rate;
return 0;
}
static int wsaud_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
- WsAudDemuxContext *wsaud = s->priv_data;
AVIOContext *pb = s->pb;
unsigned char preamble[AUD_CHUNK_PREAMBLE_SIZE];
unsigned int chunk_size;
int ret = 0;
+ AVStream *st = s->streams[0];
if (avio_read(pb, preamble, AUD_CHUNK_PREAMBLE_SIZE) !=
AUD_CHUNK_PREAMBLE_SIZE)
return AVERROR_INVALIDDATA;
chunk_size = AV_RL16(&preamble[0]);
- ret= av_get_packet(pb, pkt, chunk_size);
- if (ret != chunk_size)
- return AVERROR(EIO);
- pkt->stream_index = wsaud->audio_stream_index;
- pkt->pts = wsaud->audio_frame_counter;
- pkt->pts /= wsaud->audio_samplerate;
- /* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
- wsaud->audio_frame_counter += (chunk_size * 2) / wsaud->audio_channels;
+ if (st->codec->codec_id == CODEC_ID_WESTWOOD_SND1) {
+ /* For Westwood SND1 audio we need to add the output size and input
+ size to the start of the packet to match what is in VQA.
+ Specifically, this is needed to signal when a packet should be
+ decoding as raw 8-bit pcm or variable-size ADPCM. */
+ int out_size = AV_RL16(&preamble[2]);
+ if ((ret = av_new_packet(pkt, chunk_size + 4)))
+ return ret;
+ if ((ret = avio_read(pb, &pkt->data[4], chunk_size)) != chunk_size)
+ return ret < 0 ? ret : AVERROR(EIO);
+ AV_WL16(&pkt->data[0], out_size);
+ AV_WL16(&pkt->data[2], chunk_size);
+
+ pkt->duration = out_size;
+ } else {
+ ret = av_get_packet(pb, pkt, chunk_size);
+ if (ret != chunk_size)
+ return AVERROR(EIO);
+
+ /* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
+ pkt->duration = (chunk_size * 2) / st->codec->channels;
+ }
+ pkt->stream_index = st->index;
return ret;
}
AVInputFormat ff_wsaud_demuxer = {
.name = "wsaud",
.long_name = NULL_IF_CONFIG_SMALL("Westwood Studios audio format"),
- .priv_data_size = sizeof(WsAudDemuxContext),
.read_probe = wsaud_probe,
.read_header = wsaud_read_header,
.read_packet = wsaud_read_packet,
#define CMDS_TAG MKBETAG('C', 'M', 'D', 'S')
#define VQA_HEADER_SIZE 0x2A
-#define VQA_FRAMERATE 15
#define VQA_PREAMBLE_SIZE 8
typedef struct WsVqaDemuxContext {
- int audio_samplerate;
int audio_channels;
- int audio_bits;
-
int audio_stream_index;
int video_stream_index;
-
- int64_t audio_frame_counter;
} WsVqaDemuxContext;
static int wsvqa_probe(AVProbeData *p)
unsigned char scratch[VQA_PREAMBLE_SIZE];
unsigned int chunk_tag;
unsigned int chunk_size;
+ int fps, version, flags, sample_rate, channels;
/* initialize the video decoder stream */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- avpriv_set_pts_info(st, 33, 1, VQA_FRAMERATE);
+ st->start_time = 0;
wsvqa->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_WS_VQA;
}
st->codec->width = AV_RL16(&header[6]);
st->codec->height = AV_RL16(&header[8]);
+ fps = header[12];
+ if (fps < 1 || fps > 30) {
+ av_log(s, AV_LOG_ERROR, "invalid fps: %d\n", fps);
+ return AVERROR_INVALIDDATA;
+ }
+ avpriv_set_pts_info(st, 64, 1, fps);
/* initialize the audio decoder stream for VQA v1 or nonzero samplerate */
- if (AV_RL16(&header[24]) || (AV_RL16(&header[0]) == 1 && AV_RL16(&header[2]) == 1)) {
+ version = AV_RL16(&header[ 0]);
+ flags = AV_RL16(&header[ 2]);
+ sample_rate = AV_RL16(&header[24]);
+ channels = header[26];
+ if (sample_rate || (version == 1 && flags == 1)) {
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- avpriv_set_pts_info(st, 33, 1, VQA_FRAMERATE);
+ st->start_time = 0;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- if (AV_RL16(&header[0]) == 1)
+
+ st->codec->extradata_size = VQA_HEADER_SIZE;
+ st->codec->extradata = av_mallocz(VQA_HEADER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!st->codec->extradata)
+ return AVERROR(ENOMEM);
+ memcpy(st->codec->extradata, header, VQA_HEADER_SIZE);
+
+ if (!sample_rate)
+ sample_rate = 22050;
+ st->codec->sample_rate = sample_rate;
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
+
+ if (!channels)
+ channels = 1;
+ st->codec->channels = channels;
+
+ switch (version) {
+ case 1:
st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
- else
+ break;
+ case 2:
+ case 3:
st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
- st->codec->codec_tag = 0; /* no tag */
- st->codec->sample_rate = AV_RL16(&header[24]);
- if (!st->codec->sample_rate)
- st->codec->sample_rate = 22050;
- st->codec->channels = header[26];
- if (!st->codec->channels)
- st->codec->channels = 1;
- st->codec->bits_per_coded_sample = 16;
- st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
- st->codec->bits_per_coded_sample / 4;
- st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
+ st->codec->bits_per_coded_sample = 4;
+ st->codec->bit_rate = channels * sample_rate * 4;
+ break;
+ default:
+ /* NOTE: version 0 is supposedly raw pcm_u8 or pcm_s16le, but we do
+ not have any samples to validate this */
+ av_log_ask_for_sample(s, "VQA version %d audio\n", version);
+ return AVERROR_PATCHWELCOME;
+ }
wsvqa->audio_stream_index = st->index;
- wsvqa->audio_samplerate = st->codec->sample_rate;
wsvqa->audio_channels = st->codec->channels;
- wsvqa->audio_frame_counter = 0;
}
/* there are 0 or more chunks before the FINF chunk; iterate until
if (chunk_type == SND2_TAG) {
pkt->stream_index = wsvqa->audio_stream_index;
/* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
- wsvqa->audio_frame_counter += (chunk_size * 2) / wsvqa->audio_channels;
+ pkt->duration = (chunk_size * 2) / wsvqa->audio_channels;
} else if(chunk_type == SND1_TAG) {
pkt->stream_index = wsvqa->audio_stream_index;
/* unpacked size is stored in header */
- wsvqa->audio_frame_counter += AV_RL16(pkt->data) / wsvqa->audio_channels;
+ pkt->duration = AV_RL16(pkt->data) / wsvqa->audio_channels;
} else {
pkt->stream_index = wsvqa->video_stream_index;
+ pkt->duration = 1;
}
/* stay on 16-bit alignment */
if (skip_byte)
// Audio
audio_dec = audio_stream->codec;
audio_dec->codec_type = AVMEDIA_TYPE_AUDIO;
- audio_dec->codec_id = CODEC_ID_ADPCM_IMA_WS;
+ audio_dec->codec_id = CODEC_ID_ADPCM_IMA_APC;
audio_dec->channels = 1;
audio_dec->sample_rate = 22050;