int wav_codec_get_id(unsigned int tag, int bps)
{
int id;
id = codec_get_id(codec_wav_tags, tag);
if (id <= 0)
return id;
/* handle specific u8 codec */
if (id == CODEC_ID_PCM_S16LE && bps == 8)
id = CODEC_ID_PCM_U8;
return id;
}
/* Returns the number of sound data frames or negative on error */
unsigned int get_aiff_header(ByteIOContext *pb, AVCodecContext *codec,
int size, unsigned version)
{
AVExtFloat ext;
double sample_rate;
unsigned int num_frames;
if (size & 1)
size++;
codec->codec_type = CODEC_TYPE_AUDIO;
codec->channels = get_be16(pb);
num_frames = get_be32(pb);
codec->bits_per_sample = get_be16(pb);
get_buffer(pb, (uint8_t*)&ext, sizeof(ext));/* Sample rate is in */
sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */
codec->sample_rate = sample_rate;
size -= 18;
/* Got an AIFF-C? */
if (version == AIFF_C_VERSION1) {
codec->codec_tag = get_le32(pb);
codec->codec_id = codec_get_id (codec_aiff_tags, codec->codec_tag);
if (codec->codec_id == CODEC_ID_PCM_S16BE) {
codec->codec_id = aiff_codec_get_id (codec->bits_per_sample);
codec->bits_per_sample = fix_bps(codec->codec_id);
}
size -= 4;
} else {
/* Need the codec type */
codec->codec_id = aiff_codec_get_id (codec->bits_per_sample);
codec->bits_per_sample = fix_bps(codec->codec_id);
}
if (!codec->codec_id)
return AVERROR_INVALIDDATA;
/* Block align needs to be computed in all cases, as the definition
* is specific to applications -> here we use the WAVE format definition */
codec->block_align = (codec->bits_per_sample * codec->channels) >> 3;
codec->bit_rate = codec->sample_rate * codec->block_align;
/* Chunk is over */
if (size)
url_fseek(pb, size, SEEK_CUR);
return num_frames;
}
/* au input */
static int au_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
int size;
unsigned int tag;
ByteIOContext *pb = s->pb;
unsigned int id, channels, rate;
enum CodecID codec;
AVStream *st;
/* check ".snd" header */
tag = get_le32(pb);
if (tag != MKTAG('.', 's', 'n', 'd'))
return -1;
size = get_be32(pb); /* header size */
get_be32(pb); /* data size */
id = get_be32(pb);
rate = get_be32(pb);
channels = get_be32(pb);
codec = codec_get_id(codec_au_tags, id);
if (size >= 24) {
/* skip unused data */
url_fseek(pb, size - 24, SEEK_CUR);
}
/* now we are ready: build format streams */
st = av_new_stream(s, 0);
if (!st)
return -1;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = id;
st->codec->codec_id = codec;
st->codec->channels = channels;
st->codec->sample_rate = rate;
av_set_pts_info(st, 64, 1, rate);
return 0;
}
/**
* \brief read until we found all data needed for decoding
* \param vst video stream of which to change parameters
* \param ast video stream of which to change parameters
* \param myth set if this is a MythTVVideo format file
* \return 1 if all required codec data was found
*/
static int get_codec_data(ByteIOContext *pb, AVStream *vst,
AVStream *ast, int myth) {
nuv_frametype frametype;
if (!vst && !myth)
return 1; // no codec data needed
while (!url_feof(pb)) {
int size, subtype;
frametype = get_byte(pb);
switch (frametype) {
case NUV_EXTRADATA:
subtype = get_byte(pb);
url_fskip(pb, 6);
size = PKTSIZE(get_le32(pb));
if (vst && subtype == 'R') {
vst->codec->extradata_size = size;
vst->codec->extradata = av_malloc(size);
get_buffer(pb, vst->codec->extradata, size);
size = 0;
if (!myth)
return 1;
}
break;
case NUV_MYTHEXT:
url_fskip(pb, 7);
size = PKTSIZE(get_le32(pb));
if (size != 128 * 4)
break;
get_le32(pb); // version
if (vst) {
vst->codec->codec_tag = get_le32(pb);
vst->codec->codec_id =
codec_get_id(codec_bmp_tags, vst->codec->codec_tag);
if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))
vst->codec->codec_id = CODEC_ID_NUV;
} else
url_fskip(pb, 4);
if (ast) {
ast->codec->codec_tag = get_le32(pb);
ast->codec->sample_rate = get_le32(pb);
ast->codec->bits_per_coded_sample = get_le32(pb);
ast->codec->channels = get_le32(pb);
ast->codec->codec_id =
wav_codec_get_id(ast->codec->codec_tag,
ast->codec->bits_per_coded_sample);
ast->need_parsing = AVSTREAM_PARSE_FULL;
} else
url_fskip(pb, 4 * 4);
size -= 6 * 4;
url_fskip(pb, size);
return 1;
case NUV_SEEKP:
size = 11;
break;
default:
url_fskip(pb, 7);
size = PKTSIZE(get_le32(pb));
break;
}
url_fskip(pb, size);
}
return 0;
}
int
voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
{
voc_dec_context_t *voc = s->priv_data;
AVCodecContext *dec = st->codec;
ByteIOContext *pb = s->pb;
voc_type_t type;
int size;
int sample_rate = 0;
int channels = 1;
while (!voc->remaining_size) {
type = get_byte(pb);
if (type == VOC_TYPE_EOF)
return AVERROR(EIO);
voc->remaining_size = get_le24(pb);
max_size -= 4;
switch (type) {
case VOC_TYPE_VOICE_DATA:
dec->sample_rate = 1000000 / (256 - get_byte(pb));
if (sample_rate)
dec->sample_rate = sample_rate;
dec->channels = channels;
dec->codec_id = codec_get_id(voc_codec_tags, get_byte(pb));
dec->bits_per_sample = av_get_bits_per_sample(dec->codec_id);
voc->remaining_size -= 2;
max_size -= 2;
channels = 1;
break;
case VOC_TYPE_VOICE_DATA_CONT:
break;
case VOC_TYPE_EXTENDED:
sample_rate = get_le16(pb);
get_byte(pb);
channels = get_byte(pb) + 1;
sample_rate = 256000000 / (channels * (65536 - sample_rate));
voc->remaining_size = 0;
max_size -= 4;
break;
case VOC_TYPE_NEW_VOICE_DATA:
dec->sample_rate = get_le32(pb);
dec->bits_per_sample = get_byte(pb);
dec->channels = get_byte(pb);
dec->codec_id = codec_get_id(voc_codec_tags, get_le16(pb));
url_fskip(pb, 4);
voc->remaining_size -= 12;
max_size -= 12;
break;
default:
url_fskip(pb, voc->remaining_size);
max_size -= voc->remaining_size;
voc->remaining_size = 0;
break;
}
}
dec->bit_rate = dec->sample_rate * dec->bits_per_sample;
if (max_size <= 0)
max_size = 2048;
size = FFMIN(voc->remaining_size, max_size);
voc->remaining_size -= size;
return av_get_packet(pb, pkt, size);
}
static int avisynth_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
AVISynthContext *avs = s->priv_data;
HRESULT res;
AVIFILEINFO info;
DWORD id;
AVStream *st;
AVISynthStream *stream;
AVIFileInit();
res = AVIFileOpen(&avs->file, s->filename, OF_READ|OF_SHARE_DENY_WRITE, NULL);
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileOpen failed with error %ld", res);
AVIFileExit();
return -1;
}
res = AVIFileInfo(avs->file, &info, sizeof(info));
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileInfo failed with error %ld", res);
AVIFileExit();
return -1;
}
avs->streams = av_mallocz(info.dwStreams * sizeof(AVISynthStream));
for (id=0; id<info.dwStreams; id++)
{
stream = &avs->streams[id];
stream->read = 0;
if (AVIFileGetStream(avs->file, &stream->handle, 0, id) == S_OK)
{
if (AVIStreamInfo(stream->handle, &stream->info, sizeof(stream->info)) == S_OK)
{
if (stream->info.fccType == streamtypeAUDIO)
{
WAVEFORMATEX wvfmt;
LONG struct_size = sizeof(WAVEFORMATEX);
if (AVIStreamReadFormat(stream->handle, 0, &wvfmt, &struct_size) != S_OK)
continue;
st = av_new_stream(s, id);
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->block_align = wvfmt.nBlockAlign;
st->codec->channels = wvfmt.nChannels;
st->codec->sample_rate = wvfmt.nSamplesPerSec;
st->codec->bit_rate = wvfmt.nAvgBytesPerSec * 8;
st->codec->bits_per_sample = wvfmt.wBitsPerSample;
stream->chunck_samples = wvfmt.nSamplesPerSec * (uint64_t)info.dwScale / (uint64_t)info.dwRate;
stream->chunck_size = stream->chunck_samples * wvfmt.nChannels * wvfmt.wBitsPerSample / 8;
st->codec->codec_tag = wvfmt.wFormatTag;
st->codec->codec_id = wav_codec_get_id(wvfmt.wFormatTag, st->codec->bits_per_sample);
}
else if (stream->info.fccType == streamtypeVIDEO)
{
BITMAPINFO imgfmt;
LONG struct_size = sizeof(BITMAPINFO);
stream->chunck_size = stream->info.dwSampleSize;
stream->chunck_samples = 1;
if (AVIStreamReadFormat(stream->handle, 0, &imgfmt, &struct_size) != S_OK)
continue;
st = av_new_stream(s, id);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->r_frame_rate.num = stream->info.dwRate;
st->r_frame_rate.den = stream->info.dwScale;
st->codec->width = imgfmt.bmiHeader.biWidth;
st->codec->height = imgfmt.bmiHeader.biHeight;
st->codec->bits_per_sample = imgfmt.bmiHeader.biBitCount;
st->codec->bit_rate = (uint64_t)stream->info.dwSampleSize * (uint64_t)stream->info.dwRate * 8 / (uint64_t)stream->info.dwScale;
st->codec->codec_tag = imgfmt.bmiHeader.biCompression;
st->codec->codec_id = codec_get_id(codec_bmp_tags, imgfmt.bmiHeader.biCompression);
st->duration = stream->info.dwLength;
}
else
{
AVIStreamRelease(stream->handle);
continue;
}
avs->nb_streams++;
st->codec->stream_codec_tag = stream->info.fccHandler;
av_set_pts_info(st, 64, info.dwScale, info.dwRate);
st->start_time = stream->info.dwStart;
}
}
}
return 0;
}
enum CodecID codec_get_wav_id(unsigned int tag)
{
return codec_get_id(codec_wav_tags, tag);
}
enum CodecID codec_get_bmp_id(unsigned int tag)
{
return codec_get_id(codec_bmp_tags, tag);
}
/* Returns the number of sound data frames or negative on error */
static unsigned int get_aiff_header(ByteIOContext *pb, AVCodecContext *codec,
int size, unsigned version)
{
AVExtFloat ext;
double sample_rate;
unsigned int num_frames;
if (size & 1)
size++;
codec->codec_type = CODEC_TYPE_AUDIO;
codec->channels = get_be16(pb);
num_frames = get_be32(pb);
codec->bits_per_coded_sample = get_be16(pb);
get_buffer(pb, (uint8_t*)&ext, sizeof(ext));/* Sample rate is in */
sample_rate = av_ext2dbl(ext); /* 80 bits BE IEEE extended float */
codec->sample_rate = sample_rate;
size -= 18;
/* Got an AIFF-C? */
if (version == AIFF_C_VERSION1) {
codec->codec_tag = get_le32(pb);
codec->codec_id = codec_get_id(codec_aiff_tags, codec->codec_tag);
switch (codec->codec_id) {
case CODEC_ID_PCM_S16BE:
codec->codec_id = aiff_codec_get_id(codec->bits_per_coded_sample);
codec->bits_per_coded_sample = av_get_bits_per_sample(codec->codec_id);
break;
case CODEC_ID_ADPCM_IMA_QT:
codec->block_align = 34*codec->channels;
codec->frame_size = 64;
break;
case CODEC_ID_MACE3:
codec->block_align = 2*codec->channels;
codec->frame_size = 6;
break;
case CODEC_ID_MACE6:
codec->block_align = 1*codec->channels;
codec->frame_size = 6;
break;
case CODEC_ID_GSM:
codec->block_align = 33;
codec->frame_size = 160;
break;
default:
break;
}
size -= 4;
} else {
/* Need the codec type */
codec->codec_id = aiff_codec_get_id(codec->bits_per_coded_sample);
codec->bits_per_coded_sample = av_get_bits_per_sample(codec->codec_id);
}
/* Block align needs to be computed in all cases, as the definition
* is specific to applications -> here we use the WAVE format definition */
if (!codec->block_align)
codec->block_align = (codec->bits_per_coded_sample * codec->channels) >> 3;
codec->bit_rate = (codec->frame_size ? codec->sample_rate/codec->frame_size :
codec->sample_rate) * (codec->block_align << 3);
/* Chunk is over */
if (size)
url_fseek(pb, size, SEEK_CUR);
return num_frames;
}
