git.sesse.net Git - ffmpeg/blob - libavformat/vocdec.c

   1 /*
   2  * Creative Voice File demuxer.
   3  * Copyright (c) 2006  Aurelien Jacobs <aurel@gnuage.org>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/intreadwrite.h"
  23 #include "voc.h"
  24 #include "internal.h"
  25
  26 int
  27 ff_voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
  28 {
  29     VocDecContext *voc = s->priv_data;
  30     AVCodecContext *dec = st->codec;
  31     AVIOContext *pb = s->pb;
  32     VocType type;
  33     int size, tmp_codec=-1;
  34     int sample_rate = 0;
  35     int channels = 1;
  36     int64_t duration;
  37     int ret;
  38
  39     av_add_index_entry(st,
  40                        avio_tell(pb),
  41                        voc->pts,
  42                        voc->remaining_size,
  43                        0,
  44                        AVINDEX_KEYFRAME);
  45
  46     while (!voc->remaining_size) {
  47         type = avio_r8(pb);
  48         if (type == VOC_TYPE_EOF)
  49             return AVERROR_EOF;
  50         voc->remaining_size = avio_rl24(pb);
  51         if (!voc->remaining_size) {
  52             if (!s->pb->seekable)
  53                 return AVERROR(EIO);
  54             voc->remaining_size = avio_size(pb) - avio_tell(pb);
  55         }
  56         max_size -= 4;
  57
  58         switch (type) {
  59         case VOC_TYPE_VOICE_DATA:
  60             if (!dec->sample_rate) {
  61                 dec->sample_rate = 1000000 / (256 - avio_r8(pb));
  62                 if (sample_rate)
  63                     dec->sample_rate = sample_rate;
  64                 avpriv_set_pts_info(st, 64, 1, dec->sample_rate);
  65                 dec->channels = channels;
  66                 dec->bits_per_coded_sample = av_get_bits_per_sample(dec->codec_id);
  67             } else
  68                 avio_skip(pb, 1);
  69             tmp_codec = avio_r8(pb);
  70             voc->remaining_size -= 2;
  71             max_size -= 2;
  72             channels = 1;
  73             break;
  74
  75         case VOC_TYPE_VOICE_DATA_CONT:
  76             break;
  77
  78         case VOC_TYPE_EXTENDED:
  79             sample_rate = avio_rl16(pb);
  80             avio_r8(pb);
  81             channels = avio_r8(pb) + 1;
  82             sample_rate = 256000000 / (channels * (65536 - sample_rate));
  83             voc->remaining_size = 0;
  84             max_size -= 4;
  85             break;
  86
  87         case VOC_TYPE_NEW_VOICE_DATA:
  88             if (!dec->sample_rate) {
  89                 dec->sample_rate = avio_rl32(pb);
  90                 avpriv_set_pts_info(st, 64, 1, dec->sample_rate);
  91                 dec->bits_per_coded_sample = avio_r8(pb);
  92                 dec->channels = avio_r8(pb);
  93             } else
  94                 avio_skip(pb, 6);
  95             tmp_codec = avio_rl16(pb);
  96             avio_skip(pb, 4);
  97             voc->remaining_size -= 12;
  98             max_size -= 12;
  99             break;
 100
 101         default:
 102             avio_skip(pb, voc->remaining_size);
 103             max_size -= voc->remaining_size;
 104             voc->remaining_size = 0;
 105             break;
 106         }
 107     }
 108
 109     if (tmp_codec >= 0) {
 110         tmp_codec = ff_codec_get_id(ff_voc_codec_tags, tmp_codec);
 111         if (dec->codec_id == AV_CODEC_ID_NONE)
 112             dec->codec_id = tmp_codec;
 113         else if (dec->codec_id != tmp_codec)
 114             av_log(s, AV_LOG_WARNING, "Ignoring mid-stream change in audio codec\n");
 115         if (dec->codec_id == AV_CODEC_ID_NONE) {
 116             if (s->audio_codec_id == AV_CODEC_ID_NONE) {
 117                 av_log(s, AV_LOG_ERROR, "unknown codec tag\n");
 118                 return AVERROR(EINVAL);
 119             }
 120             av_log(s, AV_LOG_WARNING, "unknown codec tag\n");
 121         }
 122     }
 123
 124     dec->bit_rate = dec->sample_rate * dec->channels * dec->bits_per_coded_sample;
 125
 126     if (max_size <= 0)
 127         max_size = 2048;
 128     size = FFMIN(voc->remaining_size, max_size);
 129     voc->remaining_size -= size;
 130
 131     ret = av_get_packet(pb, pkt, size);
 132     pkt->dts = pkt->pts = voc->pts;
 133
 134     duration = av_get_audio_frame_duration(st->codec, size);
 135     if (duration > 0 && voc->pts != AV_NOPTS_VALUE)
 136         voc->pts += duration;
 137     else
 138         voc->pts = AV_NOPTS_VALUE;
 139
 140     return ret;
 141 }
 142
 143 #if CONFIG_VOC_DEMUXER
 144 static int voc_probe(AVProbeData *p)
 145 {
 146     int version, check;
 147
 148     if (memcmp(p->buf, ff_voc_magic, sizeof(ff_voc_magic) - 1))
 149         return 0;
 150     version = AV_RL16(p->buf + 22);
 151     check = AV_RL16(p->buf + 24);
 152     if (~version + 0x1234 != check)
 153         return 10;
 154
 155     return AVPROBE_SCORE_MAX;
 156 }
 157
 158 static int voc_read_header(AVFormatContext *s)
 159 {
 160     VocDecContext *voc = s->priv_data;
 161     AVIOContext *pb = s->pb;
 162     int header_size;
 163     AVStream *st;
 164
 165     avio_skip(pb, 20);
 166     header_size = avio_rl16(pb) - 22;
 167     if (header_size != 4) {
 168         av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size);
 169         return AVERROR(ENOSYS);
 170     }
 171     avio_skip(pb, header_size);
 172     st = avformat_new_stream(s, NULL);
 173     if (!st)
 174         return AVERROR(ENOMEM);
 175     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 176
 177     voc->remaining_size = 0;
 178     return 0;
 179 }
 180
 181 static int voc_read_packet(AVFormatContext *s, AVPacket *pkt)
 182 {
 183     return ff_voc_get_packet(s, pkt, s->streams[0], 0);
 184 }
 185
 186 static int voc_read_seek(AVFormatContext *s, int stream_index,
 187                          int64_t timestamp, int flags)
 188 {
 189     VocDecContext *voc = s->priv_data;
 190     AVStream *st = s->streams[stream_index];
 191     int index = av_index_search_timestamp(st, timestamp, flags);
 192
 193     if (index >= 0 && index < st->nb_index_entries - 1) {
 194         AVIndexEntry *e = &st->index_entries[index];
 195         avio_seek(s->pb, e->pos, SEEK_SET);
 196         voc->pts = e->timestamp;
 197         voc->remaining_size = e->size;
 198         return 0;
 199     } else if (st->nb_index_entries && st->index_entries[0].timestamp <= timestamp) {
 200         AVIndexEntry *e = &st->index_entries[st->nb_index_entries - 1];
 201         // prepare context for seek_frame_generic()
 202         voc->pts = e->timestamp;
 203         voc->remaining_size = e->size;
 204     }
 205     return -1;
 206 }
 207
 208 AVInputFormat ff_voc_demuxer = {
 209     .name           = "voc",
 210     .long_name      = NULL_IF_CONFIG_SMALL("Creative Voice"),
 211     .priv_data_size = sizeof(VocDecContext),
 212     .read_probe     = voc_probe,
 213     .read_header    = voc_read_header,
 214     .read_packet    = voc_read_packet,
 215     .read_seek      = voc_read_seek,
 216     .codec_tag      = (const AVCodecTag* const []){ ff_voc_codec_tags, 0 },
 217 };
 218 #endif /* CONFIG_VOC_DEMUXER */