* up and sending out the chunks.
*/
+#include "libavutil/channel_layout.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "internal.h"
int64_t video_pts;
uint32_t palette[256];
int has_palette;
+ int changed;
unsigned int audio_bits;
unsigned int audio_channels;
unsigned int audio_sample_rate;
- enum CodecID audio_type;
+ enum AVCodecID audio_type;
unsigned int audio_frame_count;
int video_stream_index;
int chunk_type;
if (s->audio_chunk_offset) {
+ if (s->audio_type == AV_CODEC_ID_NONE) {
+ av_log(NULL, AV_LOG_ERROR, "Can not read audio packet before"
+ "audio codec is known\n");
+ return CHUNK_BAD;
+ }
/* adjust for PCM audio by skipping chunk header */
- if (s->audio_type != CODEC_ID_INTERPLAY_DPCM) {
+ if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM) {
s->audio_chunk_offset += 6;
s->audio_chunk_size -= 6;
}
pkt->pts = s->audio_frame_count;
/* audio frame maintenance */
- if (s->audio_type != CODEC_ID_INTERPLAY_DPCM)
+ if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM)
s->audio_frame_count +=
(s->audio_chunk_size / s->audio_channels / (s->audio_bits / 8));
else
s->audio_frame_count +=
- (s->audio_chunk_size - 6) / s->audio_channels;
+ (s->audio_chunk_size - 6 - s->audio_channels) / s->audio_channels;
- av_dlog(NULL, "sending audio frame with pts %"PRId64" (%d audio frames)\n",
+ av_log(NULL, AV_LOG_TRACE, "sending audio frame with pts %"PRId64" (%d audio frames)\n",
pkt->pts, s->audio_frame_count);
chunk_type = CHUNK_VIDEO;
}
}
+ if (s->changed) {
+ ff_add_param_change(pkt, 0, 0, 0, s->video_width, s->video_height);
+ s->changed = 0;
+ }
pkt->pos= s->decode_map_chunk_offset;
avio_seek(pb, s->decode_map_chunk_offset, SEEK_SET);
s->decode_map_chunk_offset = 0;
pkt->stream_index = s->video_stream_index;
pkt->pts = s->video_pts;
- av_dlog(NULL, "sending video frame with pts %"PRId64"\n", pkt->pts);
+ av_log(NULL, AV_LOG_TRACE, "sending video frame with pts %"PRId64"\n", pkt->pts);
s->video_pts += s->frame_pts_inc;
int first_color, last_color;
int audio_flags;
unsigned char r, g, b;
+ unsigned int width, height;
/* see if there are any pending packets */
chunk_type = load_ipmovie_packet(s, pb, pkt);
chunk_size = AV_RL16(&chunk_preamble[0]);
chunk_type = AV_RL16(&chunk_preamble[2]);
- av_dlog(NULL, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size);
+ av_log(NULL, AV_LOG_TRACE, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size);
switch (chunk_type) {
case CHUNK_INIT_AUDIO:
- av_dlog(NULL, "initialize audio\n");
+ av_log(NULL, AV_LOG_TRACE, "initialize audio\n");
break;
case CHUNK_AUDIO_ONLY:
- av_dlog(NULL, "audio only\n");
+ av_log(NULL, AV_LOG_TRACE, "audio only\n");
break;
case CHUNK_INIT_VIDEO:
- av_dlog(NULL, "initialize video\n");
+ av_log(NULL, AV_LOG_TRACE, "initialize video\n");
break;
case CHUNK_VIDEO:
- av_dlog(NULL, "video (and audio)\n");
+ av_log(NULL, AV_LOG_TRACE, "video (and audio)\n");
break;
case CHUNK_SHUTDOWN:
- av_dlog(NULL, "shutdown\n");
+ av_log(NULL, AV_LOG_TRACE, "shutdown\n");
break;
case CHUNK_END:
- av_dlog(NULL, "end\n");
+ av_log(NULL, AV_LOG_TRACE, "end\n");
break;
default:
- av_dlog(NULL, "invalid chunk\n");
+ av_log(NULL, AV_LOG_TRACE, "invalid chunk\n");
chunk_type = CHUNK_BAD;
break;
chunk_size -= OPCODE_PREAMBLE_SIZE;
chunk_size -= opcode_size;
if (chunk_size < 0) {
- av_dlog(NULL, "chunk_size countdown just went negative\n");
+ av_log(NULL, AV_LOG_TRACE, "chunk_size countdown just went negative\n");
chunk_type = CHUNK_BAD;
break;
}
- av_dlog(NULL, " opcode type %02X, version %d, 0x%04X bytes: ",
+ av_log(NULL, AV_LOG_TRACE, " opcode type %02X, version %d, 0x%04X bytes: ",
opcode_type, opcode_version, opcode_size);
switch (opcode_type) {
case OPCODE_END_OF_STREAM:
- av_dlog(NULL, "end of stream\n");
+ av_log(NULL, AV_LOG_TRACE, "end of stream\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_END_OF_CHUNK:
- av_dlog(NULL, "end of chunk\n");
+ av_log(NULL, AV_LOG_TRACE, "end of chunk\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_CREATE_TIMER:
- av_dlog(NULL, "create timer\n");
+ av_log(NULL, AV_LOG_TRACE, "create timer\n");
if ((opcode_version > 0) || (opcode_size > 6)) {
- av_dlog(NULL, "bad create_timer opcode\n");
+ av_log(NULL, AV_LOG_TRACE, "bad create_timer opcode\n");
chunk_type = CHUNK_BAD;
break;
}
break;
}
s->frame_pts_inc = ((uint64_t)AV_RL32(&scratch[0])) * AV_RL16(&scratch[4]);
- av_dlog(NULL, " %.2f frames/second (timer div = %d, subdiv = %d)\n",
+ av_log(NULL, AV_LOG_TRACE, " %.2f frames/second (timer div = %d, subdiv = %d)\n",
1000000.0 / s->frame_pts_inc, AV_RL32(&scratch[0]),
AV_RL16(&scratch[4]));
break;
case OPCODE_INIT_AUDIO_BUFFERS:
- av_dlog(NULL, "initialize audio buffers\n");
+ av_log(NULL, AV_LOG_TRACE, "initialize audio buffers\n");
if ((opcode_version > 1) || (opcode_size > 10)) {
- av_dlog(NULL, "bad init_audio_buffers opcode\n");
+ av_log(NULL, AV_LOG_TRACE, "bad init_audio_buffers opcode\n");
chunk_type = CHUNK_BAD;
break;
}
s->audio_bits = (((audio_flags >> 1) & 1) + 1) * 8;
/* bit 2 indicates compressed audio in version 1 opcode */
if ((opcode_version == 1) && (audio_flags & 0x4))
- s->audio_type = CODEC_ID_INTERPLAY_DPCM;
+ s->audio_type = AV_CODEC_ID_INTERPLAY_DPCM;
else if (s->audio_bits == 16)
- s->audio_type = CODEC_ID_PCM_S16LE;
+ s->audio_type = AV_CODEC_ID_PCM_S16LE;
else
- s->audio_type = CODEC_ID_PCM_U8;
- av_dlog(NULL, "audio: %d bits, %d Hz, %s, %s format\n",
+ s->audio_type = AV_CODEC_ID_PCM_U8;
+ av_log(NULL, AV_LOG_TRACE, "audio: %d bits, %d Hz, %s, %s format\n",
s->audio_bits, s->audio_sample_rate,
(s->audio_channels == 2) ? "stereo" : "mono",
- (s->audio_type == CODEC_ID_INTERPLAY_DPCM) ?
+ (s->audio_type == AV_CODEC_ID_INTERPLAY_DPCM) ?
"Interplay audio" : "PCM");
break;
case OPCODE_START_STOP_AUDIO:
- av_dlog(NULL, "start/stop audio\n");
+ av_log(NULL, AV_LOG_TRACE, "start/stop audio\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_INIT_VIDEO_BUFFERS:
- av_dlog(NULL, "initialize video buffers\n");
+ av_log(NULL, AV_LOG_TRACE, "initialize video buffers\n");
if ((opcode_version > 2) || (opcode_size > 8)) {
- av_dlog(NULL, "bad init_video_buffers opcode\n");
+ av_log(NULL, AV_LOG_TRACE, "bad init_video_buffers opcode\n");
chunk_type = CHUNK_BAD;
break;
}
chunk_type = CHUNK_BAD;
break;
}
- s->video_width = AV_RL16(&scratch[0]) * 8;
- s->video_height = AV_RL16(&scratch[2]) * 8;
+ width = AV_RL16(&scratch[0]) * 8;
+ height = AV_RL16(&scratch[2]) * 8;
+ if (width != s->video_width) {
+ s->video_width = width;
+ s->changed++;
+ }
+ if (height != s->video_height) {
+ s->video_height = height;
+ s->changed++;
+ }
if (opcode_version < 2 || !AV_RL16(&scratch[6])) {
s->video_bpp = 8;
} else {
s->video_bpp = 16;
}
- av_dlog(NULL, "video resolution: %d x %d\n",
+ av_log(NULL, AV_LOG_TRACE, "video resolution: %d x %d\n",
s->video_width, s->video_height);
break;
case OPCODE_UNKNOWN_13:
case OPCODE_UNKNOWN_14:
case OPCODE_UNKNOWN_15:
- av_dlog(NULL, "unknown (but documented) opcode %02X\n", opcode_type);
+ av_log(NULL, AV_LOG_TRACE, "unknown (but documented) opcode %02X\n", opcode_type);
avio_skip(pb, opcode_size);
break;
case OPCODE_SEND_BUFFER:
- av_dlog(NULL, "send buffer\n");
+ av_log(NULL, AV_LOG_TRACE, "send buffer\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_AUDIO_FRAME:
- av_dlog(NULL, "audio frame\n");
+ av_log(NULL, AV_LOG_TRACE, "audio frame\n");
/* log position and move on for now */
s->audio_chunk_offset = avio_tell(pb);
break;
case OPCODE_SILENCE_FRAME:
- av_dlog(NULL, "silence frame\n");
+ av_log(NULL, AV_LOG_TRACE, "silence frame\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_INIT_VIDEO_MODE:
- av_dlog(NULL, "initialize video mode\n");
+ av_log(NULL, AV_LOG_TRACE, "initialize video mode\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_CREATE_GRADIENT:
- av_dlog(NULL, "create gradient\n");
+ av_log(NULL, AV_LOG_TRACE, "create gradient\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_SET_PALETTE:
- av_dlog(NULL, "set palette\n");
+ av_log(NULL, AV_LOG_TRACE, "set palette\n");
/* check for the logical maximum palette size
* (3 * 256 + 4 bytes) */
if (opcode_size > 0x304) {
- av_dlog(NULL, "demux_ipmovie: set_palette opcode too large\n");
+ av_log(NULL, AV_LOG_TRACE, "demux_ipmovie: set_palette opcode too large\n");
chunk_type = CHUNK_BAD;
break;
}
last_color = first_color + AV_RL16(&scratch[2]) - 1;
/* sanity check (since they are 16 bit values) */
if ((first_color > 0xFF) || (last_color > 0xFF)) {
- av_dlog(NULL, "demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",
+ av_log(NULL, AV_LOG_TRACE, "demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",
first_color, last_color);
chunk_type = CHUNK_BAD;
break;
break;
case OPCODE_SET_PALETTE_COMPRESSED:
- av_dlog(NULL, "set palette compressed\n");
+ av_log(NULL, AV_LOG_TRACE, "set palette compressed\n");
avio_skip(pb, opcode_size);
break;
case OPCODE_SET_DECODING_MAP:
- av_dlog(NULL, "set decoding map\n");
+ av_log(NULL, AV_LOG_TRACE, "set decoding map\n");
/* log position and move on for now */
s->decode_map_chunk_offset = avio_tell(pb);
break;
case OPCODE_VIDEO_DATA:
- av_dlog(NULL, "set video data\n");
+ av_log(NULL, AV_LOG_TRACE, "set video data\n");
/* log position and move on for now */
s->video_chunk_offset = avio_tell(pb);
break;
default:
- av_dlog(NULL, "*** unknown opcode type\n");
+ av_log(NULL, AV_LOG_TRACE, "*** unknown opcode type\n");
chunk_type = CHUNK_BAD;
break;
return 0;
}
-static int ipmovie_read_header(AVFormatContext *s,
- AVFormatParameters *ap)
+static int ipmovie_read_header(AVFormatContext *s)
{
IPMVEContext *ipmovie = s->priv_data;
AVIOContext *pb = s->pb;
avio_seek(pb, -CHUNK_PREAMBLE_SIZE, SEEK_CUR);
if (chunk_type == CHUNK_VIDEO)
- ipmovie->audio_type = CODEC_ID_NONE; /* no audio */
+ ipmovie->audio_type = AV_CODEC_ID_NONE; /* no audio */
else if (process_ipmovie_chunk(ipmovie, pb, &pkt) != CHUNK_INIT_AUDIO)
return AVERROR_INVALIDDATA;
avpriv_set_pts_info(st, 63, 1, 1000000);
ipmovie->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
- st->codec->codec_id = CODEC_ID_INTERPLAY_VIDEO;
+ st->codec->codec_id = AV_CODEC_ID_INTERPLAY_VIDEO;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = ipmovie->video_width;
st->codec->height = ipmovie->video_height;
st->codec->codec_id = ipmovie->audio_type;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = ipmovie->audio_channels;
+ st->codec->channel_layout = st->codec->channels == 1 ? AV_CH_LAYOUT_MONO :
+ AV_CH_LAYOUT_STEREO;
st->codec->sample_rate = ipmovie->audio_sample_rate;
st->codec->bits_per_coded_sample = ipmovie->audio_bits;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_coded_sample;
- if (st->codec->codec_id == CODEC_ID_INTERPLAY_DPCM)
+ if (st->codec->codec_id == AV_CODEC_ID_INTERPLAY_DPCM)
st->codec->bit_rate /= 2;
st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;
}
AVInputFormat ff_ipmovie_demuxer = {
.name = "ipmovie",
- .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE format"),
+ .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE"),
.priv_data_size = sizeof(IPMVEContext),
.read_probe = ipmovie_probe,
.read_header = ipmovie_read_header,
projects / ffmpeg / blobdiff