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