git.sesse.net Git - ffmpeg/blob - 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/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 uint16_t read10in32(const uint8_t **ptr, uint32_t * lbuf,
  45                                   int * n_datum, int is_big)
  46 {
  47     if (*n_datum)
  48         (*n_datum)--;
  49     else {
  50         *lbuf = read32(ptr, is_big);
  51         *n_datum = 2;
  52     }
  53
  54     *lbuf = (*lbuf << 10) | (*lbuf >> 22);
  55
  56     return *lbuf & 0x3FF;
  57 }
  58
  59 static int decode_frame(AVCodecContext *avctx,
  60                         void *data,
  61                         int *data_size,
  62                         AVPacket *avpkt)
  63 {
  64     const uint8_t *buf = avpkt->data;
  65     int buf_size       = avpkt->size;
  66     DPXContext *const s = avctx->priv_data;
  67     AVFrame *picture  = data;
  68     AVFrame *const p = &s->picture;
  69     uint8_t *ptr[AV_NUM_DATA_POINTERS];
  70
  71     unsigned int offset;
  72     int magic_num, endian;
  73     int x, y, i;
  74     int w, h, bits_per_color, descriptor, elements, packing, total_size;
  75
  76     unsigned int rgbBuffer = 0;
  77     int n_datum = 0;
  78
  79     if (avpkt->size <= 1634) {
  80         av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
  81         return AVERROR_INVALIDDATA;
  82     }
  83
  84     magic_num = AV_RB32(buf);
  85     buf += 4;
  86
  87     /* Check if the files "magic number" is "SDPX" which means it uses
  88      * big-endian or XPDS which is for little-endian files */
  89     if (magic_num == AV_RL32("SDPX")) {
  90         endian = 0;
  91     } else if (magic_num == AV_RB32("SDPX")) {
  92         endian = 1;
  93     } else {
  94         av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
  95         return -1;
  96     }
  97
  98     offset = read32(&buf, endian);
  99     if (avpkt->size <= offset) {
 100         av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
 101         return AVERROR_INVALIDDATA;
 102     }
 103     // Need to end in 0x304 offset from start of file
 104     buf = avpkt->data + 0x304;
 105     w = read32(&buf, endian);
 106     h = read32(&buf, endian);
 107
 108     // Need to end in 0x320 to read the descriptor
 109     buf += 20;
 110     descriptor = buf[0];
 111
 112     // Need to end in 0x323 to read the bits per color
 113     buf += 3;
 114     avctx->bits_per_raw_sample =
 115     bits_per_color = buf[0];
 116     buf++;
 117     packing = *((uint16_t*)buf);
 118
 119     buf += 824;
 120     avctx->sample_aspect_ratio.num = read32(&buf, endian);
 121     avctx->sample_aspect_ratio.den = read32(&buf, endian);
 122     if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
 123         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 124                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den,
 125                   0x10000);
 126     else
 127         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
 128
 129     switch (descriptor) {
 130         case 51: // RGBA
 131             elements = 4;
 132             break;
 133         case 50: // RGB
 134             elements = 3;
 135             break;
 136         default:
 137             av_log(avctx, AV_LOG_ERROR, "Unsupported descriptor %d\n", descriptor);
 138             return -1;
 139     }
 140
 141     switch (bits_per_color) {
 142         case 8:
 143             if (elements == 4) {
 144                 avctx->pix_fmt = AV_PIX_FMT_RGBA;
 145             } else {
 146                 avctx->pix_fmt = AV_PIX_FMT_RGB24;
 147             }
 148             total_size = avctx->width * avctx->height * elements;
 149             break;
 150         case 10:
 151             if (!packing) {
 152                 av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
 153                 return -1;
 154             }
 155             avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 156             total_size = (4 * avctx->width * avctx->height * elements) / 3;
 157             break;
 158         case 12:
 159             if (!packing) {
 160                 av_log(avctx, AV_LOG_ERROR, "Packing to 16bit required\n");
 161                 return -1;
 162             }
 163             if (endian) {
 164                 avctx->pix_fmt = AV_PIX_FMT_GBRP12BE;
 165             } else {
 166                 avctx->pix_fmt = AV_PIX_FMT_GBRP12LE;
 167             }
 168             total_size = 2 * avctx->width * avctx->height * elements;
 169             break;
 170         case 16:
 171             if (endian) {
 172                 avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_RGBA64BE : AV_PIX_FMT_RGB48BE;
 173             } else {
 174                 avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_RGB48LE;
 175             }
 176             total_size = 2 * avctx->width * avctx->height * elements;
 177             break;
 178         default:
 179             av_log(avctx, AV_LOG_ERROR, "Unsupported color depth : %d\n", bits_per_color);
 180             return -1;
 181     }
 182
 183     if (s->picture.data[0])
 184         avctx->release_buffer(avctx, &s->picture);
 185     if (av_image_check_size(w, h, 0, avctx))
 186         return -1;
 187     if (w != avctx->width || h != avctx->height)
 188         avcodec_set_dimensions(avctx, w, h);
 189     if (avctx->get_buffer(avctx, p) < 0) {
 190         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 191         return -1;
 192     }
 193
 194     // Move pointer to offset from start of file
 195     buf =  avpkt->data + offset;
 196
 197     for (i=0; i<AV_NUM_DATA_POINTERS; i++)
 198         ptr[i] = p->data[i];
 199
 200     if (total_size > avpkt->size) {
 201         av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
 202         return -1;
 203     }
 204     switch (bits_per_color) {
 205     case 10:
 206         for (x = 0; x < avctx->height; x++) {
 207             uint16_t *dst[3] = {(uint16_t*)ptr[0],
 208                                 (uint16_t*)ptr[1],
 209                                 (uint16_t*)ptr[2]};
 210             for (y = 0; y < avctx->width; y++) {
 211                 *dst[2]++ = read10in32(&buf, &rgbBuffer,
 212                                        &n_datum, endian);
 213                 *dst[0]++ = read10in32(&buf, &rgbBuffer,
 214                                        &n_datum, endian);
 215                 *dst[1]++ = read10in32(&buf, &rgbBuffer,
 216                                        &n_datum, endian);
 217                 // For 10 bit, ignore alpha
 218                 if (elements == 4)
 219                     read10in32(&buf, &rgbBuffer,
 220                                &n_datum, endian);
 221             }
 222             for (i = 0; i < 3; i++)
 223                 ptr[i] += p->linesize[i];
 224         }
 225         break;
 226     case 12:
 227         for (x = 0; x < avctx->height; x++) {
 228             uint16_t *dst[3] = {(uint16_t*)ptr[0],
 229                                 (uint16_t*)ptr[1],
 230                                 (uint16_t*)ptr[2]};
 231             for (y = 0; y < avctx->width; y++) {
 232                 *dst[2] = *((uint16_t*)buf);
 233                 *dst[2] = (*dst[2] >> 4) | (*dst[2] << 12);
 234                 dst[2]++;
 235                 buf += 2;
 236                 *dst[0] = *((uint16_t*)buf);
 237                 *dst[0] = (*dst[0] >> 4) | (*dst[0] << 12);
 238                 dst[0]++;
 239                 buf += 2;
 240                 *dst[1] = *((uint16_t*)buf);
 241                 *dst[1] = (*dst[1] >> 4) | (*dst[1] << 12);
 242                 dst[1]++;
 243                 buf += 2;
 244                 // For 12 bit, ignore alpha
 245                 if (elements == 4)
 246                     buf += 2;
 247             }
 248             for (i = 0; i < 3; i++)
 249                 ptr[i] += p->linesize[i];
 250         }
 251         break;
 252     case 16:
 253         elements *= 2;
 254     case 8:
 255         for (x = 0; x < avctx->height; x++) {
 256             memcpy(ptr[0], buf, elements*avctx->width);
 257             ptr[0] += p->linesize[0];
 258             buf += elements*avctx->width;
 259         }
 260         break;
 261     }
 262
 263     *picture   = s->picture;
 264     *data_size = sizeof(AVPicture);
 265
 266     return buf_size;
 267 }
 268
 269 static av_cold int decode_init(AVCodecContext *avctx)
 270 {
 271     DPXContext *s = avctx->priv_data;
 272     avcodec_get_frame_defaults(&s->picture);
 273     avctx->coded_frame = &s->picture;
 274     return 0;
 275 }
 276
 277 static av_cold int decode_end(AVCodecContext *avctx)
 278 {
 279     DPXContext *s = avctx->priv_data;
 280     if (s->picture.data[0])
 281         avctx->release_buffer(avctx, &s->picture);
 282
 283     return 0;
 284 }
 285
 286 AVCodec ff_dpx_decoder = {
 287     .name           = "dpx",
 288     .type           = AVMEDIA_TYPE_VIDEO,
 289     .id             = AV_CODEC_ID_DPX,
 290     .priv_data_size = sizeof(DPXContext),
 291     .init           = decode_init,
 292     .close          = decode_end,
 293     .decode         = decode_frame,
 294     .long_name      = NULL_IF_CONFIG_SMALL("DPX image"),
 295     .capabilities   = CODEC_CAP_DR1,
 296 };