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