avcodec/mpegvideo: Use intra_scantable in dct_unquantize_h263_intra_c()
[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 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
398 AVCodec 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 };