Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dpx.c @ 1b5282a2

History | View | Annotate | Download (7.06 KB)

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/imgutils.h"
24
#include "bytestream.h"
25
#include "avcodec.h"
26

    
27
typedef struct DPXContext {
28
    AVFrame picture;
29
} DPXContext;
30

    
31

    
32
static unsigned int read32(const uint8_t **ptr, int is_big)
33
{
34
    unsigned int temp;
35
    if (is_big) {
36
        temp = AV_RB32(*ptr);
37
    } else {
38
        temp = AV_RL32(*ptr);
39
    }
40
    *ptr += 4;
41
    return temp;
42
}
43

    
44
static inline unsigned make_16bit(unsigned value)
45
{
46
    // mask away invalid bits
47
    value &= 0xFFC0;
48
    // correctly expand to 16 bits
49
    return value + (value >> 10);
50
}
51

    
52
static int decode_frame(AVCodecContext *avctx,
53
                        void *data,
54
                        int *data_size,
55
                        AVPacket *avpkt)
56
{
57
    const uint8_t *buf = avpkt->data;
58
    const uint8_t *buf_end = avpkt->data + avpkt->size;
59
    int buf_size       = avpkt->size;
60
    DPXContext *const s = avctx->priv_data;
61
    AVFrame *picture  = data;
62
    AVFrame *const p = &s->picture;
63
    uint8_t *ptr;
64

    
65
    int magic_num, offset, endian;
66
    int x, y;
67
    int w, h, stride, bits_per_color, descriptor, elements, target_packet_size, source_packet_size;
68

    
69
    unsigned int rgbBuffer;
70

    
71
    if (avpkt->size <= 1634) {
72
        av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
73
        return AVERROR_INVALIDDATA;
74
    }
75

    
76
    magic_num = AV_RB32(buf);
77
    buf += 4;
78

    
79
    /* Check if the files "magic number" is "SDPX" which means it uses
80
     * big-endian or XPDS which is for little-endian files */
81
    if (magic_num == AV_RL32("SDPX")) {
82
        endian = 0;
83
    } else if (magic_num == AV_RB32("SDPX")) {
84
        endian = 1;
85
    } else {
86
        av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
87
        return -1;
88
    }
89

    
90
    offset = read32(&buf, endian);
91
    if (avpkt->size <= offset) {
92
        av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
93
        return AVERROR_INVALIDDATA;
94
    }
95
    // Need to end in 0x304 offset from start of file
96
    buf = avpkt->data + 0x304;
97
    w = read32(&buf, endian);
98
    h = read32(&buf, endian);
99

    
100
    // Need to end in 0x320 to read the descriptor
101
    buf += 20;
102
    descriptor = buf[0];
103

    
104
    // Need to end in 0x323 to read the bits per color
105
    buf += 3;
106
    avctx->bits_per_raw_sample =
107
    bits_per_color = buf[0];
108

    
109
    buf += 825;
110
    avctx->sample_aspect_ratio.num = read32(&buf, endian);
111
    avctx->sample_aspect_ratio.den = read32(&buf, endian);
112

    
113
    switch (descriptor) {
114
        case 51: // RGBA
115
            elements = 4;
116
            break;
117
        case 50: // RGB
118
            elements = 3;
119
            break;
120
        default:
121
            av_log(avctx, AV_LOG_ERROR, "Unsupported descriptor %d\n", descriptor);
122
            return -1;
123
    }
124

    
125
    switch (bits_per_color) {
126
        case 8:
127
            if (elements == 4) {
128
                avctx->pix_fmt = PIX_FMT_RGBA;
129
            } else {
130
                avctx->pix_fmt = PIX_FMT_RGB24;
131
            }
132
            source_packet_size = elements;
133
            target_packet_size = elements;
134
            break;
135
        case 10:
136
            avctx->pix_fmt = PIX_FMT_RGB48;
137
            target_packet_size = 6;
138
            source_packet_size = 4;
139
            break;
140
        case 12:
141
        case 16:
142
            if (endian) {
143
                avctx->pix_fmt = PIX_FMT_RGB48BE;
144
            } else {
145
                avctx->pix_fmt = PIX_FMT_RGB48LE;
146
            }
147
            target_packet_size = 6;
148
            source_packet_size = elements * 2;
149
            break;
150
        default:
151
            av_log(avctx, AV_LOG_ERROR, "Unsupported color depth : %d\n", bits_per_color);
152
            return -1;
153
    }
154

    
155
    if (s->picture.data[0])
156
        avctx->release_buffer(avctx, &s->picture);
157
    if (av_image_check_size(w, h, 0, avctx))
158
        return -1;
159
    if (w != avctx->width || h != avctx->height)
160
        avcodec_set_dimensions(avctx, w, h);
161
    if (avctx->get_buffer(avctx, p) < 0) {
162
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
163
        return -1;
164
    }
165

    
166
    // Move pointer to offset from start of file
167
    buf =  avpkt->data + offset;
168

    
169
    ptr    = p->data[0];
170
    stride = p->linesize[0];
171

    
172
    if (source_packet_size*avctx->width*avctx->height > buf_end - buf) {
173
        av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
174
        return -1;
175
    }
176
    switch (bits_per_color) {
177
        case 10:
178
            for (x = 0; x < avctx->height; x++) {
179
               uint16_t *dst = (uint16_t*)ptr;
180
               for (y = 0; y < avctx->width; y++) {
181
                   rgbBuffer = read32(&buf, endian);
182
                   // Read out the 10-bit colors and convert to 16-bit
183
                   *dst++ = make_16bit(rgbBuffer >> 16);
184
                   *dst++ = make_16bit(rgbBuffer >>  6);
185
                   *dst++ = make_16bit(rgbBuffer <<  4);
186
               }
187
               ptr += stride;
188
            }
189
            break;
190
        case 8:
191
        case 12: // Treat 12-bit as 16-bit
192
        case 16:
193
            if (source_packet_size == target_packet_size) {
194
                for (x = 0; x < avctx->height; x++) {
195
                    memcpy(ptr, buf, target_packet_size*avctx->width);
196
                    ptr += stride;
197
                    buf += source_packet_size*avctx->width;
198
                }
199
            } else {
200
                for (x = 0; x < avctx->height; x++) {
201
                    uint8_t *dst = ptr;
202
                    for (y = 0; y < avctx->width; y++) {
203
                        memcpy(dst, buf, target_packet_size);
204
                        dst += target_packet_size;
205
                        buf += source_packet_size;
206
                    }
207
                    ptr += stride;
208
                }
209
            }
210
            break;
211
    }
212

    
213
    *picture   = s->picture;
214
    *data_size = sizeof(AVPicture);
215

    
216
    return buf_size;
217
}
218

    
219
static av_cold int decode_init(AVCodecContext *avctx)
220
{
221
    DPXContext *s = avctx->priv_data;
222
    avcodec_get_frame_defaults(&s->picture);
223
    avctx->coded_frame = &s->picture;
224
    return 0;
225
}
226

    
227
static av_cold int decode_end(AVCodecContext *avctx)
228
{
229
    DPXContext *s = avctx->priv_data;
230
    if (s->picture.data[0])
231
        avctx->release_buffer(avctx, &s->picture);
232

    
233
    return 0;
234
}
235

    
236
AVCodec ff_dpx_decoder = {
237
    "dpx",
238
    AVMEDIA_TYPE_VIDEO,
239
    CODEC_ID_DPX,
240
    sizeof(DPXContext),
241
    decode_init,
242
    NULL,
243
    decode_end,
244
    decode_frame,
245
    0,
246
    NULL,
247
    .long_name = NULL_IF_CONFIG_SMALL("DPX image"),
248
};