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

   1 /*
   2  * IFV demuxer
   3  *
   4  * Copyright (c) 2019 Swaraj Hota
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "avformat.h"
  24 #include "internal.h"
  25 #include "avio_internal.h"
  26
  27 typedef struct IFVContext {
  28     uint32_t next_video_index;
  29     uint32_t next_audio_index;
  30     uint32_t total_vframes;
  31     uint32_t total_aframes;
  32
  33     int width, height;
  34     int is_audio_present;
  35     int sample_rate;
  36
  37     int video_stream_index;
  38     int audio_stream_index;
  39 } IFVContext;
  40
  41 static int ifv_probe(const AVProbeData *p)
  42 {
  43     static const uint8_t ifv_magic[] = {0x11, 0xd2, 0xd3, 0xab, 0xba, 0xa9,
  44         0xcf, 0x11, 0x8e, 0xe6, 0x00, 0xc0, 0x0c, 0x20, 0x53, 0x65, 0x44};
  45
  46     if (!memcmp(p->buf, ifv_magic, sizeof(ifv_magic)))
  47         return AVPROBE_SCORE_MAX;
  48
  49     return 0;
  50 }
  51
  52 static int read_index(AVFormatContext *s,
  53                       enum AVMediaType frame_type,
  54                       uint32_t start_index)
  55 {
  56     IFVContext *ifv = s->priv_data;
  57     AVStream *st;
  58     int64_t pos, size, timestamp;
  59     uint32_t end_index, i;
  60     int ret;
  61
  62     if (frame_type == AVMEDIA_TYPE_VIDEO) {
  63         end_index = ifv->total_vframes;
  64         st = s->streams[ifv->video_stream_index];
  65     } else {
  66         end_index = ifv->total_aframes;
  67         st = s->streams[ifv->audio_stream_index];
  68     }
  69
  70     for (i = start_index; i < end_index; i++) {
  71         if (avio_feof(s->pb))
  72             return AVERROR_EOF;
  73         pos = avio_rl32(s->pb);
  74         size = avio_rl32(s->pb);
  75
  76         avio_skip(s->pb, 8);
  77         timestamp = avio_rl32(s->pb);
  78
  79         ret = av_add_index_entry(st, pos, timestamp, size, 0, 0);
  80         if (ret < 0)
  81             return ret;
  82
  83         avio_skip(s->pb, frame_type == AVMEDIA_TYPE_VIDEO ? 8: 4);
  84     }
  85
  86     return 0;
  87 }
  88
  89 static int parse_header(AVFormatContext *s)
  90 {
  91     IFVContext *ifv = s->priv_data;
  92     uint32_t aud_magic;
  93     uint32_t vid_magic;
  94
  95     avio_skip(s->pb, 0x34);
  96     avpriv_dict_set_timestamp(&s->metadata, "creation_time", avio_rl32(s->pb) * 1000000LL);
  97     avio_skip(s->pb, 0x24);
  98
  99     ifv->width = avio_rl16(s->pb);
 100     ifv->height = avio_rl16(s->pb);
 101
 102     avio_skip(s->pb, 0x8);
 103     vid_magic = avio_rl32(s->pb);
 104
 105     if (vid_magic != MKTAG('H','2','6','4'))
 106         avpriv_request_sample(s, "Unknown video codec %x", vid_magic);
 107
 108     avio_skip(s->pb, 0x2c);
 109     ifv->sample_rate = avio_rl32(s->pb);
 110     aud_magic = avio_rl32(s->pb);
 111
 112     if (aud_magic == MKTAG('G','R','A','W')) {
 113         ifv->is_audio_present = 1;
 114     } else if (aud_magic == MKTAG('P','C','M','U')) {
 115         ifv->is_audio_present = 0;
 116     } else {
 117         avpriv_request_sample(s, "Unknown audio codec %x", aud_magic);
 118     }
 119
 120     avio_skip(s->pb, 0x44);
 121     ifv->total_vframes = avio_rl32(s->pb);
 122     ifv->total_aframes = avio_rl32(s->pb);
 123
 124     return 0;
 125 }
 126
 127 static int ifv_read_header(AVFormatContext *s)
 128 {
 129     IFVContext *ifv = s->priv_data;
 130     AVStream *st;
 131     int ret;
 132
 133     ret = parse_header(s);
 134     if (ret < 0)
 135         return ret;
 136
 137     st = avformat_new_stream(s, NULL);
 138     if (!st)
 139         return AVERROR(ENOMEM);
 140
 141     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 142     st->codecpar->codec_id = AV_CODEC_ID_H264;
 143     st->codecpar->width = ifv->width;
 144     st->codecpar->height = ifv->height;
 145     st->start_time = 0;
 146     ifv->video_stream_index = st->index;
 147
 148     avpriv_set_pts_info(st, 32, 1, 1000);
 149
 150     if (ifv->is_audio_present) {
 151         st = avformat_new_stream(s, NULL);
 152         if (!st)
 153             return AVERROR(ENOMEM);
 154
 155         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
 156         st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
 157         st->codecpar->channels = 1;
 158         st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
 159         st->codecpar->sample_rate = ifv->sample_rate;
 160         ifv->audio_stream_index = st->index;
 161
 162         avpriv_set_pts_info(st, 32, 1, 1000);
 163     }
 164
 165     /*read video index*/
 166     avio_seek(s->pb, 0xf8, SEEK_SET);
 167
 168     ret = read_index(s, AVMEDIA_TYPE_VIDEO, 0);
 169     if (ret < 0)
 170         return ret;
 171
 172     if (ifv->is_audio_present) {
 173         /*read audio index*/
 174         avio_seek(s->pb, 0x14918, SEEK_SET);
 175
 176         ret = read_index(s, AVMEDIA_TYPE_AUDIO, 0);
 177         if (ret < 0)
 178             return ret;
 179     }
 180
 181     ifv->next_video_index = 0;
 182     ifv->next_audio_index = 0;
 183
 184     return 0;
 185 }
 186
 187 static int ifv_read_packet(AVFormatContext *s, AVPacket *pkt)
 188 {
 189     IFVContext *ifv = s->priv_data;
 190     AVStream *st;
 191     AVIndexEntry *ev, *ea, *e_next;
 192     int ret;
 193
 194     ev = ea = e_next = NULL;
 195
 196     if (ifv->next_video_index < ifv->total_vframes) {
 197         st = s->streams[ifv->video_stream_index];
 198         if (ifv->next_video_index < st->nb_index_entries)
 199             e_next = ev = &st->index_entries[ifv->next_video_index];
 200     }
 201
 202     if (ifv->is_audio_present &&
 203         ifv->next_audio_index < ifv->total_aframes) {
 204         st = s->streams[ifv->audio_stream_index];
 205         if (ifv->next_audio_index < st->nb_index_entries) {
 206             ea = &st->index_entries[ifv->next_audio_index];
 207             if (!ev || ea->timestamp < ev->timestamp)
 208                 e_next = ea;
 209         }
 210     }
 211
 212     if (!ev) {
 213         if (ifv->is_audio_present && !ea) {
 214             /*read new video and audio indexes*/
 215
 216             ifv->next_video_index = ifv->total_vframes;
 217             ifv->next_audio_index = ifv->total_aframes;
 218
 219             avio_skip(s->pb, 0x1c);
 220             ifv->total_vframes += avio_rl32(s->pb);
 221             ifv->total_aframes += avio_rl32(s->pb);
 222             avio_skip(s->pb, 0xc);
 223
 224             if (avio_feof(s->pb))
 225                 return AVERROR_EOF;
 226
 227             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
 228             if (ret < 0)
 229                 return ret;
 230
 231             ret = read_index(s, AVMEDIA_TYPE_AUDIO, ifv->next_audio_index);
 232             if (ret < 0)
 233                 return ret;
 234
 235             return 0;
 236
 237         } else if (!ifv->is_audio_present) {
 238             /*read new video index*/
 239
 240             ifv->next_video_index = ifv->total_vframes;
 241
 242             avio_skip(s->pb, 0x1c);
 243             ifv->total_vframes += avio_rl32(s->pb);
 244             avio_skip(s->pb, 0x10);
 245
 246             if (avio_feof(s->pb))
 247                 return AVERROR_EOF;
 248
 249             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
 250             if (ret < 0)
 251                 return ret;
 252
 253             return 0;
 254         }
 255     }
 256
 257     if (!e_next) return AVERROR_EOF;
 258
 259     avio_seek(s->pb, e_next->pos, SEEK_SET);
 260     ret = av_get_packet(s->pb, pkt, e_next->size);
 261     if (ret < 0)
 262         return ret;
 263
 264     if (e_next == ev) {
 265         ifv->next_video_index++;
 266         pkt->stream_index = ifv->video_stream_index;
 267     } else {
 268         ifv->next_audio_index++;
 269         pkt->stream_index = ifv->audio_stream_index;
 270     }
 271
 272     pkt->pts = e_next->timestamp;
 273     pkt->pos = e_next->pos;
 274
 275     return 0;
 276 }
 277
 278 static int ifv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
 279 {
 280     IFVContext *ifv = s->priv_data;
 281
 282     for (unsigned i = 0; i < s->nb_streams; i++) {
 283         int index = av_index_search_timestamp(s->streams[i], ts, AVSEEK_FLAG_ANY);
 284         if (index < 0) {
 285             ifv->next_video_index = ifv->total_vframes - 1;
 286             ifv->next_audio_index = ifv->total_aframes - 1;
 287             return 0;
 288         }
 289
 290         if (i == ifv->video_stream_index) {
 291             ifv->next_video_index = index;
 292         } else {
 293             ifv->next_audio_index = index;
 294         }
 295     }
 296
 297     return 0;
 298 }
 299
 300 AVInputFormat ff_ifv_demuxer = {
 301     .name           = "ifv",
 302     .long_name      = NULL_IF_CONFIG_SMALL("IFV CCTV DVR"),
 303     .priv_data_size = sizeof(IFVContext),
 304     .extensions     = "ifv",
 305     .read_probe     = ifv_probe,
 306     .read_header    = ifv_read_header,
 307     .read_packet    = ifv_read_packet,
 308     .read_seek      = ifv_read_seek,
 309 };