lavf: Constify the probe function argument.
[ffmpeg.git] / 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(const AVProbeData *p)
38 {
39     if (AV_RL32(p->buf) == 0x29111994)
40         return AVPROBE_SCORE_MAX;
41
42     return 0;
43 }
44
45 static 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     if (!fps)
90         return AVERROR_INVALIDDATA;
91
92     snd_flags = avio_rl16(pb);
93     if (snd_flags & 1) {
94         ast = avformat_new_stream(ctx, 0);
95         if (!ast)
96             return AVERROR(ENOMEM);
97
98         ast->start_time = 0;
99         ast->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
100         ast->codecpar->codec_tag   = 0;
101         ast->codecpar->sample_rate = avio_rl16(pb);
102         ast->codecpar->channels    = 1 + !!(snd_flags & 2);
103         if (snd_flags & 8) {
104             ast->codecpar->codec_id = AV_CODEC_ID_GREMLIN_DPCM;
105         } else {
106             ast->codecpar->codec_id = (snd_flags & 4) ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_U8;
107         }
108
109         avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
110         gdv->audio_size = (ast->codecpar->sample_rate / fps) *
111                            ast->codecpar->channels * (1 + !!(snd_flags & 4)) / (1 + !!(snd_flags & 8));
112         gdv->is_audio = 1;
113     } else {
114         avio_skip(pb, 2);
115     }
116     vid_depth = avio_rl16(pb);
117     avio_skip(pb, 4);
118
119     vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
120     vst->codecpar->codec_id   = AV_CODEC_ID_GDV;
121     vst->codecpar->codec_tag  = 0;
122     vst->codecpar->width      = avio_rl16(pb);
123     vst->codecpar->height     = avio_rl16(pb);
124
125     if (vst->codecpar->width == 0 || vst->codecpar->height == 0) {
126         int i;
127
128         for (i = 0; i < FF_ARRAY_ELEMS(FixedSize) - 1; i++) {
129             if (FixedSize[i].id == size_id)
130                 break;
131         }
132
133         vst->codecpar->width  = FixedSize[i].width;
134         vst->codecpar->height = FixedSize[i].height;
135     }
136
137     avpriv_set_pts_info(vst, 64, 1, fps);
138
139     if (vid_depth & 1) {
140         int i;
141
142         for (i = 0; i < 256; i++) {
143             unsigned r = avio_r8(pb);
144             unsigned g = avio_r8(pb);
145             unsigned b = avio_r8(pb);
146             gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
147         }
148     }
149
150     gdv->is_first_video = 1;
151
152     return 0;
153 }
154
155 static int gdv_read_packet(AVFormatContext *ctx, AVPacket *pkt)
156 {
157     GDVContext *gdv = ctx->priv_data;
158     AVIOContext *pb = ctx->pb;
159     int ret;
160
161     if (avio_feof(pb))
162         return pb->error ? pb->error : AVERROR_EOF;
163
164     if (gdv->audio_size && gdv->is_audio) {
165         ret = av_get_packet(pb, pkt, gdv->audio_size);
166         if (ret < 0)
167             return ret;
168         pkt->stream_index = 1;
169         gdv->is_audio = 0;
170     } else {
171         uint8_t *pal;
172
173         if (avio_rl16(pb) != 0x1305)
174             return AVERROR_INVALIDDATA;
175         ret = av_get_packet(pb, pkt, 4 + avio_rl16(pb));
176         if (ret < 0)
177             return ret;
178         pkt->stream_index = 0;
179         gdv->is_audio = 1;
180
181         if (gdv->is_first_video) {
182             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
183                                           AVPALETTE_SIZE);
184             if (!pal) {
185                 av_packet_unref(pkt);
186                 return AVERROR(ENOMEM);
187             }
188             memcpy(pal, gdv->pal, AVPALETTE_SIZE);
189             pkt->flags |= AV_PKT_FLAG_KEY;
190             gdv->is_first_video = 0;
191         }
192     }
193
194     return 0;
195 }
196
197 AVInputFormat ff_gdv_demuxer = {
198     .name           = "gdv",
199     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
200     .priv_data_size = sizeof(GDVContext),
201     .read_probe     = gdv_read_probe,
202     .read_header    = gdv_read_header,
203     .read_packet    = gdv_read_packet,
204 };