2 * DPX (.dpx) image decoder
3 * Copyright (c) 2009 Jimmy Christensen
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/intfloat.h"
24 #include "libavutil/imgutils.h"
25 #include "bytestream.h"
29 static unsigned int read16(const uint8_t **ptr
, int is_big
)
41 static unsigned int read32(const uint8_t **ptr
, int is_big
)
53 static uint16_t read10in32(const uint8_t **ptr
, uint32_t * lbuf
,
54 int * n_datum
, int is_big
)
59 *lbuf
= read32(ptr
, is_big
);
63 *lbuf
= (*lbuf
<< 10) | (*lbuf
>> 22);
68 static int decode_frame(AVCodecContext
*avctx
,
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
];
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;
84 unsigned int rgbBuffer
= 0;
87 if (avpkt
->size
<= 1634) {
88 av_log(avctx
, AV_LOG_ERROR
, "Packet too small for DPX header\n");
89 return AVERROR_INVALIDDATA
;
92 magic_num
= AV_RB32(buf
);
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")) {
99 } else if (magic_num
== AV_RB32("SDPX")) {
102 av_log(avctx
, AV_LOG_ERROR
, "DPX marker not found\n");
103 return AVERROR_INVALIDDATA
;
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
;
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");
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
);
126 if ((ret
= ff_set_dimensions(avctx
, w
, h
)) < 0)
129 // Need to end in 0x320 to read the descriptor
133 // Need to end in 0x323 to read the bits per color
135 avctx
->bits_per_raw_sample
=
136 bits_per_color
= buf
[0];
138 packing
= read16(&buf
, endian
);
139 encoding
= read16(&buf
, endian
);
142 avpriv_report_missing_feature(avctx
, "Packing %d", packing
);
143 return AVERROR_PATCHWELCOME
;
146 avpriv_report_missing_feature(avctx
, "Encoding %d", encoding
);
147 return AVERROR_PATCHWELCOME
;
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
,
158 avctx
->sample_aspect_ratio
= (AVRational
){ 0, 1 };
160 if (offset
>= 1724 + 4) {
161 buf
= avpkt
->data
+ 1724;
162 i
= read32(&buf
, endian
);
164 AVRational q
= av_d2q(av_int2float(i
), 4096);
165 if (q
.num
> 0 && q
.den
> 0)
166 avctx
->framerate
= q
;
170 switch (descriptor
) {
182 avpriv_report_missing_feature(avctx
, "Descriptor %d", descriptor
);
183 return AVERROR_PATCHWELCOME
;
186 switch (bits_per_color
) {
188 stride
= avctx
->width
* elements
;
192 av_log(avctx
, AV_LOG_ERROR
, "Packing to 32bit required\n");
195 stride
= (avctx
->width
* elements
+ 2) / 3 * 4;
199 av_log(avctx
, AV_LOG_ERROR
, "Packing to 16bit required\n");
202 stride
= 2 * avctx
->width
* elements
;
205 stride
= 2 * avctx
->width
* elements
;
210 avpriv_report_missing_feature(avctx
, "Depth %d", bits_per_color
);
211 return AVERROR_PATCHWELCOME
;
213 return AVERROR_INVALIDDATA
;
216 // Table 3c: Runs will always break at scan line boundaries. Packing
217 // will always break to the next 32-bit word at scan-line boundaries.
218 // Unfortunately, the encoder produced invalid files, so attempt
220 need_align
= FFALIGN(stride
, 4);
221 if (need_align
*avctx
->height
+ (int64_t)offset
> avpkt
->size
) {
222 // Alignment seems unappliable, try without
223 if (stride
*avctx
->height
+ (int64_t)offset
> avpkt
->size
) {
224 av_log(avctx
, AV_LOG_ERROR
, "Overread buffer. Invalid header?\n");
225 return AVERROR_INVALIDDATA
;
227 av_log(avctx
, AV_LOG_INFO
, "Decoding DPX without scanline "
232 need_align
-= stride
;
233 stride
= FFALIGN(stride
, 4);
236 switch (1000 * descriptor
+ 10 * bits_per_color
+ endian
) {
239 avctx
->pix_fmt
= AV_PIX_FMT_GRAY8
;
243 avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
247 avctx
->pix_fmt
= AV_PIX_FMT_ABGR
;
251 avctx
->pix_fmt
= AV_PIX_FMT_RGBA
;
257 avctx
->pix_fmt
= AV_PIX_FMT_GBRP10
;
263 avctx
->pix_fmt
= AV_PIX_FMT_GBRP12
;
266 avctx
->pix_fmt
= AV_PIX_FMT_GRAY16BE
;
269 avctx
->pix_fmt
= AV_PIX_FMT_GRAY16LE
;
272 avctx
->pix_fmt
= AV_PIX_FMT_RGB48BE
;
275 avctx
->pix_fmt
= AV_PIX_FMT_RGB48LE
;
278 avctx
->pix_fmt
= AV_PIX_FMT_RGBA64BE
;
281 avctx
->pix_fmt
= AV_PIX_FMT_RGBA64LE
;
284 av_log(avctx
, AV_LOG_ERROR
, "Unsupported format\n");
285 return AVERROR_PATCHWELCOME
;
288 ff_set_sar(avctx
, avctx
->sample_aspect_ratio
);
290 if ((ret
= ff_get_buffer(avctx
, p
, 0)) < 0)
293 // Move pointer to offset from start of file
294 buf
= avpkt
->data
+ offset
;
296 for (i
=0; i
<AV_NUM_DATA_POINTERS
; i
++)
299 switch (bits_per_color
) {
301 for (x
= 0; x
< avctx
->height
; x
++) {
302 uint16_t *dst
[3] = {(uint16_t*)ptr
[0],
305 for (y
= 0; y
< avctx
->width
; y
++) {
306 *dst
[2]++ = read10in32(&buf
, &rgbBuffer
,
308 *dst
[0]++ = read10in32(&buf
, &rgbBuffer
,
310 *dst
[1]++ = read10in32(&buf
, &rgbBuffer
,
312 // For 10 bit, ignore alpha
314 read10in32(&buf
, &rgbBuffer
,
318 for (i
= 0; i
< 3; i
++)
319 ptr
[i
] += p
->linesize
[i
];
323 for (x
= 0; x
< avctx
->height
; x
++) {
324 uint16_t *dst
[3] = {(uint16_t*)ptr
[0],
327 for (y
= 0; y
< avctx
->width
; y
++) {
328 *dst
[2] = read16(&buf
, endian
) >> 4;
330 *dst
[0] = read16(&buf
, endian
) >> 4;
332 *dst
[1] = read16(&buf
, endian
) >> 4;
334 // For 12 bit, ignore alpha
337 // Jump to next aligned position
340 for (i
= 0; i
< 3; i
++)
341 ptr
[i
] += p
->linesize
[i
];
347 av_image_copy_plane(ptr
[0], p
->linesize
[0],
349 elements
* avctx
->width
, avctx
->height
);
358 AVCodec ff_dpx_decoder
= {
360 .long_name
= NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
361 .type
= AVMEDIA_TYPE_VIDEO
,
362 .id
= AV_CODEC_ID_DPX
,
363 .decode
= decode_frame
,
364 .capabilities
= CODEC_CAP_DR1
,