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

   1 /*
   2  * Gremlin Digital Video demuxer
   3  * Copyright (c) 2017 Paul B Mahol
   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
  24 #include "avformat.h"
  25 #include "avio.h"
  26 #include "internal.h"
  27
  28 typedef struct GDVContext {
  29     int is_first_video;
  30     int is_audio;
  31     int audio_size;
  32     int audio_stream_index;
  33     int video_stream_index;
  34     unsigned pal[256];
  35 } GDVContext;
  36
  37 static int gdv_read_probe(AVProbeData *p)
  38 {
  39     if (AV_RL32(p->buf) == 0x29111994)
  40         return AVPROBE_SCORE_MAX;
  41
  42     return 0;
  43 }
  44
  45 struct {
  46     uint16_t id;
  47     uint16_t width;
  48     uint16_t height;
  49 } FixedSize[] = {
  50     { 0, 320, 200},
  51     { 1, 640, 200},
  52     { 2, 320, 167},
  53     { 3, 320, 180},
  54     { 4, 320, 400},
  55     { 5, 320, 170},
  56     { 6, 160,  85},
  57     { 7, 160,  83},
  58     { 8, 160,  90},
  59     { 9, 280, 128},
  60     {10, 320, 240},
  61     {11, 320, 201},
  62     {16, 640, 400},
  63     {17, 640, 200},
  64     {18, 640, 180},
  65     {19, 640, 167},
  66     {20, 640, 170},
  67     {21, 320, 240}
  68 };
  69
  70 static int gdv_read_header(AVFormatContext *ctx)
  71 {
  72     GDVContext *gdv = ctx->priv_data;
  73     AVIOContext *pb = ctx->pb;
  74     AVStream *vst, *ast;
  75     unsigned fps, snd_flags, vid_depth, size_id;
  76
  77     avio_skip(pb, 4);
  78     size_id = avio_rl16(pb);
  79
  80     vst = avformat_new_stream(ctx, 0);
  81     if (!vst)
  82         return AVERROR(ENOMEM);
  83
  84     vst->start_time        = 0;
  85     vst->duration          =
  86     vst->nb_frames         = avio_rl16(pb);
  87
  88     fps = avio_rl16(pb);
  89     snd_flags = avio_rl16(pb);
  90     if (snd_flags & 1) {
  91         ast = avformat_new_stream(ctx, 0);
  92         if (!ast)
  93             return AVERROR(ENOMEM);
  94
  95         ast->start_time = 0;
  96         ast->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
  97         ast->codecpar->codec_tag   = 0;
  98         ast->codecpar->sample_rate = avio_rl16(pb);
  99         ast->codecpar->channels    = 1 + !!(snd_flags & 2);
 100         if (snd_flags & 8) {
 101             ast->codecpar->codec_id = AV_CODEC_ID_GREMLIN_DPCM;
 102         } else {
 103             ast->codecpar->codec_id = (snd_flags & 4) ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_U8;
 104         }
 105
 106         avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
 107         gdv->audio_size = (ast->codecpar->sample_rate / fps) *
 108                            ast->codecpar->channels * (1 + !!(snd_flags & 4)) / (1 + !!(snd_flags & 8));
 109         gdv->is_audio = 1;
 110     }
 111     vid_depth = avio_rl16(pb);
 112     avio_skip(pb, 4);
 113
 114     vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 115     vst->codecpar->codec_id   = AV_CODEC_ID_GDV;
 116     vst->codecpar->codec_tag  = 0;
 117     vst->codecpar->width      = avio_rl16(pb);
 118     vst->codecpar->height     = avio_rl16(pb);
 119
 120     if (vst->codecpar->width == 0 || vst->codecpar->height == 0) {
 121         int i;
 122
 123         for (i = 0; i < FF_ARRAY_ELEMS(FixedSize) - 1; i++) {
 124             if (FixedSize[i].id == size_id)
 125                 break;
 126         }
 127
 128         vst->codecpar->width  = FixedSize[i].width;
 129         vst->codecpar->height = FixedSize[i].height;
 130     }
 131
 132     avpriv_set_pts_info(vst, 64, 1, fps);
 133
 134     if (vid_depth & 1) {
 135         int i;
 136
 137         for (i = 0; i < 256; i++) {
 138             unsigned r = avio_r8(pb);
 139             unsigned g = avio_r8(pb);
 140             unsigned b = avio_r8(pb);
 141             gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
 142         }
 143     }
 144
 145     gdv->is_first_video = 1;
 146
 147     return 0;
 148 }
 149
 150 static int gdv_read_packet(AVFormatContext *ctx, AVPacket *pkt)
 151 {
 152     GDVContext *gdv = ctx->priv_data;
 153     AVIOContext *pb = ctx->pb;
 154     int ret;
 155
 156     if (avio_feof(pb))
 157         return pb->error ? pb->error : AVERROR_EOF;
 158
 159     if (gdv->audio_size && gdv->is_audio) {
 160         ret = av_get_packet(pb, pkt, gdv->audio_size);
 161         if (ret < 0)
 162             return ret;
 163         pkt->stream_index = 1;
 164         gdv->is_audio = 0;
 165     } else {
 166         uint8_t *pal;
 167
 168         if (avio_rl16(pb) != 0x1305)
 169             return AVERROR_INVALIDDATA;
 170         ret = av_get_packet(pb, pkt, 4 + avio_rl16(pb));
 171         if (ret < 0)
 172             return ret;
 173         pkt->stream_index = 0;
 174         gdv->is_audio = 1;
 175
 176         if (gdv->is_first_video) {
 177             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
 178                                           AVPALETTE_SIZE);
 179             if (!pal) {
 180                 av_packet_unref(pkt);
 181                 return AVERROR(ENOMEM);
 182             }
 183             memcpy(pal, gdv->pal, AVPALETTE_SIZE);
 184             pkt->flags |= AV_PKT_FLAG_KEY;
 185             gdv->is_first_video = 0;
 186         }
 187     }
 188
 189     return 0;
 190 }
 191
 192 AVInputFormat ff_gdv_demuxer = {
 193     .name           = "gdv",
 194     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
 195     .priv_data_size = sizeof(GDVContext),
 196     .read_probe     = gdv_read_probe,
 197     .read_header    = gdv_read_header,
 198     .read_packet    = gdv_read_packet,
 199 };