summaryrefslogtreecommitdiff
path: root/libavcodec/dpx.c (plain)
blob: 1aa2cbd1c8acab8f7ad45656546fb6f150041d47
1/*
2 * DPX (.dpx) image decoder
3 * Copyright (c) 2009 Jimmy Christensen
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#include "libavutil/intfloat.h"
24#include "libavutil/imgutils.h"
25#include "bytestream.h"
26#include "avcodec.h"
27#include "internal.h"
28
29static unsigned int read16(const uint8_t **ptr, int is_big)
30{
31 unsigned int temp;
32 if (is_big) {
33 temp = AV_RB16(*ptr);
34 } else {
35 temp = AV_RL16(*ptr);
36 }
37 *ptr += 2;
38 return temp;
39}
40
41static unsigned int read32(const uint8_t **ptr, int is_big)
42{
43 unsigned int temp;
44 if (is_big) {
45 temp = AV_RB32(*ptr);
46 } else {
47 temp = AV_RL32(*ptr);
48 }
49 *ptr += 4;
50 return temp;
51}
52
53static uint16_t read10in32(const uint8_t **ptr, uint32_t * lbuf,
54 int * n_datum, int is_big)
55{
56 if (*n_datum)
57 (*n_datum)--;
58 else {
59 *lbuf = read32(ptr, is_big);
60 *n_datum = 2;
61 }
62
63 *lbuf = (*lbuf << 10) | (*lbuf >> 22);
64
65 return *lbuf & 0x3FF;
66}
67
68static int decode_frame(AVCodecContext *avctx,
69 void *data,
70 int *got_frame,
71 AVPacket *avpkt)
72{
73 const uint8_t *buf = avpkt->data;
74 int buf_size = avpkt->size;
75 AVFrame *const p = data;
76 uint8_t *ptr[AV_NUM_DATA_POINTERS];
77
78 unsigned int offset;
79 int magic_num, endian;
80 int x, y, stride, i, ret;
81 int w, h, bits_per_color, descriptor, elements, packing;
82 int encoding, need_align = 0;
83
84 unsigned int rgbBuffer = 0;
85 int n_datum = 0;
86
87 if (avpkt->size <= 1634) {
88 av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
89 return AVERROR_INVALIDDATA;
90 }
91
92 magic_num = AV_RB32(buf);
93 buf += 4;
94
95 /* Check if the files "magic number" is "SDPX" which means it uses
96 * big-endian or XPDS which is for little-endian files */
97 if (magic_num == AV_RL32("SDPX")) {
98 endian = 0;
99 } else if (magic_num == AV_RB32("SDPX")) {
100 endian = 1;
101 } else {
102 av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
103 return AVERROR_INVALIDDATA;
104 }
105
106 offset = read32(&buf, endian);
107 if (avpkt->size <= offset) {
108 av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
109 return AVERROR_INVALIDDATA;
110 }
111
112 // Check encryption
113 buf = avpkt->data + 660;
114 ret = read32(&buf, endian);
115 if (ret != 0xFFFFFFFF) {
116 avpriv_report_missing_feature(avctx, "Encryption");
117 av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "
118 "not properly decode.\n");
119 }
120
121 // Need to end in 0x304 offset from start of file
122 buf = avpkt->data + 0x304;
123 w = read32(&buf, endian);
124 h = read32(&buf, endian);
125
126 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
127 return ret;
128
129 // Need to end in 0x320 to read the descriptor
130 buf += 20;
131 descriptor = buf[0];
132
133 // Need to end in 0x323 to read the bits per color
134 buf += 3;
135 avctx->bits_per_raw_sample =
136 bits_per_color = buf[0];
137 buf++;
138 packing = read16(&buf, endian);
139 encoding = read16(&buf, endian);
140
141 if (packing > 1) {
142 avpriv_report_missing_feature(avctx, "Packing %d", packing);
143 return AVERROR_PATCHWELCOME;
144 }
145 if (encoding) {
146 avpriv_report_missing_feature(avctx, "Encoding %d", encoding);
147 return AVERROR_PATCHWELCOME;
148 }
149
150 buf += 820;
151 avctx->sample_aspect_ratio.num = read32(&buf, endian);
152 avctx->sample_aspect_ratio.den = read32(&buf, endian);
153 if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
154 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
155 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den,
156 0x10000);
157 else
158 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
159
160 if (offset >= 1724 + 4) {
161 buf = avpkt->data + 1724;
162 i = read32(&buf, endian);
163 if(i) {
164 AVRational q = av_d2q(av_int2float(i), 4096);
165 if (q.num > 0 && q.den > 0)
166 avctx->framerate = q;
167 }
168 }
169
170 switch (descriptor) {
171 case 6: // Y
172 elements = 1;
173 break;
174 case 52: // ABGR
175 case 51: // RGBA
176 case 103: // UYVA4444
177 elements = 4;
178 break;
179 case 50: // RGB
180 case 102: // UYV444
181 elements = 3;
182 break;
183 case 100: // UYVY422
184 elements = 2;
185 break;
186 default:
187 avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
188 return AVERROR_PATCHWELCOME;
189 }
190
191 switch (bits_per_color) {
192 case 8:
193 stride = avctx->width * elements;
194 break;
195 case 10:
196 if (!packing) {
197 av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
198 return -1;
199 }
200 stride = (avctx->width * elements + 2) / 3 * 4;
201 break;
202 case 12:
203 if (!packing) {
204 av_log(avctx, AV_LOG_ERROR, "Packing to 16bit required\n");
205 return -1;
206 }
207 stride = 2 * avctx->width * elements;
208 break;
209 case 16:
210 stride = 2 * avctx->width * elements;
211 break;
212 case 1:
213 case 32:
214 case 64:
215 avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
216 return AVERROR_PATCHWELCOME;
217 default:
218 return AVERROR_INVALIDDATA;
219 }
220
221 // Table 3c: Runs will always break at scan line boundaries. Packing
222 // will always break to the next 32-bit word at scan-line boundaries.
223 // Unfortunately, the encoder produced invalid files, so attempt
224 // to detect it
225 need_align = FFALIGN(stride, 4);
226 if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
227 // Alignment seems unappliable, try without
228 if (stride*avctx->height + (int64_t)offset > avpkt->size) {
229 av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
230 return AVERROR_INVALIDDATA;
231 } else {
232 av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
233 "alignment.\n");
234 need_align = 0;
235 }
236 } else {
237 need_align -= stride;
238 stride = FFALIGN(stride, 4);
239 }
240
241 switch (1000 * descriptor + 10 * bits_per_color + endian) {
242 case 6081:
243 case 6080:
244 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
245 break;
246 case 6121:
247 case 6120:
248 avctx->pix_fmt = AV_PIX_FMT_GRAY12;
249 break;
250 case 50081:
251 case 50080:
252 avctx->pix_fmt = AV_PIX_FMT_RGB24;
253 break;
254 case 52081:
255 case 52080:
256 avctx->pix_fmt = AV_PIX_FMT_ABGR;
257 break;
258 case 51081:
259 case 51080:
260 avctx->pix_fmt = AV_PIX_FMT_RGBA;
261 break;
262 case 50100:
263 case 50101:
264 avctx->pix_fmt = AV_PIX_FMT_GBRP10;
265 break;
266 case 51100:
267 case 51101:
268 avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
269 break;
270 case 50120:
271 case 50121:
272 avctx->pix_fmt = AV_PIX_FMT_GBRP12;
273 break;
274 case 51120:
275 case 51121:
276 avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
277 break;
278 case 6161:
279 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
280 break;
281 case 6160:
282 avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
283 break;
284 case 50161:
285 avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
286 break;
287 case 50160:
288 avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
289 break;
290 case 51161:
291 avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
292 break;
293 case 51160:
294 avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
295 break;
296 case 100081:
297 avctx->pix_fmt = AV_PIX_FMT_UYVY422;
298 break;
299 case 102081:
300 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
301 break;
302 case 103081:
303 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
304 break;
305 default:
306 av_log(avctx, AV_LOG_ERROR, "Unsupported format\n");
307 return AVERROR_PATCHWELCOME;
308 }
309
310 ff_set_sar(avctx, avctx->sample_aspect_ratio);
311
312 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
313 return ret;
314
315 // Move pointer to offset from start of file
316 buf = avpkt->data + offset;
317
318 for (i=0; i<AV_NUM_DATA_POINTERS; i++)
319 ptr[i] = p->data[i];
320
321 switch (bits_per_color) {
322 case 10:
323 for (x = 0; x < avctx->height; x++) {
324 uint16_t *dst[4] = {(uint16_t*)ptr[0],
325 (uint16_t*)ptr[1],
326 (uint16_t*)ptr[2],
327 (uint16_t*)ptr[3]};
328 for (y = 0; y < avctx->width; y++) {
329 *dst[2]++ = read10in32(&buf, &rgbBuffer,
330 &n_datum, endian);
331 *dst[0]++ = read10in32(&buf, &rgbBuffer,
332 &n_datum, endian);
333 *dst[1]++ = read10in32(&buf, &rgbBuffer,
334 &n_datum, endian);
335 if (elements == 4)
336 *dst[3]++ =
337 read10in32(&buf, &rgbBuffer,
338 &n_datum, endian);
339 }
340 n_datum = 0;
341 for (i = 0; i < elements; i++)
342 ptr[i] += p->linesize[i];
343 }
344 break;
345 case 12:
346 for (x = 0; x < avctx->height; x++) {
347 uint16_t *dst[4] = {(uint16_t*)ptr[0],
348 (uint16_t*)ptr[1],
349 (uint16_t*)ptr[2],
350 (uint16_t*)ptr[3]};
351 for (y = 0; y < avctx->width; y++) {
352 if (elements >= 3)
353 *dst[2]++ = read16(&buf, endian) >> 4;
354 *dst[0] = read16(&buf, endian) >> 4;
355 dst[0]++;
356 if (elements >= 2)
357 *dst[1]++ = read16(&buf, endian) >> 4;
358 if (elements == 4)
359 *dst[3]++ = read16(&buf, endian) >> 4;
360 }
361 for (i = 0; i < elements; i++)
362 ptr[i] += p->linesize[i];
363 // Jump to next aligned position
364 buf += need_align;
365 }
366 break;
367 case 16:
368 elements *= 2;
369 case 8:
370 if ( avctx->pix_fmt == AV_PIX_FMT_YUVA444P
371 || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
372 for (x = 0; x < avctx->height; x++) {
373 ptr[0] = p->data[0] + x * p->linesize[0];
374 ptr[1] = p->data[1] + x * p->linesize[1];
375 ptr[2] = p->data[2] + x * p->linesize[2];
376 ptr[3] = p->data[3] + x * p->linesize[3];
377 for (y = 0; y < avctx->width; y++) {
378 *ptr[1]++ = *buf++;
379 *ptr[0]++ = *buf++;
380 *ptr[2]++ = *buf++;
381 if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
382 *ptr[3]++ = *buf++;
383 }
384 }
385 } else {
386 av_image_copy_plane(ptr[0], p->linesize[0],
387 buf, stride,
388 elements * avctx->width, avctx->height);
389 }
390 break;
391 }
392
393 *got_frame = 1;
394
395 return buf_size;
396}
397
398AVCodec ff_dpx_decoder = {
399 .name = "dpx",
400 .long_name = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
401 .type = AVMEDIA_TYPE_VIDEO,
402 .id = AV_CODEC_ID_DPX,
403 .decode = decode_frame,
404 .capabilities = AV_CODEC_CAP_DR1,
405};
406
generated by cgit at 2024-05-17 06:12:42 (GMT)