avformat/cinedec: fix sizeof()
[ffmpeg.git] / libavformat / cinedec.c
1 /*
2  * Phanton Cine demuxer
3  * Copyright (c) 2010-2011 Peter Ross <pross@xvid.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 /**
23  * @file
24  * Phantom Cine demuxer
25  * @author Peter Ross <pross@xvid.org>
26  */
27
28 #include "libavutil/intreadwrite.h"
29 #include "libavcodec/bmp.h"
30 #include "avformat.h"
31 #include "internal.h"
32
33 typedef struct {
34     uint64_t pts;
35 } CineDemuxContext;
36
37 /** Compression */
38 enum {
39     CC_RGB   = 0,  /**< Gray */
40     CC_LEAD  = 1,  /**< LEAD (M)JPEG */
41     CC_UNINT = 2   /**< Uninterpolated color image (CFA field indicates color ordering)  */
42 };
43
44 /** Color Filter Array */
45 enum {
46     CFA_NONE      = 0,  /**< GRAY */
47     CFA_VRI       = 1,  /**< GBRG/RGGB */
48     CFA_VRIV6     = 2,  /**< BGGR/GRBG */
49     CFA_BAYER     = 3,  /**< GB/RG */
50     CFA_BAYERFLIP = 4,  /**< RG/GB */
51
52     CFA_TLGRAY    = 0x80000000,
53     CFA_TRGRAY    = 0x40000000,
54     CFA_BLGRAY    = 0x20000000,
55     CFA_BRGRAY    = 0x10000000
56 };
57
58 static int cine_read_probe(AVProbeData *p)
59 {
60     int HeaderSize;
61     if (p->buf[0] == 'C' && p->buf[1] == 'I' &&  // Type
62         (HeaderSize = AV_RL16(p->buf + 2)) >= 0x2C &&  // HeaderSize
63         AV_RL16(p->buf + 4) <= CC_UNINT &&       // Compression
64         AV_RL16(p->buf + 6) <= 1 &&              // Version
65         AV_RL32(p->buf + 20) &&                  // ImageCount
66         AV_RL32(p->buf + 24) >= HeaderSize &&    // OffImageHeader
67         AV_RL32(p->buf + 28) >= HeaderSize &&    // OffSetup
68         AV_RL32(p->buf + 32) >= HeaderSize)      // OffImageOffsets
69         return AVPROBE_SCORE_MAX;
70     return 0;
71 }
72
73 static int set_metadata_int(AVDictionary **dict, const char *key, int value)
74 {
75     if (value) {
76         char buf[64];
77         snprintf(buf, sizeof(buf), "%i", value);
78         buf[sizeof(buf) - 1] = 0;
79         return av_dict_set(dict, key, buf, 0);
80     }
81     return 0;
82 }
83
84 static int cine_read_header(AVFormatContext *avctx)
85 {
86     AVIOContext *pb = avctx->pb;
87     AVStream *st;
88     unsigned int version, compression, offImageHeader, offSetup, offImageOffsets, biBitCount, length, CFA;
89     int vflip;
90     char *description;
91     uint64_t i;
92
93     st = avformat_new_stream(avctx, NULL);
94     if (!st)
95         return AVERROR(ENOMEM);
96     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
97     st->codec->codec_id   = AV_CODEC_ID_RAWVIDEO;
98     st->codec->codec_tag  = 0;
99
100     /* CINEFILEHEADER structure */
101     avio_skip(pb, 4); // Type, Headersize
102
103     compression = avio_rl16(pb);
104     version     = avio_rl16(pb);
105     if (version != 1) {
106         avpriv_request_sample(avctx, "uknown version %i", version);
107         return AVERROR_INVALIDDATA;
108     }
109
110     avio_skip(pb, 12); // FirstMovieImage, TotalImageCount, FirstImageNumber
111
112     st->duration    = avio_rl32(pb);
113     offImageHeader  = avio_rl32(pb);
114     offSetup        = avio_rl32(pb);
115     offImageOffsets = avio_rl32(pb);
116
117     avio_skip(pb, 8); // TriggerTime
118
119     /* BITMAPINFOHEADER structure */
120     avio_seek(pb, offImageHeader, SEEK_SET);
121     avio_skip(pb, 4); //biSize
122     st->codec->width      = avio_rl32(pb);
123     st->codec->height     = avio_rl32(pb);
124
125     if (avio_rl16(pb) != 1) // biPlanes
126         return AVERROR_INVALIDDATA;
127
128     biBitCount = avio_rl16(pb);
129     if (biBitCount != 8 && biBitCount != 16 && biBitCount != 24 && biBitCount != 48)
130         return AVERROR_INVALIDDATA;
131
132     switch (avio_rl32(pb)) {
133     case BMP_RGB:
134         vflip = 0;
135         break;
136     case 0x100: /* BI_PACKED */
137         st->codec->codec_tag = MKTAG('B', 'I', 'T', 0);
138         vflip = 1;
139         break;
140     default:
141         avpriv_request_sample(avctx, "unknown bitmap compression");
142         return AVERROR_INVALIDDATA;
143     }
144
145     avio_skip(pb, 4); // biSizeImage
146
147     /* parse SETUP structure */
148     avio_seek(pb, offSetup, SEEK_SET);
149     avio_skip(pb, 140); // FrameRatae16 .. descriptionOld
150     if (avio_rl16(pb) != 0x5453)
151         return AVERROR_INVALIDDATA;
152     length = avio_rl16(pb);
153     if (length < 0x163C) {
154         avpriv_request_sample(avctx, "short SETUP header");
155         return AVERROR_INVALIDDATA;
156     }
157
158     avio_skip(pb, 616); // Binning .. bFlipH
159     if (!avio_rl32(pb) ^ vflip) {
160         st->codec->extradata  = av_strdup("BottomUp");
161         st->codec->extradata_size  = 9;
162     }
163
164     avio_skip(pb, 4); // Grid
165
166     avpriv_set_pts_info(st, 64, 1, avio_rl32(pb));
167
168     avio_skip(pb, 20); // Shutter .. bEnableColor
169
170     set_metadata_int(&st->metadata, "camera_version", avio_rl32(pb));
171     set_metadata_int(&st->metadata, "firmware_version", avio_rl32(pb));
172     set_metadata_int(&st->metadata, "software_version", avio_rl32(pb));
173     set_metadata_int(&st->metadata, "recording_timezone", avio_rl32(pb));
174
175     CFA = avio_rl32(pb);
176
177     set_metadata_int(&st->metadata, "brightness", avio_rl32(pb));
178     set_metadata_int(&st->metadata, "contrast", avio_rl32(pb));
179     set_metadata_int(&st->metadata, "gamma", avio_rl32(pb));
180
181     avio_skip(pb, 72); // Reserved1 .. WBView
182
183     st->codec->bits_per_coded_sample = avio_rl32(pb);
184
185     if (compression == CC_RGB) {
186         if (biBitCount == 8) {
187             st->codec->pix_fmt = AV_PIX_FMT_GRAY8;
188         } else if (biBitCount == 16) {
189             st->codec->pix_fmt = AV_PIX_FMT_GRAY16LE;
190         } else if (biBitCount == 24) {
191             st->codec->pix_fmt = AV_PIX_FMT_BGR24;
192         } else if (biBitCount == 48) {
193             st->codec->pix_fmt = AV_PIX_FMT_BGR48LE;
194         } else {
195             avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
196             return AVERROR_INVALIDDATA;
197         }
198     } else if (compression == CC_UNINT) {
199         switch (CFA & 0xFFFFFF) {
200         case CFA_BAYER:
201             if (biBitCount == 8) {
202                 st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG8;
203             } else if (biBitCount == 16) {
204                 st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG16LE;
205             } else {
206                 avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
207                 return AVERROR_INVALIDDATA;
208             }
209             break;
210         case CFA_BAYERFLIP:
211             if (biBitCount == 8) {
212                 st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB8;
213             } else if (biBitCount == 16) {
214                 st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB16LE;
215             } else {
216                 avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
217                 return AVERROR_INVALIDDATA;
218             }
219             break;
220         default:
221            avpriv_request_sample(avctx, "unsupported Color Field Array (CFA) %i", CFA & 0xFFFFFF);
222             return AVERROR_INVALIDDATA;
223         }
224     } else { //CC_LEAD
225         avpriv_request_sample(avctx, "unsupported compression %i", compression);
226         return AVERROR_INVALIDDATA;
227     }
228
229     avio_skip(pb, 696); // Conv8Min ... ImHeightAcq
230
231 #define DESCRIPTION_SIZE 4096
232     description = av_malloc(DESCRIPTION_SIZE + 1);
233     if (!description)
234         return AVERROR(ENOMEM);
235     i = avio_get_str(pb, DESCRIPTION_SIZE, description, DESCRIPTION_SIZE + 1);
236     if (i < DESCRIPTION_SIZE)
237         avio_skip(pb, DESCRIPTION_SIZE - i);
238     if (description[0])
239         av_dict_set(&st->metadata, "description", description, AV_DICT_DONT_STRDUP_VAL);
240     else
241         av_free(description);
242
243     /* parse image offsets */
244     avio_seek(pb, offImageOffsets, SEEK_SET);
245     for (i = 0; i < st->duration; i++)
246         av_add_index_entry(st, avio_rl64(pb), i, 0, 0, AVINDEX_KEYFRAME);
247
248     return 0;
249 }
250
251 static int cine_read_packet(AVFormatContext *avctx, AVPacket *pkt)
252 {
253     CineDemuxContext *cine = avctx->priv_data;
254     AVStream *st = avctx->streams[0];
255     AVIOContext *pb = avctx->pb;
256     int n, size, ret;
257
258     if (cine->pts >= st->duration)
259         return AVERROR_EOF;
260
261     avio_seek(pb, st->index_entries[cine->pts].pos, SEEK_SET);
262     n = avio_rl32(pb);
263     if (n < 8)
264         return AVERROR_INVALIDDATA;
265     avio_skip(pb, n - 8);
266     size = avio_rl32(pb);
267
268     ret = av_get_packet(pb, pkt, size);
269     if (ret < 0)
270         return ret;
271
272     pkt->pts = cine->pts++;
273     pkt->stream_index = 0;
274     pkt->flags |= AV_PKT_FLAG_KEY;
275     return 0;
276 }
277
278 static int cine_read_seek(AVFormatContext *avctx, int stream_index, int64_t timestamp, int flags)
279 {
280     CineDemuxContext *cine = avctx->priv_data;
281
282     if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
283         return AVERROR(ENOSYS);
284
285     if (!avctx->pb->seekable)
286         return AVERROR(EIO);
287
288     cine->pts = timestamp;
289     return 0;
290 }
291
292 AVInputFormat ff_cine_demuxer = {
293     .name           = "cine",
294     .long_name      = NULL_IF_CONFIG_SMALL("Phantom Cine"),
295     .priv_data_size = sizeof(CineDemuxContext),
296     .read_probe     = cine_read_probe,
297     .read_header    = cine_read_header,
298     .read_packet    = cine_read_packet,
299     .read_seek      = cine_read_seek,
300 };